diff --git a/CHANGELOG.md b/CHANGELOG.md index b1d0bbd..8f12b7a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,6 +13,9 @@ Given a version number MAJOR.MINOR.PATCH, increment: ## [Unreleased] +### Added +- VerifiedAccount resource with create, get, cancel, query and page methods, and VerifiedAccount.Log sub-resource +- VerifiedTransfer resource with create method, reusing transfer.Rule ### Fixed - Docstrings diff --git a/README.md b/README.md index c12dac7..5f975c2 100644 --- a/README.md +++ b/README.md @@ -42,6 +42,8 @@ is as easy as sending a text message to your client! - [UtilityPayments](#create-utility-payments): Pay Utility bills (water, light, etc.) - [TaxPayments](#create-tax-payment): Pay taxes - [DarfPayments](#create-darf-payment): Pay DARFs + - [VerifiedAccounts](#create-verifiedaccounts): Confirm that a bank account or Pix key belongs to a tax ID + - [VerifiedTransfers](#create-verifiedtransfers): Transfer to a previously verified account - [PaymentPreviews](#preview-payment-information-before-executing-the-payment): Preview all sorts of payments - [PaymentRequest](#create-payment-requests-to-be-approved-by-authorized-people-in-a-cost-center): Request a payment approval to a cost center - [CorporateHolders](#create-corporateholders): Manage cardholders @@ -1878,6 +1880,119 @@ log = starkbank.darfpayment.log.get("1902837198237992") print(log) ``` +## Create VerifiedAccounts + +You can create VerifiedAccounts to confirm that a bank account or Pix key belongs to a given tax ID before sending a transfer. + +```python +import starkbank + +accounts = starkbank.verifiedaccount.create([ + starkbank.VerifiedAccount( + tax_id="012.345.678-90", + name="Tony Stark", + bank_code="341", + branch_code="2201", + number="76543-8", + type="checking", + tags=["iron", "suit"], + ), + starkbank.VerifiedAccount( + tax_id="012.345.678-90", + key_id="tony@starkbank.com", + tags=["iron", "suit"], + ), +]) + +for account in accounts: + print(account) +``` + +## Get a VerifiedAccount + +You can get a specific VerifiedAccount by its id: + +```python +import starkbank + +account = starkbank.verifiedaccount.get("5155165527080960") + +print(account) +``` + +## Cancel a VerifiedAccount + +You can cancel a VerifiedAccount by its id: + +```python +import starkbank + +account = starkbank.verifiedaccount.cancel("5155165527080960") + +print(account) +``` + +## Query VerifiedAccounts + +To search for VerifiedAccounts using filters, run: + +```python +import starkbank + +accounts = starkbank.verifiedaccount.query( + limit=10, + status="active", + tags=["iron", "suit"], +) + +for account in accounts: + print(account) +``` + +## Query VerifiedAccount logs + +You can search for VerifiedAccount logs by specifying filters: + +```python +import starkbank + +logs = starkbank.verifiedaccount.log.query(limit=10) + +for log in logs: + print(log) +``` + +## Get a VerifiedAccount log + +If you want to get a specific VerifiedAccount log by its id, just run: + +```python +import starkbank + +log = starkbank.verifiedaccount.log.get("1902837198237992") + +print(log) +``` + +## Create VerifiedTransfers + +You can send a transfer to a previously verified account by creating a VerifiedTransfer: + +```python +import starkbank + +transfers = starkbank.verifiedtransfer.create([ + starkbank.VerifiedTransfer( + amount=1000, + account_id="5155165527080960", + tags=["iron", "suit"], + ), +]) + +for transfer in transfers: + print(transfer) +``` + ## Preview payment information before executing the payment You can preview multiple types of payment to confirm any information before actually paying. diff --git a/starkbank/__init__.py b/starkbank/__init__.py index 2838f42..fe9d96c 100644 --- a/starkbank/__init__.py +++ b/starkbank/__init__.py @@ -121,6 +121,12 @@ from . import deposit from .deposit.__deposit import Deposit +from . import verifiedaccount +from .verifiedaccount.__verifiedaccount import VerifiedAccount + +from . import verifiedtransfer +from .verifiedtransfer.__verifiedtransfer import VerifiedTransfer + from . import split from .split.__split import Split diff --git a/starkbank/verifiedaccount/__init__.py b/starkbank/verifiedaccount/__init__.py new file mode 100644 index 0000000..fdcfe6a --- /dev/null +++ b/starkbank/verifiedaccount/__init__.py @@ -0,0 +1,3 @@ +from .__verifiedaccount import create, get, query, page, cancel +from .log.__log import Log +from . import log diff --git a/starkbank/verifiedaccount/__verifiedaccount.py b/starkbank/verifiedaccount/__verifiedaccount.py new file mode 100644 index 0000000..93240ac --- /dev/null +++ b/starkbank/verifiedaccount/__verifiedaccount.py @@ -0,0 +1,143 @@ +from ..utils import rest +from starkcore.utils.resource import Resource +from starkcore.utils.checks import check_datetime, check_date + + +class VerifiedAccount(Resource): + """# VerifiedAccount object + When you initialize a VerifiedAccount, the entity will not be automatically + created in the Stark Bank API. The 'create' function sends the objects + to the Stark Bank API and returns the list of created objects. + ## Parameters (required): + - tax_id [string]: receiver tax ID (CPF or CNPJ) with or without formatting. ex: "01234567890" or "20.018.183/0001-80" + ## Parameters (conditionally required): + - bank_code [string]: code of the receiver bank institution in Brazil. If an ISPB (8 digits) is informed, a Pix transfer will be created, else a TED will be issued. The bank_code parameter is required if verifying with bank details. ex: "20018183" or "341" + - branch_code [string]: receiver bank account branch. Use "-" in case there is a verifier digit. ex: "1357-9". The branch_code parameter is required if verifying with bank details. + - key_id [string]: pix key identifier. ex: "tony@starkbank.com", "012.345.678-90". The key_id parameter is required if verifying with Pix key. + - name [string]: receiver full name. ex: "Anthony Edward Stark". The name parameter is required if verifying with bank details. + - number [string]: receiver bank account number. Use "-" before the verifier digit. ex: "876543-2". The number parameter is required if verifying with bank details. + - type [string]: verified account type. ex: "checking", "savings", "salary" or "payment". The type parameter is required if verifying with bank details. + ## Parameters (optional): + - tags [list of strings, default []]: list of strings for reference when searching for verified accounts. ex: ["employees", "monthly"] + ## Attributes (return-only): + - id [string]: unique id returned when the VerifiedAccount is created. ex: "5656565656565656" + - bank_name [string]: bank name associated with the verified account. ex: "Stark Bank" + - status [string]: current verified account status. ex: "creating", "created", "processing", "active", "failed" or "canceled" + - created [datetime.datetime]: creation datetime for the verified account. ex: datetime.datetime(2020, 3, 10, 10, 30, 0, 0) + - updated [datetime.datetime]: latest update datetime for the verified account. ex: datetime.datetime(2020, 3, 10, 10, 30, 0, 0) + """ + + def __init__(self, tax_id, bank_code=None, branch_code=None, key_id=None, name=None, number=None, + type=None, tags=None, id=None, bank_name=None, status=None, created=None, updated=None): + Resource.__init__(self, id=id) + + self.tax_id = tax_id + self.bank_code = bank_code + self.branch_code = branch_code + self.key_id = key_id + self.name = name + self.number = number + self.type = type + self.tags = tags + self.bank_name = bank_name + self.status = status + self.created = check_datetime(created) + self.updated = check_datetime(updated) + + +_resource = {"class": VerifiedAccount, "name": "VerifiedAccount"} + + +def create(verified_accounts, user=None): + """# Create VerifiedAccounts + Send a list of VerifiedAccount objects for creation in the Stark Bank API + ## Parameters (required): + - verified_accounts [list of VerifiedAccount objects]: list of VerifiedAccount objects to be created in the API + ## Parameters (optional): + - user [Organization/Project object, default None]: Organization or Project object. Not necessary if starkbank.user was set before function call + ## Return: + - list of VerifiedAccount objects with updated attributes + """ + return rest.post_multi(resource=_resource, entities=verified_accounts, user=user) + + +def get(id, user=None): + """# Retrieve a specific VerifiedAccount + Receive a single VerifiedAccount object previously created in the Stark Bank API by its id + ## Parameters (required): + - id [string]: object unique id. ex: "5656565656565656" + ## Parameters (optional): + - user [Organization/Project object, default None]: Organization or Project object. Not necessary if starkbank.user was set before function call + ## Return: + - VerifiedAccount object with updated attributes + """ + return rest.get_id(resource=_resource, id=id, user=user) + + +def cancel(id, user=None): + """# Cancel a VerifiedAccount entity + Cancel a VerifiedAccount entity previously created in the Stark Bank API + ## Parameters (required): + - id [string]: VerifiedAccount unique id. ex: "5656565656565656" + ## Parameters (optional): + - user [Organization/Project object, default None]: Organization or Project object. Not necessary if starkbank.user was set before function call + ## Return: + - canceled VerifiedAccount object + """ + return rest.delete_id(resource=_resource, id=id, user=user) + + +def query(limit=None, after=None, before=None, status=None, ids=None, tags=None, user=None): + """# Retrieve VerifiedAccounts + Receive a generator of VerifiedAccount objects previously created in the Stark Bank API + ## Parameters (optional): + - limit [integer, default None]: maximum number of objects to be retrieved. Unlimited if None. ex: 35 + - after [datetime.date or string, default None]: date filter for objects created or updated only after specified date. ex: datetime.date(2020, 3, 10) + - before [datetime.date or string, default None]: date filter for objects created or updated only before specified date. ex: datetime.date(2020, 3, 10) + - status [string, default None]: filter for status of retrieved objects. ex: "creating", "created", "processing", "active", "failed" or "canceled" + - ids [list of strings, default None]: list of ids to filter retrieved objects. ex: ["5656565656565656", "4545454545454545"] + - tags [list of strings, default None]: tags to filter retrieved objects. ex: ["tony", "stark"] + - user [Organization/Project object, default None]: Organization or Project object. Not necessary if starkbank.user was set before function call + ## Return: + - generator of VerifiedAccount objects with updated attributes + """ + return rest.get_stream( + resource=_resource, + limit=limit, + after=check_date(after), + before=check_date(before), + status=status, + ids=ids, + tags=tags, + user=user, + ) + + +def page(cursor=None, limit=None, after=None, before=None, status=None, ids=None, tags=None, user=None): + """# Retrieve paged VerifiedAccounts + Receive a list of up to 100 VerifiedAccount objects previously created in the Stark Bank API and the cursor to the next page. + Use this function instead of query if you want to manually page your requests. + ## Parameters (optional): + - cursor [string, default None]: cursor returned on the previous page function call + - limit [integer, default 100]: maximum number of objects to be retrieved. It must be an integer between 1 and 100. ex: 50 + - after [datetime.date or string, default None]: date filter for objects created or updated only after specified date. ex: datetime.date(2020, 3, 10) + - before [datetime.date or string, default None]: date filter for objects created or updated only before specified date. ex: datetime.date(2020, 3, 10) + - status [string, default None]: filter for status of retrieved objects. ex: "creating", "created", "processing", "active", "failed" or "canceled" + - ids [list of strings, default None]: list of ids to filter retrieved objects. ex: ["5656565656565656", "4545454545454545"] + - tags [list of strings, default None]: tags to filter retrieved objects. ex: ["tony", "stark"] + - user [Organization/Project object, default None]: Organization or Project object. Not necessary if starkbank.user was set before function call + ## Return: + - list of VerifiedAccount objects with updated attributes + - cursor to retrieve the next page of VerifiedAccount objects + """ + return rest.get_page( + resource=_resource, + cursor=cursor, + limit=limit, + after=check_date(after), + before=check_date(before), + status=status, + ids=ids, + tags=tags, + user=user, + ) diff --git a/starkbank/verifiedaccount/log/__init__.py b/starkbank/verifiedaccount/log/__init__.py new file mode 100644 index 0000000..ba79045 --- /dev/null +++ b/starkbank/verifiedaccount/log/__init__.py @@ -0,0 +1 @@ +from .__log import get, query, page, Log diff --git a/starkbank/verifiedaccount/log/__log.py b/starkbank/verifiedaccount/log/__log.py new file mode 100644 index 0000000..2b34a5c --- /dev/null +++ b/starkbank/verifiedaccount/log/__log.py @@ -0,0 +1,94 @@ +from ...utils import rest +from starkcore.utils.api import from_api_json +from starkcore.utils.resource import Resource +from starkcore.utils.checks import check_datetime, check_date +from ..__verifiedaccount import _resource as _verified_account_resource + + +class Log(Resource): + """# verifiedaccount.Log object + Every time a VerifiedAccount entity is modified, a corresponding verifiedaccount.Log + is generated for the entity. This log is never generated by the user. + ## Attributes (return-only): + - id [string]: unique id returned when the log is created. ex: "5656565656565656" + - account [VerifiedAccount]: VerifiedAccount entity to which the log refers to. + - errors [list of strings]: list of errors linked to this VerifiedAccount event. + - type [string]: type of the VerifiedAccount event which triggered the log creation. ex: "created" or "processing" + - created [datetime.datetime]: creation datetime for the log. ex: datetime.datetime(2020, 3, 10, 10, 30, 0, 0) + """ + + def __init__(self, id, created, type, errors, account): + Resource.__init__(self, id=id) + + self.created = check_datetime(created) + self.type = type + self.errors = errors + self.account = from_api_json(_verified_account_resource, account) + + +_resource = {"class": Log, "name": "VerifiedAccountLog"} + + +def get(id, user=None): + """# Retrieve a specific verifiedaccount.Log + Receive a single verifiedaccount.Log object previously created by the Stark Bank API by its id + ## Parameters (required): + - id [string]: object unique id. ex: "5656565656565656" + ## Parameters (optional): + - user [Organization/Project object, default None]: Organization or Project object. Not necessary if starkbank.user was set before function call + ## Return: + - verifiedaccount.Log object with updated attributes + """ + return rest.get_id(resource=_resource, id=id, user=user) + + +def query(limit=None, after=None, before=None, types=None, account_ids=None, user=None): + """# Retrieve verifiedaccount.Logs + Receive a generator of verifiedaccount.Log objects previously created in the Stark Bank API + ## Parameters (optional): + - limit [integer, default None]: maximum number of objects to be retrieved. Unlimited if None. ex: 35 + - after [datetime.date or string, default None]: date filter for objects created only after specified date. ex: datetime.date(2020, 3, 10) + - before [datetime.date or string, default None]: date filter for objects created only before specified date. ex: datetime.date(2020, 3, 10) + - types [list of strings, default None]: filter retrieved objects by types. ex: "created" or "processing" + - account_ids [list of strings, default None]: list of VerifiedAccount ids to filter retrieved objects. ex: ["5656565656565656", "4545454545454545"] + - user [Organization/Project object, default None]: Organization or Project object. Not necessary if starkbank.user was set before function call + ## Return: + - generator of verifiedaccount.Log objects with updated attributes + """ + return rest.get_stream( + resource=_resource, + limit=limit, + after=check_date(after), + before=check_date(before), + types=types, + account_ids=account_ids, + user=user, + ) + + +def page(cursor=None, limit=None, after=None, before=None, types=None, account_ids=None, user=None): + """# Retrieve paged verifiedaccount.Logs + Receive a list of up to 100 verifiedaccount.Log objects previously created in the Stark Bank API and the cursor to the next page. + Use this function instead of query if you want to manually page your requests. + ## Parameters (optional): + - cursor [string, default None]: cursor returned on the previous page function call + - limit [integer, default 100]: maximum number of objects to be retrieved. It must be an integer between 1 and 100. ex: 50 + - after [datetime.date or string, default None]: date filter for objects created only after specified date. ex: datetime.date(2020, 3, 10) + - before [datetime.date or string, default None]: date filter for objects created only before specified date. ex: datetime.date(2020, 3, 10) + - types [list of strings, default None]: filter retrieved objects by types. ex: "created" or "processing" + - account_ids [list of strings, default None]: list of VerifiedAccount ids to filter retrieved objects. ex: ["5656565656565656", "4545454545454545"] + - user [Organization/Project object, default None]: Organization or Project object. Not necessary if starkbank.user was set before function call + ## Return: + - list of verifiedaccount.Log objects with updated attributes + - cursor to retrieve the next page of verifiedaccount.Log objects + """ + return rest.get_page( + resource=_resource, + cursor=cursor, + limit=limit, + after=check_date(after), + before=check_date(before), + types=types, + account_ids=account_ids, + user=user, + ) diff --git a/starkbank/verifiedtransfer/__init__.py b/starkbank/verifiedtransfer/__init__.py new file mode 100644 index 0000000..9d350e1 --- /dev/null +++ b/starkbank/verifiedtransfer/__init__.py @@ -0,0 +1 @@ +from .__verifiedtransfer import create diff --git a/starkbank/verifiedtransfer/__verifiedtransfer.py b/starkbank/verifiedtransfer/__verifiedtransfer.py new file mode 100644 index 0000000..24a899f --- /dev/null +++ b/starkbank/verifiedtransfer/__verifiedtransfer.py @@ -0,0 +1,80 @@ +from ..utils import rest +from ..transfer.rule.__rule import Rule +from ..transfer.rule.__rule import _sub_resource as _rule_resource +from starkcore.utils.api import from_api_json +from starkcore.utils.resource import Resource +from starkcore.utils.checks import check_datetime, check_datetime_or_date + + +class VerifiedTransfer(Resource): + """# VerifiedTransfer object + When you initialize a VerifiedTransfer, the entity will not be automatically + created in the Stark Bank API. The 'create' function sends the objects + to the Stark Bank API and returns the list of created objects. + ## Parameters (required): + - amount [integer]: transfer value in cents. ex: 1234 (= R$ 12.34) + - account_id [string]: receiver's VerifiedAccount ID. ex: "5656565656565656" + ## Parameters (optional): + - external_id [string, default None]: url safe string that must be unique among all your transfers. Duplicated external_ids will cause failures. By default, this parameter will block any transfer that repeats amount and receiver information on the same date. ex: "my-internal-id-123456" + - scheduled [datetime.date, datetime.datetime or string, default now]: date or datetime when the transfer will be processed. May be pushed to next business day if necessary. ex: "2020-11-12T00:14:22.806+00:00" or "2020-11-30" + - description [string, default None]: optional description to override default description to be shown in the bank statement. ex: "Payment for service #1234" + - display_description [string, default None]: optional description to be shown in the receiver bank interface. ex: "Payment for service #1234" + - tags [list of strings, default []]: list of strings for reference when searching for verified transfers. ex: ["employees", "monthly"] + - rules [list of transfer.Rule objects, default []]: list of transfer.Rule objects for modifying transfer behaviour. ex: [transfer.Rule(key="resendingLimit", value=5)] + ## Attributes (return-only): + - id [string]: unique id returned when the VerifiedTransfer is created. ex: "5656565656565656" + - fee [integer]: fee charged when the transfer is created. ex: 200 (= R$ 2.00) + - status [string]: current verified transfer status. ex: "created", "processing", "success" or "failed" + - transaction_ids [list of strings]: ledger transaction ids linked to this transfer (if there are two, second is the chargeback). ex: ["19827356981273"] + - metadata [dictionary]: dictionary object used to store additional information about the VerifiedTransfer object. + - created [datetime.datetime]: creation datetime for the verified transfer. ex: datetime.datetime(2020, 3, 10, 10, 30, 0, 0) + - updated [datetime.datetime]: latest update datetime for the verified transfer. ex: datetime.datetime(2020, 3, 10, 10, 30, 0, 0) + """ + + def __init__(self, amount, account_id, external_id=None, scheduled=None, description=None, + display_description=None, tags=None, rules=None, id=None, fee=None, status=None, + transaction_ids=None, metadata=None, created=None, updated=None): + Resource.__init__(self, id=id) + + self.amount = amount + self.account_id = account_id + self.external_id = external_id + self.scheduled = check_datetime_or_date(scheduled) + self.description = description + self.display_description = display_description + self.tags = tags + self.rules = _parse_rules(rules) + self.fee = fee + self.status = status + self.transaction_ids = transaction_ids + self.metadata = metadata + self.created = check_datetime(created) + self.updated = check_datetime(updated) + + +_resource = {"class": VerifiedTransfer, "name": "VerifiedTransfer"} + + +def _parse_rules(rules): + if rules is None: + return None + parsed_rules = [] + for rule in rules: + if isinstance(rule, Rule): + parsed_rules.append(rule) + continue + parsed_rules.append(from_api_json(_rule_resource, rule)) + return parsed_rules + + +def create(verified_transfers, user=None): + """# Create VerifiedTransfers + Send a list of VerifiedTransfer objects for creation in the Stark Bank API + ## Parameters (required): + - verified_transfers [list of VerifiedTransfer objects]: list of VerifiedTransfer objects to be created in the API + ## Parameters (optional): + - user [Organization/Project object, default None]: Organization or Project object. Not necessary if starkbank.user was set before function call + ## Return: + - list of VerifiedTransfer objects with updated attributes + """ + return rest.post_multi(resource=_resource, entities=verified_transfers, user=user) diff --git a/tests/sdk/test_verified_account.py b/tests/sdk/test_verified_account.py new file mode 100644 index 0000000..7648746 --- /dev/null +++ b/tests/sdk/test_verified_account.py @@ -0,0 +1,96 @@ +import starkbank +from unittest import TestCase, main +from datetime import date, timedelta +from tests.utils.verifiedAccount import generateExampleBankInfoVerifiedAccountJson, generateExamplePixKeyVerifiedAccountJson +from tests.utils.user import exampleProject + + +starkbank.user = exampleProject + + +class TestVerifiedAccountCreate(TestCase): + + def test_success(self): + accounts = starkbank.verifiedaccount.create([generateExampleBankInfoVerifiedAccountJson()]) + self.assertEqual(len(accounts), 1) + self.assertIsNotNone(accounts[0].id) + + +class TestVerifiedAccountCreateWithPixKey(TestCase): + + def test_success(self): + accounts = starkbank.verifiedaccount.create([generateExamplePixKeyVerifiedAccountJson()]) + self.assertEqual(len(accounts), 1) + self.assertIsNotNone(accounts[0].id) + + +class TestVerifiedAccountCreateAndGet(TestCase): + + def test_success(self): + accounts = starkbank.verifiedaccount.create([generateExampleBankInfoVerifiedAccountJson()]) + created = accounts[0] + self.assertIsNotNone(created.id) + retrieved = starkbank.verifiedaccount.get(created.id) + self.assertEqual(retrieved.id, created.id) + + +class TestVerifiedAccountCreateAndCancel(TestCase): + + def test_success(self): + accounts = starkbank.verifiedaccount.create([generateExampleBankInfoVerifiedAccountJson()]) + created = accounts[0] + self.assertIsNotNone(created.id) + canceled = starkbank.verifiedaccount.cancel(created.id) + self.assertEqual(canceled.id, created.id) + self.assertEqual(canceled.status, "canceled") + + +class TestVerifiedAccountQuery(TestCase): + + def test_success(self): + accounts = list(starkbank.verifiedaccount.query(limit=3, status="active")) + self.assertLessEqual(len(accounts), 3) + for account in accounts: + self.assertIsNotNone(account.id) + + +class TestVerifiedAccountQueryFilters(TestCase): + + def test_success(self): + created = starkbank.verifiedaccount.create([generateExampleBankInfoVerifiedAccountJson()])[0] + + accounts = list(starkbank.verifiedaccount.query( + tags=["verified-account-test"], + after=date.today() - timedelta(days=100), + before=date.today(), + )) + self.assertGreater(len(accounts), 0) + found = False + for account in accounts: + self.assertIsNotNone(account.id) + if account.id == created.id: + found = True + self.assertTrue(found) + + accounts_by_id = list(starkbank.verifiedaccount.query(ids=[created.id])) + self.assertEqual(len(accounts_by_id), 1) + self.assertEqual(accounts_by_id[0].id, created.id) + + +class TestVerifiedAccountPage(TestCase): + + def test_success(self): + cursor = None + ids = [] + for _ in range(2): + accounts, cursor = starkbank.verifiedaccount.page(limit=5, cursor=cursor) + for account in accounts: + self.assertFalse(account.id in ids) + ids.append(account.id) + if cursor is None: + break + self.assertGreater(len(ids), 0) + + +if __name__ == '__main__': + main() diff --git a/tests/sdk/test_verified_account_log.py b/tests/sdk/test_verified_account_log.py new file mode 100644 index 0000000..cfc821e --- /dev/null +++ b/tests/sdk/test_verified_account_log.py @@ -0,0 +1,57 @@ +import starkbank +from unittest import TestCase, main +from tests.utils.verifiedAccount import generateExampleBankInfoVerifiedAccountJson +from tests.utils.user import exampleProject + + +starkbank.user = exampleProject + + +class TestVerifiedAccountLogQuery(TestCase): + + def test_success(self): + logs = list(starkbank.verifiedaccount.log.query(limit=3)) + self.assertLessEqual(len(logs), 3) + for log in logs: + self.assertIsNotNone(log.id) + + +class TestVerifiedAccountLogQueryByAccountIds(TestCase): + + def test_success(self): + account = starkbank.verifiedaccount.create([generateExampleBankInfoVerifiedAccountJson()])[0] + logs = list(starkbank.verifiedaccount.log.query(account_ids=[account.id], limit=1)) + self.assertGreater(len(logs), 0) + for log in logs: + self.assertIsNotNone(log.id) + self.assertEqual(log.account.id, account.id) + + +class TestVerifiedAccountLogPage(TestCase): + + def test_success(self): + cursor = None + ids = [] + for _ in range(2): + logs, cursor = starkbank.verifiedaccount.log.page(limit=5, cursor=cursor) + for log in logs: + self.assertFalse(log.id in ids) + ids.append(log.id) + if cursor is None: + break + self.assertGreater(len(ids), 0) + + +class TestVerifiedAccountLogGet(TestCase): + + def test_success(self): + logs = list(starkbank.verifiedaccount.log.query(limit=5)) + self.assertGreater(len(logs), 0) + log_id = logs[0].id + log = starkbank.verifiedaccount.log.get(log_id) + self.assertEqual(log.id, log_id) + self.assertIsNotNone(log.account.id) + + +if __name__ == '__main__': + main() diff --git a/tests/sdk/test_verified_transfer.py b/tests/sdk/test_verified_transfer.py new file mode 100644 index 0000000..6acd6a0 --- /dev/null +++ b/tests/sdk/test_verified_transfer.py @@ -0,0 +1,38 @@ +import starkbank +from unittest import TestCase, main +from tests.utils.verifiedAccount import generateExampleBankInfoVerifiedAccountJson +from tests.utils.verifiedTransfer import generateExampleVerifiedTransferJson +from tests.utils.user import exampleProject + + +starkbank.user = exampleProject + + +class TestVerifiedTransferCreate(TestCase): + + def test_success(self): + accounts = starkbank.verifiedaccount.create([generateExampleBankInfoVerifiedAccountJson()]) + account_id = accounts[0].id + + example = generateExampleVerifiedTransferJson(account_id) + transfers = starkbank.verifiedtransfer.create([example]) + self.assertEqual(len(transfers), 1) + transfer = transfers[0] + self.assertIsNotNone(transfer.id) + self.assertEqual(transfer.amount, example.amount) + self.assertIsNotNone(transfer.status) + + self.assertTrue(len(transfer.rules) > 0) + resending_limit_rule = None + for rule in transfer.rules: + if rule.key == "resendingLimit": + resending_limit_rule = rule + self.assertIsNotNone(resending_limit_rule) + self.assertEqual(resending_limit_rule.value, 5) + + retrieved = starkbank.transfer.get(transfer.id) + self.assertEqual(retrieved.id, transfer.id) + + +if __name__ == '__main__': + main() diff --git a/tests/utils/verifiedAccount.py b/tests/utils/verifiedAccount.py new file mode 100644 index 0000000..74f085d --- /dev/null +++ b/tests/utils/verifiedAccount.py @@ -0,0 +1,22 @@ +from starkbank import VerifiedAccount +from tests.utils.taxIdGenerator import TaxIdGenerator + + +def generateExampleBankInfoVerifiedAccountJson(): + return VerifiedAccount( + tax_id=TaxIdGenerator.cpf(), + name="Daenerys Targaryen Stormborn", + bank_code="341", + branch_code="2201", + number="76543-8", + type="checking", + tags=["verified-account-test"], + ) + + +def generateExamplePixKeyVerifiedAccountJson(): + return VerifiedAccount( + tax_id="039.946.040-36", + key_id="arya.stark@starkbank.com", + tags=["verified-account-test"], + ) diff --git a/tests/utils/verifiedTransfer.py b/tests/utils/verifiedTransfer.py new file mode 100644 index 0000000..38b1c76 --- /dev/null +++ b/tests/utils/verifiedTransfer.py @@ -0,0 +1,17 @@ +from uuid import uuid4 +from starkbank import VerifiedTransfer +from starkbank.transfer import Rule + + +def generateExampleVerifiedTransferJson(account_id): + return VerifiedTransfer( + amount=1000, + account_id=account_id, + external_id=str(uuid4()), + tags=["verified-transfer-test"], + description="Test description", + display_description="Test display description", + rules=[ + Rule(key="resendingLimit", value=5), + ], + )