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"], 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 Transaction::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(RuntimeError) do
66 Transaction.sale(
67 customer(plan_name: "test_usd"),
68 amount: 99,
69 payment_method: OpenStruct.new(token: "token")
70 ).sync
71 end
72 assert_mock CustomerFinancials::REDIS
73 assert_mock Transaction::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 Transaction::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 Transaction.sale(
102 customer(plan_name: "test_usd"),
103 amount: 123,
104 payment_method: OpenStruct.new(token: "token")
105 ).sync
106 end
107 assert_mock CustomerFinancials::REDIS
108 assert_mock Transaction::REDIS
109 assert_mock TrustLevelRepo::REDIS
110 assert_mock TrustLevelRepo::DB
111 end
112 em :test_sale_locked
113
114 def test_sale
115 Transaction::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 Transaction::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 Transaction::REDIS.expect(
151 :setex,
152 EMPromise.resolve(1),
153 ["jmp_customer_credit_card_lock-test", 86400, "1"]
154 )
155 result = Transaction.sale(
156 customer(plan_name: "test_usd"),
157 amount: 99,
158 payment_method: OpenStruct.new(token: "token")
159 ).sync
160 assert_kind_of Transaction, result
161 assert_mock CustomerFinancials::REDIS
162 assert_mock Transaction::REDIS
163 assert_mock TrustLevelRepo::REDIS
164 assert_mock TrustLevelRepo::DB
165 end
166 em :test_sale
167
168 def test_insert
169 Transaction::DB.expect(:transaction, []) do |&block|
170 block.call
171 true
172 end
173 Transaction::DB.expect(
174 :exec,
175 EMPromise.resolve(nil),
176 [
177 String,
178 ["customer", "transaction", Time.at(0), Time.at(7776000), 12]
179 ]
180 )
181 Transaction.new(FAKE_BRAINTREE_TRANSACTION).insert.sync
182 Transaction::DB.verify
183 end
184 em :test_insert
185
186 def test_insert_with_bonus
187 Transaction::DB.expect(:transaction, []) do |&block|
188 block.call
189 true
190 end
191 Transaction::DB.expect(
192 :exec,
193 EMPromise.resolve(nil),
194 [
195 String,
196 ["customer", "transaction", Time.at(0), Time.at(7776000), 100]
197 ]
198 )
199 Transaction::DB.expect(
200 :exec,
201 EMPromise.resolve(nil),
202 [
203 String,
204 ["customer", "bonus_for_transaction", Time.at(0), Time.at(7776000), 3]
205 ]
206 )
207 tx = FAKE_BRAINTREE_TRANSACTION.dup
208 tx.amount = 100
209 Transaction.new(tx).insert.sync
210 Transaction::DB.verify
211 end
212 em :test_insert_with_bonus
213end