1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
|
import re
import time
import datetime
from tests.test_helper import *
from braintree.test.credit_card_numbers import CreditCardNumbers
class TestDisputes(unittest.TestCase):
def create_evidence_document(self):
file_path = os.path.join(os.path.dirname(__file__), "..", "fixtures/bt_logo.png")
png_file = open(file_path, "rb")
return DocumentUpload.create({
"kind": braintree.DocumentUpload.Kind.EvidenceDocument,
"file": png_file
}).document_upload
def create_sample_dispute(self):
return Transaction.sale({
"amount": "100.00",
"credit_card": {
"number": CreditCardNumbers.Disputes.Chargeback,
"expiration_date": "12/2019"
}
}).transaction.disputes[0]
def test_accept_changes_dispute_status_to_accepted(self):
dispute = self.create_sample_dispute()
result = Dispute.accept(dispute.id)
self.assertTrue(result.is_success)
updated_dispute = Dispute.find(dispute.id)
self.assertEqual(updated_dispute.status, Dispute.Status.Accepted)
dispute_from_transaction = Transaction.find(dispute.transaction.id).disputes[0]
self.assertEqual(dispute_from_transaction.status, Dispute.Status.Accepted)
def test_accept_errors_when_dispute_not_open(self):
result = Dispute.accept("wells_dispute")
self.assertFalse(result.is_success)
self.assertEqual(result.errors.for_object("dispute")[0].code, ErrorCodes.Dispute.CanOnlyAcceptOpenDispute)
self.assertEqual(result.errors.for_object("dispute")[0].message, "Disputes can only be accepted when they are in an Open state")
def test_accept_raises_error_when_dispute_not_found(self):
with self.assertRaisesRegex(NotFoundError, "dispute with id 'invalid-id' not found"):
dispute = Dispute.accept("invalid-id")
def test_add_file_evidence_adds_evidence(self):
dispute = self.create_sample_dispute()
document = self.create_evidence_document()
result = Dispute.add_file_evidence(dispute.id, document.id)
self.assertTrue(result.is_success)
updated_dispute = Dispute.find(dispute.id)
self.assertEqual(updated_dispute.evidence[0].id, result.evidence.id)
def test_add_file_evidence_adds_category_file_evidence(self):
dispute = self.create_sample_dispute()
document = self.create_evidence_document()
result = Dispute.add_file_evidence(dispute.id, { "document_id": document.id, "category": "GENERAL" })
self.assertTrue(result.is_success)
self.assertEqual(result.evidence.category, "GENERAL")
def test_add_file_evidence_raises_error_when_dispute_not_found(self):
with self.assertRaisesRegex(NotFoundError, "dispute with id 'unknown_dispute_id' not found"):
dispute = Dispute.add_file_evidence("unknown_dispute_id", "text evidence")
def test_add_file_evidence_raises_error_when_dispute_not_open(self):
dispute = self.create_sample_dispute()
document = self.create_evidence_document()
Dispute.accept(dispute.id)
result = Dispute.add_file_evidence(dispute.id, document.id)
self.assertFalse(result.is_success)
self.assertEqual(result.errors.for_object("dispute")[0].code, ErrorCodes.Dispute.CanOnlyAddEvidenceToOpenDispute)
self.assertEqual(result.errors.for_object("dispute")[0].message, "Evidence can only be attached to disputes that are in an Open state")
def test_categorized_file_evidence_for_text_only_category(self):
dispute = self.create_sample_dispute()
document = self.create_evidence_document()
result = Dispute.add_file_evidence(dispute.id, { "document_id": document.id, "category": "DEVICE_ID" })
self.assertFalse(result.is_success)
self.assertEqual(result.errors.for_object("dispute")[0].code, ErrorCodes.Dispute.EvidenceCategoryTextOnly)
self.assertEqual(result.errors.for_object("dispute")[0].message, "Only text evidence can be provided for this category")
def test_categorized_file_evidence_with_unsupported_category(self):
dispute = self.create_sample_dispute()
document = self.create_evidence_document()
result = Dispute.add_file_evidence(dispute.id, { "document_id": document.id, "category": "DOESNOTEXIST" })
self.assertFalse(result.is_success)
self.assertEqual(result.errors.for_object("dispute")[0].code, ErrorCodes.Dispute.CanOnlyCreateEvidenceWithValidCategory)
self.assertEqual(result.errors.for_object("dispute")[0].message, "The category you supplied on the evidence record is not valid")
def test_add_text_evidence_adds_text_evidence(self):
dispute = self.create_sample_dispute()
result = Dispute.add_text_evidence(dispute.id, "text evidence")
evidence = result.evidence
self.assertTrue(result.is_success)
self.assertEqual(evidence.comment, "text evidence")
self.assertIsNotNone(evidence.created_at)
self.assertTrue(re.match("^\w{16,}$", evidence.id))
self.assertIsNone(evidence.sent_to_processor_at)
self.assertIsNone(evidence.url)
self.assertIsNone(evidence.category)
self.assertIsNone(evidence.sequence_number)
def test_add_text_evidence_adds_category_and_sequence_number_text_evidence(self):
dispute = self.create_sample_dispute()
result = Dispute.add_text_evidence(dispute.id, { "content": "PROOF_OF_FULFILLMENT", "category": "DEVICE_ID", "sequence_number": "0" })
self.assertTrue(result.is_success)
evidence = result.evidence
self.assertEqual(evidence.comment, "PROOF_OF_FULFILLMENT")
self.assertEqual(evidence.category, "DEVICE_ID")
self.assertEqual(evidence.sequence_number, 0)
def test_add_text_evidence_raises_error_when_dispute_not_found(self):
with self.assertRaisesRegex(NotFoundError, "Dispute with ID 'unknown_dispute_id' not found"):
dispute = Dispute.add_text_evidence("unknown_dispute_id", "text evidence")
def test_add_text_evidence_raises_error_when_dispute_not_open(self):
dispute = self.create_sample_dispute()
Dispute.accept(dispute.id)
result = Dispute.add_text_evidence(dispute.id, "text evidence")
self.assertFalse(result.is_success)
self.assertEqual(result.errors.for_object("dispute")[0].code, ErrorCodes.Dispute.CanOnlyAddEvidenceToOpenDispute)
self.assertEqual(result.errors.for_object("dispute")[0].message, "Evidence can only be attached to disputes that are in an Open state")
def test_add_text_evidence_shows_new_record_in_find(self):
dispute = self.create_sample_dispute()
evidence = Dispute.add_text_evidence(dispute.id, "text evidence").evidence
refreshed_dispute = Dispute.find(dispute.id)
self.assertEqual(refreshed_dispute.evidence[0].id, evidence.id)
self.assertEqual(refreshed_dispute.evidence[0].comment, "text evidence")
def test_categorized_text_evidence_with_unsupported_category(self):
dispute = self.create_sample_dispute()
result = Dispute.add_text_evidence(dispute.id, { "content": "evidence", "category": "DOESNOTEXIST" })
self.assertFalse(result.is_success)
self.assertEqual(result.errors.for_object("dispute")[0].code, ErrorCodes.Dispute.CanOnlyCreateEvidenceWithValidCategory)
self.assertEqual(result.errors.for_object("dispute")[0].message, "The category you supplied on the evidence record is not valid")
def test_categorized_text_evidence_with_file_category(self):
dispute = self.create_sample_dispute()
result = Dispute.add_text_evidence(dispute.id, { "content": "evidence", "category": "MERCHANT_WEBSITE_OR_APP_ACCESS" })
self.assertFalse(result.is_success)
self.assertEqual(result.errors.for_object("dispute")[0].code, ErrorCodes.Dispute.EvidenceCategoryDocumentOnly)
self.assertEqual(result.errors.for_object("dispute")[0].message, "Only document evidence can be provided for this category")
def test_categorized_text_evidence_with_invalid_date_time_format(self):
dispute = self.create_sample_dispute()
result = Dispute.add_text_evidence(dispute.id, { "content": "not a date", "category": "DOWNLOAD_DATE_TIME" })
self.assertFalse(result.is_success)
self.assertEqual(result.errors.for_object("dispute")[0].code, ErrorCodes.Dispute.EvidenceContentDateInvalid)
def test_categorized_text_evidence_with_valid_date_time_format(self):
dispute = self.create_sample_dispute()
result = Dispute.add_text_evidence(dispute.id, { "content": "2018-10-20T18:00:00-0500", "category": "DOWNLOAD_DATE_TIME" })
self.assertTrue(result.is_success)
def test_add_text_evidence_adds_category_and_shipping_tracking_carrier_name(self):
dispute = self.create_sample_dispute()
result = Dispute.add_text_evidence(dispute.id, { "content": "UPS", "category": "CARRIER_NAME", "sequence_number": "0" })
self.assertTrue(result.is_success)
evidence = result.evidence
self.assertEqual(evidence.comment, "UPS")
self.assertEqual(evidence.category, "CARRIER_NAME")
self.assertEqual(evidence.sequence_number, 0)
def test_add_text_evidence_adds_category_and_shipping_tracking_tracking_number(self):
dispute = self.create_sample_dispute()
result = Dispute.add_text_evidence(dispute.id, { "content": "3", "category": "TRACKING_NUMBER", "sequence_number": "0" })
self.assertTrue(result.is_success)
evidence = result.evidence
self.assertEqual(evidence.comment, "3")
self.assertEqual(evidence.category, "TRACKING_NUMBER")
self.assertEqual(evidence.sequence_number, 0)
def test_add_text_evidence_adds_category_and_shipping_tracking_tracking_url(self):
dispute = self.create_sample_dispute()
result = Dispute.add_text_evidence(dispute.id, { "content": "https://example.com/tracking-number/abc12345", "category": "TRACKING_URL", "sequence_number": "1" })
self.assertTrue(result.is_success)
evidence = result.evidence
self.assertEqual(evidence.comment, "https://example.com/tracking-number/abc12345")
self.assertEqual(evidence.category, "TRACKING_URL")
self.assertEqual(evidence.sequence_number, 1)
def test_finalize_changes_dispute_status_to_disputed(self):
dispute = self.create_sample_dispute()
result = Dispute.finalize(dispute.id)
self.assertTrue(result.is_success)
updated_dispute = Dispute.find(dispute.id)
self.assertEqual(updated_dispute.status, Dispute.Status.Disputed)
def test_finalize_errors_when_dispute_not_open(self):
result = Dispute.finalize("wells_dispute")
self.assertFalse(result.is_success)
self.assertEqual(result.errors.for_object("dispute")[0].code, ErrorCodes.Dispute.CanOnlyFinalizeOpenDispute)
self.assertEqual(result.errors.for_object("dispute")[0].message, "Disputes can only be finalized when they are in an Open state")
def test_finalize_when_digital_goods_missing(self):
dispute = self.create_sample_dispute()
result = Dispute.add_text_evidence(dispute.id, { "content": "device_id", "category": "DEVICE_ID" })
self.assertTrue(result.is_success)
result = dispute.finalize(dispute.id)
self.assertFalse(result.is_success)
error_codes = [error.code for error in result.errors.for_object("dispute")]
self.assertIn(ErrorCodes.Dispute.DigitalGoodsMissingDownloadDate, error_codes)
self.assertIn(ErrorCodes.Dispute.DigitalGoodsMissingEvidence, error_codes)
def test_finalize_when_missing_non_disputed_payments_date(self):
dispute = self.create_sample_dispute()
result = Dispute.add_text_evidence(dispute.id, { "content": "123", "category": "PRIOR_NON_DISPUTED_TRANSACTION_ARN" })
self.assertTrue(result.is_success)
result = dispute.finalize(dispute.id)
self.assertFalse(result.is_success)
error_codes = [error.code for error in result.errors.for_object("dispute")]
self.assertIn(ErrorCodes.Dispute.NonDisputedPriorTransactionEvidenceMissingDate, error_codes)
def test_finalize_raises_error_when_dispute_not_found(self):
with self.assertRaisesRegex(NotFoundError, "dispute with id 'invalid-id' not found"):
dispute = Dispute.finalize("invalid-id")
def test_find_returns_dispute_with_given_id(self):
dispute = Dispute.find("open_dispute")
self.assertEqual(dispute.amount_disputed, 31.0)
self.assertEqual(dispute.amount_won, 0.0)
self.assertEqual(dispute.id, "open_dispute")
self.assertEqual(dispute.status, Dispute.Status.Open)
self.assertEqual(dispute.transaction.id, "open_disputed_transaction")
self.assertEqual(None, dispute.transaction.installment_count)
self.assertNotEqual(None, dispute.graphql_id)
def test_find_raises_error_when_dispute_not_found(self):
with self.assertRaisesRegex(NotFoundError, "dispute with id 'invalid-id' not found"):
dispute = Dispute.find("invalid-id")
def test_delete_customer_with_path_traversal(self):
try:
customer = Customer.create({"first_name":"Waldo"}).customer
dispute = self.create_sample_dispute()
Dispute.remove_evidence(dispute.id, "../../../customers/{}".format(customer.id))
except NotFoundError:
pass
found_customer = Customer.find(customer.id)
self.assertNotEqual(None, found_customer)
self.assertEqual("Waldo", found_customer.first_name)
def test_remove_evidence_removes_evidence_from_the_dispute(self):
dispute = self.create_sample_dispute()
evidence = Dispute.add_text_evidence(dispute.id, "text evidence").evidence
result = Dispute.remove_evidence(dispute.id, evidence.id)
self.assertTrue(result.is_success)
def test_remove_evidence_raises_error_when_dispute_or_evidence_not_found(self):
with self.assertRaisesRegex(NotFoundError, "evidence with id 'unknown_evidence_id' for dispute with id 'unknown_dispute_id' not found"):
Dispute.remove_evidence("unknown_dispute_id", "unknown_evidence_id")
def test_remove_evidence_errors_when_dispute_not_open(self):
dispute = self.create_sample_dispute()
evidence = Dispute.add_text_evidence(dispute.id, "text evidence").evidence
Dispute.accept(dispute.id)
result = Dispute.remove_evidence(dispute.id, evidence.id)
self.assertFalse(result.is_success)
self.assertEqual(result.errors.for_object("dispute")[0].code, ErrorCodes.Dispute.CanOnlyRemoveEvidenceFromOpenDispute)
self.assertEqual(result.errors.for_object("dispute")[0].message, "Evidence can only be removed from disputes that are in an Open state")
|
