def test_anonymous_listing_fail_kyc(self):
email_address = '*****@*****.**'
payload = self._guest_listing_payload_fail_kyc(email_address)
resp = self.client.post('/list', data=payload)
self.assertEqual(resp.status_code, 302)
self.assertIn('/list/1/complete', resp.data)
# create the account for realz
with balanced.key_switcher(None):
api_key = balanced.APIKey(
**self._merchant_payload(email_address)).save()
merchant_uri = api_key.merchant.uri
# GET the redirect uri
uri = '/accounts/verify'
uri += '?listing_id={}&email_address={}&merchant_uri={}'.format(
1,
email_address,
merchant_uri,
)
resp = self.client.get(uri)
self.assertEqual(resp.status_code, 302)
self.assertIn('/list/1/complete', resp.data)
def test_authenticated_listing_fail_kyc(self):
email_address = '*****@*****.**'
self._create_user(email_address)
payload = self._listing_payload_fail_kyc()
user = User.query.filter(User.email_address == email_address).one()
resp = self.client.post('/list', data=payload)
self.assertEqual(resp.status_code, 302)
self.assertIn('/list/1/complete', resp.data)
# create the account for realz
with balanced.key_switcher(None):
api_key = balanced.APIKey(
**self._merchant_payload(email_address)).save()
merchant_uri = api_key.merchant.uri
# GET the redirect uri
uri = '/accounts/verify'
uri += '?listing_id={}&email_address={}&merchant_uri={}'.format(
1,
email_address,
merchant_uri,
)
user = User.query.filter(User.email_address == email_address).one()
self.assertFalse(user.account_uri)
resp = self.client.get(uri)
self.assertEqual(resp.status_code, 302)
self.assertIn('/list/1/complete', resp.data)
def setUpClass(cls):
balanced.config.root_uri = 'http://127.0.0.1:5000/'
if not balanced.config.api_key_secret:
api_key = balanced.APIKey().save()
balanced.configure(api_key.secret)
cls.api_key = api_key
cls.merchant = api_key.merchant
balanced.Marketplace().save()
def setUpClass(cls):
super(BalancedHarness, cls).setUpClass()
cls.balanced_api_key = balanced.APIKey().save().secret
balanced.configure(cls.balanced_api_key)
mp = balanced.Marketplace.my_marketplace
if not mp:
mp = balanced.Marketplace().save()
cls.balanced_marketplace = mp
def test_redirects(self):
with self.start_server(app):
with self.assertRaises(balanced.exc.HTTPError) as exc:
balanced.APIKey().save()
exception = exc.exception
self.assertEqual(exception.response.status_code, 302)
self.assertEqual(exception.response.headers['location'],
'/v1/your-mom')
def test_upgrade_account_to_merchant_success(self):
card = self.mp.create_card(**cards.CARD)
with balanced.key_switcher(None):
api_key = balanced.APIKey().save()
merchant = api_key.merchant
buyer = self.mp.create_buyer(self._email_address(), card.uri)
self.assertItemsEqual(buyer.roles, ['buyer'])
buyer.promote_to_merchant(merchant.uri)
self.assertItemsEqual(buyer.roles, ['buyer', 'merchant'])
def test_create_merchants_with_same_identity_on_same_marketplace(self):
with balanced.key_switcher(None):
api_key = balanced.APIKey().save()
merchant = api_key.merchant
merch_account_1 = self.mp.create_merchant(self._email_address(),
merchant_uri=merchant.uri)
merch_account_2 = self.mp.create_merchant(self._email_address(),
merchant_uri=merchant.uri)
self.assertEqual(merch_account_1.roles, ['merchant'])
self.assertEqual(merch_account_2.roles, ['merchant'])
def callbacks_create(ctx):
with balanced.key_switcher(None):
secret = balanced.APIKey().save().secret
with balanced.key_switcher(secret):
mp = balanced.Marketplace().save()
balanced.Callback(
uri=mp.callbacks_uri,
url='http://www.example.com/cb/nu',
method='post',
).save()
return ctx.last_req, ctx.last_resp
def setUpClass(cls):
cls.processor_key = os.environ.get('BILLY_TEST_PROCESSOR_KEY', None)
cls.marketplace_uri = os.environ.get('BILLY_TEST_MARKETPLACE_URI',
None)
if cls.processor_key is None:
api_key = balanced.APIKey().save()
cls.processor_key = api_key.secret
balanced.configure(cls.processor_key)
try:
cls.marketplace_uri = balanced.Marketplace.my_marketplace.href
except (NoResultFound, balanced.exc.NoResultFound):
cls.marketplace_uri = balanced.Marketplace().save().href
def marketplace(self):
balanced.config.root_uri = self.root_uri
if not self.secret:
logger.debug('creating api key')
self.secret = balanced.APIKey().save().secret
balanced.configure(self.secret)
try:
marketplace = balanced.Marketplace.mine
except balanced.exc.NoResultFound:
logger.debug('creating marketplace')
marketplace = balanced.Marketplace().save()
return marketplace
def setUpClass(cls):
with balanced.key_switcher(None):
cls.api_key = balanced.APIKey().save()
balanced.configure(cls.api_key.secret)
cls.marketplace = balanced.Marketplace().save()
cls.user = User.objects.create_user('john', '*****@*****.**', 'pass')
cls.user.save()
card = balanced.Card(**FIXTURES['card']).save()
cls.card = models.Card.create_from_card_uri(cls.user, card.uri)
cls.buyer = cls.card.user.balanced_account
# put some money in the escrow account
cls.buyer.debit(100 * 100, 'test') # $100.00
def marketplaces_create(ctx):
with balanced.key_switcher(None):
secret = balanced.APIKey().save().secret
with balanced.key_switcher(secret):
balanced.Marketplace(**{
'support_email_address': '*****@*****.**',
'name': 'Seller of things',
'domain_url': 'example.com',
'support_phone_number': '+12125551212',
'meta': {
'my-useful-data': 'abc123'
}
}).save()
return ctx.last_req, ctx.last_resp
def bootstrap(cls, ctx):
# api conf
if ctx.storage.get('api_location') != ctx.api_location:
ctx.storage.clear()
ctx.storage['api_location'] = ctx.api_location
balanced.config.root_uri = ctx.storage['api_location']
if 'api_key' not in ctx.storage:
ctx.storage.clear()
ctx.storage['api_location'] = ctx.api_location
logger.debug('creating api key')
key = balanced.APIKey().save()
ctx.storage['api_key'] = key.secret
balanced.configure(ctx.storage['api_key'])
# marketplace
if 'marketplace_id' not in ctx.storage:
logger.debug('creating marketplace')
marketplace = balanced.Marketplace().save()
ctx.storage['marketplace_uri'] = marketplace.uri
ctx.storage['marketplace_id'] = marketplace.id
# card
if 'card_id' not in ctx.storage:
logger.debug('creating card')
card = ctx.marketplace.create_card(
**{
'name': 'Benny Riemann',
'card_number': '4111111111111111',
'expiration_month': 4,
'expiration_year': 2014,
'security_code': 323,
'street_address': '167 West 74th Street',
'postal_code': '10023',
'country_code': 'USA',
'phone_number': '+16509241212'
})
ctx.marketplace.create_buyer(None, card.uri)
ctx.storage['card_uri'] = card.uri
ctx.storage['card_id'] = card.id
# escrow
thresh_h, thresh_l = 10000000, 100000
if ctx.marketplace.in_escrow < thresh_l:
amount = thresh_h - ctx.marketplace.in_escrow
logger.debug('incrementing escrow balanced %s', amount)
ctx.card.debit(amount)
def marketplaces_update(ctx):
with balanced.key_switcher(None):
secret = balanced.APIKey().save().secret
with balanced.key_switcher(secret):
mp = balanced.Marketplace(
**{
'support_email_address': '*****@*****.**',
'name': 'Seller of things',
'domain_url': 'example.com',
'support_phone_number': '+12125551212',
'meta': {
'my-useful-data': 'abc123'
}
}).save()
mp.support_email_address = '*****@*****.**'
mp.name = 'Seller of thingz'
mp.support_phone_number = '+18185551212'
mp.meta.update({'even-more-useful-data': '321cba'})
mp.save()
return ctx.last_req, ctx.last_resp
'janet',
is_suspicious=False,
claimed_time='now',
balanced_customer_href=self.janet_href,
last_bill_result='')
self.homer = self.make_participant(
'homer',
is_suspicious=False,
claimed_time='now',
balanced_customer_href=self.homer_href,
last_ach_result='')
with use_cassette('BalancedHarness'):
cls = BalancedHarness
balanced.configure(balanced.APIKey().save().secret)
mp = balanced.Marketplace.my_marketplace
if not mp:
mp = balanced.Marketplace().save()
cls.balanced_marketplace = mp
cls.david_href = cls.make_balanced_customer()
cls.janet_href = cls.make_balanced_customer()
cls.card = balanced.Card(
number='4111111111111111',
expiration_month=10,
expiration_year=2020,
address={
'line1': "123 Main Street",
'state': 'Confusion',
import balanced
balanced.configure('ak-test-2eKlj1ZDfAcZSARMf3NMhBHywDej0avSY')
api_key = balanced.APIKey()
api_key.save()
def api_keys_delete(ctx):
k = balanced.APIKey().save()
k.delete()
return ctx.last_req, ctx.last_resp
def api_keys_update(ctx):
k = balanced.APIKey().save()
k.meta.update({'some': 'different data'})
k.save()
return ctx.last_req, ctx.last_resp
def api_keys_show(ctx):
k = balanced.APIKey().save()
balanced.APIKey.find(k.uri)
return ctx.last_req, ctx.last_resp
def api_keys_create(ctx):
balanced.APIKey().save()
return ctx.last_req, ctx.last_resp
def init():
key = balanced.APIKey().save()
balanced.configure(key.secret)
balanced.Marketplace().save()
def create_marketplace(self):
balanced.configure(None)
api_key = balanced.APIKey().save()
balanced.configure(api_key.secret)
marketplace = balanced.Marketplace().save()
return marketplace, api_key
from __future__ import unicode_literals
import balanced
api_key = balanced.APIKey().save()
balanced.configure(api_key.secret)
marketplace = balanced.Marketplace().save()
# https://docs.balancedpayments.com/1.1/overview/resources/#test-credit-card-numbers
declined_card = balanced.Card(
number='4444444444444448',
expiration_month='12',
expiration_year='2015',
).save()
bank_account = balanced.BankAccount(
account_number='1234567890',
routing_number='321174851',
name='Jack Q Merchant',
).save()
# see https://github.com/balanced/balanced-api/blob/master/fixtures/_models/error.json for all possible error codes
try:
declined_card.debit(amount=100)
except balanced.exc.BalancedError as ex:
assert ex.category_code == 'card-declined'
try:
bank_account.credit(amount=1000)
except balanced.exc.HTTPError as ex:
def setUpClass(cls):
# ensure we won't consume API key from other test case
balanced.configure()
cls.api_key = balanced.APIKey().save()
balanced.configure(cls.api_key.secret)
cls.marketplace = balanced.Marketplace().save()
