def test_get_by_id_with_include_optional_metadata():
client = create_client()
response = client.Institutions.get_by_id(
SANDBOX_INSTITUTION, [SANDBOX_INSTITUTION_COUNTRY_CODE], _options={
'include_optional_metadata': True,
})
assert response['institution']['institution_id'] == SANDBOX_INSTITUTION
def test_get():
client = create_client()
response = client.Identity.get(access_token)
assert response['accounts'] is not None
for account in response['accounts']:
assert account['owners'] is not None
assert len(account['owners']) > 0
def test_dwolla_processor_token():
client = create_client()
# Just test the failure case - behavior here depends on the API keys used
with pytest.raises(InvalidRequestError) as e:
client.Processor.dwollaBankAccountTokenCreate('fakeAccessToken',
'fakeAccountId')
assert e.code == 'INVALID_INPUT'
def test_all_payment_routes_with_bacs():
client = create_client()
bacs = {
'account': '12345678',
'sort_code': '01-02-03',
}
# create recipient
response = client.PaymentInitiation.create_recipient(
'John Doe',
None,
{
'street': ['street name 999'],
'city': 'city',
'postal_code': '99999',
'country': 'GB',
},
bacs,
)
recipient_id = response['recipient_id']
assert recipient_id is not None
# get recipient
response = client.PaymentInitiation.get_recipient(recipient_id)
assert response['recipient_id'] is not None
assert response['name'] is not None
assert response['bacs'] is not None
assert response['address'] is not None
payments_after_recipient_creation(client, recipient_id)
def test_full_flow():
client = create_client()
# get account id
account_id_response = client.Accounts.get(access_token)
assert len(account_id_response['accounts']) != 0
target_account_id = account_id_response['accounts'][0]['account_id']
# create deposit switch
create_response = client.DepositSwitch.create(target_account_id,
access_token)
assert create_response['deposit_switch_id'] is not None
deposit_switch_id = create_response['deposit_switch_id']
# get deposit switch
get_response = client.DepositSwitch.get(deposit_switch_id)
assert get_response['deposit_switch_id'] is not None
assert get_response['target_item_id'] is not None
assert get_response['target_account_id'] is not None
assert get_response['date_created'] is not None
assert get_response['state'] is not None
# create deposit switch token
token_response = client.DepositSwitch.create_token(deposit_switch_id)
assert token_response['deposit_switch_token'] is not None
assert token_response['deposit_switch_token_expiration_time'] is not None
def test_all_payment_routes_with_iban():
client = create_client()
# create recipient
response = client.PaymentInitiation.create_recipient(
'John Doe',
'GB33BUKB20201555555555',
{
'street': ['street name 999'],
'city': 'city',
'postal_code': '99999',
'country': 'GB',
},
None
)
recipient_id = response['recipient_id']
assert recipient_id is not None
# get recipient
response = client.PaymentInitiation.get_recipient(recipient_id)
assert response['recipient_id'] is not None
assert response['name'] is not None
assert response['iban'] is not None
assert response['address'] is not None
payments_after_recipient_creation(client, recipient_id)
def test_get():
client = create_client()
response = client.Identity.get(access_token)
assert response['accounts'] is not None
for account in response['accounts']:
assert account['owners'] is not None
assert len(account['owners']) > 0
def test_search_with_include_optional_metadata():
client = create_client()
response = client.Institutions.search(
SANDBOX_INSTITUTION_NAME, _options={
'include_optional_metadata': True,
})
assert len(response['institutions']) >= 1
def test_link_token_create_optional():
client = create_client()
# build the configs
configs = {
'user': {
'client_user_id': str(time.time()),
},
'products': ["auth", "transactions"],
'client_name': "Plaid Test",
'country_codes': ['GB'],
'language': 'en',
'webhook': 'https://sample-webhook-uri.com',
'link_customization_name': 'default',
'account_filters': {
'depository': {
'account_subtypes': ['checking', 'savings'],
},
},
}
# create link token
response = client.LinkToken.create(configs)
# assert on response
assert response['link_token'] is not None
assert response['expiration'] is not None
def test_get():
client = create_client()
response = client.Holdings.get(access_token)
assert response['item'] is not None
assert response['accounts'] is not None
assert response['securities'] is not None
assert response['holdings'] is not None
def test_delete():
client = create_client()
create_response = client.Item.create(CREDENTIALS, SANDBOX_INSTITUTION,
['transactions'])
delete_response = client.Item.delete(create_response['access_token'])
assert delete_response['deleted']
def test_remove():
client = create_client()
create_response = client.Item.create(CREDENTIALS, SANDBOX_INSTITUTION,
['transactions'])
remove_response = client.Item.remove(create_response['access_token'])
assert remove_response['removed']
def test_import():
client = create_client()
at_response = client.Item.import_item(['identity', 'auth'], {
'user_id': 'user_good',
'auth_token': 'pass_good'
}, None)
assert at_response['access_token'] is not None
def test_dwolla_processor_token():
client = create_client()
# Just test the failure case - behavior here depends on the API keys used
with pytest.raises(InvalidRequestError) as e:
client.Processor.dwollaBankAccountTokenCreate(
'fakeAccessToken', 'fakeAccountId')
assert e.code == 'INVALID_INPUT'
def test_search_with_products():
client = create_client()
response = client.Institutions.search(
SANDBOX_INSTITUTION_NAME,
[SANDBOX_INSTITUTION_COUNTRY_CODE],
products=['transactions'])
assert len(response['institutions']) >= 1
def setup_module(module):
client = create_client()
pt_response = client.Sandbox.public_token.create(BALANCE_INSTITUTION,
['transactions'])
exchange_response = client.Item.public_token.exchange(
pt_response['public_token'])
global access_token
access_token = exchange_response['access_token']
def test_get_with_options():
client = create_client()
response = client.Transactions.get(access_token,
'2016-01-01',
'2017-01-01',
count=2,
offset=1)
assert len(response['transactions']) == 2
def test_get():
client = create_client()
create_response = client.Item.create(CREDENTIALS, SANDBOX_INSTITUTION,
['transactions'])
with ensure_item_deleted(create_response['access_token']):
get_response = client.Item.get(create_response['access_token'])
assert get_response['item'] is not None
def setup_module(module):
client = create_client()
pt_response = client.Sandbox.public_token.create(
SANDBOX_INSTITUTION, ['liabilities'])
exchange_response = client.Item.public_token.exchange(
pt_response['public_token'])
global access_token
access_token = exchange_response['access_token']
def test_add_token():
client = create_client()
create_response = client.Item.add_token.create({
'client_user_id':
str(time.time()),
})
assert create_response['add_token'] is not None
assert create_response['expiration'] is not None
def setup_module(module):
client = create_client()
pt_response = client.Sandbox.public_token.create(
SANDBOX_INSTITUTION, ['auth'])
exchange_response = client.Item.public_token.exchange(
pt_response['public_token'])
global access_token
access_token = exchange_response['access_token']
def test_remove():
client = create_client()
pt_response = client.Sandbox.public_token.create(SANDBOX_INSTITUTION,
['transactions'])
exchange_response = client.Item.public_token.exchange(
pt_response['public_token'])
client.Item.remove(exchange_response['access_token'])
async def test_search_with_include_optional_metadata():
client = create_client()
response = await client.Institutions.search(
SANDBOX_INSTITUTION_NAME,
_options={
'include_optional_metadata': True,
})
assert len(response['institutions']) >= 1
def test_public_token():
client = create_client()
pt_response = client.Sandbox.public_token.create(
SANDBOX_INSTITUTION, ['transactions'])
exchange_response = client.Item.public_token.exchange(
pt_response['public_token'])
with ensure_item_removed(exchange_response['access_token']):
assert pt_response['public_token'] is not None
assert exchange_response['access_token'] is not None
def test_get_with_options():
client = create_client()
response = get_transactions_with_retries(client,
access_token,
'2018-01-01',
'2019-01-01',
count=2,
offset=1)
assert len(response['transactions']) == 2
def test_get_with_options():
client = create_client()
response = get_transactions_with_retries(client,
access_token,
START_DATE,
END_DATE,
count=2,
offset=1)
assert len(response['transactions']) == 2
def test_remove():
client = create_client()
pt_response = client.Sandbox.public_token.create(
SANDBOX_INSTITUTION, ['transactions'])
exchange_response = client.Item.public_token.exchange(
pt_response['public_token'])
remove_response = client.Item.remove(exchange_response['access_token'])
assert remove_response['removed']
def test_public_token():
client = create_client()
pt_response = client.Sandbox.public_token.create(SANDBOX_INSTITUTION,
['transactions'])
exchange_response = client.Item.public_token.exchange(
pt_response['public_token'])
with ensure_item_removed(exchange_response['access_token']):
assert pt_response['public_token'] is not None
assert exchange_response['access_token'] is not None
def test_add_token_with_user():
client = create_client()
user = {
'phone_number': '+1 415 555 0123',
'email_address': '*****@*****.**',
'phone_number_verified_time': '2020-01-01T00:00:00Z',
}
create_response = client.Item.add_token.create(user=user)
assert create_response['add_token'] is not None
assert create_response['expiration'] is not None
def test_webhook_update():
client = create_client()
create_response = client.Item.create(CREDENTIALS, SANDBOX_INSTITUTION,
['transactions'])
with ensure_item_deleted(create_response['access_token']):
webhook_response = client.Item.webhook.update(
create_response['access_token'], 'https://plaid.com/webhook-test')
assert (webhook_response['item']['webhook'] ==
'https://plaid.com/webhook-test')
def setup_module(module):
client = create_client()
# import an item
at_response = client.Item.import_item(['identity', 'auth'], {
'user_id': 'user_good',
'auth_token': 'pass_good'
}, None)
assert at_response['access_token'] is not None
global access_token
access_token = at_response['access_token']
def test_create():
client = create_client()
response = client.Item.create(CREDENTIALS, SANDBOX_INSTITUTION,
['transactions'])
with ensure_item_deleted(response['access_token']):
assert response['access_token'] is not None
assert response['item']['billed_products'] == ['transactions']
assert response['item']['institution_id'] == SANDBOX_INSTITUTION
assert response.get('mfa_type') is None
def test_sandbox_public_token():
client = create_client()
create_response = client.Sandbox.public_token.create(
SANDBOX_INSTITUTION, ['transactions'])
assert create_response['public_token'] is not None
# public token -> access token
exchange_response = client.Item.public_token.exchange(
create_response['public_token'])
assert exchange_response['access_token'] is not None
def test_sandbox_public_token():
client = create_client()
create_response = client.Sandbox.public_token.create(
SANDBOX_INSTITUTION, ['transactions'])
assert create_response['public_token'] is not None
# public token -> access token
exchange_response = client.Item.public_token.exchange(
create_response['public_token'])
assert exchange_response['access_token'] is not None
def setup_module(_module):
client = create_client()
pt_response = client.Sandbox.public_token.create(
SANDBOX_INSTITUTION, ['investments'],
transactions__start_date='2018-01-01',
transactions__end_date='2019-01-01',
)
exchange_response = client.Item.public_token.exchange(
pt_response['public_token'])
global access_token
access_token = exchange_response['access_token']
def test_get():
client = create_client()
# get all accounts
response = client.Accounts.get(access_token)
assert response['accounts'] is not None
# get selected accounts
account_id = response['accounts'][0]['account_id']
response = client.Accounts.get(access_token, account_ids=[account_id])
assert len(response['accounts']) == 1
def test_mfa_questions():
client = create_client()
item_response = client.Item.create(MFA_QUESTIONS_CREDENTIALS,
SANDBOX_INSTITUTION, ['transactions'])
with ensure_item_deleted(item_response['access_token']):
assert item_response['mfa_type'] == 'questions'
mfa_response = client.Item.mfa(item_response['access_token'],
'questions', ['answer_0_0'])
assert mfa_response['item'] is not None
def test_get():
client = create_client()
# get all accounts
response = client.Accounts.get(access_token)
assert response['accounts'] is not None
# get selected accounts
account_id = response['accounts'][0]['account_id']
response = client.Accounts.get(access_token, account_ids=[account_id])
assert len(response['accounts']) == 1
def test_webhook_update():
client = create_client()
pt_response = client.Sandbox.public_token.create(
SANDBOX_INSTITUTION, ['transactions'])
exchange_response = client.Item.public_token.exchange(
pt_response['public_token'])
with ensure_item_removed(exchange_response['access_token']):
webhook_response = client.Item.webhook.update(
exchange_response['access_token'],
'https://plaid.com/webhook-test')
assert (webhook_response['item']['webhook'] ==
'https://plaid.com/webhook-test')
def test_access_token_invalidate():
client = create_client()
pt_response = client.Sandbox.public_token.create(
SANDBOX_INSTITUTION, ['transactions'])
exchange_response = client.Item.public_token.exchange(
pt_response['public_token'])
try:
invalidate_response = client.Item.access_token.invalidate(
exchange_response['access_token'])
with ensure_item_removed(invalidate_response['new_access_token']):
assert invalidate_response['new_access_token'] is not None
except Exception:
with ensure_item_removed(exchange_response['access_token']):
raise
def test_get_with_include_optional_metadata():
client = create_client()
response = client.Institutions.get(3, offset=1, _options={
'include_optional_metadata': True,
})
assert len(response['institutions']) == 3
assert len(response['institutions'][0]['url']) > 0
assert len(response['institutions'][0]['logo']) > 0
assert len(response['institutions'][0]['primary_color']) > 0
assert len(response['institutions'][1]['url']) > 0
assert len(response['institutions'][1]['logo']) > 0
assert len(response['institutions'][1]['primary_color']) > 0
assert len(response['institutions'][2]['url']) > 0
assert len(response['institutions'][2]['logo']) > 0
assert len(response['institutions'][2]['primary_color']) > 0
def test_sandbox_fire_webhook():
client = create_client()
create_response = client.Sandbox.public_token.create(
SANDBOX_INSTITUTION, ['transactions'], webhook='https://plaid.com/foo/bar/hook')
assert create_response['public_token'] is not None
# public token -> access token
exchange_response = client.Item.public_token.exchange(
create_response['public_token'])
assert exchange_response['access_token'] is not None
# fire webhook
fire_webhook_response = client.Sandbox.item.fire_webhook(
exchange_response['access_token'],
'DEFAULT_UPDATE'
)
assert fire_webhook_response['webhook_fired'] is True
def test_get():
client = create_client()
# get auth for all accounts
response = client.Auth.get(access_token)
assert response['accounts'] is not None
assert response['numbers'] is not None
# get auth for selected accounts
account_id = response['accounts'][0]['account_id']
response = client.Auth.get(access_token, account_ids=[account_id])
for key in [
'eft',
'ach',
'international',
'bacs',
]:
assert key in response['numbers']
def test_get_by_id_with_include_optional_metadata():
client = create_client()
response = client.Institutions.get_by_id(SANDBOX_INSTITUTION, _options={
'include_optional_metadata': True,
})
assert response['institution']['institution_id'] == SANDBOX_INSTITUTION
def ensure_item_removed(access_token):
try:
yield
finally:
create_client().Item.remove(access_token)
def test_full_flow():
client = create_client()
# create an asset report for one item
options = {
'client_report_id': '123',
'webhook': 'https://www.example.com',
'user': {
'client_user_id': '789',
'first_name': 'Jane',
'middle_name': 'Leah',
'last_name': 'Doe',
'ssn': '123-45-6789',
'phone_number': '(555) 123-4567',
'email': '*****@*****.**',
}
}
response = client.AssetReport.create(
[access_token],
days_requested=60,
options=options)
asset_report_token = response['asset_report_token']
asset_report_id = response['asset_report_id']
assert asset_report_token is not None
assert asset_report_id is not None
# retrieve the asset report
response = poll_for_asset_report(client, asset_report_token)
report = response['report']
assert report is not None
# retrieve the asset report as an Asset Report with Insights
response = client.AssetReport.get(asset_report_token, True)
report = response['report']
assert report is not None
# The transactions in an Asset Report with Insights should have a non-null
# `name` (when available).
assert (
name_exists_for_some_transaction(report))
# retrieve the asset report as a PDF
pdf = client.AssetReport.get_pdf(asset_report_token)
assert pdf is not None
# create a filtered copy of the asset report
account_ids_to_exclude = [report['items'][0]['accounts'][0]['account_id']]
response = client.AssetReport.filter(
asset_report_token, account_ids_to_exclude)
assert response['asset_report_token'] is not None
# create a refreshed copy of the asset report
response = client.AssetReport.refresh(asset_report_token, 10)
assert response['asset_report_token'] is not None
# create an audit copy
response = client.AssetReport.audit_copy.create(
asset_report_token,
client.client_id)
audit_copy_token = response['audit_copy_token']
assert audit_copy_token is not None
# get the audit copy
response = client.AssetReport.audit_copy.get(audit_copy_token)
audit_copy = response['report']
assert audit_copy is not None
# remove the audit copy token
response = client.AssetReport.audit_copy.remove(audit_copy_token)
removed = response['removed']
assert removed
# remove the asset report
response = client.AssetReport.remove(asset_report_token)
removed = response['removed']
assert removed
def test_get():
client = create_client()
try:
client.Income.get(access_token)
except ItemError as ie:
assert ie.code == u'PRODUCT_NOT_READY'
def test_get():
client = create_client()
response = client.CreditDetails.get(access_token)
assert response['accounts'] is not None
assert response['credit_details'] is not None
def test_get():
client = create_client()
response = client.Institutions.get(3, offset=1)
assert len(response['institutions']) == 3
def teardown_module(module):
client = create_client()
client.Item.remove(access_token)
def test_search():
client = create_client()
response = client.Institutions.search(SANDBOX_INSTITUTION_NAME)
assert len(response['institutions']) >= 1
def test_search_with_products():
client = create_client()
response = client.Institutions.search(
SANDBOX_INSTITUTION_NAME, products=['transactions'])
assert len(response['institutions']) >= 1
def test_get_by_id():
client = create_client()
response = client.Institutions.get_by_id(SANDBOX_INSTITUTION)
assert response['institution']['institution_id'] == SANDBOX_INSTITUTION
def test_get():
client = create_client()
response = client.Categories.get()
assert response['categories'] is not None
