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)
