def test_monthly_schedule_with_end_of_month(self): with freeze_time('2013-08-31'): now = utc_now() self.assert_schedule(started_at=now, frequency=self.plan_model.frequencies.MONTHLY, interval=1, length=7, expected=[ utc_datetime(2013, 8, 31), utc_datetime(2013, 9, 30), utc_datetime(2013, 10, 31), utc_datetime(2013, 11, 30), utc_datetime(2013, 12, 31), utc_datetime(2014, 1, 31), utc_datetime(2014, 2, 28), ]) with freeze_time('2013-11-30'): now = utc_now() self.assert_schedule(started_at=now, frequency=self.plan_model.frequencies.MONTHLY, interval=1, length=6, expected=[ utc_datetime(2013, 11, 30), utc_datetime(2013, 12, 30), utc_datetime(2014, 1, 30), utc_datetime(2014, 2, 28), utc_datetime(2014, 3, 30), utc_datetime(2014, 4, 30), ])
def test_monthly_schedule_with_end_of_month(self): with freeze_time('2013-08-31'): now = utc_now() self.assert_schedule( started_at=now, frequency=self.plan_model.frequencies.MONTHLY, interval=1, length=7, expected=[ utc_datetime(2013, 8, 31), utc_datetime(2013, 9, 30), utc_datetime(2013, 10, 31), utc_datetime(2013, 11, 30), utc_datetime(2013, 12, 31), utc_datetime(2014, 1, 31), utc_datetime(2014, 2, 28), ] ) with freeze_time('2013-11-30'): now = utc_now() self.assert_schedule( started_at=now, frequency=self.plan_model.frequencies.MONTHLY, interval=1, length=6, expected=[ utc_datetime(2013, 11, 30), utc_datetime(2013, 12, 30), utc_datetime(2014, 1, 30), utc_datetime(2014, 2, 28), utc_datetime(2014, 3, 30), utc_datetime(2014, 4, 30), ] )
def test_invalid_interval(self): with self.assertRaises(ValueError): next_transaction_datetime( started_at=utc_now(), frequency=self.plan_model.frequencies.DAILY, period=0, interval=0, ) with self.assertRaises(ValueError): next_transaction_datetime( started_at=utc_now(), frequency=self.plan_model.frequencies.DAILY, period=0, interval=-1, )
def test_create_customer( self, create_customer_method, validate_customer_method, configure_api_key_method, ): now = utc_now() now_iso = now.isoformat() validate_customer_method.return_value = True res = self.testapp.post( '/v1/customers', dict(processor_uri='MOCK_CUSTOMER_URI'), extra_environ=dict(REMOTE_USER=self.api_key), status=200, ) self.failUnless('guid' in res.json) self.assertEqual(res.json['created_at'], now_iso) self.assertEqual(res.json['updated_at'], now_iso) self.assertEqual(res.json['processor_uri'], 'MOCK_CUSTOMER_URI') self.assertEqual(res.json['company_guid'], self.company.guid) self.assertEqual(res.json['deleted'], False) self.assertFalse(create_customer_method.called) validate_customer_method.assert_called_once_with('MOCK_CUSTOMER_URI') configure_api_key_method.assert_called_once_with('MOCK_PROCESSOR_KEY')
def test_callback_only_latest_event_affects_status(self): time1 = utc_now() time2 = time1 + datetime.timedelta(seconds=10) time3 = time1 + datetime.timedelta(seconds=20) ts = self.transaction_model.statuses vs = self.invoice_model.statuses def assert_status( ev_id, status, time, expected_iv_status, expected_tx_status ): self._do_callback(ev_id, status, time) self.assertEqual(self.transaction.status, expected_tx_status) self.assertEqual(self.invoice.status, expected_iv_status) assert_status('EV_ID_1', 'pending', time1, vs.PROCESSING, ts.PENDING) assert_status('EV_ID_3', 'failed', time3, vs.FAILED, ts.FAILED) # this is the point, EV_ID_2 arrived later than EV_ID_3, but its # occurred_at time is earlier than EV_ID3, so it should never affect # the status of transaction and invoice assert_status('EV_ID_2', 'succeeded', time2, vs.FAILED, ts.FAILED) # ensure events are generated correctly and in right order for event, (expected_ev_id, expected_status, expected_time) in zip( self.transaction.events, [ ('EV_ID_3', ts.FAILED, time3), ('EV_ID_2', ts.SUCCEEDED, time2), ('EV_ID_1', ts.PENDING, time1), ] ): self.assertEqual(event.processor_id, expected_ev_id) self.assertEqual(event.status, expected_status) self.assertEqual(event.occurred_at, expected_time)
def test_create_invoice(self): amount = 5566 title = 'foobar invoice' external_id = 'external ID' appears_on_statement_as = 'hello baby' now = utc_now() now_iso = now.isoformat() res = self.testapp.post( '/v1/invoices', dict( customer_guid=self.customer.guid, amount=amount, title=title, external_id=external_id, appears_on_statement_as=appears_on_statement_as, ), extra_environ=dict(REMOTE_USER=self.api_key), status=200, ) self.failUnless('guid' in res.json) self.assertEqual(res.json['created_at'], now_iso) self.assertEqual(res.json['updated_at'], now_iso) self.assertEqual(res.json['amount'], amount) self.assertEqual(res.json['title'], title) self.assertEqual(res.json['external_id'], external_id) self.assertEqual(res.json['appears_on_statement_as'], appears_on_statement_as) self.assertEqual(res.json['customer_guid'], self.customer.guid) self.assertEqual(res.json['funding_instrument_uri'], None) invoice = self.invoice_model.get(res.json['guid']) self.assertEqual(len(invoice.transactions), 0)
def test_callback_only_latest_event_affects_status(self): time1 = utc_now() time2 = time1 + datetime.timedelta(seconds=10) time3 = time1 + datetime.timedelta(seconds=20) ts = self.transaction_model.statuses vs = self.invoice_model.statuses def assert_status(ev_id, status, time, expected_iv_status, expected_tx_status): self._do_callback(ev_id, status, time) self.assertEqual(self.transaction.status, expected_tx_status) self.assertEqual(self.invoice.status, expected_iv_status) assert_status('EV_ID_1', 'pending', time1, vs.PROCESSING, ts.PENDING) assert_status('EV_ID_3', 'failed', time3, vs.FAILED, ts.FAILED) # this is the point, EV_ID_2 arrived later than EV_ID_3, but its # occurred_at time is earlier than EV_ID3, so it should never affect # the status of transaction and invoice assert_status('EV_ID_2', 'succeeded', time2, vs.FAILED, ts.FAILED) # ensure events are generated correctly and in right order for event, (expected_ev_id, expected_status, expected_time) in zip(self.transaction.events, [ ('EV_ID_3', ts.FAILED, time3), ('EV_ID_2', ts.SUCCEEDED, time2), ('EV_ID_1', ts.PENDING, time1), ]): self.assertEqual(event.processor_id, expected_ev_id) self.assertEqual(event.status, expected_status) self.assertEqual(event.occurred_at, expected_time)
def make_event( self, event_id='EV_MOCK_EVENT_ID', transaction_guid=None, occurred_at=None, status='succeeded', ): """Make a mock Balanced.Event instance and return """ if transaction_guid is None: transaction_guid = self.transaction.guid if occurred_at is None: occurred_at = utc_now() event = mock.Mock( id=event_id, occurred_at=occurred_at, entity=dict( entity_type=[dict( meta={'billy.transaction_guid': transaction_guid}, status=status, )], links=[], ) ) return event
def test_create_plan(self): plan_type = 'debit' amount = 5566 frequency = 'weekly' interval = 123 now = utc_now() now_iso = now.isoformat() res = self.testapp.post( '/v1/plans', dict( plan_type=plan_type, amount=amount, frequency=frequency, interval=interval, ), extra_environ=dict(REMOTE_USER=self.api_key), status=200, ) self.failUnless('guid' in res.json) self.assertEqual(res.json['created_at'], now_iso) self.assertEqual(res.json['updated_at'], now_iso) self.assertEqual(res.json['plan_type'], plan_type) self.assertEqual(res.json['amount'], amount) self.assertEqual(res.json['frequency'], frequency) self.assertEqual(res.json['interval'], interval) self.assertEqual(res.json['company_guid'], self.company.guid) self.assertEqual(res.json['deleted'], False)
def test_create_subscription_with_started_at(self): amount = 5566 now = utc_now() now_iso = now.isoformat() # next week next_invoice_at = utc_datetime(2013, 8, 17) next_iso = next_invoice_at.isoformat() res = self.testapp.post( '/v1/subscriptions', dict( customer_guid=self.customer.guid, plan_guid=self.plan.guid, amount=amount, started_at='2013-08-17T00:00:00Z', ), extra_environ=dict(REMOTE_USER=self.api_key), status=200, ) self.failUnless('guid' in res.json) self.assertEqual(res.json['created_at'], now_iso) self.assertEqual(res.json['updated_at'], now_iso) self.assertEqual(res.json['next_invoice_at'], next_iso) self.assertEqual(res.json['invoice_count'], 0) self.assertEqual(res.json['amount'], amount) self.assertEqual(res.json['customer_guid'], self.customer.guid) self.assertEqual(res.json['plan_guid'], self.plan.guid)
def make_event( self, event_id='EV_MOCK_EVENT_ID', transaction_guid=None, occurred_at=None, status='succeeded', ): """Make a mock Balanced.Event instance and return """ if transaction_guid is None: transaction_guid = self.transaction.guid if occurred_at is None: occurred_at = utc_now() event = mock.Mock( id=event_id, occurred_at=occurred_at, entity=dict( entity_type=[ dict( meta={'billy.transaction_guid': transaction_guid}, status=status, ) ], links=[], )) return event
def assert_next_day(now_dt, expected): with freeze_time(now_dt): now = utc_now() next_dt = next_transaction_datetime( started_at=now, frequency=self.plan_model.frequencies.DAILY, period=1, ) self.assertEqual(next_dt, expected)
def test_yearly_schedule_with_interval(self): with freeze_time('2013-08-18'): now = utc_now() self.assert_schedule(started_at=now, frequency=self.plan_model.frequencies.YEARLY, interval=2, length=3, expected=[ utc_datetime(2013, 8, 18), utc_datetime(2015, 8, 18), utc_datetime(2017, 8, 18), ])
def test_yearly_schedule_with_interval(self): with freeze_time('2013-08-18'): now = utc_now() self.assert_schedule( started_at=now, frequency=self.plan_model.frequencies.YEARLY, interval=2, length=3, expected=[ utc_datetime(2013, 8, 18), utc_datetime(2015, 8, 18), utc_datetime(2017, 8, 18), ])
def test_monthly_schedule_with_interval(self): with freeze_time('2013-08-18'): now = utc_now() self.assert_schedule(started_at=now, frequency=self.plan_model.frequencies.MONTHLY, interval=6, length=4, expected=[ utc_datetime(2013, 8, 18), utc_datetime(2014, 2, 18), utc_datetime(2014, 8, 18), utc_datetime(2015, 2, 18), ])
def test_daily_schedule_with_interval(self): with freeze_time('2013-07-28'): now = utc_now() self.assert_schedule(started_at=now, frequency=self.plan_model.frequencies.DAILY, interval=3, length=4, expected=[ utc_datetime(2013, 7, 28), utc_datetime(2013, 7, 31), utc_datetime(2013, 8, 3), utc_datetime(2013, 8, 6), ])
def test_weekly_schedule(self): with freeze_time('2013-08-18'): now = utc_now() self.assert_schedule(started_at=now, frequency=self.plan_model.frequencies.WEEKLY, interval=1, length=5, expected=[ utc_datetime(2013, 8, 18), utc_datetime(2013, 8, 25), utc_datetime(2013, 9, 1), utc_datetime(2013, 9, 8), utc_datetime(2013, 9, 15), ])
def test_yearly_schedule_with_leap_year(self): with freeze_time('2012-02-29'): now = utc_now() self.assert_schedule(started_at=now, frequency=self.plan_model.frequencies.YEARLY, interval=1, length=5, expected=[ utc_datetime(2012, 2, 29), utc_datetime(2013, 2, 28), utc_datetime(2014, 2, 28), utc_datetime(2015, 2, 28), utc_datetime(2016, 2, 29), ])
def test_monthly_schedule_with_interval(self): with freeze_time('2013-08-18'): now = utc_now() self.assert_schedule( started_at=now, frequency=self.plan_model.frequencies.MONTHLY, interval=6, length=4, expected=[ utc_datetime(2013, 8, 18), utc_datetime(2014, 2, 18), utc_datetime(2014, 8, 18), utc_datetime(2015, 2, 18), ] )
def test_daily_schedule_with_interval(self): with freeze_time('2013-07-28'): now = utc_now() self.assert_schedule( started_at=now, frequency=self.plan_model.frequencies.DAILY, interval=3, length=4, expected=[ utc_datetime(2013, 7, 28), utc_datetime(2013, 7, 31), utc_datetime(2013, 8, 3), utc_datetime(2013, 8, 6), ] )
def test_yearly_schedule_with_leap_year(self): with freeze_time('2012-02-29'): now = utc_now() self.assert_schedule( started_at=now, frequency=self.plan_model.frequencies.YEARLY, interval=1, length=5, expected=[ utc_datetime(2012, 2, 29), utc_datetime(2013, 2, 28), utc_datetime(2014, 2, 28), utc_datetime(2015, 2, 28), utc_datetime(2016, 2, 29), ] )
def test_weekly_schedule(self): with freeze_time('2013-08-18'): now = utc_now() self.assert_schedule( started_at=now, frequency=self.plan_model.frequencies.WEEKLY, interval=1, length=5, expected=[ utc_datetime(2013, 8, 18), utc_datetime(2013, 8, 25), utc_datetime(2013, 9, 1), utc_datetime(2013, 9, 8), utc_datetime(2013, 9, 15), ] )
def test_create_invoice_with_funding_instrument_uri(self, debit_method): amount = 5566 funding_instrument_uri = 'MOCK_CARD_URI' now = utc_now() now_iso = now.isoformat() adjustments = [ dict(amount=-100, reason='A Lannister always pays his debts!'), ] adjustment_params = self._encode_adjustment_params(adjustments) debit_method.return_value = dict( processor_uri='MOCK_DEBIT_URI', status=self.transaction_model.statuses.SUCCEEDED, ) res = self.testapp.post( '/v1/invoices', dict( customer_guid=self.customer.guid, amount=amount, funding_instrument_uri=funding_instrument_uri, **adjustment_params ), extra_environ=dict(REMOTE_USER=self.api_key), status=200, ) self.failUnless('guid' in res.json) self.assertEqual(res.json['created_at'], now_iso) self.assertEqual(res.json['updated_at'], now_iso) self.assertEqual(res.json['amount'], amount) self.assertEqual(res.json['effective_amount'], amount - 100) self.assertEqual(res.json['title'], None) self.assertEqual(res.json['customer_guid'], self.customer.guid) self.assertEqual(res.json['funding_instrument_uri'], funding_instrument_uri) invoice = self.invoice_model.get(res.json['guid']) self.assertEqual(len(invoice.transactions), 1) transaction = invoice.transactions[0] self.assertEqual(transaction.amount, invoice.effective_amount) self.assertEqual(transaction.processor_uri, 'MOCK_DEBIT_URI') self.assertEqual(transaction.submit_status, self.transaction_model.submit_statuses.DONE) self.assertEqual(transaction.status, self.transaction_model.statuses.SUCCEEDED) debit_method.assert_called_once_with(transaction)
def test_cancel_subscription(self): with db_transaction.manager: subscription = self.subscription_model.create( customer=self.customer, plan=self.plan, ) with freeze_time('2013-08-16 07:00:00'): canceled_at = utc_now() res = self.testapp.post( '/v1/subscriptions/{}/cancel'.format(subscription.guid), extra_environ=dict(REMOTE_USER=self.api_key), status=200, ) subscription = res.json self.assertEqual(subscription['canceled'], True) self.assertEqual(subscription['canceled_at'], canceled_at.isoformat())
def test_create_invoice_with_funding_instrument_uri(self, debit_method): amount = 5566 funding_instrument_uri = 'MOCK_CARD_URI' now = utc_now() now_iso = now.isoformat() adjustments = [ dict(amount=-100, reason='A Lannister always pays his debts!'), ] adjustment_params = self._encode_adjustment_params(adjustments) debit_method.return_value = dict( processor_uri='MOCK_DEBIT_URI', status=self.transaction_model.statuses.SUCCEEDED, ) res = self.testapp.post( '/v1/invoices', dict(customer_guid=self.customer.guid, amount=amount, funding_instrument_uri=funding_instrument_uri, **adjustment_params), extra_environ=dict(REMOTE_USER=self.api_key), status=200, ) self.failUnless('guid' in res.json) self.assertEqual(res.json['created_at'], now_iso) self.assertEqual(res.json['updated_at'], now_iso) self.assertEqual(res.json['amount'], amount) self.assertEqual(res.json['effective_amount'], amount - 100) self.assertEqual(res.json['title'], None) self.assertEqual(res.json['customer_guid'], self.customer.guid) self.assertEqual(res.json['funding_instrument_uri'], funding_instrument_uri) invoice = self.invoice_model.get(res.json['guid']) self.assertEqual(len(invoice.transactions), 1) transaction = invoice.transactions[0] self.assertEqual(transaction.amount, invoice.effective_amount) self.assertEqual(transaction.processor_uri, 'MOCK_DEBIT_URI') self.assertEqual(transaction.submit_status, self.transaction_model.submit_statuses.DONE) self.assertEqual(transaction.status, self.transaction_model.statuses.SUCCEEDED) debit_method.assert_called_once_with(transaction)
def test_create_company(self, register_callback_method): processor_key = 'MOCK_PROCESSOR_KEY' now = utc_now() now_iso = now.isoformat() res = self.testapp.post('/v1/companies', dict(processor_key=processor_key), status=200) self.failUnless('processor_key' not in res.json) self.failUnless('guid' in res.json) self.failUnless('api_key' in res.json) self.assertEqual(res.json['created_at'], now_iso) self.assertEqual(res.json['updated_at'], now_iso) company = self.company_model.get(res.json['guid']) expected_url = 'http://localhost/v1/companies/{}/callbacks/{}/'.format( company.guid, company.callback_key, ) register_callback_method.assert_called_once_with(company, expected_url)
def test_create_company(self, register_callback_method): processor_key = 'MOCK_PROCESSOR_KEY' now = utc_now() now_iso = now.isoformat() res = self.testapp.post( '/v1/companies', dict(processor_key=processor_key), status=200 ) self.failUnless('processor_key' not in res.json) self.failUnless('guid' in res.json) self.failUnless('api_key' in res.json) self.assertEqual(res.json['created_at'], now_iso) self.assertEqual(res.json['updated_at'], now_iso) company = self.company_model.get(res.json['guid']) expected_url = 'http://localhost/v1/companies/{}/callbacks/{}/'.format( company.guid, company.callback_key, ) register_callback_method.assert_called_once_with(company, expected_url)
def test_subscription(self): subscription = self.subscription json_data = subscription_adapter(subscription, self.dummy_request) expected = dict( guid=subscription.guid, amount=None, effective_amount=subscription.plan.amount, funding_instrument_uri=subscription.funding_instrument_uri, appears_on_statement_as=subscription.appears_on_statement_as, invoice_count=subscription.invoice_count, canceled=subscription.canceled, next_invoice_at=subscription.next_invoice_at.isoformat(), created_at=subscription.created_at.isoformat(), updated_at=subscription.updated_at.isoformat(), started_at=subscription.started_at.isoformat(), canceled_at=None, customer_guid=subscription.customer_guid, plan_guid=subscription.plan_guid, ) self.assertEqual(json_data, expected) def assert_amount(amount, expected_amount, expected_effective_amount): subscription.amount = amount json_data = subscription_adapter(subscription, self.dummy_request) self.assertEqual(json_data['amount'], expected_amount) self.assertEqual(json_data['effective_amount'], expected_effective_amount) assert_amount(None, None, subscription.plan.amount) assert_amount(1234, 1234, 1234) def assert_canceled_at(canceled_at, expected_canceled_at): subscription.canceled_at = canceled_at json_data = subscription_adapter(subscription, self.dummy_request) self.assertEqual(json_data['canceled_at'], expected_canceled_at) now = utc_now() assert_canceled_at(None, None) assert_canceled_at(now, now.isoformat())
def test_callback_with_duplicate_event(self): now = utc_now() self._do_callback('EV_ID_1', 'succeeded', now) with self.assertRaises(DuplicateEventError): self._do_callback('EV_ID_1', 'succeeded', now)
def test_callback_with_other_company(self): with db_transaction.manager: other_company = self.company_model.create('MOCK_PROCESSOR_KEY') with self.assertRaises(InvalidCallbackPayload): self._do_callback('EVID', 'succeeded', utc_now(), other_company)
def test_create_subscription(self, debit_method): amount = 5566 funding_instrument_uri = 'MOCK_CARD_URI' appears_on_statement_as = 'hello baby' now = utc_now() now_iso = now.isoformat() # next week next_invoice_at = utc_datetime(2013, 8, 23) next_iso = next_invoice_at.isoformat() debit_method.return_value = dict( processor_uri='MOCK_DEBIT_URI', status=self.transaction_model.statuses.SUCCEEDED, ) res = self.testapp.post( '/v1/subscriptions', dict( customer_guid=self.customer.guid, plan_guid=self.plan.guid, amount=amount, funding_instrument_uri=funding_instrument_uri, appears_on_statement_as=appears_on_statement_as, ), extra_environ=dict(REMOTE_USER=self.api_key), status=200, ) self.failUnless('guid' in res.json) self.assertEqual(res.json['created_at'], now_iso) self.assertEqual(res.json['updated_at'], now_iso) self.assertEqual(res.json['canceled_at'], None) self.assertEqual(res.json['next_invoice_at'], next_iso) self.assertEqual(res.json['invoice_count'], 1) self.assertEqual(res.json['amount'], amount) self.assertEqual(res.json['effective_amount'], amount) self.assertEqual(res.json['customer_guid'], self.customer.guid) self.assertEqual(res.json['plan_guid'], self.plan.guid) self.assertEqual(res.json['funding_instrument_uri'], funding_instrument_uri) self.assertEqual(res.json['appears_on_statement_as'], appears_on_statement_as) self.assertEqual(res.json['canceled'], False) subscription = self.subscription_model.get(res.json['guid']) self.assertEqual(subscription.invoice_count, 1) invoice = subscription.invoices[0] self.assertEqual(len(invoice.transactions), 1) self.assertEqual(invoice.amount, amount) self.assertEqual(invoice.scheduled_at, now) self.assertEqual(invoice.transaction_type, self.invoice_model.transaction_types.DEBIT) self.assertEqual(invoice.invoice_type, self.invoice_model.types.SUBSCRIPTION) self.assertEqual(invoice.appears_on_statement_as, appears_on_statement_as) transaction = invoice.transactions[0] debit_method.assert_called_once_with(transaction) self.assertEqual(transaction.processor_uri, 'MOCK_DEBIT_URI') self.assertEqual(transaction.submit_status, self.transaction_model.submit_statuses.DONE) self.assertEqual(transaction.appears_on_statement_as, subscription.appears_on_statement_as) self.assertEqual(transaction.amount, amount) self.assertEqual(transaction.transaction_type, self.transaction_model.types.DEBIT)
def setUp(self): super(TestRenderer, self).setUp() with db_transaction.manager: self.company = self.company_model.create( processor_key='MOCK_PROCESSOR_KEY', ) self.customer = self.customer_model.create(company=self.company) self.plan = self.plan_model.create( company=self.company, frequency=self.plan_model.frequencies.WEEKLY, plan_type=self.plan_model.types.DEBIT, amount=1234, ) self.subscription = self.subscription_model.create( customer=self.customer, plan=self.plan, appears_on_statement_as='hello baby', ) self.customer_invoice = self.invoice_model.create( customer=self.customer, amount=7788, title='foobar invoice', external_id='external ID', appears_on_statement_as='hello baby', items=[ dict(type='debit', name='foo', amount=123, volume=5678), dict(name='bar', amount=456, quantity=10, unit='hours', volume=7788), ], adjustments=[ dict(amount=20, reason='A Lannister always pays his debts!'), dict(amount=3), ], ) self.subscription_invoice = self.invoice_model.create( subscription=self.subscription, amount=7788, title='foobar invoice', external_id='external ID2', appears_on_statement_as='hello baby', items=[ dict(type='debit', name='foo', amount=123, volume=5678), dict(name='bar', amount=456, quantity=10, unit='hours', volume=7788), ], adjustments=[ dict(amount=20, reason='A Lannister always pays his debts!'), dict(amount=3), ], scheduled_at=utc_now(), ) self.transaction = self.transaction_model.create( invoice=self.customer_invoice, transaction_type=self.transaction_model.types.DEBIT, amount=5678, funding_instrument_uri='/v1/cards/tester', appears_on_statement_as='hello baby', ) self.transaction_failure1 = self.transaction_failure_model.create( transaction=self.transaction, error_message='boom!', error_number=666, error_code='damin-it', ) with freeze_time('2013-08-17'): self.transaction_failure2 = self.transaction_failure_model.create( transaction=self.transaction, error_message='doomed!', error_number=777, error_code='screw-it', )
def setUp(self): super(TestRenderer, self).setUp() with db_transaction.manager: self.company = self.company_model.create( processor_key='MOCK_PROCESSOR_KEY', ) self.customer = self.customer_model.create( company=self.company ) self.plan = self.plan_model.create( company=self.company, frequency=self.plan_model.frequencies.WEEKLY, plan_type=self.plan_model.types.DEBIT, amount=1234, ) self.subscription = self.subscription_model.create( customer=self.customer, plan=self.plan, appears_on_statement_as='hello baby', ) self.customer_invoice = self.invoice_model.create( customer=self.customer, amount=7788, title='foobar invoice', external_id='external ID', appears_on_statement_as='hello baby', items=[ dict(type='debit', name='foo', amount=123, volume=5678), dict(name='bar', amount=456, quantity=10, unit='hours', volume=7788), ], adjustments=[ dict(amount=20, reason='A Lannister always pays his debts!'), dict(amount=3), ], ) self.subscription_invoice = self.invoice_model.create( subscription=self.subscription, amount=7788, title='foobar invoice', external_id='external ID2', appears_on_statement_as='hello baby', items=[ dict(type='debit', name='foo', amount=123, volume=5678), dict(name='bar', amount=456, quantity=10, unit='hours', volume=7788), ], adjustments=[ dict(amount=20, reason='A Lannister always pays his debts!'), dict(amount=3), ], scheduled_at=utc_now(), ) self.transaction = self.transaction_model.create( invoice=self.customer_invoice, transaction_type=self.transaction_model.types.DEBIT, amount=5678, funding_instrument_uri='/v1/cards/tester', appears_on_statement_as='hello baby', ) self.transaction_failure1 = self.transaction_failure_model.create( transaction=self.transaction, error_message='boom!', error_number=666, error_code='damin-it', ) with freeze_time('2013-08-17'): self.transaction_failure2 = self.transaction_failure_model.create( transaction=self.transaction, error_message='doomed!', error_number=777, error_code='screw-it', )