def test_timeout_successful_post(self):
mocurly_ = mocurly.mocurly()
mocurly_.start()
mocurly_.start_timeout_successful_post()
self.assertFalse(
mocurly.backend.accounts_backend.has_object(
self.base_account_data['account_code']))
self.assertRaises(ssl.SSLError,
recurly.Account(**self.base_account_data).save)
self.assertTrue(
mocurly.backend.accounts_backend.has_object(
self.base_account_data['account_code']))
mocurly_.stop_timeout_successful_post()
self.base_account_data['account_code'] = 'foo'
self.assertFalse(
mocurly.backend.accounts_backend.has_object(
self.base_account_data['account_code']))
recurly.Account(**self.base_account_data).save()
self.assertTrue(
mocurly.backend.accounts_backend.has_object(
self.base_account_data['account_code']))
mocurly_.stop()
def new_subscription():
# We'll wrap this in a try to catch any API
# errors that may occur
try:
# Create the scubscription using minimal
# information: plan_code, account_code, currency and
# the token we generated on the frontend
subscription = recurly.Subscription(
plan_code='basic',
currency='USD',
account=recurly.Account(
account_code=uuid.uuid1(),
billing_info=recurly.BillingInfo(
token_id=request.form['recurly-token'])))
# The subscription has been created and we can redirect
# to a confirmation page
subscription.save()
return redirect('SUCCESS_URL')
except recurly.ValidationError, errors:
# Here we may wish to log the API error and send the
# customer to an appropriate URL, perhaps including
# and error message. See the `error_redirect` and
# `compose_errors` functions below.
error_redirect(compose_errors(errors))
def new_recurly_account():
# If user is not logged in, have them login or register
if not current_user.is_authenticated:
flash('Please login or register to create an account first!', 'danger')
return redirect(url_for('users.login'))
# Create user's account_code from hidden hash library
user_account_code = fa.create_account_code(current_user.id)
try:
# Create user account
new_account = recurly.Account(
account_code=user_account_code,
billing_info=recurly.BillingInfo(
token_id=request.form['recurly-token']))
# Create subscription
subscription = recurly.Subscription()
subscription.plan_code = request.form['plan']
subscription.currency = 'USD'
subscription.account = new_account
subscription.save()
flash('Account subscribed successfully!', 'success')
return redirect(url_for('users.account'))
except recurly.ValidationError:
flash('ValidationError! Please try again shortly.', 'danger')
return redirect(url_for('users.account'))
def test_timeout_successful_post(self):
mocurly_ = mocurly.mocurly()
mocurly_.start()
# Only timeout on creating transactions
def timeout_filter(request):
return request.path.endswith('transactions')
mocurly_.start_timeout_successful_post(timeout_filter=timeout_filter)
self.assertFalse(mocurly.backend.accounts_backend.has_object(self.base_account_data['account_code']))
new_account = recurly.Account(**self.base_account_data)
new_account.billing_info = recurly.BillingInfo(**self.base_billing_info_data)
new_account.save()
self.assertTrue(mocurly.backend.accounts_backend.has_object(self.base_account_data['account_code']))
self.assertEqual(len(mocurly.backend.transactions_backend.datastore), 0)
new_transaction = recurly.Transaction(account=new_account, amount_in_cents=20, currency='USD')
self.assertRaises(recurly.errors.BadGatewayError, new_transaction.save)
self.assertEqual(len(mocurly.backend.transactions_backend.datastore), 1)
mocurly_.stop_timeout_successful_post()
recurly.Transaction(account=new_account, amount_in_cents=20, currency='USD').save()
self.assertEqual(len(mocurly.backend.transactions_backend.datastore), 2)
mocurly_.stop()
def test_account_creation_with_billing_info(self):
self.assertFalse(
mocurly.backend.accounts_backend.has_object(
self.base_account_data['account_code']))
self.assertFalse(
mocurly.backend.billing_info_backend.has_object(
self.base_account_data['account_code']))
self.base_account_data['billing_info'] = recurly.BillingInfo(
**self.base_billing_info_data)
new_account = recurly.Account(**self.base_account_data)
new_account.save()
del self.base_account_data['billing_info']
# Verify account object exists in backend
self.assertTrue(
mocurly.backend.accounts_backend.has_object(
self.base_account_data['account_code']))
new_account = mocurly.backend.accounts_backend.get_object(
self.base_account_data['account_code'])
for k, v in self.base_account_data.items():
self.assertEqual(new_account[k], v)
self.assertTrue('hosted_login_token'
in new_account) # adds a hosted_login_token by default
self.assertTrue('created_at'
in new_account) # adds a created_at field by default
# Verify billing info object exists in backend
self.assertTrue(
mocurly.backend.billing_info_backend.has_object(
self.base_account_data['account_code']))
new_billing_info = mocurly.backend.billing_info_backend.get_object(
self.base_account_data['account_code'])
for k, v in self.base_billing_info_data.items():
self.assertEqual(new_billing_info[k], v)
def test_selective_timeout(self):
mocurly_ = mocurly.mocurly()
mocurly_.start()
# Only timeout on get requests
def timeout_filter(request):
return request.method == 'GET'
mocurly_.start_timeout(timeout_filter=timeout_filter)
self.assertFalse(
mocurly.backend.accounts_backend.has_object(
self.base_account_data['account_code']))
recurly.Account(**self.base_account_data).save()
self.assertTrue(
mocurly.backend.accounts_backend.has_object(
self.base_account_data['account_code']))
self.assertRaises(ssl.SSLError, recurly.Account.get,
self.base_account_data['account_code'])
mocurly_.stop_timeout()
self.assertEqual(
recurly.Account.get(
self.base_account_data['account_code']).account_code,
self.base_account_data['account_code'])
mocurly_.stop()
def test_account_creation_with_address(self):
self.assertFalse(
mocurly.backend.accounts_backend.has_object(
self.base_account_data['account_code']))
self.base_account_data['address'] = recurly.Address(
**self.base_address_data)
new_account = recurly.Account(**self.base_account_data)
new_account.save()
# Verify account object exists in backend
self.assertTrue(
mocurly.backend.accounts_backend.has_object(
self.base_account_data['account_code']))
new_account = mocurly.backend.accounts_backend.get_object(
self.base_account_data['account_code'])
for k, v in self.base_account_data.items():
if k == 'address':
address = new_account[k]
for address_k, address_v in self.base_address_data.items():
self.assertEqual(address[address_k], address_v)
else:
self.assertEqual(new_account[k], v)
self.assertTrue('hosted_login_token'
in new_account) # adds a hosted_login_token by default
self.assertTrue('created_at'
in new_account) # adds a created_at field by default
def test_normal(self):
mocurly_ = mocurly.mocurly()
mocurly_.start()
self.assertFalse(mocurly.backend.accounts_backend.has_object(self.base_account_data['account_code']))
recurly.Account(**self.base_account_data).save()
self.assertTrue(mocurly.backend.accounts_backend.has_object(self.base_account_data['account_code']))
mocurly_.stop()
def test_simple_transaction_creation(self):
self.assertEqual(len(mocurly.backend.transactions_backend.datastore),
0)
self.assertEqual(len(mocurly.backend.invoices_backend.datastore), 0)
self.base_transaction_data['account'] = recurly.Account(
account_code=self.base_account_data['uuid'])
new_transaction = recurly.Transaction(**self.base_transaction_data)
new_transaction.save()
self.assertEqual(len(mocurly.backend.transactions_backend.datastore),
1)
self.assertEqual(len(mocurly.backend.invoices_backend.datastore), 1)
new_transaction_backed = mocurly.backend.transactions_backend.get_object(
new_transaction.uuid)
for k, v in self.base_transaction_data.items():
if k == 'account':
self.assertEqual(new_transaction_backed[k], v.account_code)
else:
self.assertEqual(new_transaction_backed[k], str(v))
self.assertTrue('created_at' in new_transaction_backed)
self.assertTrue(new_transaction_backed['test'])
self.assertTrue(new_transaction_backed['voidable'])
self.assertTrue(new_transaction_backed['refundable'])
self.assertEqual(new_transaction_backed['tax_in_cents'], 0)
self.assertEqual(new_transaction_backed['action'], 'purchase')
self.assertEqual(new_transaction_backed['status'], 'success')
new_invoice = new_transaction.invoice()
new_invoice_backed = mocurly.backend.invoices_backend.get_object(
str(new_invoice.invoice_number))
self.assertEqual(len(new_invoice_backed['transactions']), 1)
self.assertEqual(new_invoice_backed['transactions'][0],
new_transaction.uuid)
self.assertEqual(new_invoice_backed['state'], 'collected')
self.assertEqual(new_invoice_backed['subtotal_in_cents'],
self.base_transaction_data['amount_in_cents'])
self.assertEqual(new_invoice_backed['total_in_cents'],
self.base_transaction_data['amount_in_cents'])
self.assertEqual(new_invoice_backed['currency'],
self.base_transaction_data['currency'])
self.assertEqual(new_invoice_backed['tax_in_cents'], 0)
self.assertEqual(new_invoice_backed['tax_type'], 'usst')
self.assertEqual(new_invoice_backed['tax_rate'], 0)
self.assertEqual(new_invoice_backed['net_terms'], 0)
line_items = new_invoice.line_items
self.assertEqual(len(line_items), 1)
new_line_item_backed = mocurly.backend.adjustments_backend.get_object(
line_items[0].uuid)
self.assertEqual(new_line_item_backed['description'],
self.base_transaction_data['description'])
self.assertEqual(new_line_item_backed['unit_amount_in_cents'],
self.base_transaction_data['amount_in_cents'])
self.assertEqual(new_line_item_backed['total_in_cents'],
self.base_transaction_data['amount_in_cents'])
self.assertEqual(new_line_item_backed['currency'],
self.base_transaction_data['currency'])
self.assertEqual(new_line_item_backed['type'], 'charge')
self.assertEqual(new_line_item_backed['tax_in_cents'], 0)
def new_subscription(self):
try:
subscription = recurly.Subscription()
subscription.plan_code = 'pro'
subscription.currency = 'USD'
account = recurly.Account(account_code=uuid.uuid1())
account.email = '*****@*****.**'
account.first_name = 'Michael1'
account.last_name = 'McGovern'
billing_info = recurly.BillingInfo()
billing_info.number = '4111-1111-1111-1111'
billing_info.month = 05
billing_info.year = 2019
account.billing_info = billing_info
subscription.account = account
log.warn("========================test========================")
subscription.save()
except recurly.NotFoundError:
print 'Account not Found.\n'
except recurly.errors:
for e in errors:
print "%s:%s" % (e.field, e.message)
def foo(this):
self.assertFalse(
mocurly.backend.accounts_backend.has_object(
self.base_account_data['account_code']))
recurly.Account(**self.base_account_data).save()
self.assertTrue(
mocurly.backend.accounts_backend.has_object(
self.base_account_data['account_code']))
def test_timeout(self):
mocurly_ = mocurly.mocurly()
mocurly_.start()
mocurly_.start_timeout()
self.assertFalse(mocurly.backend.accounts_backend.has_object(self.base_account_data['account_code']))
self.assertRaises(recurly.errors.BadGatewayError, recurly.Account(**self.base_account_data).save)
self.assertFalse(mocurly.backend.accounts_backend.has_object(self.base_account_data['account_code']))
mocurly_.stop_timeout()
self.assertFalse(mocurly.backend.accounts_backend.has_object(self.base_account_data['account_code']))
recurly.Account(**self.base_account_data).save()
self.assertTrue(mocurly.backend.accounts_backend.has_object(self.base_account_data['account_code']))
mocurly_.stop()
def test_context_manager(self):
with mocurly.mocurly():
self.assertFalse(
mocurly.backend.accounts_backend.has_object(
self.base_account_data['account_code']))
recurly.Account(**self.base_account_data).save()
self.assertTrue(
mocurly.backend.accounts_backend.has_object(
self.base_account_data['account_code']))
def test_xml(self):
import recurly
account = recurly.Account()
account.username = '******'
account_xml = ElementTree.tostring(account.to_element(),
encoding='UTF-8')
self.assertEqual(
account_xml,
xml('<account><username>importantbreakfast</username></account>'))
def new_account():
try:
account = recurly.Account(account_code=uuid.uuid1(),
billing_info=recurly.BillingInfo(
token_id=request.form['recurly-token']))
account.save()
return redirect(SUCCESS_URL)
except recurly.ValidationError as errors:
error_redirect(compose_errors(errors))
def new_subscription():
# We'll wrap this in a try to catch any API
# errors that may occur
try:
recurly_token_id = request.form['recurly-token']
if 'recurly-account-code' in request.form:
recurly_account_code = request.form['recurly-account-code']
else:
recurly_account_code = uuid.uuid1()
# Build our billing info object
billing_info = recurly.BillingInfo(token_id=recurly_token_id)
# Optionally add a 3D Secure token if one is present. You only need to do this
# if you are integrating with Recurly's 3D Secure support
if 'three-d-secure-token' in request.form:
billing_info.three_d_secure_action_result_token_id = request.form[
'three-d-secure-token']
# Create the scubscription using minimal
# information: plan_code, account_code, currency and
# the token we generated on the frontend
subscription = recurly.Subscription(
plan_code='basic',
currency='USD',
account=recurly.Account(account_code=recurly_account_code,
billing_info=billing_info))
# The subscription has been created and we can redirect
# to a confirmation page
subscription.save()
return redirect(SUCCESS_URL)
except recurly.ValidationError as error:
# Here we handle a 3D Secure required error by redirecting to an authentication page
if error.transaction_error_code == 'three_d_secure_action_required':
action_token_id = error.transaction_error.three_d_secure_action_token_id
return redirect("/3d-secure/authenticate.html#token_id=" +
recurly_token_id + "&action_token_id=" +
action_token_id + "&account_code=" +
str(recurly_account_code))
# Here we may wish to log the API error and send the
# customer to an appropriate URL, perhaps including
# and error message. See the `error_redirect` and
# `compose_errors` functions below.
error_redirect(compose_errors(error))
def _construct_recurly_account_resource(account_params,
billing_info_params=None):
"""
Might modify "account_params" object.
Returns UNSAVED instance.
"""
if not isinstance(account_params, recurly.Account):
account_params = recurly.Account(**account_params)
if billing_info_params:
if isinstance(billing_info_params, recurly.BillingInfo):
billing_info = billing_info_params
else:
billing_info = recurly.BillingInfo(**billing_info_params)
account_params.billing_info = billing_info # OVERRIDE
return account_params
def test_simple_account_update_billing_info(self):
# Create a simple account
recurly.Account(**self.base_account_data).save()
# Verify account has no billing info
recurly_account = recurly.Account.get(
self.base_account_data['account_code'])
self.assertRaises(AttributeError, lambda: recurly_account.billing_info)
# Update the billing info using the update_billing_info method
billing_info = recurly.BillingInfo(**self.base_billing_info_data)
recurly_account.update_billing_info(billing_info)
# Verify billing info object exists in backend
self.assertTrue(
mocurly.backend.billing_info_backend.has_object(
self.base_account_data['account_code']))
new_billing_info = mocurly.backend.billing_info_backend.get_object(
self.base_account_data['account_code'])
for k, v in self.base_billing_info_data.items():
self.assertEqual(new_billing_info[k], v)
def test_transaction_failure(self):
self.assertEqual(len(mocurly.backend.transactions_backend.datastore),
0)
self.assertEqual(len(mocurly.backend.invoices_backend.datastore), 0)
self.mocurly_.register_transaction_failure(
self.base_account_data['uuid'],
mocurly.errors.TRANSACTION_DECLINED)
self.base_transaction_data['account'] = recurly.Account(
account_code=self.base_account_data['uuid'])
new_transaction = recurly.Transaction(**self.base_transaction_data)
try:
new_transaction.save()
self.fail('No exception raised')
except recurly.ValidationError as exc:
self.assertEqual(
exc.error, mocurly.errors.TRANSACTION_ERRORS[
mocurly.errors.TRANSACTION_DECLINED]['customer'])
self.assertEqual(len(mocurly.backend.transactions_backend.datastore),
1)
self.assertEqual(len(mocurly.backend.invoices_backend.datastore), 0)
def create(cls, user, email, first_name, last_name, company_name,
accept_language):
recurly_account = recurly.Account(account_code=user.username,
username=user.username,
email=user.email,
first_name=user.first_name,
last_name=user.last_name,
company_name=company_name,
accept_language=accept_language)
recurly_account.save()
account = cls(user=user,
account_code=user.username,
username=user.username,
email=email,
first_name=first_name,
last_name=last_name,
company_name=company_name,
accept_language=accept_language,
hosted_login_token=recurly_account.hosted_login_token,
created_at=recurly_account.created_at)
account.save()
return account
def test_simple_account_creation(self):
self.assertFalse(
mocurly.backend.accounts_backend.has_object(
self.base_account_data['account_code']))
recurly.Account(**self.base_account_data).save()
# Verify account object exists in backend
self.assertTrue(
mocurly.backend.accounts_backend.has_object(
self.base_account_data['account_code']))
new_account = mocurly.backend.accounts_backend.get_object(
self.base_account_data['account_code'])
for k, v in self.base_account_data.items():
self.assertEqual(new_account[k], v)
self.assertTrue('hosted_login_token'
in new_account) # adds a hosted_login_token by default
self.assertTrue('created_at'
in new_account) # adds a created_at field by default
# Verify account has no billing info
recurly_account = recurly.Account.get(
self.base_account_data['account_code'])
self.assertRaises(AttributeError, lambda: recurly_account.billing_info)
def setUp(self):
self.mocurly_ = mocurly.core.mocurly()
self.mocurly_.start()
self.base_address_data = {
'address1': '123 Jackson St.',
'address2': 'Data City',
'state': 'CA',
'zip': '94105'
}
self.base_billing_info_data = {
'uuid': 'blah',
'first_name': 'Foo',
'last_name': 'Bar'
}
self.base_account_data = {
'uuid': 'blah',
'account_code': 'blah',
'email': '*****@*****.**',
'first_name': 'Foo',
'last_name': 'Bar',
'address': self.base_address_data,
'hosted_login_token': 'abcd1234',
'created_at': '2014-08-11'
}
mocurly.backend.accounts_backend.add_object(
self.base_account_data['uuid'], self.base_account_data)
mocurly.backend.billing_info_backend.add_object(
self.base_billing_info_data['uuid'], self.base_billing_info_data)
self.base_plan_data = {
'plan_code': 'gold',
'name': 'Gold Plan',
'unit_amount_in_cents': recurly.Money(USD=1000, EUR=800)
}
self.base_backed_plan_data = self.base_plan_data.copy()
self.base_backed_plan_data['uuid'] = self.base_plan_data['plan_code']
self.base_backed_plan_data['unit_amount_in_cents'] = {
u'USD': u'1000',
u'EUR': u'800'
}
self.base_backed_plan_data['display_quantity'] = False
self.base_backed_plan_data['trial_interval_length'] = 0
self.base_backed_plan_data['plan_interval_unit'] = 'months'
self.base_backed_plan_data['created_at'] = '2014-08-20'
self.base_backed_plan_data['tax_exempt'] = False
self.base_backed_plan_data['trial_interval_unit'] = 'months'
self.base_backed_plan_data['plan_interval_length'] = 1
self.base_subscription_data = {
'plan_code':
'gold',
'account':
recurly.Account(
account_code=self.base_account_data['account_code']),
'currency':
'USD'
}
self.base_add_on_backed_data = [{
'add_on_code':
'foo',
'name':
'Foo',
'plan':
self.base_backed_plan_data['plan_code'],
'accounting_code':
'foo',
'unit_amount_in_cents': {
'USD': 1000
},
'created_at':
'2014-08-20',
}, {
'add_on_code':
'bar',
'name':
'Bar',
'plan':
self.base_backed_plan_data['plan_code'],
'accounting_code':
'bar',
'unit_amount_in_cents': {
'USD': 80
},
'created_at':
'2014-08-20',
}]
self.base_add_on_data = [{
'add_on_code': 'foo',
'unit_amount_in_cents': {
'USD': 1000
}
}, {
'add_on_code': 'bar',
'unit_amount_in_cents': {
'USD': 80
}
}]
