def test_make_payment(self): account = self.synchronize(accounts.get(self.connection, self.user_id)) self.assertEqual(0, account.balance) balance = self.synchronize(statistics.get_per_day(self.connection)).balance transaction = self.synchronize(payments.start_transaction(self.connection, self.user_id, 10, merchant_id="test")) self.assertGreater(transaction.id, 0) transaction = self.synchronize(payments.get_one(self.connection, transaction.id)) self.assertEqual(constants.PAYMENT_STATUS_IN_PROCESS, transaction.status) self.assertEqual('test', transaction.merchant_id) record = self.synchronize(journal.get_all(self.connection, self.user_id))[0] self.assertEqual(constants.JOURNAL_STATUS_IN_PROCESS, record.status) active_payments = self.synchronize(payments.get_all(self.connection)) self.assertEqual(transaction.id, active_payments[-1].id) self.assertEqual(constants.PAYMENT_STATUS_IN_PROCESS, active_payments[-1].status) with self.assertRaises(payments.exceptions.Forbidden): self.synchronize(payments.finish_transaction(self.connection, transaction.id, imi_amount=11, status=0)) self.synchronize(payments.finish_transaction(self.connection, transaction.id, imi_amount=10, status=0)) balance_after = self.synchronize(statistics.get_per_day(self.connection)).balance self.assertEqual(balance.total + 10, balance_after.total) self.assertEqual(balance.debit, balance_after.debit) account = self.synchronize(accounts.get(self.connection, self.user_id)) self.assertEqual(10, account.balance) record = self.synchronize(journal.get_all(self.connection, self.user_id))[0] self.assertEqual(constants.BANK_USER_ID, record.other_user_id) self.assertEqual(journal.ObjectClass.payments.value, record.object_class) self.assertEqual(transaction.id, record.object_id) self.assertEqual(10, record.amount) self.assertEqual(constants.JOURNAL_STATUS_SUCCESS, record.status)
def test_withdraw_fail_if_not_enough_money(self): self.add_money_for(self.user_id, 10) account = self.synchronize(accounts.get(self.connection, self.user_id)) self.assertEqual(10, account.balance) with self.assertRaises(withdraw_queue.exceptions.NotEnoughMoney): self.synchronize(withdraw_queue.put( self.connection, self.user_id, 50, '{"wallet": "test wallet"}' )) account = self.synchronize(accounts.get(self.connection, self.user_id)) self.assertEqual(10, account.balance)
def test_no_payment_if_transaction_fail(self): account = self.synchronize(accounts.get(self.connection, self.user_id)) self.assertEqual(0, account.balance) transaction = self.synchronize(payments.start_transaction(self.connection, self.user_id, 10)) self.synchronize(payments.finish_transaction(self.connection, transaction.id, 10, 1)) account = self.synchronize(accounts.get(self.connection, self.user_id)) self.assertEqual(0, account.balance) record = self.synchronize(journal.get_all(self.connection, self.user_id))[0] self.assertEqual(constants.JOURNAL_STATUS_ERROR, record.status)
def test_no_double_payment_for_one_transaction(self): account = self.synchronize(accounts.get(self.connection, self.user_id)) self.assertEqual(0, account.balance) transaction = self.synchronize(payments.start_transaction(self.connection, self.user_id, 10)) self.synchronize(payments.finish_transaction(self.connection, transaction.id, 10, 0)) account = self.synchronize(accounts.get(self.connection, self.user_id)) self.assertEqual(10, account.balance) self.synchronize(payments.finish_transaction(self.connection, transaction.id, 10, 0)) account = self.synchronize(accounts.get(self.connection, self.user_id)) self.assertEqual(10, account.balance) records = self.synchronize(journal.get_all(self.connection, self.user_id)) self.assertEqual(2, len(records))
def test_withdraw_money(self): stats1 = self.synchronize(statistics.get_per_day(self.connection)) self.add_money_for(self.user_id, 100) account = self.synchronize(accounts.get(self.connection, self.user_id)) self.assertEqual(100, account.balance) stats2 = self.synchronize(statistics.get_per_day(self.connection)) withdraw_record = self.synchronize(withdraw_queue.put( self.connection, self.user_id, 50, '{"wallet": "test wallet"}' )) records = self.synchronize(journal.get_all(self.connection, self.user_id)) # withdraw self.assertEqual(constants.BANK_USER_ID, records[0].other_user_id) self.assertEqual(journal.ObjectClass.withdraw.value, records[0].object_class) self.assertEqual(withdraw_record.id, records[0].object_id) self.assertEqual(-50, records[0].amount) self.assertEqual(constants.JOURNAL_STATUS_IN_PROCESS, records[0].status) stats3 = self.synchronize(statistics.get_per_day(self.connection)) self.assertEqual(stats2.withdraw_queue.size + 1, stats3.withdraw_queue.size) self.assertEqual(stats1.balance.total + 100, stats2.balance.total) self.assertEqual(stats1.balance.debit, stats2.balance.debit) self.assertEqual(stats2.balance.total, stats3.balance.total) self.assertEqual(stats2.balance.debit, stats3.balance.debit) self.assertEqual(stats2.balance.credit + 50, stats3.balance.credit) account = self.synchronize(accounts.get(self.connection, self.user_id)) self.assertEqual(50, account.balance) self.assertEqual(50, account.frozen) withdraw_record = self.synchronize(withdraw_queue.get_all(self.connection))[-1] self.synchronize(withdraw_queue.complete(self.connection, withdraw_record.id)) records = self.synchronize(journal.get_all(self.connection, self.user_id)) # withdraw self.assertEqual(withdraw_record.id, records[0].object_id) self.assertEqual(-50, records[0].amount) self.assertEqual(constants.BANK_USER_ID, records[0].other_user_id) self.assertEqual(journal.ObjectClass.withdraw.value, records[0].object_class) self.assertEqual(constants.JOURNAL_STATUS_SUCCESS, records[0].status) stats4 = self.synchronize(statistics.get_per_day(self.connection)) self.assertEqual(stats3.withdraw_queue.size - 1, stats4.withdraw_queue.size) self.assertEqual(stats3.balance.total - 50, stats4.balance.total) self.assertEqual(stats3.balance.credit - 50, stats4.balance.credit) self.assertEqual( constants.WITHDRAW_STATUS_SUCCESS, self.synchronize(withdraw_queue.get_one(self.connection, withdraw_record.id)).status ) withdraw_records = self.synchronize(withdraw_queue.get_all(self.connection)) self.assertNotIn(withdraw_record.id, {x.id for x in withdraw_records})
def test_get_for_user(self): self.add_money_for(self.user_id, 100) account = self.synchronize(accounts.get(self.connection, self.user_id)) self.assertEqual(100, account.balance) record = self.synchronize(withdraw_queue.put( self.connection, self.user_id, 50, '{"wallet": "test wallet"}' )) records = self.synchronize(withdraw_queue.get_for_user(self.connection, self.user_id)) self.assertIn(record.id, {x.id for x in records})
def test_rollback_completed(self): self.add_money_for(self.user_id, 100) request = self.synchronize(withdraw_queue.put(self.connection, self.user_id, 20, '{}')) self.synchronize(withdraw_queue.complete(self.connection, request.id)) self.synchronize(withdraw_queue.rollback(self.connection, request.id)) account = self.synchronize(accounts.get(self.connection, self.user_id)) self.assertEqual(80, account.balance) self.assertEqual(0, account.frozen)
def test_rollback_active(self): self.add_money_for(self.user_id, 100) request = self.synchronize(withdraw_queue.put(self.connection, self.user_id, 20, '{}')) self.synchronize(withdraw_queue.rollback(self.connection, request.id)) record = self.synchronize(journal.get_all(self.connection, self.user_id))[0] self.assertEqual(constants.JOURNAL_STATUS_ROLLBACK, record.status) self.assertEqual(journal.ObjectClass.withdraw.value, record.object_class) account = self.synchronize(accounts.get(self.connection, self.user_id)) self.assertEqual(100, account.balance) self.assertEqual(0, account.frozen) request = self.synchronize(withdraw_queue.get_one(self.connection, request.id)) self.assertEqual(constants.WITHDRAW_STATUS_ROLLBACK, request.status)
def test_clean(self): transaction = self.synchronize(payments.start_transaction(self.connection, self.user_id, 10)) self.synchronize(payments.finish_transaction(self.connection, transaction.id, imi_amount=10, status=0)) account = self.synchronize(accounts.get(self.connection, self.user_id)) self.assertEqual(10, account.balance) self.synchronize(payments.finish_transaction(self.connection, transaction.id, imi_amount=10, status=0)) transaction = self.synchronize(payments.get_one(self.connection, transaction.id)) self.synchronize(payments.clean(self.connection, -1)) with self.assertRaises(payments.exceptions.NotFound): self.synchronize(payments.get_one(self.connection, transaction.id)) records = self.synchronize(journal.get_all(self.connection, self.user_id)) obj_ids = {x.object_id for x in records if x.object_class == journal.ObjectClass.payments.value} self.assertNotIn(transaction.id, obj_ids)
def test_payments_add_card_to_black_list_if_error(self): card_number = str(uuid.uuid4()) transaction = self.synchronize(payments.start_transaction(self.connection, self.user_id, 10, card_number=card_number)) self.synchronize(payments.finish_transaction(self.connection, transaction.id, imi_amount=10, status=constants.PAYMENT_STATUS_NOT_ENOUGH_MONEY)) with self.assertRaisesRegex(payments.exceptions.Forbidden, 'ID: %s' % card_number): self.synchronize(payments.start_transaction(self.connection, self.user_id, 10, card_number=card_number)) transaction = self.synchronize(payments.start_transaction(self.connection, self.user_id, 10, card_number=card_number, black_list_tolerance=1)) self.synchronize(payments.finish_transaction(self.connection, transaction.id, imi_amount=10, status=constants.PAYMENT_STATUS_NOT_ENOUGH_MONEY)) with self.assertRaisesRegex(payments.exceptions.Forbidden, 'ID: %s' % card_number): self.synchronize(payments.start_transaction(self.connection, self.user_id, 10, card_number=card_number, black_list_tolerance=1)) account = self.synchronize(accounts.get(self.connection, self.user_id)) self.assertEqual(0, account.balance)
def test_clean(self): self.add_money_for(self.user_id, 100) account = self.synchronize(accounts.get(self.connection, self.user_id)) self.assertEqual(100, account.balance) record = self.synchronize(withdraw_queue.put( self.connection, self.user_id, 50, '{"wallet": "test wallet"}' )) self.synchronize(withdraw_queue.complete(self.connection, record.id)) self.synchronize(withdraw_queue.clean(self.connection, -1)) with self.assertRaises(withdraw_queue.exceptions.NotFound): self.synchronize(withdraw_queue.get_one(self.connection, record.id)) records = self.synchronize(journal.get_all(self.connection, self.user_id)) obj_ids = {x.object_id for x in records if x.object_class == journal.ObjectClass.withdraw.value} self.assertNotIn(record.id, obj_ids)
def test_put(self): user_id, user_email = self.user_id_and_email() account = self.synchronize( accounts.put(self.connection, user_id=user_id, user_email=user_email)) self.assertEqual(user_id, account.user_id) account = self.synchronize( accounts.get(self.connection, user_id=user_id)) self.assertEqual(user_id, account.user_id) self.assertEqual(0, account.balance) self.synchronize( accounts.put(self.connection, user_id=user_id, user_email=user_email))
def test_rollback_one_payment(self): stats_before = self.synchronize(statistics.get_per_day( self.connection)) payment = self.add_money_for(self.user_id, 50) result = self.synchronize( actions.rollback_payment(self.connection, payment.id)) self.assertEqual(1, len(result)) self.assertEqual({'actual': 50, 'total': 50}, result[self.user_id]) payment = self.synchronize( payments.get_one(self.connection, payment.id)) self.assertEqual(constants.PAYMENT_STATUS_ROLLBACK, payment.status) log = self.synchronize(journal.get_all(self.connection, self.user_id)) self.assertEqual(constants.JOURNAL_STATUS_ROLLBACK, log[0].status) account = self.synchronize(accounts.get(self.connection, self.user_id)) self.assertEqual((0, 0), (account.balance, account.frozen)) stats_after = self.synchronize(statistics.get_per_day(self.connection)) self.assertEqual(stats_before.balance, stats_after.balance)
def test_get_raise_not_found(self): user_id, _ = self.user_id_and_email() with self.assertRaises(exceptions.NotFound): self.synchronize(accounts.get(self.connection, user_id=user_id))