def test_01_create_marketplace(self):
self.assertTrue(self.merchant.accounts_uri.endswith('/accounts'))
self.assertIsNotNone(balanced.config.api_key_secret)
marketplace = balanced.Marketplace().save()
self.assertTrue(marketplace.id.startswith('TEST-MP'))
self.merchant = balanced.Merchant.find(self.merchant.uri)
self.assertEqual(marketplace.in_escrow, 0)
def test_20_test_filter_and_sort(self):
try:
self._find_marketplace()
except balanced.exc.NoResultFound:
balanced.Marketplace().save()
buyer = self._find_account('buyer')
deb1 = buyer.debit(amount=1122, meta={'tag': '1'})
deb2 = buyer.debit(amount=3322, meta={'tag': '1'})
deb3 = buyer.debit(amount=2211, meta={'tag': '2'})
debs = (balanced.Debit.query.filter(
balanced.Debit.f.meta.tag == '1').all())
self.assertItemsEqual([deb.id for deb in debs], [deb1.id, deb2.id])
debs = (balanced.Debit.query.filter(
balanced.Debit.f.meta.tag == '2').all())
self.assertItemsEqual([deb.id for deb in debs], [deb3.id])
debs = (balanced.Debit.query.filter(
balanced.Debit.f.meta.contains('tag')).sort(
balanced.Debit.f.amount.asc()).all())
self.assertEqual(len(debs), 3)
self.assertEqual([deb.id for deb in debs], [deb1.id, deb3.id, deb2.id])
debs = (balanced.Debit.query.filter(
balanced.Debit.f.meta.contains('tag')).sort(
balanced.Debit.f.amount.desc()).all())
self.assertEqual(len(debs), 3)
self.assertEqual([deb.id for deb in debs], [deb2.id, deb3.id, deb1.id])
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 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 test_21_mask_bank_account(self):
try:
mp = balanced.Marketplace.query.one()
except NoResultFound:
mp = balanced.Marketplace().save()
payload = BANK_ACCOUNT.copy()
payload['account_number'] = '1212121-110-019'
bank_account = mp.create_bank_account(**payload)
self.assertEqual(bank_account.last_four, '0019')
def test_22_create_international_card(self):
try:
mp = balanced.Marketplace.query.one()
except NoResultFound:
mp = balanced.Marketplace().save()
card = mp.create_card(**INTERNATIONAL_CARD)
self.assertTrue(card.id.startswith('CC'))
self.assertEqual(card.street_address,
INTERNATIONAL_CARD['street_address'])
def test_19_create_and_associate_bank_account(self):
try:
mp = balanced.Marketplace.query.one()
except NoResultFound:
mp = balanced.Marketplace().save()
bank_account = mp.create_bank_account(**BANK_ACCOUNT)
self.assertTrue(bank_account.id.startswith('BA'))
account = mp.create_merchant('*****@*****.**',
merchant=PERSON_MERCHANT)
account.add_bank_account(bank_account.uri)
def test_18_create_and_associate_card(self):
try:
mp = balanced.Marketplace.query.one()
except NoResultFound:
mp = balanced.Marketplace().save()
card = mp.create_card(**CARD)
self.assertTrue(card.id.startswith('CC'))
account = mp.create_merchant('*****@*****.**',
merchant=PERSON_MERCHANT)
account.add_card(card.uri)
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 test_region_deprecation(self, warnings, _):
mkt = balanced.Marketplace()
mkt.create_card('John Name',
'341111111111111',
'12',
'2020',
region='CA')
call_args, _ = warnings.warn.call_args
self.assertEqual(call_args[0],
('The region parameter will be deprecated in the '
'next minor version of balanced-python'))
self.assertEqual(call_args[1], PendingDeprecationWarning)
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 test_23_kyc_redirect(self):
try:
mp = balanced.Marketplace.query.one()
except NoResultFound:
mp = balanced.Marketplace().save()
redirect_pattern = ('https://www.balancedpayments.com'
'/marketplaces/(.*)/kyc')
with self.assertRaises(MoreInformationRequiredError) as ex:
mp.create_merchant('*****@*****.**', PERSON_FAILING_KYC)
redirect_uri = ex.exception.redirect_uri
result = re.search(redirect_pattern, redirect_uri)
self.assertTrue(result)
def test_region_deprecation(self, _card):
mkt = balanced.Marketplace()
with warnings.catch_warnings(record=True) as w:
mkt.create_card(
'John Name', '341111111111111', '12', '2020',
region='CA'
)
self.assertEqual(len(w), 1)
warning_ = w[0]
self.assertEqual(
warning_.message.message,
('The region parameter will be deprecated in the '
'next minor version of balanced-python')
)
self.assertTrue(isinstance(warning_.message, UserWarning))
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
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',
'postal_code': '90210',
},
# gratipay stores some of the address data in the meta fields,
def init():
key = balanced.APIKey().save()
balanced.configure(key.secret)
balanced.Marketplace().save()
def test_create_a_second_marketplace_should_fail(self):
with self.assertRaises(requests.HTTPError) as exc:
balanced.Marketplace().save()
the_exception = exc.exception
self.assertEqual(the_exception.status_code, 409)
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
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()
def setUp(self):
try:
self.mp = balanced.Marketplace.my_marketplace
except:
self.mp = balanced.Marketplace().save()
def _create_marketplace(self):
try:
return balanced.Marketplace.query.one()
except NoResultFound:
return balanced.Marketplace().save()
def test_load_resource(self):
resp = fixtures.Resources.marketplaces
marketplace = balanced.Marketplace(**resp)
self.assertIsNotNone(marketplace.debits)
def test_02_create_a_second_marketplace_should_fail(self):
self.assertIsNotNone(balanced.config.api_key_secret)
with self.assertRaises(requests.HTTPError) as exc:
balanced.Marketplace().save()
the_exception = exc.exception
self.assertEqual(the_exception.status_code, 409)
