def test_routing_slip_find_search(session):
"""Assert a routing slip is stored.
Start with a blank database.
"""
payment_account = factory_payment_account()
payment_account.save()
rs = factory_routing_slip(number=fake.name(),
payment_account_id=payment_account.id)
rs.save()
for i in range(20):
factory_routing_slip(number=fake.name(),
payment_account_id=payment_account.id).save()
routing_slip = RoutingSlip()
search_dict = {'routingSlipNumber': rs.number}
res, count = routing_slip.search(search_dict,
page=1,
limit=1,
return_all=True)
assert count == 1
assert len(res) == 1, 'searched with routing slip.so only one record'
res, count = routing_slip.search({}, page=1, limit=1, return_all=True)
assert count == 21
assert len(res) == 21, 'retun all true ;so shud return all records'
res, count = routing_slip.search({}, page=1, limit=1, return_all=False)
assert count == 1
assert len(res) == 1, 'return all false'
def test_create_comment(session, monkeypatch):
"""Assert create comment."""
# create a routing slip
# create a comment
# retrieve all comments of a routing slip
def token_info(): # pylint: disable=unused-argument; mocks of library methods
return {
'username': '******',
'realm_access': {
'roles': ['system', 'edit']
}
}
def mock_auth(): # pylint: disable=unused-argument; mocks of library methods
return 'test'
monkeypatch.setattr('pay_api.utils.user_context._get_token', mock_auth)
monkeypatch.setattr('pay_api.utils.user_context._get_token_info',
token_info)
payment_account = factory_payment_account()
payment_account.save()
rs = factory_routing_slip(payment_account_id=payment_account.id,
number='test_number')
rs.save()
CommentService.create(comment_value='test', rs_number=rs.number)
result = CommentService.find_all_comments_for_a_routingslip(rs.number)
assert result
comments = result.get('comments')
assert len(comments) == 1
assert comments[0].get('routing_slip_number') == rs.number
def test_create_payment_record_with_internal_pay(session, public_user_mock):
"""Assert that the payment records are created."""
# Create invoice without routing slip.
payment_response = PaymentService.create_invoice(
get_routing_slip_payment_request(), get_auth_staff())
account_model = PaymentAccount.find_by_auth_account_id(get_auth_staff().get('account').get('id'))
account_id = account_model.id
assert account_id is not None
assert payment_response.get('id') is not None
rs_number = '123456789'
rs = factory_routing_slip(number=rs_number, payment_account_id=account_id, remaining_amount=50.00)
rs.save()
# Create another invoice with a routing slip.
PaymentService.create_invoice(get_routing_slip_payment_request(), get_auth_staff())
account_model = PaymentAccount.find_by_auth_account_id(get_auth_staff().get('account').get('id'))
assert account_id == account_model.id
rs = RoutingSlipModel.find_by_number(rs_number)
assert rs.remaining_amount == 0.0
"""12033 - Scenario 1.
Manual transaction reduces RS to 0.00
Routing slip status becomes Completed
"""
assert rs.status == RoutingSlipStatus.COMPLETE.name
def test_internal_rs_back_active(session, public_user_mock):
"""12033 - Scenario 2.
Routing slip is complete and a transaction is cancelled
the balance is restored - Should move back to Active
"""
payment_response = PaymentService.create_invoice(
get_routing_slip_payment_request(), get_auth_staff())
account_model = PaymentAccount.find_by_auth_account_id(get_auth_staff().get('account').get('id'))
account_id = account_model.id
assert account_id is not None
assert payment_response.get('id') is not None
rs_number = '123456789'
rs = factory_routing_slip(number=rs_number, payment_account_id=account_id, remaining_amount=50.00)
rs.save()
# Create another invoice with a routing slip.
invoice = PaymentService.create_invoice(get_routing_slip_payment_request(), get_auth_staff())
account_model = PaymentAccount.find_by_auth_account_id(get_auth_staff().get('account').get('id'))
assert account_id == account_model.id
rs = RoutingSlipModel.find_by_number(rs_number)
assert rs.remaining_amount == 0.0
assert rs.status == RoutingSlipStatus.COMPLETE.name
invoice = Invoice.find_by_id(invoice['id'])
InternalPayService().process_cfs_refund(invoice)
assert rs.status == RoutingSlipStatus.ACTIVE.name
def test_routing_slip_find_creation(session):
"""Assert a routing slip is stored.
Start with a blank database.
"""
payment_account = factory_payment_account()
payment_account.save()
rs = factory_routing_slip(payment_account_id=payment_account.id)
rs.save()
assert rs.id is not None
routing_slip = RoutingSlip()
assert routing_slip.find_by_number(rs.number) is not None
def test_get_links(session):
"""Assert routing slip functionalities comprehensively."""
payment_account = factory_payment_account()
payment_account.save()
child_rs = factory_routing_slip(payment_account_id=payment_account.id,
total=10,
remaining_amount=5)
child_rs.save()
parent_payment_account2 = factory_payment_account()
parent_payment_account2.save()
parent_rs = factory_routing_slip(
payment_account_id=parent_payment_account2.id,
total=100,
remaining_amount=50)
parent_rs.save()
links = RoutingSlip_service.get_links(child_rs.number)
assert not links.get('parent', None)
assert len(links.get('children')) == 0
# link now
child = RoutingSlip_service.do_link(child_rs.number, parent_rs.number)
assert child.get('status') == RoutingSlipStatus.LINKED.value
assert child.get('total') == child_rs.total
assert child.get('remaining_amount') == 0
# do a search for parent
results = RoutingSlip_service.search(
{'routingSlipNumber': parent_rs.number}, page=1, limit=1)
parent_rs_from_search = results.get('items')[0]
assert parent_rs_from_search.get(
'remaining_amount'
) == child_rs.remaining_amount + parent_rs.remaining_amount
assert parent_rs_from_search.get('total') == parent_rs.total
def test_find_comment(session):
"""Assert a comment is stored and fetched."""
# Create a payment account and routing slip and then a comment record
payment_account = factory_payment_account()
payment_account.save()
rs = factory_routing_slip(payment_account_id=payment_account.id)
rs.save()
comments = factory_comments(routing_slip_number=rs.number)
comments.save()
fetched_comment = CommentModel.find_all_comments_for_a_routingslip(
routing_slip_number=rs.number
)
assert fetched_comment
assert fetched_comment[0].routing_slip_number == rs.number
def test_create_payment_record_with_rs(session, public_user_mock):
"""Assert that the payment records are created and completed."""
payment_account = factory_payment_account()
payment_account.save()
rs = factory_routing_slip(payment_account_id=payment_account.id, total=1000, remaining_amount=1000)
rs.save()
cfs_response = Mock(spec=Response)
cfs_response.json.return_value = {'invoice_number': 'abcde', }
cfs_response.status_code = 200
request = get_payment_request()
request['accountInfo'] = {'routingSlip': rs.number}
with patch.object(CFSService, 'create_account_invoice', return_value=cfs_response) as mock_post:
PaymentService.create_invoice(request, get_auth_basic_user())
mock_post.assert_called()
request = get_zero_dollar_payment_request()
request['accountInfo'] = {'routingSlip': rs.number}
with patch.object(CFSService, 'create_account_invoice', return_value=cfs_response) as mock_post:
PaymentService.create_invoice(request, get_auth_basic_user())
mock_post.assert_not_called()