def test_001_reverse_transaction_200(self):
payload = {
"user_handle": user_handle,
"amount": 200,
"card_name": "visa"
}
response = Transaction.issue_sila(app, payload, eth_private_key)
self.assertEqual(response.get("success"), True)
payload = {
"user_handle": user_handle,
'search_filters': {
'bank_account_name': 'visa'
}
}
response1 = User.get_transactions(app, payload, eth_private_key)
while response1['transactions'][0]['status'] == "pending":
time.sleep(50)
response1 = User.get_transactions(app, payload, eth_private_key)
payload = {
"user_handle": user_handle,
"transaction_id": response["transaction_id"]
}
response2 = Transaction.reverseTransaction(app, payload,
eth_private_key)
self.assertTrue(response2.get('success'))
def test_issue_sila_vaccount_200(self):
payload = {
"virtual_account_name": "test_v_acc",
"user_handle": user_handle
}
response = User.openVirtualAccount(app, payload, eth_private_key)
self.assertTrue(response["success"])
v_id = response.get("virtual_account").get("virtual_account_id")
payload = {
"user_handle": user_handle
}
response = User.getPaymentMethods(app, payload, eth_private_key)
self.assertTrue(response["success"])
for item in response.get("payment_methods"):
if item["payment_method_type"] == "card":
card_id = item.get("card_id")
descriptor = "test descriptor"
payload = {
"message": "issue_msg",
"user_handle": user_handle,
"amount": 200,
"source_id": card_id,
"descriptor": descriptor,
"business_uuid": business_uuid,
"processing_type": ProcessingTypes.STANDARD_ACH,
"destination_id": v_id,
}
response = Transaction.issue_sila(app, payload, eth_private_key)
self.assertEqual(response.get("success"), True)
self.assertEqual(response["status"], "SUCCESS")
self.assertIsNotNone(response["transaction_id"])
def test_register_kyc_200(self):
payload = {"user_handle": user_handle}
response = User.requestKyc(app, payload, eth_private_key)
self.assertEqual(response.get('status'), "SUCCESS")
self.assertTrue(response.get('success'))
self.assertIsNotNone(response['verification_uuid'])
self.assertEqual(response.get('status_code'), 200)
payload = {"user_handle": user_handle_2}
response = User.requestKyc(app, payload, eth_private_key_2)
self.assertEqual(response.get('status'), "SUCCESS")
self.assertTrue(response.get('success'))
self.assertEqual(response.get('status_code'), 200)
self.assertIsNotNone(response['verification_uuid'])
payload = {"user_handle": business_handle}
response = User.requestKyc(app, payload, eth_private_key_3)
self.assertEqual(response.get('status'), "SUCCESS")
self.assertTrue(response.get('success'))
self.assertEqual(response.get('status_code'), 200)
self.assertIsNotNone(response['verification_uuid'])
payload = {
'user_handle': instant_ach_handle,
'kyc_level': 'INSTANT-ACH'
}
response = User.requestKyc(app, payload, eth_private_key_4)
self.assertTrue(response.get('success'))
self.assertEqual(response.get('status'), 'SUCCESS')
self.assertEqual(response.get('status_code'), 200)
self.assertIsNotNone(response['verification_uuid'])
def test_delete_registration_data_200(self):
payload = {"user_handle": user_handle}
response = User.get_entity(app, payload, eth_private_key)
email_uuid = response["emails"][0]["uuid"]
phone_uuid = response["phones"][0]["uuid"]
address_uuid = response["addresses"][0]["uuid"]
payload = {"user_handle": user_handle, "uuid": email_uuid}
response = User.deleteRegistrationData(app, RegistrationFields.EMAIL,
payload, eth_private_key)
self.assertTrue(response["success"])
self.assertIsNotNone(response["message"])
self.assertEqual(response["status"], "SUCCESS")
self.assertIsNotNone(response["reference"])
payload = {"user_handle": user_handle, "uuid": phone_uuid}
response = User.deleteRegistrationData(app, RegistrationFields.PHONE,
payload, eth_private_key)
self.assertTrue(response["success"])
self.assertIsNotNone(response["message"])
self.assertEqual(response["status"], "SUCCESS")
self.assertIsNotNone(response["reference"])
payload = {"user_handle": user_handle, "uuid": address_uuid}
response = User.deleteRegistrationData(app, RegistrationFields.ADDRESS,
payload, eth_private_key)
self.assertTrue(response["success"])
self.assertIsNotNone(response["message"])
self.assertEqual(response["status"], "SUCCESS")
self.assertIsNotNone(response["reference"])
def test_transfer_sila_v2v_200(self):
payload = {
"virtual_account_name": "source_v_acc",
"user_handle": user_handle
}
response = User.openVirtualAccount(app, payload, eth_private_key)
self.assertTrue(response["success"])
source_v_id = response.get("virtual_account").get("virtual_account_id")
payload = {
"virtual_account_name": "destination_v_acc",
"user_handle": user_handle
}
response = User.openVirtualAccount(app, payload, eth_private_key)
self.assertTrue(response["success"])
destination_v_id = response.get("virtual_account").get(
"virtual_account_id")
descriptor = "test descriptor"
payload = {
"message": "issue_msg",
"user_handle": user_handle,
"amount": 200,
"account_name": "default_plaid",
"descriptor": descriptor,
"business_uuid": business_uuid,
"processing_type": ProcessingTypes.STANDARD_ACH,
"destination_id": source_v_id,
}
response = Transaction.issue_sila(app, payload, eth_private_key)
poll(self, response["transaction_id"], "success", app, user_handle,
eth_private_key)
payload = {
"message": "transfer_msg",
"user_handle": user_handle,
"source_id": source_v_id,
"destination_id": destination_v_id,
"destination": user_handle,
"amount": 100,
"descriptor": "test descriptor",
"business_uuid": business_uuid
}
response = Transaction.transferSila(app, payload, eth_private_key)
poll(self, response["transaction_id"], "success", app, user_handle,
eth_private_key)
self.assertEqual(response["status"], "SUCCESS")
self.assertEqual(response["descriptor"], "test descriptor")
self.assertIsNotNone(response["transaction_id"])
def test_delete_account_200(self):
payload = {"user_handle": user_handle, "account_name": "unlink"}
response = User.delete_account(app, payload, eth_private_key)
self.assertEqual(response["status"], "SUCCESS")
self.assertEqual(response["account_name"], "unlink")
self.assertIsNotNone(response["reference"])
def test_get_entity_401_with_empty_eth_private_key(self):
payload = {"user_handle": user_handle}
response = User.get_entity(app, payload, '')
self.assertFalse(response.get("success"))
self.assertEqual(response.get("status_code"), 403)
self.assertRegex(response.get("message"),
r'\bsignature is required for this request\b')
def test_register_kyc_200(self):
payload = {
"user_handle": self.getUserHandle
}
response = User.requestKyc(app, payload, self.getPrivateKey)
self.assertEqual(response["status"], "SUCCESS")
self.log.info(response)
def test_register_kyc_custom_403(self):
payload = {
"user_handle": user_handle,
"kyc_level": "CUSTOM_KYC_FLOW_NAME"
}
response = User.requestKyc(app, payload, eth_private_key, True)
self.assertEqual(response.get('status'), "FAILURE")
def test_get_entity_200_deprecated(self):
payload = {
"user_handle": user_handle
}
with self.assertWarns(DeprecationWarning):
response = User.getEntity(app, payload, eth_private_key)
self.assertTrue(response["success"])
self.assertIsNotNone(response["reference"])
def test_get_entity_200_with_pretty_dates(self):
payload = {
"user_handle": user_handle
}
response = User.get_entity(app, payload, eth_private_key, True)
self.assertTrue(response["success"])
self.assertIsNotNone(response["entity"])
self.assertTrue("created" in response["entity"])
self.assertIsNotNone(response["reference"])
def test_check_partner_kyc_200(self):
payload = {
"query_app_handle": "digital_geko_e2e_new",
"query_user_handle": user_handle
}
response = User.check_partner_kyc(app, payload)
self.assertIsNotNone(response["status"])
self.assertIsNotNone(response['success'])
def test_register_kyc_custom_403(self):
payload = {
"user_handle": self.getUserHandle,
"kyc_level": "CUSTOM_KYC_FLOW_NAME"
}
response = User.requestKyc(app, payload, self.getPrivateKey, True)
self.assertEqual(response["status"], "FAILURE")
self.log.info(response)
def test_get_transactions_filter_by_account_name(self):
payload = {
"user_handle": user_handle,
'search_filters': {
'bank_account_name': 'default'
}
}
response = User.get_transactions(app, payload)
self.assertTrue(response.get('success'))
def poll(test: TestCase, transaction_id: str, expected_status: str, app: App,
user_handle: str, eth_private_key: str):
payload = {
"user_handle": user_handle,
"search_filters": {
'page': 1,
'per_page': 1,
"transaction_id": transaction_id,
}
}
response = User.getTransactions(app, payload, eth_private_key)
status = response["transactions"][0]["status"]
while status == "queued" or status == "pending":
time.sleep(30)
response = User.getTransactions(app, payload, eth_private_key)
status = response["transactions"][0]["status"]
test.assertEqual(status, expected_status)
def test_delete_registration_data_400(self):
payload = {
"user_handle": user_handle,
}
response = User.deleteRegistrationData(
app, RegistrationFields.EMAIL, payload, eth_private_key)
self.assertEqual(response["status"], "FAILURE")
response = User.deleteRegistrationData(
app, RegistrationFields.PHONE, payload, eth_private_key)
self.assertEqual(response["status"], "FAILURE")
response = User.deleteRegistrationData(
app, RegistrationFields.IDENTITY, payload, eth_private_key)
self.assertEqual(response["status"], "FAILURE")
response = User.deleteRegistrationData(
app, RegistrationFields.ADDRESS, payload, eth_private_key)
self.assertEqual(response["status"], "FAILURE")
def test_update_account_200(self):
payload = {
"user_handle": user_handle,
"account_name": "forupdate",
"new_account_name": "accountupdated"
}
response = User.update_account(app, payload, eth_private_key)
self.assertEqual(response["status"], "SUCCESS")
self.assertEqual(response["account"]["account_name"], "accountupdated")
def test_register_200_basic(self):
basic_individual = {
'user_handle': basic_individual_handle,
'crypto_address': eth_address_5,
'first_name': 'Basic',
'last_name': 'Test'
}
response = User.register(app, basic_individual)
self.assertTrue(response.get('success'))
self.assertEqual(response.get('status_code'), 200)
self.assertEqual(response.get('status'), 'SUCCESS')
def test_freeze_account(self):
"""Verify user is able to freeze there bank account."""
payload = {
"user_handle": user_handle,
"account_name": "forupdate",
"active": False
}
response = User.update_account(app, payload, eth_private_key)
self.assertEqual(response["status"], "SUCCESS")
self.assertEqual(response["account"]["active"], False)
self.assertEqual(response["account"]["account_status"], 'inactive')
def test_check_kyc_200(self):
payload = {
"user_handle": user_handle
}
response = User.checkKyc(app, payload, eth_private_key)
payload = {
"user_handle": user_handle_2
}
response_2 = User.checkKyc(app, payload, eth_private_key_2)
payload = {
"user_handle": business_handle
}
response_3 = User.checkKyc(app, payload, eth_private_key_3)
while response["status"] != "SUCCESS" or response_2["status"] != "SUCCESS" or "Business has passed verification" not in response_3["message"]:
time.sleep(100)
payload = {
"user_handle": user_handle
}
response = User.checkKyc(app, payload, eth_private_key)
payload = {
"user_handle": user_handle_2
}
response_2 = User.checkKyc(app, payload, eth_private_key_2)
payload = {
"user_handle": business_handle
}
response_3 = User.checkKyc(app, payload, eth_private_key_3)
self.assertEqual(response["status"], "SUCCESS")
def test_unfreeze_account(self):
"""Verify user is able to unfreeze the freeze account"""
bank_name = "unfreeze_account"
payload = {
"user_handle": user_handle,
"account_name": "forupdate",
"active": True
}
response = User.update_account(app, payload, eth_private_key)
self.assertEqual(response["status"], "SUCCESS")
self.assertEqual(response["account"]["active"], True)
self.assertEqual(response["account"]["account_status"], 'active')
def test_get_transactions_200_deprecated(self):
payload = {
"user_handle": user_handle,
"search_filters": {
'page': 1,
'per_page': 1
}
}
with self.assertWarns(DeprecationWarning):
response = User.getTransactions(app, payload, eth_private_key)
self.assertTrue(response["success"])
self.assertEqual(len(response["transactions"]), 1)
self.assertEqual(response["transactions"][0]["processing_type"],
ProcessingTypes.STANDARD_ACH)
def test_get_transactions_200(self):
payload = {
"user_handle": user_handle,
"search_filters": {
'page': 1,
'per_page': 1,
'show_timelines': True
}
}
response = User.get_transactions(app, payload, eth_private_key)
self.assertTrue(response["success"])
self.assertEqual(len(response["transactions"]), 1)
self.assertEqual(response["transactions"][0]["processing_type"],
ProcessingTypes.STANDARD_ACH)
self.assertIsNotNone(response.get('transactions')[0].get('timeline'))
def test_get_transactions_200_with_filters(self):
payload = {
'user_handle': user_handle,
'search_filters': {
'statuses': ['success'],
'transaction_types': ['issue']
}
}
response = User.get_transactions(app, payload, eth_private_key)
self.assertTrue(response.get('success'))
self.assertGreater(len(response.get('transactions')), 1)
self.assertEqual(
response.get('transactions')[0].get('status'), 'success')
self.assertEqual(
response.get('transactions')[0].get('transaction_type'), 'issue')
def test_get_transactions_200(self):
lai = False
di = False
si = False
dslt = False
dlai = False
payload = {
"user_handle": user_handle,
"search_filters": {
'page': 1,
'per_page': 13,
'show_timelines': True
}
}
response = User.get_transactions(app, payload)
self.assertTrue(response["success"])
self.assertIsNotNone(response["reference"])
self.assertEqual(len(response["transactions"]), 13)
self.assertIsNotNone(response.get('transactions')[0].get('timeline'))
self.assertIsNotNone(
response.get('transactions')[0].get('sila_ledger_type'))
for item in response.get("transactions"):
if item.get("ledger_account_id") and not lai:
self.assertIsNotNone(item["ledger_account_id"])
lai = True
if item.get("destination_id") and not di:
self.assertIsNotNone(item["destination_id"])
di = True
if item.get("source_id") and not si:
self.assertIsNotNone(item["source_id"])
si = True
if item.get("destination_sila_ledger_type") and not dslt:
self.assertIsNotNone(item["destination_sila_ledger_type"])
dslt = True
if item.get("destination_ledger_account_id") and not dlai:
self.assertIsNotNone(item["destination_ledger_account_id"])
dlai = True
self.assertTrue(lai)
self.assertTrue(di)
self.assertTrue(si)
self.assertTrue(dslt)
self.assertTrue(dlai)
def test_001_link_card_200(self):
"""Generate plaid legacy token"""
url = plaid_token_for_card_url
payload = plaid_token_for_card_payload
headers = plaid_token_for_card_headers
response = requests.request("POST", url, headers=headers, data=payload)
response = response.text
card_token = response[3:]
payload = {
"user_handle": user_handle,
"card_name": "visa",
"account_postal_code": "12345",
"token": card_token
}
response = User.link_card(app, payload, eth_private_key)
self.assertTrue(response["success"])
self.assertIsNotNone(response["reference"])
def test_register_400(self):
payload = {
"country": "US",
"user_handle": user_handle,
"first_name": 'Example',
"last_name": 'User',
"entity_name": 'Example User',
"identity_value": "123452222",
"phone": 1234567890,
"email": "*****@*****.**",
"street_address_1": '123 Main Street',
"city": 'New City',
"state": 'OR',
"postal_code": 97204,
"crypto_address": eth_address,
"crypto_alias": "python_wallet_1",
"birthdate": "1990-05-19"
}
response = User.register(app, payload)
self.assertEqual(response["status"], "FAILURE")
def test_get_transactions_200_with_error_code(self):
payload = {
"user_handle": user_handle,
"search_filters": {
'page': 1,
'per_page': 1,
'show_timelines': True,
'min_sila_amount': 410,
'max_sila_amount': 430
}
}
response = User.get_transactions(app, payload)
self.assertTrue(response["success"])
self.assertIsNotNone(response["reference"])
self.assertEqual(len(response["transactions"]), 1)
self.assertEqual(response["transactions"][0]["error_code"],
'ACH_RETURN')
self.assertIsNotNone(response.get('transactions')[0].get('error_msg'))
self.assertIsNotNone(
response.get('transactions')[0].get('return_code'))
self.assertIsNotNone(
response.get('transactions')[0].get('return_desc'))
def test_register_200(self):
payload = {
"country": "US",
"user_handle": user_handle,
"first_name": 'Example',
"last_name": 'User',
"entity_name": 'Example User',
"identity_value": "123452222",
"identity_alias": "SSN",
"phone": 1234567890,
"email": "*****@*****.**",
"address_alias": "default",
"street_address_1": '123 Main Street',
"city": 'New City',
"state": 'OR',
"postal_code": 97204,
"crypto_address": eth_address,
"crypto_alias": "python_wallet_1",
"birthdate": "1990-05-19"
}
payload_2 = {
"country": "US",
"user_handle": user_handle_2,
"first_name": 'Example 2',
"last_name": 'User 2',
"entity_name": 'Example User 2',
"identity_alias": "SSN",
"identity_value": "123452222",
"phone": 1234567890,
"email": "*****@*****.**",
"address_alias": "default",
"street_address_1": '1232 Main Street',
"city": 'New City 2',
"state": 'OR',
"postal_code": 97204,
"crypto_address": eth_address_2,
"crypto_alias": "python_wallet_2",
"birthdate": "1990-05-12"
}
instant_ach = {
"country": "US",
"user_handle": instant_ach_handle,
"first_name": 'Instant',
"last_name": 'Ach',
"entity_name": 'Instant Ach',
"identity_alias": "SSN",
"identity_value": "123452222",
"phone": 1234567890,
"sms_opt_in": True,
"email": "*****@*****.**",
"address_alias": "default",
"street_address_1": '1232 Main Street',
"city": 'New City',
"state": 'OR',
"postal_code": 97204,
"crypto_address": eth_address_4,
"crypto_alias": "default",
"birthdate": "1994-01-08",
"device_fingerprint": "test_instant_ach"
}
business = {
"country": "US",
"user_handle": business_handle,
"entity_name": 'Business name',
"identity_alias": "EIN",
"identity_value": "123452222",
"phone": 1234567890,
"email": "*****@*****.**",
"address_alias": "default",
"street_address_1": '1232 Main Street',
"city": 'New City 2',
"state": 'OR',
"postal_code": 97204,
"crypto_address": eth_address_3,
"crypto_alias": "python_wallet_2",
"type": "business",
"business_type": "corporation",
"business_website": "https://www.yourbusinesscustomer.com",
"doing_business_as": "Your Business Customer Alias Co.",
"naics_code": 721
}
response = User.register(app, payload)
self.assertTrue(response.get('success'))
self.assertEqual(response.get('status_code'), 200)
self.assertEqual(response.get('status'), 'SUCCESS')
response = User.register(app, payload_2)
self.assertTrue(response.get('success'))
self.assertEqual(response.get('status_code'), 200)
self.assertEqual(response.get('status'), 'SUCCESS')
response = User.register(app, business)
self.assertTrue(response.get('success'))
self.assertEqual(response.get('status_code'), 200)
self.assertEqual(response.get('status'), 'SUCCESS')
response = User.register(app, instant_ach)
self.assertTrue(response.get('success'))
self.assertEqual(response.get('status_code'), 200)
self.assertEqual(response.get('status'), 'SUCCESS')
def test_get_transactions_400(self):
payload = {"user_handle": ""}
response = User.get_transactions(app, payload, eth_private_key)
self.assertFalse(response.get('success'))
self.assertEqual(response.get('status_code'), 400)
