def test_plan(self):
plan_code = 'plan%s' % self.test_id
with self.mock_request('plan/does-not-exist.xml'):
self.assertRaises(NotFoundError, Plan.get, plan_code)
plan = Plan(
plan_code=plan_code,
name='Mock Plan',
setup_fee_in_cents=Money(0),
unit_amount_in_cents=Money(1000),
)
with self.mock_request('plan/created.xml'):
plan.save()
try:
self.assertEqual(plan.plan_code, plan_code)
with self.mock_request('plan/exists.xml'):
same_plan = Plan.get(plan_code)
self.assertEqual(same_plan.plan_code, plan_code)
self.assertEqual(same_plan.name, 'Mock Plan')
plan.plan_interval_length = 2
plan.plan_interval_unit = 'months'
plan.unit_amount_in_cents = Money(USD=2000)
plan.setup_fee_in_cents = Money(USD=0)
with self.mock_request('plan/updated.xml'):
plan.save()
finally:
with self.mock_request('plan/deleted.xml'):
plan.delete()
def test_add_on(self):
plan_code = 'plan%s' % self.test_id
add_on_code = 'addon%s' % self.test_id
plan = Plan(
plan_code=plan_code,
name='Mock Plan',
setup_fee_in_cents=Money(0),
unit_amount_in_cents=Money(1000),
)
with self.mock_request('add-on/plan-created.xml'):
plan.save()
try:
add_on = AddOn(add_on_code=add_on_code, name='Mock Add-On')
with self.mock_request('add-on/created.xml'):
plan.create_add_on(add_on)
self.assertEqual(add_on.add_on_code, add_on_code)
self.assertEqual(add_on.name, 'Mock Add-On')
try:
with self.mock_request('add-on/exists.xml'):
same_add_on = plan.get_add_on(add_on_code)
self.assertEqual(same_add_on.add_on_code, add_on_code)
self.assertEqual(same_add_on.name, 'Mock Add-On')
finally:
with self.mock_request('add-on/deleted.xml'):
add_on.delete()
finally:
with self.mock_request('add-on/plan-deleted.xml'):
plan.delete()
def test_subscribe_add_on(self):
plan = Plan(
plan_code='basicplan',
name='Basic Plan',
setup_fee_in_cents=Money(0),
unit_amount_in_cents=Money(1000),
)
with self.mock_request('subscribe-add-on/plan-created.xml'):
plan.save()
try:
add_on = AddOn(
add_on_code='mock_add_on',
name='Mock Add-On',
unit_amount_in_cents=Money(100),
)
with self.mock_request('subscribe-add-on/add-on-created.xml'):
plan.create_add_on(add_on)
second_add_on = AddOn(
add_on_code='second_add_on',
name='Second Add-On',
unit_amount_in_cents=Money(50),
)
with self.mock_request(
'subscribe-add-on/second-add-on-created.xml'):
plan.create_add_on(second_add_on)
account_code = 'sad-on-%s' % self.test_id
sub = Subscription(
plan_code='basicplan',
subscription_add_ons=[
SubscriptionAddOn(add_on_code='mock_add_on', ),
SubscriptionAddOn(add_on_code='second_add_on', ),
],
currency='USD',
account=Account(
account_code=account_code,
billing_info=BillingInfo(
first_name='Verena',
last_name='Example',
number='4111 1111 1111 1111',
verification_value='7777',
year='2015',
month='12',
),
),
)
with self.mock_request('subscribe-add-on/subscribed.xml'):
sub.save()
with self.mock_request('subscribe-add-on/account-exists.xml'):
account = Account.get(account_code)
with self.mock_request('subscribe-add-on/account-deleted.xml'):
account.delete()
finally:
with self.mock_request('subscribe-add-on/plan-deleted.xml'):
plan.delete()
def test_add_on(self):
plan_code = 'plan%s' % self.test_id
add_on_code = 'addon%s' % self.test_id
plan = Plan(
plan_code=plan_code,
name='Mock Plan',
setup_fee_in_cents=Money(0),
unit_amount_in_cents=Money(1000),
)
with self.mock_request('add-on/plan-created.xml'):
plan.save()
try:
add_on = AddOn(add_on_code=add_on_code, name='Mock Add-On')
exc = None
with self.mock_request('add-on/need-amount.xml'):
try:
plan.create_add_on(add_on)
except ValidationError as _exc:
exc = _exc
else:
self.fail(
"Creating a plan add-on without an amount did not raise a ValidationError"
)
error = exc.errors['add_on.unit_amount_in_cents']
self.assertEqual(error.symbol, 'blank')
add_on = AddOn(add_on_code=add_on_code,
name='Mock Add-On',
unit_amount_in_cents=Money(40))
with self.mock_request('add-on/created.xml'):
plan.create_add_on(add_on)
self.assertEqual(add_on.add_on_code, add_on_code)
self.assertEqual(add_on.name, 'Mock Add-On')
try:
with self.mock_request('add-on/exists.xml'):
same_add_on = plan.get_add_on(add_on_code)
self.assertEqual(same_add_on.add_on_code, add_on_code)
self.assertEqual(same_add_on.name, 'Mock Add-On')
self.assertEqual(same_add_on.unit_amount_in_cents['USD'], 40)
finally:
with self.mock_request('add-on/deleted.xml'):
add_on.delete()
finally:
with self.mock_request('add-on/plan-deleted.xml'):
plan.delete()
def test_add_on(self):
plan_code = 'plan%s' % self.test_id
add_on_code = 'addon%s' % self.test_id
plan = Plan(
plan_code=plan_code,
name='Mock Plan',
setup_fee_in_cents=Money(0),
unit_amount_in_cents=Money(1000),
)
with self.mock_request('add-on/plan-created.xml'):
plan.save()
try:
add_on = AddOn(add_on_code=add_on_code, name='Mock Add-On')
with self.mock_request('add-on/need-amount.xml'):
try:
plan.create_add_on(add_on)
except ValidationError, exc:
pass
else:
def test_subscribe(self):
logging.basicConfig(level=logging.DEBUG) # make sure it's init'ed
logger = logging.getLogger('recurly.http.request')
logger.setLevel(logging.DEBUG)
plan = Plan(
plan_code='basicplan',
name='Basic Plan',
setup_fee_in_cents=Money(0),
unit_amount_in_cents=Money(1000),
)
with self.mock_request('subscription/plan-created.xml'):
plan.save()
try:
account = Account(account_code='subscribe%s' % self.test_id)
with self.mock_request('subscription/account-created.xml'):
account.save()
try:
sub = Subscription(
plan_code='basicplan',
currency='USD',
unit_amount_in_cents=1000,
)
with self.mock_request(
'subscription/error-no-billing-info.xml'):
try:
account.subscribe(sub)
except BadRequestError, exc:
error = exc
else:
self.fail(
"Subscribing with no billing info did not raise a BadRequestError"
)
def test_subscribe_add_on(self):
plan = Plan(
plan_code='basicplan',
name='Basic Plan',
setup_fee_in_cents=Money(0),
unit_amount_in_cents=Money(1000),
)
with self.mock_request('subscribe-add-on/plan-created.xml'):
plan.save()
try:
add_on = AddOn(
add_on_code='mock_add_on',
name='Mock Add-On',
unit_amount_in_cents=Money(100),
)
with self.mock_request('subscribe-add-on/add-on-created.xml'):
plan.create_add_on(add_on)
second_add_on = AddOn(
add_on_code='second_add_on',
name='Second Add-On',
unit_amount_in_cents=Money(50),
)
with self.mock_request(
'subscribe-add-on/second-add-on-created.xml'):
plan.create_add_on(second_add_on)
account_code = 'sad-on-%s' % self.test_id
sub = Subscription(
plan_code='basicplan',
subscription_add_ons=[
SubscriptionAddOn(add_on_code='mock_add_on', ),
SubscriptionAddOn(add_on_code='second_add_on', ),
],
currency='USD',
account=Account(
account_code=account_code,
billing_info=BillingInfo(
first_name='Verena',
last_name='Example',
number='4111 1111 1111 1111',
address1='123 Main St',
city='San Francisco',
state='CA',
zip='94105',
country='US',
verification_value='7777',
year='2015',
month='12',
),
),
)
with self.mock_request('subscribe-add-on/subscribed.xml'):
sub.save()
# Subscription amounts are in one real currency, so they aren't Money instances.
sub_amount = sub.unit_amount_in_cents
self.assertTrue(not isinstance(sub_amount, Money))
self.assertEqual(sub_amount, 1000)
# Test that the add-ons' amounts aren't real Money instances either.
add_on_1, add_on_2 = sub.subscription_add_ons
self.assertIsInstance(add_on_1, SubscriptionAddOn)
amount_1 = add_on_1.unit_amount_in_cents
self.assertTrue(not isinstance(amount_1, Money))
self.assertEqual(amount_1, 100)
with self.mock_request('subscribe-add-on/account-exists.xml'):
account = Account.get(account_code)
with self.mock_request('subscribe-add-on/account-deleted.xml'):
account.delete()
finally:
with self.mock_request('subscribe-add-on/plan-deleted.xml'):
plan.delete()
def test_coupon(self):
# Check that a coupon may not exist.
coupon_code = 'coupon%s' % self.test_id
with self.mock_request('coupon/does-not-exist.xml'):
self.assertRaises(NotFoundError, Coupon.get, coupon_code)
# Create a coupon?
coupon = Coupon(
coupon_code=coupon_code,
name='Nice Coupon',
discount_in_cents=Money(1000),
)
with self.mock_request('coupon/created.xml'):
coupon.save()
self.assertTrue(coupon._url)
try:
with self.mock_request('coupon/exists.xml'):
same_coupon = Coupon.get(coupon_code)
self.assertEqual(same_coupon.coupon_code, coupon_code)
self.assertEqual(same_coupon.name, 'Nice Coupon')
discount = same_coupon.discount_in_cents
self.assertEqual(discount['USD'], 1000)
self.assertTrue('USD' in discount)
account_code = 'coupon%s' % self.test_id
account = Account(account_code=account_code)
with self.mock_request('coupon/account-created.xml'):
account.save()
try:
redemption = Redemption(
account_code=account_code,
currency='USD',
)
with self.mock_request('coupon/redeemed.xml'):
real_redemption = coupon.redeem(redemption)
self.assertTrue(isinstance(real_redemption, Redemption))
self.assertEqual(real_redemption.currency, 'USD')
with self.mock_request('coupon/account-with-redemption.xml'):
account = Account.get(account_code)
with self.mock_request('coupon/redemption-exists.xml'):
same_redemption = account.redemption()
self.assertEqual(same_redemption._url, real_redemption._url)
with self.mock_request('coupon/unredeemed.xml'):
real_redemption.delete()
finally:
with self.mock_request('coupon/account-deleted.xml'):
account.delete()
plan = Plan(
plan_code='basicplan',
name='Basic Plan',
setup_fee_in_cents=Money(0),
unit_amount_in_cents=Money(1000),
)
with self.mock_request('coupon/plan-created.xml'):
plan.save()
try:
account_code_2 = 'coupon-%s-2' % self.test_id
sub = Subscription(
plan_code='basicplan',
coupon_code='coupon%s' % self.test_id,
currency='USD',
account=Account(
account_code=account_code_2,
billing_info=BillingInfo(
first_name='Verena',
last_name='Example',
number='4111 1111 1111 1111',
address1='123 Main St',
city='San Francisco',
state='CA',
zip='94105',
country='US',
verification_value='7777',
year='2015',
month='12',
),
),
)
with self.mock_request('coupon/subscribed.xml'):
sub.save()
with self.mock_request('coupon/second-account-exists.xml'):
account_2 = Account.get(account_code_2)
try:
with self.mock_request(
'coupon/second-account-redemption.xml'):
redemption_2 = account_2.redemption()
self.assertTrue(isinstance(redemption_2, Redemption))
self.assertEqual(redemption_2.currency, 'USD')
with self.mock_request('coupon/exists.xml'):
same_coupon = redemption_2.coupon()
self.assertEqual(same_coupon.coupon_code, coupon_code)
finally:
with self.mock_request(
'coupon/second-account-deleted.xml'):
account_2.delete()
plan_coupon = Coupon(
coupon_code='plancoupon%s' % self.test_id,
name='Plan Coupon',
discount_in_cents=Money(1000),
applies_to_all_plans=False,
plan_codes=('basicplan', ),
)
with self.mock_request('coupon/plan-coupon-created.xml'):
plan_coupon.save()
try:
self.assertTrue(plan_coupon._url)
coupon_plans = list(plan_coupon.plan_codes)
self.assertEqual(len(coupon_plans), 1)
self.assertEqual(coupon_plans[0], 'basicplan')
finally:
with self.mock_request('coupon/plan-coupon-deleted.xml'):
plan_coupon.delete()
finally:
with self.mock_request('coupon/plan-deleted.xml'):
plan.delete()
finally:
with self.mock_request('coupon/deleted.xml'):
coupon.delete()
add_on = AddOn(add_on_code=add_on_code, name='Mock Add-On')
with self.mock_request('add-on/need-amount.xml'):
try:
plan.create_add_on(add_on)
except ValidationError, exc:
pass
else:
self.fail(
"Creating a plan add-on without an amount did not raise a ValidationError"
)
error = exc.errors['add_on.unit_amount_in_cents']
self.assertEqual(error.symbol, 'blank')
add_on = AddOn(add_on_code=add_on_code,
name='Mock Add-On',
unit_amount_in_cents=Money(40))
with self.mock_request('add-on/created.xml'):
plan.create_add_on(add_on)
self.assertEqual(add_on.add_on_code, add_on_code)
self.assertEqual(add_on.name, 'Mock Add-On')
try:
with self.mock_request('add-on/exists.xml'):
same_add_on = plan.get_add_on(add_on_code)
self.assertEqual(same_add_on.add_on_code, add_on_code)
self.assertEqual(same_add_on.name, 'Mock Add-On')
self.assertEqual(same_add_on.unit_amount_in_cents['USD'], 40)
finally:
with self.mock_request('add-on/deleted.xml'):
def test_subscribe(self):
logging.basicConfig(level=logging.DEBUG) # make sure it's init'ed
logger = logging.getLogger('recurly.http.request')
logger.setLevel(logging.DEBUG)
plan = Plan(
plan_code='basicplan',
name='Basic Plan',
setup_fee_in_cents=Money(0),
unit_amount_in_cents=Money(1000),
)
with self.mock_request('subscription/plan-created.xml'):
plan.save()
try:
account = Account(account_code='subscribe%s' % self.test_id)
with self.mock_request('subscription/account-created.xml'):
account.save()
try:
sub = Subscription(
plan_code='basicplan',
currency='USD',
unit_amount_in_cents=1000,
)
with self.mock_request('subscription/error-no-billing-info.xml'):
try:
account.subscribe(sub)
except BadRequestError as exc:
error = exc
else:
self.fail("Subscribing with no billing info did not raise a BadRequestError")
self.assertEqual(error.symbol, 'billing_info_required')
binfo = BillingInfo(
first_name='Verena',
last_name='Example',
address1='123 Main St',
city=six.u('San Jos\xe9'),
state='CA',
zip='94105',
country='US',
type='credit_card',
number='4111 1111 1111 1111',
verification_value='7777',
year='2015',
month='12',
)
with self.mock_request('subscription/update-billing-info.xml'):
account.update_billing_info(binfo)
with self.mock_request('subscription/subscribed.xml'):
account.subscribe(sub)
self.assertTrue(sub._url)
manualsub = Subscription(
plan_code='basicplan',
currency='USD',
net_terms=10,
po_number='1000',
collection_method='manual'
)
with self.mock_request('subscription/subscribed-manual.xml'):
account.subscribe(manualsub)
self.assertTrue(manualsub._url)
self.assertEqual(manualsub.net_terms, 10)
self.assertEqual(manualsub.collection_method, 'manual')
self.assertEqual(manualsub.po_number, '1000')
with self.mock_request('subscription/account-subscriptions.xml'):
subs = account.subscriptions()
self.assertTrue(len(subs) > 0)
self.assertEqual(subs[0].uuid, sub.uuid)
with self.mock_request('subscription/all-subscriptions.xml'):
subs = Subscription.all()
self.assertTrue(len(subs) > 0)
self.assertEqual(subs[0].uuid, sub.uuid)
with self.mock_request('subscription/cancelled.xml'):
sub.cancel()
with self.mock_request('subscription/reactivated.xml'):
sub.reactivate()
# Try modifying the subscription.
sub.timeframe = 'renewal'
sub.unit_amount_in_cents = 800
with self.mock_request('subscription/updated-at-renewal.xml'):
sub.save()
pending_sub = sub.pending_subscription
self.assertTrue(isinstance(pending_sub, Subscription))
self.assertEqual(pending_sub.unit_amount_in_cents, 800)
self.assertEqual(sub.unit_amount_in_cents, 1000)
with self.mock_request('subscription/terminated.xml'):
sub.terminate(refund='none')
log_content = StringIO()
log_handler = logging.StreamHandler(log_content)
logger.addHandler(log_handler)
sub = Subscription(
plan_code='basicplan',
currency='USD',
account=Account(
account_code='subscribe%s' % self.test_id,
billing_info=BillingInfo(
first_name='Verena',
last_name='Example',
address1='123 Main St',
city=six.u('San Jos\xe9'),
state='CA',
zip='94105',
country='US',
type='credit_card',
number='4111 1111 1111 1111',
verification_value='7777',
year='2015',
month='12',
),
),
)
with self.mock_request('subscription/subscribed-billing-info.xml'):
account.subscribe(sub)
logger.removeHandler(log_handler)
log_content = log_content.getvalue()
self.assertTrue('<subscription' in log_content)
self.assertTrue('<billing_info' in log_content)
# See if we redacted our sensitive fields properly.
self.assertTrue('4111' not in log_content)
self.assertTrue('7777' not in log_content)
finally:
with self.mock_request('subscription/account-deleted.xml'):
account.delete()
account_code_2 = 'subscribe-%s-2' % self.test_id
sub = Subscription(
plan_code='basicplan',
currency='USD',
account=Account(
account_code=account_code_2,
billing_info=BillingInfo(
first_name='Verena',
last_name='Example',
address1='123 Main St',
city=six.u('San Jos\xe9'),
state='CA',
zip='94105',
country='US',
type='credit_card',
number='4111 1111 1111 1111',
verification_value='7777',
year='2015',
month='12',
),
),
)
with self.mock_request('subscription/subscribe-embedded-account.xml'):
sub.save()
with self.mock_request('subscription/embedded-account-exists.xml'):
acc = Account.get(account_code_2)
self.assertEqual(acc.account_code, account_code_2)
with self.mock_request('subscription/embedded-account-deleted.xml'):
acc.delete()
finally:
with self.mock_request('subscription/plan-deleted.xml'):
plan.delete()