1# frozen_string_literal: true
2
3require "test_helper"
4require "customer"
5require "transaction"
6
7Transaction::DB = Minitest::Mock.new
8Transaction::BRAINTREE = Minitest::Mock.new
9Transaction::REDIS = Minitest::Mock.new
10TrustLevelRepo::REDIS = Minitest::Mock.new
11TrustLevelRepo::DB = Minitest::Mock.new
12
13class TransactionTest < Minitest::Test
14 FAKE_BRAINTREE_TRANSACTION =
15 OpenStruct.new(
16 customer_details: OpenStruct.new(id: "customer"),
17 id: "transaction",
18 created_at: Time.at(0),
19 amount: 12
20 )
21
22 def test_sale_fails
23 Transaction::REDIS.expect(
24 :exists,
25 EMPromise.resolve(0),
26 ["jmp_customer_credit_card_lock-test"]
27 )
28 TrustLevelRepo::REDIS.expect(
29 :get,
30 EMPromise.resolve("Customer"),
31 ["jmp_customer_trust_level-test"]
32 )
33 TrustLevelRepo::DB.expect(
34 :query_one,
35 EMPromise.resolve({}),
36 [String, "test", Hash]
37 )
38 CustomerFinancials::REDIS.expect(
39 :get,
40 EMPromise.resolve("1"),
41 ["jmp_pay_decline-test"]
42 )
43 CustomerFinancials::REDIS.expect(
44 :incr,
45 EMPromise.resolve(nil),
46 ["jmp_pay_decline-test"]
47 )
48 CustomerFinancials::REDIS.expect(
49 :expire,
50 EMPromise.resolve(nil),
51 ["jmp_pay_decline-test", 60 * 60 * 24]
52 )
53 braintree_transaction = Minitest::Mock.new
54 Transaction::BRAINTREE.expect(:transaction, braintree_transaction)
55 braintree_transaction.expect(
56 :sale,
57 EMPromise.resolve(
58 OpenStruct.new(success?: false, message: "declined")
59 ),
60 [Hash]
61 )
62 assert_raises("declined") do
63 Transaction.sale(
64 customer(plan_name: "test_usd"),
65 amount: 99,
66 payment_method: OpenStruct.new(token: "token")
67 ).sync
68 end
69 assert_mock CustomerFinancials::REDIS
70 assert_mock Transaction::REDIS
71 assert_mock TrustLevelRepo::REDIS
72 assert_mock TrustLevelRepo::DB
73 end
74 em :test_sale_fails
75
76 def test_sale_locked
77 Transaction::REDIS.expect(
78 :exists,
79 EMPromise.resolve(1),
80 ["jmp_customer_credit_card_lock-test"]
81 )
82 TrustLevelRepo::REDIS.expect(
83 :get,
84 EMPromise.resolve("Customer"),
85 ["jmp_customer_trust_level-test"]
86 )
87 TrustLevelRepo::DB.expect(
88 :query_one,
89 EMPromise.resolve({}),
90 [String, "test", Hash]
91 )
92 CustomerFinancials::REDIS.expect(
93 :get,
94 EMPromise.resolve("0"),
95 ["jmp_pay_decline-test"]
96 )
97 assert_raises("locked") do
98 Transaction.sale(
99 customer(plan_name: "test_usd"),
100 amount: 123,
101 payment_method: OpenStruct.new(token: "token")
102 ).sync
103 end
104 assert_mock CustomerFinancials::REDIS
105 assert_mock Transaction::REDIS
106 assert_mock TrustLevelRepo::REDIS
107 assert_mock TrustLevelRepo::DB
108 end
109 em :test_sale_locked
110
111 def test_sale
112 Transaction::REDIS.expect(
113 :exists,
114 EMPromise.resolve(0),
115 ["jmp_customer_credit_card_lock-test"]
116 )
117 TrustLevelRepo::REDIS.expect(
118 :get,
119 EMPromise.resolve("Customer"),
120 ["jmp_customer_trust_level-test"]
121 )
122 TrustLevelRepo::DB.expect(
123 :query_one,
124 EMPromise.resolve({}),
125 [String, "test", Hash]
126 )
127 CustomerFinancials::REDIS.expect(
128 :get,
129 EMPromise.resolve("1"),
130 ["jmp_pay_decline-test"]
131 )
132 braintree_transaction = Minitest::Mock.new
133 Transaction::BRAINTREE.expect(:transaction, braintree_transaction)
134 braintree_transaction.expect(
135 :sale,
136 EMPromise.resolve(
137 OpenStruct.new(
138 success?: true,
139 transaction: FAKE_BRAINTREE_TRANSACTION
140 )
141 ),
142 [{
143 amount: 99,
144 payment_method_token: "token",
145 merchant_account_id: "merchant_usd",
146 options: { submit_for_settlement: true }
147 }]
148 )
149 Transaction::REDIS.expect(
150 :setex,
151 EMPromise.resolve(1),
152 ["jmp_customer_credit_card_lock-test", 86400, "1"]
153 )
154 result = Transaction.sale(
155 customer(plan_name: "test_usd"),
156 amount: 99,
157 payment_method: OpenStruct.new(token: "token")
158 ).sync
159 assert_kind_of Transaction, result
160 assert_mock CustomerFinancials::REDIS
161 assert_mock Transaction::REDIS
162 assert_mock TrustLevelRepo::REDIS
163 assert_mock TrustLevelRepo::DB
164 end
165 em :test_sale
166
167 def test_insert
168 Transaction::DB.expect(:transaction, []) do |&block|
169 block.call
170 true
171 end
172 Transaction::DB.expect(
173 :exec,
174 EMPromise.resolve(nil),
175 [
176 String,
177 ["customer", "transaction", Time.at(0), Time.at(7776000), 12]
178 ]
179 )
180 Transaction.new(FAKE_BRAINTREE_TRANSACTION).insert.sync
181 Transaction::DB.verify
182 end
183 em :test_insert
184
185 def test_insert_with_bonus
186 Transaction::DB.expect(:transaction, []) do |&block|
187 block.call
188 true
189 end
190 Transaction::DB.expect(
191 :exec,
192 EMPromise.resolve(nil),
193 [
194 String,
195 ["customer", "transaction", Time.at(0), Time.at(7776000), 100]
196 ]
197 )
198 Transaction::DB.expect(
199 :exec,
200 EMPromise.resolve(nil),
201 [
202 String,
203 ["customer", "bonus_for_transaction", Time.at(0), Time.at(7776000), 3]
204 ]
205 )
206 tx = FAKE_BRAINTREE_TRANSACTION.dup
207 tx.amount = 100
208 Transaction.new(tx).insert.sync
209 Transaction::DB.verify
210 end
211 em :test_insert_with_bonus
212end