def test_camelcase_aliases_on_Address(self): addr = Address('line1', 'line2', 'city', 'region', 'postal code', 'country') self.assertIs(addr.AddressLine1, addr.address_line_1) self.assertIs(addr.AddressLine2, addr.address_line_2) self.assertIs(addr.City, addr.city) self.assertIs(addr.Region, addr.region) self.assertIs(addr.PostalCode, addr.postal_code) self.assertIs(addr.Country, addr.country) addr.AddressLine2 = None self.assertIs(addr.address_line_2, None) addr.region = None self.assertIs(addr.Region, None)
def legal_user(self): legal_user_params = { "name": "MangoPay", "legal_person_type": "BUSINESS", "headquarters_address": Address(address_line_1='AddressLine1', address_line_2='AddressLine2', city='City', region='Region', postal_code='11222', country='FR'), "legal_representative_first_name": "Mango", "legal_representative_last_name": "Pay", "legal_representative_email": "*****@*****.**", "legal_representative_birthday": time.mktime(date.today().timetuple()), "legal_representative_nationality": "FR", "legal_representative_country_of_residence": "FR", "proof_of_registration": None, "shareholder_declaration": None, "legal_representative_address": None, "statute": None, "person_type": "LEGAL", "email": "*****@*****.**", "tag": "custom tag", # "creation_date": datetime.now() } legal_user = LegalUser(**legal_user_params) legal_user.save() return legal_user
def get_user_legal(recreate=False, terms=False): if BaseTestLive._user_legal is None or recreate: legal = LegalUser() legal.name = 'MatrixSampleOrg_PythonSDK' legal.email = '*****@*****.**' legal.legal_person_type = "BUSINESS" legal.legal_representative_first_name = "Mango" legal.legal_representative_last_name = 'Pay' legal.legal_representative_email = '*****@*****.**' legal.person_type = 'LEGAL' legal.headquarters_address = Address(address_line_1='AddressLine1', address_line_2='AddressLine2', city='City', region='Region', postal_code='11222', country='FR') legal.legal_representative_birthday = 1300186358 legal.legal_representative_nationality = 'FR' legal.legal_representative_country_of_residence = 'FR' legal.company_number = 123456789 legal.tag = 'Python SDK Unit Test' legal.terms_and_conditions_accepted = terms legal.user_category = 'OWNER' BaseTestLive._user_legal = LegalUser(**legal.save()) return BaseTestLive._user_legal
def get_user(self): return LegalUser( id=self.mangopay_id, email=self.business_email, name=self.business_name, legal_person_type=self.legal_person_type, headquarters_address=Address( address_line_1=self.headquarters_address), legal_representative_first_name=self.first_name, legal_representative_last_name=self.last_name, legal_representative_address=Address(address_line_1=self.address), legal_representative_email=self.email, legal_representative_birthday=self._birthday_fmt(), legal_representative_nationality=self.nationality.code, legal_representative_country_of_residence=self. country_of_residence.code, )
def test_RecurringPayment_Get(self): user = self.get_john(True) wallet = self.get_johns_wallet(True) card = BaseTestLive.get_johns_card_3dsecure(True) recurring = RecurringPayInRegistration() recurring.author = user recurring.card = card recurring.user = user recurring.credited_wallet = wallet recurring.first_transaction_fees = Money() recurring.first_transaction_fees.amount = 1 recurring.first_transaction_fees.currency = "EUR" recurring.first_transaction_debited_funds = Money() recurring.first_transaction_debited_funds.amount = 10 recurring.first_transaction_debited_funds.currency = "EUR" address = Address() address.address_line_1 = "Big Street" address.address_line_2 = "no 2 ap 6" address.country = "FR" address.city = "Lyon" address.postal_code = "68400" recurring.billing = Billing(first_name="John", last_name="Doe", address=address) recurring.shipping = Shipping(first_name="John", last_name="Doe", address=address) result = recurring.save() self.assertIsNotNone(result) rec_id = result.get("id") get = RecurringPayInRegistration.get(rec_id) self.assertIsNotNone(get)
def test_create_ubo_declaration(self): self.mock_legal_user() self.mock_declarative_user() self.mock_ubo_declaration() params = { "first_name": "Victor", "last_name": "Hugo", "address": Address(address_line_1='AddressLine1', address_line_2='AddressLine2', city='City', region='Region', postal_code='11222', country='FR'), "birthday": today, "nationality": "FR", "country_of_residence": "FR", "occupation": "Writer", "income_range": 6, "proof_of_identity": None, "proof_of_address": None, "person_type": "NATURAL", "email": "*****@*****.**", "tag": "custom tag", "capacity": "DECLARATIVE" } user = NaturalUser(**params) user.save() params = {"user_id": "1169420", "declared_ubos": ["11694190"]} ubo_declaration = UboDeclaration(**params) ubo_declaration.save() self.assertTrue(isinstance(ubo_declaration, UboDeclaration)) self.assertTrue(ubo_declaration.id == "1169420") self.assertTrue(len(ubo_declaration.declared_ubos) == 1) ubo = ubo_declaration.declared_ubos[0] self.assertTrue(isinstance(ubo, DeclaredUbo)) self.assertTrue(ubo.user_id == '11694190') self.assertTrue(ubo.status == 'CREATED')
def test_create_bankaccount_ca(self): self.mock_natural_user() self.register_mock({ 'method': responses.POST, 'url': settings.MANGOPAY_API_SANDBOX_URL+settings.MANGOPAY_CLIENT_ID+'/users/1169419/bankaccounts/CA', 'body': { "UserId": "1169419", "OwnerName": "Victor Hugo", "OwnerAddress": { "AddressLine1": "AddressLine1", "AddressLine2": "AddressLine2", "City": "City", "Region": "Region", "PostalCode": "11222", "Country": "FR" }, "Type": "CA", "Id": "6775449", "Tag": "custom tag", "CreationDate": 1431964854, "AccountNumber": "123", "InstitutionNumber": "1234", "BranchCode": "12345", "BankName": "banque nationale of canada" }, 'status': 200 }) params = { "owner_name": "Victor Hugo", "user": self.natural_user, "type": "CA", "owner_address": Address(address_line_1='AddressLine1', address_line_2='AddressLine2', city='City', region='Region', postal_code='11222', country='FR'), "tag": "custom tag", "bank_name": "banque nationale of canada", "institution_number": "1234", "branch_code": "12345", "account_number": "123" } bankaccount = BankAccount(**params) self.assertIsNone(bankaccount.get_pk()) bankaccount.save() self.assertIsInstance(bankaccount, BankAccount) for key, value in params.items(): self.assertEqual(getattr(bankaccount, key), value) self.assertIsNotNone(bankaccount.get_pk())
def test_PreAuthorizations_CreateWithAvs(self): user = BaseTestLive.get_john() card_registration = CardRegistration() card_registration.user = user card_registration.currency = "EUR" saved_registration = card_registration.save() data = { 'cardNumber': '4972485830400049', 'cardCvx': '123', 'cardExpirationDate': '0821', 'accessKeyRef': card_registration.access_key, 'data': card_registration.preregistration_data } headers = {'content-type': 'application/x-www-form-urlencoded'} registration_data_response = requests.post( card_registration.card_registration_url, data=data, headers=headers) saved_registration[ 'registration_data'] = registration_data_response.text updated_registration = CardRegistration(**saved_registration).save() card = Card.get(updated_registration['card_id']) pre_authorization = PreAuthorization() pre_authorization.card = card pre_authorization.author = user pre_authorization.debited_funds = Money() pre_authorization.debited_funds.currency = "EUR" pre_authorization.debited_funds.amount = 500 pre_authorization.remaining_funds = Money() pre_authorization.remaining_funds.currency = "EUR" pre_authorization.remaining_funds.amount = 500 pre_authorization.secure_mode_return_url = "http://www.example.com/" billing = Billing() billing.address = Address() billing.address.address_line_1 = "Main Street" billing.address.address_line_2 = "no. 5 ap. 6" billing.address.country = "FR" billing.address.city = "Lyon" billing.address.postal_code = "65400" billing.last_name = "Doe" billing.first_name = "John" pre_authorization.billing = billing saved_pre_authorization = pre_authorization.save() self.assertIsNotNone(saved_pre_authorization) security_info = saved_pre_authorization['security_info'] self.assertIsInstance(security_info, SecurityInfo) self.assertEqual(security_info.avs_result, "NO_CHECK")
def get_user(self): return NaturalUser( id=self.mangopay_id, first_name=self._first_name, last_name=self._last_name, address=Address( address_line_1=self.address), # TODO: add other address fields birthday=self._birthday_fmt(), nationality=self.nationality.code, country_of_residence=self.country_of_residence.code, occupation=self.occupation, income_range=self.income_range, proof_of_identity=None, proof_of_address=None, email=self.email, )
def test_update_ubo_declaration(self): self.mock_legal_user() self.mock_declarative_user() self.mock_ubo_declaration() params = { "first_name": "Victor", "last_name": "Hugo", "address": Address(address_line_1='AddressLine1', address_line_2='AddressLine2', city='City', region='Region', postal_code='11222', country='FR'), "birthday": today, "nationality": "FR", "country_of_residence": "FR", "occupation": "Writer", "income_range": 6, "proof_of_identity": None, "proof_of_address": None, "person_type": "NATURAL", "email": "*****@*****.**", "tag": "custom tag", "capacity": "DECLARATIVE" } user = NaturalUser(**params) user.save() params = { "user_id": "1169420", "declared_ubos": ["11694190"] } ubo_declaration = UboDeclaration(**params) ubo_declaration.save() updated_value = 'Updated Tag' self.register_mock({ "method": responses.PUT, "url": settings.MANGOPAY_API_SANDBOX_URL + settings.MANGOPAY_CLIENT_ID + '/ubodeclarations/1169420', "body": get_fixture('ubo_declaration') % ('"' + updated_value + '"'), "status": 200 }) ubo_declaration.tag = updated_value ubo_declaration.save() self.assertTrue(ubo_declaration.id == "1169420") self.assertTrue(ubo_declaration.tag == updated_value)
def legal_user_ubo_declaration(self): self.mock_declarative_user() self.mock_ubo_declaration() params = { "first_name": "Victor", "last_name": "Hugo", "address": Address(address_line_1='AddressLine1', address_line_2='AddressLine2', city='City', region='Region', postal_code='11222', country='FR'), "birthday": 1231432, "nationality": "FR", "country_of_residence": "FR", "occupation": "Writer", "income_range": 6, "proof_of_identity": None, "proof_of_address": None, "person_type": "NATURAL", "email": "*****@*****.**", "tag": "Python SDK Unit Test", "capacity": "DECLARATIVE" } user = NaturalUser(**params) user.save() params = {"user": user, "creation_date": 1554803756} ubo_declaration = UboDeclaration(**params) ubo_declaration.save() return ubo_declaration, user
def test_create_bankaccount_gb(self): self.mock_natural_user() self.register_mock({ 'method': responses.POST, 'url': settings.MANGOPAY_API_SANDBOX_URL+settings.MANGOPAY_CLIENT_ID+'/users/1169419/bankaccounts/GB', 'body': { "UserId": "1169419", "Type": "GB", "OwnerName": "Victor Hugo", "OwnerAddress": { "AddressLine1": "AddressLine1", "AddressLine2": "AddressLine2", "City": "City", "Region": "Region", "PostalCode": "11222", "Country": "FR" }, "AccountNumber": "62136016", "SortCode": "404865", "Id": "38290008", "Tag": "custom tag", "CreationDate": 1383561267 }, 'status': 200 }) params = { "tag": "custom tag", "user": self.natural_user, "type": "GB", "owner_name": "Victor Hugo", "owner_address": Address(address_line_1='AddressLine1', address_line_2='AddressLine2', city='City', region='Region', postal_code='11222', country='FR'), "account_number": "62136016", "sort_code": "404865" } bankaccount = BankAccount(**params) self.assertIsNone(bankaccount.get_pk()) bankaccount.save() self.assertIsInstance(bankaccount, BankAccount) for key, value in params.items(): self.assertEqual(getattr(bankaccount, key), value) self.assertIsNotNone(bankaccount.get_pk())
def get_john(recreate=False): if BaseTestLive._john is None or recreate: user = NaturalUser() user.first_name = 'John' user.last_name = 'Doe' user.birthday = 188352000 user.email = "*****@*****.**" user.address = Address(address_line_1='AddressLine1', address_line_2='AddressLine2', city='City', region='Region', postal_code='11222', country='FR') user.nationality = 'FR' user.country_of_residence = 'FR' user.occupation = 'programmer' user.income_range = '1' user.person_type = 'NATURAL' BaseTestLive._john = NaturalUser(**user.save()) return BaseTestLive._john
def test_PreAuthorizations_CreateWithAvs(self): user = BaseTestLive.get_john() card_registration = CardRegistration() card_registration.user = user card_registration.currency = "EUR" saved_registration = card_registration.save() registration_data_response = requests.post( card_registration.card_registration_url, urlrequest.urlencode({ 'cardNumber': '4970100000000154', 'cardCvx': '123', 'cardExpirationDate': '0120', 'accessKeyRef': card_registration.access_key, 'data': card_registration.preregistration_data })) saved_registration[ 'registration_data'] = registration_data_response.text updated_registration = CardRegistration(**saved_registration).save() card = Card.get(updated_registration['card_id']) pre_authorization = PreAuthorization() pre_authorization.card = card pre_authorization.author = user pre_authorization.debited_funds = Money() pre_authorization.debited_funds.currency = "EUR" pre_authorization.debited_funds.amount = 500 pre_authorization.secure_mode_return_url = "http://www.example.com/" billing = Billing() billing.address = Address() billing.address.address_line_1 = "Main Street" billing.address.address_line_2 = "no. 5 ap. 6" billing.address.country = "FR" billing.address.city = "Lyon" billing.address.postal_code = "65400" pre_authorization.billing = billing saved_pre_authorization = pre_authorization.save() self.assertIsNotNone(saved_pre_authorization) security_info = saved_pre_authorization['security_info'] self.assertIsInstance(security_info, SecurityInfo) self.assertEqual(security_info.avs_result, "NO_CHECK")
def get_ubo(recreate=False): if BaseTestLive._ubo is None or recreate: address = Address(address_line_1='AddressLine1', address_line_2='AddressLine2', city='City', region='Region', postal_code='11222', country='FR') params = { "user": BaseTestLive.get_user_legal(True), "ubo_declaration": BaseTestLive.get_ubo_declaration(True), "first_name": "Victor", "last_name": "Hugo", "address": address, "birthday": 1231432, "nationality": "FR", "birthplace": Birthplace(city='Paris', country='FR') } BaseTestLive._ubo = Ubo.create(**params) return BaseTestLive._ubo
def ubo_declaration_ubo(self): params = { "first_name": "Victor", "last_name": "Hugo", "address": Address(address_line_1='AddressLine1', address_line_2='AddressLine2', city='City', region='Region', postal_code='11222', country='FR'), "birthday": 1231432, "nationality": "FR", "birthplace": Birthplace(city='Paris', country='FR') } ubo = Ubo(**params) return ubo
def natural_user(self): natural_user_params = { "first_name": "Victor", "last_name": "Hugo", "address": Address(address_line_1='AddressLine1', address_line_2='AddressLine2', city='City', region='Region', postal_code='11222', country='FR'), "birthday": time.mktime(date.today().timetuple()), "nationality": "FR", "country_of_residence": "FR", "occupation": "Writer", "income_range": 6, "proof_of_identity": None, "proof_of_address": None, "person_type": "NATURAL", "email": "*****@*****.**", "tag": "custom tag", } natural_user = NaturalUser(**natural_user_params) natural_user.save() return natural_user
def get_bank_account(self): bank_account = BankAccount( id=self.mangopay_id, owner_name=self.mangopay_user.user.get_full_name(), owner_address=Address(address_line_1=self.address), user=self.mangopay_user.get_user(), type=self.account_type) if self.account_type == BANK_ACCOUNT_TYPE_CHOICES.iban: bank_account.iban = self.iban elif self.account_type == BANK_ACCOUNT_TYPE_CHOICES.us: bank_account.aba = self.aba bank_account.deposit_account_type = self.deposit_account_type bank_account.account_number = self.account_number elif self.account_type == BANK_ACCOUNT_TYPE_CHOICES.other: bank_account.account_number = self.account_number else: raise NotImplementedError( "Bank Account Type ({0}) not implemented.".format( self.account_type)) return bank_account
def test_PayIns_CardDirect_CreateWithAvs(self): user = BaseTestLive.get_john(True) debited_wallet = BaseTestLive.get_johns_wallet(True) # create wallet credited_wallet = Wallet() credited_wallet.owners = (user, ) credited_wallet.currency = 'EUR' credited_wallet.description = 'WALLET IN EUR' credited_wallet = Wallet(**credited_wallet.save()) card = BaseTestLive.get_johns_card(True) pay_in = DirectPayIn() pay_in.author = user pay_in.debited_wallet = debited_wallet pay_in.credited_wallet = credited_wallet pay_in.card = card pay_in.fees = Money() pay_in.fees.amount = 100 pay_in.fees.currency = "EUR" pay_in.debited_funds = Money() pay_in.debited_funds.amount = 1000 pay_in.debited_funds.currency = "EUR" pay_in.secure_mode_return_url = "http://www.example.com/" address = Address() address.address_line_1 = "Big Street" address.address_line_2 = "no 2 ap 6" address.country = "FR" address.city = "Lyon" address.postal_code = "68400" pay_in.billing = Billing(first_name="John", last_name="Doe", address=address) result = pay_in.save() self.assertIsNotNone(result) security_info = result['security_info'] self.assertIsNotNone(security_info) self.assertIsInstance(security_info, SecurityInfo) self.assertEqual(security_info.avs_result, "NO_CHECK")
def test_check_eligibility(self): params = { "owner_name": "Victor Hugo", "user": self.legal_user, "type": "IBAN", "owner_address": Address(address_line_1='AddressLine1', address_line_2='AddressLine2', city='City', region='Region', postal_code='11222', country='FR'), "iban": "FR7630004000031234567890143", "bic": "BNPAFRPP", "tag": "custom tag" } bankaccount = BankAccount(**params) bankaccount.save() eligibility = { "author": self.legal_user, "debited_funds": Money(amount=10, currency='EUR'), "debited_wallet": self.legal_user_wallet, "bank_account": bankaccount, "payout_mode_requested": "INSTANT_PAYMENT" } check_eligibility = PayOutEligibility(**eligibility) result = check_eligibility.check_eligibility() self.assertIsNotNone(result) instant_payout = result.get('instant_payout') self.assertIsNotNone(instant_payout)
def get_client_bank_account(recreate=False): if BaseTestLive._client_account is None or recreate: account = BankAccount() account.owner_name = 'Joe Blogs' account.type = 'IBAN' account.owner_address = Address() account.owner_address.address_line_1 = "Main Street" account.owner_address.address_line_2 = "no. 5 ap. 6" account.owner_address.country = "FR" account.owner_address.city = "Lyon" account.owner_address.postal_code = "65400" account.iban = 'FR7630004000031234567890143' account.bic = 'BNPAFRPP' account.tag = 'custom meta' account.create_client_bank_account() BaseTestLive._client_account = BankAccount( **account.create_client_bank_account()) return BaseTestLive._client_account
def test_PayIns_CardDirect_CreateWithAvs(self): user = BaseTestLive.get_john(True) debited_wallet = BaseTestLive.get_johns_wallet(True) # create wallet credited_wallet = Wallet() credited_wallet.owners = (user,) credited_wallet.currency = 'EUR' credited_wallet.description = 'WALLET IN EUR' credited_wallet = Wallet(**credited_wallet.save()) card = BaseTestLive.get_johns_card(True) pay_in = DirectPayIn() pay_in.author = user pay_in.debited_wallet = debited_wallet pay_in.credited_wallet = credited_wallet pay_in.card = card pay_in.fees = Money() pay_in.fees.amount = 100 pay_in.fees.currency = "EUR" pay_in.debited_funds = Money() pay_in.debited_funds.amount = 1000 pay_in.debited_funds.currency = "EUR" pay_in.secure_mode_return_url = "http://www.example.com/" address = Address() address.address_line_1 = "Big Street" address.address_line_2 = "no 2 ap 6" address.country = "FR" address.city = "Lyon" address.postal_code = "68400" pay_in.billing = Billing(address=address) result = pay_in.save() self.assertIsNotNone(result) security_info = result['security_info'] self.assertIsNotNone(security_info) self.assertIsInstance(security_info, SecurityInfo) self.assertEqual(security_info.avs_result, "FULL_MATCH")
def test_PreAuthorizations_CreateDirect(self): user = BaseTestLive.get_john() card_registration = CardRegistration() card_registration.user = user card_registration.currency = "EUR" saved_registration = card_registration.save() data = { 'cardNumber': '4972485830400049', 'cardCvx': '123', 'cardExpirationDate': '0821', 'accessKeyRef': card_registration.access_key, 'data': card_registration.preregistration_data } headers = {'content-type': 'application/x-www-form-urlencoded'} registration_data_response = requests.post( card_registration.card_registration_url, data=data, headers=headers) saved_registration[ 'registration_data'] = registration_data_response.text updated_registration = CardRegistration(**saved_registration).save() card = Card.get(updated_registration['card_id']) pre_authorization = PreAuthorization() pre_authorization.card = card pre_authorization.author = user pre_authorization.debited_funds = Money() pre_authorization.debited_funds.currency = "EUR" pre_authorization.debited_funds.amount = 500 pre_authorization.remaining_funds = Money() pre_authorization.remaining_funds.currency = "EUR" pre_authorization.remaining_funds.amount = 500 pre_authorization.secure_mode_return_url = "http://www.example.com/" billing = Billing() billing.address = Address() billing.address.address_line_1 = "Main Street" billing.address.address_line_2 = "no. 5 ap. 6" billing.address.country = "FR" billing.address.city = "Lyon" billing.address.postal_code = "65400" pre_authorization.billing = billing saved_pre_authorization = pre_authorization.save() wallet = BaseTestLive.get_johns_wallet() payin = PreAuthorizedPayIn() payin.author = BaseTestLive.get_john() payin.debited_funds = Money(amount=500, currency='EUR') payin.credited_wallet = wallet payin.secure_mode_return_url = "http://test.com" payin.secure_mode = 'DEFAULT' payin.preauthorization = pre_authorization payin.fees = Money(amount=0, currency='EUR') payin.culture = 'fr' BaseTestLive._johns_payin = PreAuthorizedPayIn(**payin.save()) transactions = pre_authorization.get_transactions() self.assertIsNotNone(saved_pre_authorization) security_info = saved_pre_authorization['security_info'] self.assertIsInstance(security_info, SecurityInfo) self.assertEqual(security_info.avs_result, "NO_CHECK") self.assertEqual(payin.status, "SUCCEEDED") self.assertEqual(transactions[0].status, "SUCCEEDED")
def test_retrieve_users_all_bankaccounts(self): self.mock_natural_user() self.register_mock([{ 'method': responses.POST, 'url': settings.MANGOPAY_API_SANDBOX_URL + settings.MANGOPAY_CLIENT_ID + '/users/1169419/bankaccounts/IBAN', 'body': { "UserId": "1167502", "Type": "IBAN", "OwnerName": "Victor Hugo", "OwnerAddress": { "AddressLine1": "AddressLine1", "AddressLine2": "AddressLine2", "City": "City", "Region": "Region", "PostalCode": "11222", "Country": "FR" }, "IBAN": "FR3020041010124530725S03383", "BIC": "CRLYFRPP", "Id": "1169675", "Tag": "custom tag", "CreationDate": 1383561267 }, 'status': 200 }, { 'method': responses.GET, 'url': settings.MANGOPAY_API_SANDBOX_URL + settings.MANGOPAY_CLIENT_ID + '/users/1169419/bankaccounts', 'body': [{ "UserId": "1167502", "Type": "IBAN", "OwnerName": "Victor Hugo", "OwnerAddress": { "AddressLine1": "AddressLine1", "AddressLine2": "AddressLine2", "City": "City", "Region": "Region", "PostalCode": "11222", "Country": "FR" }, "IBAN": "FR3020041010124530725S03383", "BIC": "CRLYFRPP", "Id": "1169675", "Tag": "custom tag", "CreationDate": 1383561267 }], 'status': 200 }]) params = { "owner_name": "Victor Hugo", "user": self.natural_user, "type": "IBAN", "owner_address": Address(address_line_1='AddressLine1', address_line_2='AddressLine2', city='City', region='Region', postal_code='11222', country='FR'), "iban": "FR3020041010124530725S03383", "bic": "CRLYFRPP", "tag": "custom tag" } bankaccount = BankAccount(**params) bankaccount.save() self.assertIsNotNone(bankaccount.get_pk()) self.assertIsInstance(self.natural_user.bankaccounts.all(), list) for bankaccount in self.natural_user.bankaccounts.all(): self.assertIsInstance(bankaccount, BankAccount)
def test_retrieve_bankaccount_iban(self): self.mock_natural_user() self.register_mock([{ 'method': responses.POST, 'url': settings.MANGOPAY_API_SANDBOX_URL + settings.MANGOPAY_CLIENT_ID + '/users/1169419/bankaccounts/IBAN', 'body': { "UserId": "1169419", "Type": "IBAN", "OwnerName": "Victor Hugo", "OwnerAddress": { "AddressLine1": "AddressLine1", "AddressLine2": "AddressLine2", "City": "City", "Region": "Region", "PostalCode": "11222", "Country": "FR" }, "IBAN": "FR3020041010124530725S03383", "BIC": "CRLYFRPP", "Id": "1169675", "Tag": "custom tag", "CreationDate": 1383561267 }, 'status': 200 }, { 'method': responses.GET, 'url': settings.MANGOPAY_API_SANDBOX_URL + settings.MANGOPAY_CLIENT_ID + '/users/1169419/bankaccounts/1169675', 'body': { "UserId": "1169419", "Type": "IBAN", "OwnerName": "Victor Hugo", "OwnerAddress": { "AddressLine1": "AddressLine1", "AddressLine2": "AddressLine2", "City": "City", "Region": "Region", "PostalCode": "11222", "Country": "FR" }, "IBAN": "FR3020041010124530725S03383", "BIC": "CRLYFRPP", "Id": "1169675", "Tag": "custom tag", "CreationDate": 1383561267 }, 'status': 200 }, { 'method': responses.GET, 'url': settings.MANGOPAY_API_SANDBOX_URL + settings.MANGOPAY_CLIENT_ID + '/users/1169419/bankaccounts', 'body': [{ "UserId": "1169419", "Type": "IBAN", "OwnerName": "Victor Hugo", "OwnerAddress": { "AddressLine1": "AddressLine1", "AddressLine2": "AddressLine2", "City": "City", "Region": "Region", "PostalCode": "11222", "Country": "FR" }, "IBAN": "FR3020041010124530725S03383", "BIC": "CRLYFRPP", "Id": "1169675", "Tag": "custom tag", "CreationDate": 1383561267 }], 'status': 200 }, { 'method': responses.GET, 'url': settings.MANGOPAY_API_SANDBOX_URL + settings.MANGOPAY_CLIENT_ID + '/users/1169419', 'body': { "Id": '1169419', "FirstName": "Victor", "LastName": "Hugo", "Address": { "AddressLine1": "AddressLine1", "AddressLine2": "AddressLine2", "City": "City", "Region": "Region", "PostalCode": "11222", "Country": "FR" }, "Birthday": int(time.mktime(date.today().timetuple())), "Nationality": "FR", "CountryOfResidence": "FR", "Occupation": "Writer", "IncomeRange": 6, "PersonType": "NATURAL", "Email": "*****@*****.**", "Tag": "custom tag" }, 'status': 200 }]) params = { "owner_name": "Victor Hugo", "user": self.natural_user, "type": "IBAN", "owner_address": Address(address_line_1='AddressLine1', address_line_2='AddressLine2', city='City', region='Region', postal_code='11222', country='FR'), "iban": "FR3020041010124530725S03383", "bic": "CRLYFRPP", "tag": "custom tag" } bankaccount = BankAccount(**params) bankaccount.save() self.assertIsNotNone(bankaccount.get_pk()) pk = bankaccount.get_pk() bankaccount = BankAccount.get( bankaccount.get_pk(), **{'user_id': self.natural_user.get_pk()}) self.assertIsNotNone(bankaccount.get_pk()) self.assertEqual( self.natural_user.bankaccounts.get( pk, **{'user_id': self.natural_user.get_pk()}), bankaccount) self.assertEqual(self.natural_user.bankaccounts.all(), [bankaccount]) for key, value in params.items(): self.assertEqual(getattr(bankaccount, key), value)
def test_create_bank_wire_payout(self): self.mock_legal_user() self.mock_user_wallet() self.register_mock([{ 'method': responses.POST, 'url': settings.MANGOPAY_API_SANDBOX_URL + settings.MANGOPAY_CLIENT_ID + '/users/1169420/bankaccounts/IBAN', 'body': { "UserId": "1169420", "Type": "IBAN", "OwnerName": "MangoPay", "OwnerAddress": { "AddressLine1": "AddressLine1", "AddressLine2": "AddressLine2", "City": "City", "Region": "Region", "PostalCode": "11222", "Country": "FR" }, "IBAN": "FR3020041010124530725S03383", "BIC": "CRLYFRPP", "Id": "1169675", "Tag": "custom tag", "CreationDate": 1383561267 }, 'status': 200 }, { 'method': responses.POST, 'url': settings.MANGOPAY_API_SANDBOX_URL + settings.MANGOPAY_CLIENT_ID + '/payouts/bankwire', 'body': { "Id": 30047, "CreditedFunds": None, "BankWireRef": "John Doe's trousers", "DebitedFunds": { "Currency": "EUR", "Amount": 1000 }, "BankAccountId": 6784645, "AuthorId": 6784642, "Tag": "Custom data", "Fees": { "Currency": "EUR", "Amount": 100 }, "DebitedWalletId": 6784644 }, 'status': 200 }, { 'method': responses.GET, 'url': settings.MANGOPAY_API_SANDBOX_URL + settings.MANGOPAY_CLIENT_ID + '/payouts/30047', 'body': { "Id": 30047, "Tag": "custom tag", "CreationDate": 1374232891, "AuthorId": "20164", "CreditedUserId": None, "DebitedFunds": { "Currency": "EUR", "Amount": 100 }, "CreditedFunds": { "Currency": "EUR", "Amount": "1000" }, "Fees": { "Currency": "EUR", "Amount": "100" }, "Status": "SUCCEEDED", "ResultCode": "00000", "ExecutionDate": 1374233532, "Type": "PAY_OUT", "Nature": "NORMAL", "DebitedWalletId": "30025", "BankAccountId": "30027", "BankWireRef": "John Doe's trousers" }, 'status': 200 }]) params = { "owner_name": "Victor Hugo", "user": self.legal_user, "type": "IBAN", "owner_address": Address(address_line_1='AddressLine1', address_line_2='AddressLine2', city='City', region='Region', postal_code='11222', country='FR'), "iban": "FR3020041010124530725S03383", "bic": "CRLYFRPP", "tag": "custom tag" } bankaccount = BankAccount(**params) bankaccount.save() bank_wire_payout_params = { "tag": "Custom data", "author": self.legal_user, "debited_funds": Money(amount=1000, currency='EUR'), "fees": Money(amount=100, currency='EUR'), "debited_wallet": self.legal_user_wallet, "bank_account": bankaccount, "bank_wire_ref": "John Doe's trousers" } bank_wire_payout = BankWirePayOut(**bank_wire_payout_params) self.assertIsNone(bank_wire_payout.get_pk()) bank_wire_payout.save() self.assertIsInstance(bank_wire_payout, BankWirePayOut) self.assertEqual(bank_wire_payout.debited_funds.amount, 1000) bank_wire_payout_params.pop('debited_funds') self.assertEqual(bank_wire_payout.fees.amount, 100) bank_wire_payout_params.pop('fees') for key, value in bank_wire_payout_params.items(): self.assertEqual(getattr(bank_wire_payout, key), value) self.assertIsNotNone(bank_wire_payout.get_pk()) # test_retrieve_payouts retrieved_payout = BankWirePayOut.get(bank_wire_payout.get_pk()) self.assertIsNotNone(retrieved_payout.get_pk()) self.assertIsInstance(retrieved_payout, BankWirePayOut) self.assertEqual(getattr(retrieved_payout, 'id'), bank_wire_payout.get_pk())
def test_retrieve_specific_legal_user(self): self.mock_legal_user() self.register_mock({ 'method': responses.GET, 'url': re.compile(r'' + settings.MANGOPAY_API_SANDBOX_URL + settings.MANGOPAY_CLIENT_ID + '/users/\d+'), 'body': { "Name": "MangoPay", "LegalPersonType": "BUSINESS", "HeadquartersAddress": { "AddressLine1": "AddressLine1", "AddressLine2": "AddressLine2", "City": "City", "Region": "Region", "PostalCode": "11222", "Country": "FR" }, "LegalRepresentativeFirstName": "Mango", "LegalRepresentativeLastName": "Pay", "LegalRepresentativeEmail": "*****@*****.**", "LegalRepresentativeBirthday": today_timestamp, "LegalRepresentativeNationality": "FR", "LegalRepresentativeCountryOfResidence": "FR", "ProofOfRegistration": None, "ShareholderDeclaration": None, "LegalRepresentativeAddress": None, "Statute": None, "PersonType": "LEGAL", "Email": "*****@*****.**", "Id": "1169420", "Tag": "custom tag", "CreationDate": 1383322502, "KYCLevel": "LIGHT" }, 'status': 200 }) params = { "name": "MangoPay", "legal_person_type": "BUSINESS", "headquarters_address": Address(address_line_1='AddressLine1', address_line_2='AddressLine2', city='City', region='Region', postal_code='11222', country='FR'), "legal_representative_first_name": "Mango", "legal_representative_last_name": "Pay", "legal_representative_email": "*****@*****.**", "legal_representative_birthday": today, "legal_representative_nationality": "FR", "legal_representative_country_of_residence": "FR", "proof_of_registration": None, "shareholder_declaration": None, "legal_representative_address": None, "statute": None, "person_type": "LEGAL", "email": "*****@*****.**", "tag": "custom tag", # "creation_date": datetime.now() } user = LegalUser(**params) self.assertIsNone(user.get_pk()) user.save() self.assertIsInstance(user, LegalUser) for key, value in params.items(): self.assertEqual(getattr(user, key), value) retrieved_user = User.get(user.id) for key, value in params.items(): self.assertEqual(getattr(retrieved_user, key), value) self.assertIsInstance(retrieved_user, User)
def test_retrieve_specific_natural_user(self): self.mock_natural_user() self.register_mock({ 'method': responses.GET, 'url': re.compile(r'' + settings.MANGOPAY_API_SANDBOX_URL + settings.MANGOPAY_CLIENT_ID + '/users/\d+'), 'body': { "FirstName": "Victor", "LastName": "Hugo", "Address": { "AddressLine1": "AddressLine1", "AddressLine2": "AddressLine2", "City": "City", "Region": "Region", "PostalCode": "11222", "Country": "FR" }, "Birthday": today_timestamp, "Nationality": "FR", "CountryOfResidence": "FR", "Occupation": "Writer", "IncomeRange": 6, "PersonType": "NATURAL", "Email": "*****@*****.**", "Id": "1167495", "CreationDate": 1382605938, "KYCLevel": "LIGHT", "Tag": "custom tag" }, 'status': 200 }) params = { "first_name": "Victor", "last_name": "Hugo", "address": Address(address_line_1='AddressLine1', address_line_2='AddressLine2', city='City', region='Region', postal_code='11222', country='FR'), "birthday": today, "nationality": "FR", "country_of_residence": "FR", "occupation": "Writer", "income_range": 6, "proof_of_identity": None, "proof_of_address": None, "person_type": "NATURAL", "email": "*****@*****.**", "tag": "custom tag", } user = NaturalUser(**params) user.save() self.assertIsNotNone(user.get_pk()) retrieved_user = User.get(user.get_pk()) self.assertIsNotNone(retrieved_user.get_pk()) for key, value in params.items(): self.assertEqual(getattr(retrieved_user, key), value) self.assertIsInstance(retrieved_user, User)
def test_create_natural_user(self): self.mock_natural_user() self.register_mock({ "method": responses.PUT, "url": re.compile(r'' + settings.MANGOPAY_API_SANDBOX_URL + settings.MANGOPAY_CLIENT_ID + '/users/natural/\d+'), "body": { "FirstName": "Victor", "LastName": "Claver", "Address": { "AddressLine1": "AddressLine1", "AddressLine2": "AddressLine2", "City": "City", "Region": "Region", "PostalCode": "11222", "Country": "FR" }, "Birthday": today_timestamp, "Nationality": "FR", "CountryOfResidence": "FR", "Occupation": "Writer", "IncomeRange": 6, "PersonType": "NATURAL", "Email": "*****@*****.**", "Id": "1169419", "Tag": "custom tag", "CreationDate": 1383321421, "KYCLevel": "LIGHT" }, "status": 200 }) params = { "first_name": "Victor", "last_name": "Hugo", "address": Address(address_line_1='AddressLine1', address_line_2='AddressLine2', city='City', region='Region', postal_code='11222', country='FR'), "birthday": today, "nationality": "FR", "country_of_residence": "FR", "occupation": "Writer", "income_range": 6, "proof_of_identity": None, "proof_of_address": None, "person_type": "NATURAL", "email": "*****@*****.**", "tag": "custom tag", } user = NaturalUser(**params) self.assertIsNone(user.get_pk()) user.save() self.assertIsInstance(user, NaturalUser) for key, value in params.items(): self.assertEqual(getattr(user, key), value) self.assertIsNotNone(user.get_pk()) previous_pk = user.get_pk() user.last_name = 'Claver' user.save() self.assertEqual(previous_pk, user.get_pk()) self.assertEqual(user.last_name, 'Claver')
def test_retrieve_natural_user(self): self.mock_natural_user() self.register_mock([{ 'method': responses.GET, 'url': settings.MANGOPAY_API_SANDBOX_URL + settings.MANGOPAY_CLIENT_ID + '/users/natural/1169419', 'body': { "FirstName": "Victor", "LastName": "Hugo", "Address": { "AddressLine1": "AddressLine1", "AddressLine2": "AddressLine2", "City": "City", "Region": "Region", "PostalCode": "11222", "Country": "FR" }, "Birthday": today_timestamp, "Nationality": "FR", "CountryOfResidence": "FR", "Occupation": "Writer", "IncomeRange": 6, "ProofOfIdentity": None, "ProofOfAddress": None, "PersonType": "NATURAL", "Email": "*****@*****.**", "Id": "1169419", "Tag": "custom tag", "CreationDate": 1383321421, "KYCLevel": "LIGHT" }, 'status': 200 }, { 'method': responses.GET, 'url': settings.MANGOPAY_API_SANDBOX_URL + settings.MANGOPAY_CLIENT_ID + '/users/natural/1169420', 'body': { "errors": [] }, 'status': 404 }]) params = { "first_name": "Victor", "last_name": "Hugo", "address": Address(address_line_1='AddressLine1', address_line_2='AddressLine2', city='City', region='Region', postal_code='11222', country='FR'), "birthday": today, "nationality": "FR", "country_of_residence": "FR", "occupation": "Writer", "income_range": 6, "proof_of_identity": None, "proof_of_address": None, "person_type": "NATURAL", "email": "*****@*****.**", "tag": "custom tag", } user = NaturalUser(**params) user.save() self.assertRaises(NaturalUser.DoesNotExist, NaturalUser.get, int(user.get_pk()) + 1) self.assertIsNotNone(user.get_pk()) user = NaturalUser.get(user.get_pk()) self.assertIsNotNone(user.get_pk()) for key, value in params.items(): self.assertEqual(getattr(user, key), value)
def _make_address(**kwargs): return Address(address_line_1=kwargs['line1'], address_line_2=kwargs['line2'], region=kwargs['region'], postal_code=kwargs['pc'], country=kwargs['country'])