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 } }]