def test_disbursement_conditions(test_client, authed_sempo_admin_user, tier, initial_disbursement, is_approved, transfer_status, transfer_account_approver_tier, account_approval_http_status, final_transfer_status, final_is_approved): authed_sempo_admin_user.set_held_role('ADMIN', tier) auth = get_complete_auth_token(authed_sempo_admin_user) # Create user! payload = { 'first_name': 'Francine', 'last_name': 'Frensky', 'gender': 'female', 'phone': f'+1{random.randint(1000000000, 9999999999)}', 'account_types': ['beneficiary'], 'location': 'Elwood', 'initial_disbursement': initial_disbursement, } response = test_client.post("/api/v1/user/", headers=dict(Authorization=auth, Accept='application/json'), json=payload) transfer_account_id = response.json['data']['user'][ 'default_transfer_account_id'] transfer_account = db.session.query(TransferAccount)\ .filter(TransferAccount.id == transfer_account_id)\ .first() assert transfer_account.is_approved == is_approved assert len(transfer_account.credit_receives) == 1 disbursement = transfer_account.credit_receives[0] assert disbursement.is_initial_disbursement == True assert disbursement.transfer_status == transfer_status authed_sempo_admin_user.set_held_role('ADMIN', transfer_account_approver_tier) auth = get_complete_auth_token(authed_sempo_admin_user) response = test_client.put( f"/api/v1/transfer_account/{transfer_account_id}/", headers=dict(Authorization=auth, Accept='application/json'), json={'approve': True}) assert response.status_code == account_approval_http_status if account_approval_http_status == 201: transfer_account = db.session.query(TransferAccount)\ .filter(TransferAccount.id == transfer_account_id)\ .first() assert len( transfer_account.credit_receives ) == 1 # Make sure we don't get a double-disbursement on account approval disbursement = transfer_account.credit_receives[0] assert disbursement.transfer_status == final_transfer_status assert transfer_account.is_approved == final_is_approved
def test_dataset_api(test_client, authed_sempo_admin_user): auth = get_complete_auth_token(authed_sempo_admin_user) fake_id = 'abc' response = test_client.get( f"/api/v1/async/{fake_id}/", headers=dict( Authorization=auth, Accept='application/json', ), ) assert response.json == { 'message': 'Async job with ID abc for user 1 does not exist!' } new_key = executor.get_job_key(1, 'abcd-efgh-ijkl') red.set(new_key, json.dumps({'data': 'alf'})) response = test_client.get( f"/api/v1/async/abcd-efgh-ijkl/", headers=dict( Authorization=auth, Accept='application/json', ), ) assert response.json == {'data': 'alf'}
def test_process_vendor_payout_approve(test_client, authed_sempo_admin_user, create_transfer_account_user, mock_sms_apis): config.PAYOUT_SMS = True auth = get_complete_auth_token(authed_sempo_admin_user) user = create_transfer_account_user user.transfer_account.is_vendor = True user.set_held_role('VENDOR', 'supervendor') user.transfer_account.approve_and_disburse() user.transfer_account.organisation = authed_sempo_admin_user.organisations[0] user.transfer_account.set_balance_offset(1000) user.transfer_account.is_approved=True user.is_phone_verified = True user.phone = '+19025551234' user.kyc_applications[0].kyc_status = 'VERIFIED' db.session.commit() test_client.post( f"/api/v1/process_vendor_payout/", headers=dict( Authorization=auth, Accept='application/json', ), json={ 'csv_data': f"""ID,Phone,First Name,Last Name,Created,Current Balance,Total Sent,Total Received,Approved,Beneficiary,Vendor,Transfer ID,UnitAmount,Payment Has Been Made,Bank Payment Date\n4,{user.phone},Transfer,User,SOME DATE,10.0,10.000000000000,0,True,False,True,1,10.0,TRUE,09/30/2020""" } ) messages = mock_sms_apis transfer = user.transfer_account.credit_sends[0] assert transfer.transfer_status == TransferStatusEnum.COMPLETE assert messages[0] == {'phone': '+19025551234', 'message': 'Hello Transfer, a total of 10 AUD has been deposited into your account.'} transfer.transfer_status = TransferStatusEnum.PENDING
def test_delete_user(test_client, authed_sempo_admin_user, create_transfer_account_user, create_credit_transfer, user_id_accessor, tier, message, status_code): create_transfer_account_user.transfer_account.set_balance_offset(1000) if message == 'Balance must be zero' or message == 'Resource Already Deleted': create_credit_transfer.resolve_as_rejected() db.session.commit() if message == 'deleted': create_credit_transfer.resolve_as_complete() db.session.commit() if tier: authed_sempo_admin_user.set_held_role('ADMIN', tier) auth = get_complete_auth_token(authed_sempo_admin_user) else: auth = None response = test_client.delete( f"/api/v1/user/{user_id_accessor(create_transfer_account_user)}/", headers=dict(Authorization=auth, Accept='application/json')) assert response.status_code == status_code assert message in response.json[ 'message'] # in operator as annoying to make ID dynamic if create_credit_transfer.transfer_status == TransferStatusEnum.PENDING: create_credit_transfer.resolve_as_rejected() db.session.commit()
def test_create_credit_transfer(test_client, authed_sempo_admin_user, create_transfer_account_user, create_credit_transfer, transfer_amount, target_balance, credit_transfer_uuid_selector_func, recipient_transfer_accounts_ids_accessor, sender_user_id_accessor, recipient_user_id_accessor, transfer_type, tier, transfer_status ,invert_recipient_list, status_code): recipient_transfer_accounts_ids = recipient_transfer_accounts_ids_accessor(create_transfer_account_user) if recipient_transfer_accounts_ids: recipient_transfer_accounts_ids = [recipient_transfer_accounts_ids] # Hack to prevent previous tests from causing future tests to fail # TODO: Change design of entire testing process to enable quick setup of blockchain etc, but not have tests so path dependent create_transfer_account_user.credit_sends = [] create_transfer_account_user.credit_receives = [] sender_user_id = sender_user_id_accessor(create_transfer_account_user) recipient_user_id = recipient_user_id_accessor(create_transfer_account_user) if transfer_type == 'PAYMENT' and sender_user_id: create_transfer_account_user.transfer_account.set_balance_offset(1000000) create_transfer_account_user.transfer_account.is_approved = True if tier: authed_sempo_admin_user.set_held_role('ADMIN', tier) auth = get_complete_auth_token(authed_sempo_admin_user) else: auth = None response = test_client.post( '/api/v1/credit_transfer/', headers=dict( Authorization=auth, Accept='application/json' ), data=json.dumps(dict( transfer_amount=transfer_amount, target_balance=target_balance, uuid=credit_transfer_uuid_selector_func(create_credit_transfer), recipient_transfer_accounts_ids=recipient_transfer_accounts_ids, sender_user_id=sender_user_id, recipient_user_id=recipient_user_id, transfer_type=transfer_type, invert_recipient_list=invert_recipient_list )), content_type='application/json', follow_redirects=True) assert_resp_status_code(response, status_code) if response.status_code == 201: data = response.json['data'] is_bulk = response.json.get('bulk_responses', None) if recipient_transfer_accounts_ids: if is_bulk[0].get('status', None) != status_code: print(is_bulk) else: assert data['credit_transfers'][0]['transfer_status'] == transfer_status assert isinstance(data['credit_transfers'], list) else: assert data['credit_transfer']['transfer_status'] == transfer_status assert isinstance(data['credit_transfer'], object)
def test_put_single_transfer_account_api(test_client, authed_sempo_admin_user, create_transfer_account_user_function, transfer_account_id_accessor, tier, status_code): create_transfer_account_user_function.transfer_account.is_beneficiary = True if tier: authed_sempo_admin_user.set_held_role('ADMIN', tier) auth = get_complete_auth_token(authed_sempo_admin_user) else: auth = None response = test_client.put( f"/api/v1/transfer_account/{transfer_account_id_accessor(create_transfer_account_user_function)}/", headers=dict( Authorization=auth, Accept='application/json' ), json={ 'transfer_account_name': 'Acme Mart', 'payable_period_type': 'weekly', 'payable_period_length': '1', 'payable_epoch': '2/7/20', 'approve': True }) assert response.status_code == status_code if response.status_code == 201: assert response.json['data']['transfer_account'] is not None assert response.json['data']['transfer_account'][ 'balance'] == 0
def test_tfa_logic_error(test_client, init_database, authed_sempo_admin_user, no_token, tfa_enabled, invalid_token, invalid_user_id, message): user = authed_sempo_admin_user user.set_held_role('ADMIN', 'superadmin') user.TFA_enabled = tfa_enabled auth = get_complete_auth_token(authed_sempo_admin_user) tfa_token = None if no_token else auth.split('|')[1] if invalid_token: tfa_token = tfa_token + 'foo' if invalid_user_id: # build a fake tfa token with incorrect user ID payload = { 'exp': datetime.datetime.utcnow() + datetime.timedelta(days=1, seconds=30), 'iat': datetime.datetime.utcnow(), 'id': 123 } return jwt.encode(payload, current_app.config['SECRET_KEY'], algorithm='HS256') tfa = tfa_logic(user=user, tfa_token=tfa_token) assert tfa['message'] == message
def test_put_multiple_transfer_account_api(test_client, authed_sempo_admin_user, create_transfer_account_user_function, transfer_account_id_accessor, tier, status_code): create_transfer_account_user_function.transfer_account.is_beneficiary = True create_transfer_account_user_function.transfer_account.is_approved = False if tier: authed_sempo_admin_user.set_held_role('ADMIN', tier) auth = get_complete_auth_token(authed_sempo_admin_user) else: auth = None response = test_client.put( f"/api/v1/transfer_account/", headers=dict( Authorization=auth, Accept='application/json' ), json={ 'transfer_account_id_list': [transfer_account_id_accessor(create_transfer_account_user_function)], 'approve': True }) assert response.status_code == status_code if response.status_code == 201: assert response.json['data']['transfer_accounts'] is not None if transfer_account_id_accessor(create_transfer_account_user_function) == 123123: # This user shouldn't exist assert response.json['data']['transfer_accounts'][0][ 'status'] == 400 # todo(#320): this should be a 404 Status code else: assert response.json['data']['transfer_accounts'][0][ 'balance'] == 0
def test_edit_user(test_client, authed_sempo_admin_user, create_transfer_account_user, user_id_accessor, is_vendor, is_groupaccount, roles, tier, status_code): if tier: authed_sempo_admin_user.set_held_role('ADMIN', tier) auth = get_complete_auth_token(authed_sempo_admin_user) else: auth = None new_phone = fake.msisdn() response = test_client.put( f"/api/v1/user/{user_id_accessor(create_transfer_account_user)}/", headers=dict( Authorization=auth, Accept='application/json' ), json={ 'phone': new_phone, 'account_types': roles }) assert response.status_code == status_code if response.status_code == 200: data = response.json['data'] assert isinstance(data['user'], object) assert data['user']['phone'] == proccess_phone_number(new_phone) assert data['user']['is_vendor'] == is_vendor assert data['user']['is_groupaccount'] == is_groupaccount
def test_process_vendor_payout_reject(test_client, authed_sempo_admin_user, create_transfer_account_user): auth = get_complete_auth_token(authed_sempo_admin_user) user = create_transfer_account_user user.transfer_account.is_vendor = True user.set_held_role('VENDOR', 'supervendor') user.transfer_account.approve_and_disburse() user.transfer_account.organisation = authed_sempo_admin_user.organisations[ 0] user.transfer_account.set_balance_offset(1000) user.transfer_account.is_approved = True user.is_phone_verified = True user.kyc_applications[0].kyc_status = 'VERIFIED' db.session.commit() test_client.post( f"/api/v1/process_vendor_payout/", headers=dict( Authorization=auth, Accept='application/json', ), json={ 'csv_data': f"""ID,Phone,First Name,Last Name,Created,Current Balance,Total Sent,Total Received,Approved,Beneficiary,Vendor,Transfer ID,UnitAmount,Payment Has Been Made,Bank Payment Date\n4,{user.phone},Transfer,User,SOME DATE,10.0,10.000000000000,0,True,False,True,1,10.0,FALSE,09/30/2020""" }) transfer = user.transfer_account.credit_sends[0] assert transfer.transfer_status == TransferStatusEnum.REJECTED transfer.transfer_status = TransferStatusEnum.PENDING
def test_exchange(test_client, user_with_reserve_balance, initialised_blockchain_network, from_token, to_token, from_amount, status_code): from_token_obj = initialised_blockchain_network[from_token] to_token_obj = initialised_blockchain_network[to_token] response = test_client.post( '/api/v1/me/exchange/', headers=dict( Authorization=get_complete_auth_token(user_with_reserve_balance), Accept='application/json'), json={ 'from_token_id': from_token_obj.id, 'to_token_id': to_token_obj.id, 'from_amount': from_amount }) assert response.status_code == status_code if status_code == 200 and will_func_test_blockchain(): task_uuid = response.json['data']['exchange']['blockchain_task_uuid'] time.sleep( 1) # Have to wait til after_request for task to be submitted result = bt.await_task_success(task_uuid, timeout=config.SYNCRONOUS_TASK_TIMEOUT * 12) assert result['status'] == 'SUCCESS'
def test_get_vendor_payout_with_withdrawal_limit(test_client, authed_sempo_admin_user, create_transfer_account_user): authed_sempo_admin_user.organisations[ 0].minimum_vendor_payout_withdrawal = 200 auth = get_complete_auth_token(authed_sempo_admin_user) user = create_transfer_account_user user.transfer_account.is_vendor = True user.set_held_role('VENDOR', 'supervendor') user.transfer_account.approve_and_disburse() user.transfer_account.organisation = authed_sempo_admin_user.organisations[ 0] user.transfer_account.set_balance_offset(100) user.is_phone_verified = True kyc = KycApplication(type='INDIVIDUAL') user.kyc_applications = [kyc] user.kyc_applications[0].kyc_status = 'VERIFIED' db.session.commit() response = test_client.post(f"/api/v1/get_vendor_payout/", headers=dict( Authorization=auth, Accept='application/json', ), data=json.dumps(dict({}))) assert len(user.transfer_account.credit_sends) == 0
def test_mock_data(test_client, authed_sempo_admin_user, create_transfer_usage, safety_check, balance, status_code): users = db.session.query(func.count(User.id)).scalar() authed_sempo_admin_user.set_held_role('ADMIN', 'superadmin') auth = get_complete_auth_token(authed_sempo_admin_user) authed_sempo_admin_user.transfer_accounts.append( authed_sempo_admin_user.default_organisation.org_level_transfer_account ) if len(authed_sempo_admin_user.transfer_accounts) == 0 else None authed_sempo_admin_user.default_organisation.org_level_transfer_account.set_balance_offset(10000) if balance \ else None db.session.commit() response = test_client.post('/api/v1/mock_data/', headers=dict(Authorization=auth, Accept='application/json'), json={ 'number_of_users': 1, 'number_of_transfers': 12, 'number_of_days': 2, 'safety_check': users if safety_check else None, }) assert response.status_code == status_code
def test_create_permissions_api(test_client, authed_sempo_admin_user, creator_tier, email, invitee_tier, organisation_id_selector, response_code): """ GIVEN a Flask application WHEN A new email is POSTED to '/api/auth/permissions/' THEN check it is added successfully """ authed_sempo_admin_user.set_held_role('ADMIN', creator_tier) organisation_id = organisation_id_selector(authed_sempo_admin_user) default_org_id = get_admin_default_org_id(authed_sempo_admin_user) response = test_client.post( f'/api/v1/auth/permissions/?org={default_org_id}', headers=dict( Authorization=get_complete_auth_token(authed_sempo_admin_user), Accept='application/json'), json={ 'email': email, 'tier': invitee_tier, 'organisation_id': organisation_id }) assert response.status_code == response_code
def test_create_user(test_client, authed_sempo_admin_user, init_database, create_transfer_account_user, mock_async_set_user_gps_from_location, user_phone_accessor, phone, business_usage_name, referred_by, tier, status_code): if tier: authed_sempo_admin_user.set_held_role('ADMIN', tier) auth = get_complete_auth_token(authed_sempo_admin_user) else: auth = None # create the user who is referring create_transfer_account_user.phone = referred_by user_phone_accessor(create_transfer_account_user) response = test_client.post( "/api/v1/user/", headers=dict( Authorization=auth, Accept='application/json' ), json={ 'first_name': 'John', 'last_name': 'Smith', 'bio': 'EasyMart', 'gender': 'female', 'phone': phone, 'is_vendor': False, 'is_tokenagent': False, 'is_groupaccount': False, 'initial_disbursement': 0, 'location': 'Elwood', 'business_usage_name': business_usage_name, 'referred_by': user_phone_accessor(create_transfer_account_user) }) assert response.status_code == status_code if response.status_code == 200: data = response.json['data'] assert isinstance(data['user'], object) assert data['user']['first_name'] == 'John' assert data['user']['last_name'] == 'Smith' assert data['user']['custom_attributes']['bio'] == 'EasyMart' assert data['user']['custom_attributes']['gender'] == 'female' assert data['user']['phone'] == proccess_phone_number(phone) assert data['user']['is_vendor'] is False assert data['user']['is_tokenagent'] is False assert data['user']['is_groupaccount'] is False assert data['user']['transfer_accounts'][0]['balance'] == 0 assert data['user']['location'] == 'Elwood' assert data['user']['business_usage_id'] == init_database.session.query(TransferUsage)\ .filter_by(name=business_usage_name).first().id assert data['user']['referred_by'] == user_phone_accessor(create_transfer_account_user) # Checks that we're calling the gps location fetching job, and passing the right data to it # Used in lieu of the test below working fn_inputs = mock_async_set_user_gps_from_location args, kwargs = fn_inputs[-1] assert kwargs == {'user_id': data['user']['id'], 'location': 'Elwood'}
def test_get_token(test_client, authed_sempo_admin_user, create_transfer_account_user): authed_sempo_admin_user.set_held_role('ADMIN', 'superadmin') auth = get_complete_auth_token(authed_sempo_admin_user) token_response = test_client.get(f"/api/v1/token/", headers=dict(Authorization=auth, Accept='application/json')) assert token_response.status_code == 200 assert len(token_response.json['data']['tokens']) <= 1
def test_reset_pin_flow(test_client, init_database, create_organisation, authed_sempo_admin_user): # define different session id other_session_id = 'ATUid_05af06225e6163ec2dc9dc9cf8bc97aa000' # create organisation organisation = create_organisation organisation.external_auth_password = config.EXTERNAL_AUTH_PASSWORD # create highest tier admin admin = authed_sempo_admin_user admin.set_held_role('ADMIN', 'sempoadmin') # get admin's auth token auth = get_complete_auth_token(authed_sempo_admin_user) # create self signup user user = UserFactory(id=21, phone='+6185274136', first_name='Unknown first name', last_name='Unknown last name', pin_hash=User.salt_hash_secret('0000'), failed_pin_attempts=0, preferred_language="en", registration_method=RegistrationMethodEnum.USSD_SIGNUP) # bind user to organisation user.add_user_to_organisation(organisation, False) # reset pin as admin response = test_client.post('/api/v1/user/reset_pin/', headers=dict(Authorization=auth, Accept='application/json'), content_type='application/json', json={'user_id': user.id}) assert response.status_code == 200 assert len(user.pin_reset_tokens) > 0 # test user's reset process ussd_resp = req("", test_client, user.phone, session_id=other_session_id) assert "CON Please enter a PIN to manage your account." in ussd_resp ussd_resp = req("1212", test_client, user.phone, session_id=other_session_id) assert "CON Enter your PIN again" in ussd_resp ussd_resp = req("1212", test_client, user.phone, session_id=other_session_id) assert "CON Welcome to Sarafu" in ussd_resp
def test_admin_reset_user_pin( test_client, authed_sempo_admin_user, create_transfer_account_user, reset_user_id_accessor, status_code ): authed_sempo_admin_user.set_held_role('ADMIN', 'superadmin') auth = get_complete_auth_token(authed_sempo_admin_user) user_id = reset_user_id_accessor(create_transfer_account_user) response = test_client.post('/api/v1/user/reset_pin/', headers=dict(Authorization=auth, Accept='application/json'), data=json.dumps(dict(user_id=user_id)), content_type='application/json', follow_redirects=True) assert response.status_code == status_code
def make_new_user_and_token(name='francine', tier='superadmin'): user = User() user.create_admin_auth(email=name + '@withsempo.com', password='******', tier=tier) user.organisations.append(create_organisation) user.default_organisation = create_organisation user.is_activated = True user.set_TFA_secret() user.TFA_enabled = True db.session.commit() return user, get_complete_auth_token(user)
def test_edit_permissions_api(test_client, init_database, authed_sempo_admin_user, user_id, admin_tier, deactivated, invite_id, resend, response_code): authed_sempo_admin_user.set_held_role('ADMIN', 'superadmin') response = test_client.put(f'/api/v1/auth/permissions/', headers=dict( Authorization=get_complete_auth_token(authed_sempo_admin_user), Accept='application/json' ), json={'user_id': user_id, 'admin_tier': admin_tier, 'deactivated': deactivated, 'invite_id': invite_id, 'resend': resend}) assert response.status_code == response_code
def test_get_user_location( test_client, init_database, create_organisation, authed_sempo_admin_user, new_locations, create_temporary_extended_user, ): """ GIVEN an extended user record WHEN adding location to that user THEN the location is retrievable from the user location http api endpoint """ # create organisation organisation = create_organisation organisation.external_auth_password = config.EXTERNAL_AUTH_PASSWORD # create admin admin = authed_sempo_admin_user admin.set_held_role('ADMIN', 'admin') # create user user = create_temporary_extended_user user.full_location = new_locations['leaf'] db.session.commit() user.get_base_user().add_user_to_organisation(organisation, False) # get admin auth token auth = get_complete_auth_token(authed_sempo_admin_user) response = test_client.get( '/api/v2/user/{}/geolocation/'.format(user.id), headers=dict( Authorization=auth, Accept='application/json', ), ) assert response.status_code == 200 i = 0 for k in ['leaf', 'node', 'top']: assert response.json['location'][i]['latitude'] == new_locations[ k].latitude assert response.json['location'][i]['longitude'] == new_locations[ k].longitude assert response.json['location'][i]['common_name'] == new_locations[ k].common_name i += 1
def test_create_bulk_credit_transfer(test_client, authed_sempo_admin_user, create_transfer_account_user, create_credit_transfer, is_bulk, invert_recipient_list, transfer_amount, transfer_type, status_code): from server.utils.user import create_transfer_account_user from flask import g # Create admin user and auth authed_sempo_admin_user.set_held_role('ADMIN', 'superadmin') auth = get_complete_auth_token(authed_sempo_admin_user) g.active_organisation = authed_sempo_admin_user.default_organisation # Create 15 users to test against users = [] user_ids = [] for _ in range(15): user = create_transfer_account_user( organisation=authed_sempo_admin_user.default_organisation) db.session.commit() users.append(user) user_ids.append(user.id) # Create set subset of created users to disburse to (first 5 users) recipients = [10, 11, 12, 13] response = test_client.post( '/api/v1/credit_transfer/', headers=dict(Authorization=auth, Accept='application/json'), data=json.dumps( dict( is_bulk=is_bulk, recipient_transfer_accounts_ids=recipients, invert_recipient_list=invert_recipient_list, transfer_amount=transfer_amount, transfer_type=transfer_type, )), content_type='application/json', follow_redirects=True) db.session.commit() # Get IDs for every user disbursed to, then check that the list matches up # with the list of recipients (or the inverse if invert_recipient_list) rx_ids = [] for transfer in response.json['data']['credit_transfers']: rx_ids.append(transfer['recipient_transfer_account']['id']) if invert_recipient_list: for id in rx_ids: assert id not in recipients else: assert rx_ids == recipients
def test_blockchain_key_api(test_client, authed_sempo_admin_user, tier, status_code): """ GIVEN a Flask application WHEN '/api/auth/blockchain/' is requested (GET) THEN check the response is only returned for is_superadmin """ authed_sempo_admin_user.set_held_role('ADMIN',tier) response = test_client.get('/api/v1/auth/blockchain/', headers=dict( Authorization=get_complete_auth_token(authed_sempo_admin_user), Accept='application/json' ), content_type='application/json', follow_redirects=True) assert response.status_code == status_code
def test_delete_user(test_client, authed_sempo_admin_user, create_transfer_account_user, user_id_accessor, tier, status_code): if tier: authed_sempo_admin_user.set_held_role('ADMIN', tier) auth = get_complete_auth_token(authed_sempo_admin_user) else: auth = None response = test_client.delete( f"/api/v1/user/{user_id_accessor(create_transfer_account_user)}/", headers=dict(Authorization=auth, Accept='application/json')) assert response.status_code == status_code if response.status_code == 200: assert response.json['message'] is not None
def test_get_single_transfer_account_api(test_client, authed_sempo_admin_user, create_transfer_account_user_function, transfer_account_id_accessor, tier, status_code): if tier: authed_sempo_admin_user.set_held_role('ADMIN', tier) auth = get_complete_auth_token(authed_sempo_admin_user) else: auth = None response = test_client.get( f"/api/v1/transfer_account/{transfer_account_id_accessor(create_transfer_account_user_function)}/", headers=dict(Authorization=auth, Accept='application/json')) assert response.status_code == status_code if response.status_code == 201: assert response.json['data']['transfer_account'] is not None
def test_get_vendor_payout(test_client, authed_sempo_admin_user, create_transfer_account_user): auth = get_complete_auth_token(authed_sempo_admin_user) user = create_transfer_account_user user.transfer_account.is_vendor = True user.set_held_role('VENDOR', 'supervendor') user.transfer_account.approve_and_disburse() user.transfer_account.organisation = authed_sempo_admin_user.organisations[ 0] user.transfer_account.set_balance_offset(1000) user.is_phone_verified = True kyc = KycApplication(type='INDIVIDUAL') user.kyc_applications = [kyc] user.kyc_applications[0].kyc_status = 'VERIFIED' db.session.commit() response = test_client.post(f"/api/v1/get_vendor_payout/", headers=dict( Authorization=auth, Accept='application/json', ), data=json.dumps(dict({}))) resp = response.data.decode('ascii') f = StringIO(resp) reader = csv.reader(f) formatted_results = list(reader) formatted_results[1][9] = 'SOME DATE' formatted_results[1][10] = 'SOME DATE' assert formatted_results == [[ 'Vendor Account ID', 'Phone', 'ContactName', 'Current Balance', 'Total Sent', 'Total Received', 'Approved', 'Beneficiary', 'Vendor', 'InvoiceDate', 'DueDate', 'Transfer ID', 'UnitAmount', 'Payment Has Been Made', 'Bank Payment Date' ], [ '4', user.phone, 'Transfer User', '0', '10', '0', 'False', 'False', 'True', 'SOME DATE', 'SOME DATE', '1', '10', '', '' ]] transfer = user.transfer_account.credit_sends[0] assert transfer.transfer_type == TransferTypeEnum.WITHDRAWAL assert transfer.sender_transfer_account == user.transfer_account assert transfer.recipient_transfer_account == user.transfer_account.token.float_account assert transfer.transfer_status == TransferStatusEnum.PENDING
def test_delete_invite(test_client, authed_sempo_admin_user, create_transfer_account_user, create_credit_transfer, invite_id, tier, message, status_code): authed_sempo_admin_user.set_held_role('ADMIN', tier) default_org_id = get_admin_default_org_id(authed_sempo_admin_user) response = test_client.delete( f"/api/v1/auth/permissions/?org={default_org_id}", headers=dict( Authorization=get_complete_auth_token(authed_sempo_admin_user), Accept='application/json' ), json={'invite_id': invite_id} ) assert response.status_code == status_code assert message in response.json['message']
def test_create_token(test_client, authed_sempo_admin_user, name, symbol, decimals, address, chain, tier, status_code): authed_sempo_admin_user.set_held_role('ADMIN', tier) auth = get_complete_auth_token(authed_sempo_admin_user) response = test_client.post('/api/v1/token/', headers=dict(Authorization=auth, Accept='application/json'), data=json.dumps( dict(name=name, symbol=symbol, decimals=decimals, address=address, chain=chain)), content_type='application/json', follow_redirects=True) assert response.status_code == status_code
def test_dataset_api(test_client, authed_sempo_admin_user): data = { "data": [ { "0": "Alf", "1": "Melmac", "2": "19027192211" }, { "0": "Alf", "1": "Tanner", "2": "19027192211" # Same phone number, should trigger update }, { "0": "Willie", "1": "Tanner", "2": "19027192222" } ], "headerPositions": { "0": "first_name", "1": "last_name", "2": "phone" }, "country": "", "saveName": "", "isVendor": False } auth = get_complete_auth_token(authed_sempo_admin_user) response = test_client.post( f"/api/v1/dataset/", headers=dict( Authorization=auth, Accept='application/json', ), json=data ) redis_id = get_job_key(authed_sempo_admin_user.id, response.json['task_uuid']) status = { 'percent_complete': 0 } status = json.loads(red.get(redis_id)) assert status['message'] == 'success' assert status['percent_complete'] == 100.0 assert status['diagnostics'] == [['User Created', 200], ['User Updated', 200], ['User Created', 200]]
def test_create_user(test_client, authed_sempo_admin_user, init_database, create_transfer_account_user, user_phone_accessor, phone, business_usage_name, referred_by, tier, status_code): if tier: authed_sempo_admin_user.set_held_role('ADMIN', tier) auth = get_complete_auth_token(authed_sempo_admin_user) else: auth = None response = test_client.post( "/api/v1/user/", headers=dict(Authorization=auth, Accept='application/json'), json={ 'first_name': 'John', 'last_name': 'Smith', 'bio': 'EasyMart', 'gender': 'female', 'phone': phone, 'is_vendor': False, 'is_tokenagent': False, 'is_groupaccount': False, 'initial_disbursement': 0, 'location': 'Elwood', 'business_usage_name': business_usage_name, 'referred_by': user_phone_accessor(create_transfer_account_user ) #create the user who is referring }) assert response.status_code == status_code if response.status_code == 200: data = response.json['data'] assert isinstance(data['user'], object) assert data['user']['first_name'] == 'John' assert data['user']['last_name'] == 'Smith' assert data['user']['custom_attributes']['bio'] == 'EasyMart' assert data['user']['custom_attributes']['gender'] == 'female' assert data['user']['phone'] == proccess_phone_number(phone) assert data['user']['is_vendor'] is False assert data['user']['is_tokenagent'] is False assert data['user']['is_groupaccount'] is False assert data['user']['transfer_accounts'][0]['balance'] == 0 assert data['user']['location'] == 'Elwood' assert data['user']['business_usage_id'] == init_database.session.query(TransferUsage)\ .filter_by(name=business_usage_name).first().id