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
