1# frozen_string_literal: true
2
3require "test_helper"
4require "credit_card_sale"
5require "customer"
6require "transaction"
7
8CreditCardSale::BRAINTREE = Minitest::Mock.new
9CreditCardSale::REDIS = Minitest::Mock.new
10TrustLevelRepo::REDIS = Minitest::Mock.new
11TrustLevelRepo::DB = Minitest::Mock.new
12
13class CreditCardSaleTest < 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 CreditCardSale::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"], default: {}
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 CreditCardSale::BRAINTREE.expect(:transaction, braintree_transaction)
55 braintree_transaction.expect(
56 :sale,
57 EMPromise.resolve(
58 OpenStruct.new(success?: false, message: "declined")
59 ),
60 amount: 99,
61 merchant_account_id: "merchant_usd",
62 options: { submit_for_settlement: true },
63 payment_method_token: "token"
64 )
65 assert_raises(BraintreeFailure) do
66 CreditCardSale.new(
67 customer(plan_name: "test_usd"),
68 amount: 99,
69 payment_method: OpenStruct.new(token: "token")
70 ).sale.sync
71 end
72 assert_mock CustomerFinancials::REDIS
73 assert_mock CreditCardSale::REDIS
74 assert_mock TrustLevelRepo::REDIS
75 assert_mock TrustLevelRepo::DB
76 end
77 em :test_sale_fails
78
79 def test_sale_locked
80 CreditCardSale::REDIS.expect(
81 :exists,
82 EMPromise.resolve(1),
83 ["jmp_customer_credit_card_lock-test"]
84 )
85 TrustLevelRepo::REDIS.expect(
86 :get,
87 EMPromise.resolve("Customer"),
88 ["jmp_customer_trust_level-test"]
89 )
90 TrustLevelRepo::DB.expect(
91 :query_one,
92 EMPromise.resolve({}),
93 [String, "test"], default: {}
94 )
95 CustomerFinancials::REDIS.expect(
96 :get,
97 EMPromise.resolve("0"),
98 ["jmp_pay_decline-test"]
99 )
100 assert_raises("locked") do
101 CreditCardSale.new(
102 customer(plan_name: "test_usd"),
103 amount: 123,
104 payment_method: OpenStruct.new(token: "token")
105 ).sale.sync
106 end
107 assert_mock CustomerFinancials::REDIS
108 assert_mock CreditCardSale::REDIS
109 assert_mock TrustLevelRepo::REDIS
110 assert_mock TrustLevelRepo::DB
111 end
112 em :test_sale_locked
113
114 def test_sale
115 CreditCardSale::REDIS.expect(
116 :exists,
117 EMPromise.resolve(0),
118 ["jmp_customer_credit_card_lock-test"]
119 )
120 TrustLevelRepo::REDIS.expect(
121 :get,
122 EMPromise.resolve("Customer"),
123 ["jmp_customer_trust_level-test"]
124 )
125 TrustLevelRepo::DB.expect(
126 :query_one,
127 EMPromise.resolve({}),
128 [String, "test"], default: {}
129 )
130 CustomerFinancials::REDIS.expect(
131 :get,
132 EMPromise.resolve("1"),
133 ["jmp_pay_decline-test"]
134 )
135 braintree_transaction = Minitest::Mock.new
136 CreditCardSale::BRAINTREE.expect(:transaction, braintree_transaction)
137 braintree_transaction.expect(
138 :sale,
139 EMPromise.resolve(
140 OpenStruct.new(
141 success?: true,
142 transaction: FAKE_BRAINTREE_TRANSACTION
143 )
144 ),
145 amount: 99,
146 payment_method_token: "token",
147 merchant_account_id: "merchant_usd",
148 options: { submit_for_settlement: true }
149 )
150 CreditCardSale::REDIS.expect(
151 :setex,
152 EMPromise.resolve(1),
153 ["jmp_customer_credit_card_lock-test", 86400, "1"]
154 )
155 result = CreditCardSale.new(
156 customer(plan_name: "test_usd"),
157 amount: 99,
158 payment_method: OpenStruct.new(token: "token")
159 ).sale.sync
160 assert_equal FAKE_BRAINTREE_TRANSACTION, result
161 assert_mock CustomerFinancials::REDIS
162 assert_mock CreditCardSale::REDIS
163 assert_mock TrustLevelRepo::REDIS
164 assert_mock TrustLevelRepo::DB
165 end
166 em :test_sale
167
168 def test_builder
169 expected = Transaction.new(
170 customer_id: "customer",
171 transaction_id: "transaction",
172 created_at: Time.at(0),
173 settled_after: Time.at(7776000),
174 amount: 12,
175 note: "Credit card payment"
176 )
177
178 assert_equal(
179 expected,
180 CreditCardSale::BraintreeTransaction.build(FAKE_BRAINTREE_TRANSACTION)
181 )
182 end
183
184 def test_create
185 CreditCardSale::REDIS.expect(
186 :exists,
187 EMPromise.resolve(0),
188 ["jmp_customer_credit_card_lock-test"]
189 )
190 TrustLevelRepo::REDIS.expect(
191 :get,
192 EMPromise.resolve("Customer"),
193 ["jmp_customer_trust_level-test"]
194 )
195 TrustLevelRepo::DB.expect(
196 :query_one,
197 EMPromise.resolve({}),
198 [String, "test"], default: {}
199 )
200 CustomerFinancials::REDIS.expect(
201 :get,
202 EMPromise.resolve("1"),
203 ["jmp_pay_decline-test"]
204 )
205 braintree_transaction = Minitest::Mock.new
206 CreditCardSale::BRAINTREE.expect(:transaction, braintree_transaction)
207 response = EMPromise.resolve(
208 OpenStruct.new(
209 success?: true,
210 transaction: FAKE_BRAINTREE_TRANSACTION
211 )
212 )
213 braintree_transaction.expect(
214 :sale,
215 response,
216 amount: 99,
217 payment_method_token: "token",
218 merchant_account_id: "merchant_usd",
219 options: { submit_for_settlement: true }
220 )
221 CreditCardSale::REDIS.expect(
222 :setex,
223 EMPromise.resolve(1),
224 ["jmp_customer_credit_card_lock-test", 86400, "1"]
225 )
226
227 transaction = PromiseMock.new
228 transaction.expect(:insert, EMPromise.resolve(nil))
229
230 transaction_class = Minitest::Mock.new
231 transaction_class.expect(
232 :new,
233 transaction,
234 customer_id: "customer",
235 transaction_id: "transaction",
236 created_at: Time.at(0),
237 settled_after: Time.at(7776000),
238 amount: 12,
239 note: "Credit card payment"
240 )
241
242 result = CreditCardSale.create(
243 customer(plan_name: "test_usd"),
244 amount: 99,
245 payment_method: OpenStruct.new(token: "token"),
246 transaction_class: transaction_class
247 ).sync
248
249 assert_equal transaction.object_id, result.object_id
250 assert_mock transaction_class
251 assert_mock transaction
252 assert_mock CustomerFinancials::REDIS
253 assert_mock CreditCardSale::REDIS
254 assert_mock TrustLevelRepo::REDIS
255 assert_mock TrustLevelRepo::DB
256 end
257 em :test_create
258end