def test_get_subscription_list(self):
customer = CustomerFactory.create()
SubscriptionFactory.create_batch(40, customer=customer)
url = reverse('subscription-list',
kwargs={'customer_pk': customer.pk})
response = self.client.get(url)
full_url = None
for field in response.data:
full_url = field.get('url', None)
if full_url:
break
if full_url:
domain = full_url.split('/')[2]
full_url = full_url.split(domain)[0] + domain + url
assert response.status_code == status.HTTP_200_OK
assert response._headers['link'] == \
('Link', '<' + full_url + '?page=2; rel="next">, ' +
'<' + full_url + '?page=1; rel="first">, ' +
'<' + full_url + '?page=2; rel="last">')
response = self.client.get(url + '?page=2')
assert response.status_code == status.HTTP_200_OK
assert response._headers['link'] == \
('Link', '<' + full_url + '; rel="prev">, ' +
'<' + full_url + '?page=1; rel="first">, ' +
'<' + full_url + '?page=2; rel="last">')
def test_post_proforma_with_proforma_entries(self):
customer = CustomerFactory.create()
provider = ProviderFactory.create()
SubscriptionFactory.create()
url = reverse('proforma-list')
provider_url = build_absolute_test_url(reverse('provider-detail', [provider.pk]))
customer_url = build_absolute_test_url(reverse('customer-detail', [customer.pk]))
data = {
'provider': provider_url,
'customer': customer_url,
'series': None,
'number': None,
'currency': 'RON',
'transaction_xe_rate': 1,
'proforma_entries': [{
"description": "Page views",
"unit_price": 10.0,
"quantity": 20
}]
}
response = self.client.post(url, data=json.dumps(data),
content_type='application/json')
assert response.status_code == status.HTTP_201_CREATED
def test_post_proforma_without_proforma_entries(self):
customer = CustomerFactory.create()
provider = ProviderFactory.create()
SubscriptionFactory.create()
url = reverse('proforma-list')
provider_url = build_absolute_test_url(reverse('provider-detail', [provider.pk]))
customer_url = build_absolute_test_url(reverse('customer-detail', [customer.pk]))
data = {
'provider': provider_url,
'customer': customer_url,
'series': "",
'number': "",
'currency': 'RON',
'proforma_entries': []
}
response = self.client.post(url, data=data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
proforma = get_object_or_None(Proforma, id=response.data["id"])
self.assertTrue(proforma)
self.assertEqual(response.data, {
"id": response.data["id"],
"series": "ProformaSeries",
"number": None,
"provider": provider_url,
"customer": customer_url,
"archived_provider": '{}',
"archived_customer": '{}',
"due_date": None,
"issue_date": None,
"paid_date": None,
"cancel_date": None,
"sales_tax_name": "VAT",
"sales_tax_percent": "1.00",
"currency": "RON",
"transaction_currency": proforma.transaction_currency,
"transaction_xe_rate": (str(proforma.transaction_xe_rate)
if proforma.transaction_xe_rate else None),
"transaction_xe_date": proforma.transaction_xe_date,
"pdf_url": None,
"state": "draft",
"invoice": None,
"proforma_entries": [],
"total": 0,
"total_in_transaction_currency": 0,
"transactions": []
})
def test_get_subscription_list_reference_filter(self):
customer = CustomerFactory.create()
subscriptions = SubscriptionFactory.create_batch(3, customer=customer)
url = reverse('subscription-list',
kwargs={'customer_pk': customer.pk})
references = [subscription.reference for subscription in subscriptions]
reference = '?reference=' + references[0]
response = self.client.get(url + reference)
assert len(response.data) == 1
assert response.status_code == status.HTTP_200_OK
reference = '?reference=' + ','.join(references)
response = self.client.get(url + reference)
assert len(response.data) == 3
assert response.status_code == status.HTTP_200_OK
reference = '?reference=' + ','.join(references[:-1]) + ',invalid'
response = self.client.get(url + reference)
assert len(response.data) == 2
assert response.status_code == status.HTTP_200_OK
def test_new_active_sub_trial_end_different_month_from_start_date_w_cb(self):
plan = PlanFactory.create(generate_after=100)
subscription = SubscriptionFactory.create(
plan=plan,
state=Subscription.STATES.ACTIVE,
start_date=datetime.date(2015, 8, 12),
trial_end=datetime.date(2015, 9, 12)
)
correct_billing_date = datetime.date(2015, 9, 1)
incorrect_billing_date_1 = datetime.date(2015, 8, 12)
incorrect_billing_date_2 = datetime.date(2015, 8, 13)
incorrect_billing_date_3 = datetime.date(2015, 8, 31)
true_property = PropertyMock(return_value=True)
mocked_bucket_end_date = MagicMock(
return_value=datetime.date(2015, 8, 31)
)
with patch.multiple(
Subscription,
is_billed_first_time=true_property,
_has_existing_customer_with_consolidated_billing=true_property,
bucket_end_date=mocked_bucket_end_date
):
assert subscription.should_be_billed(correct_billing_date) is True
assert subscription.should_be_billed(incorrect_billing_date_1) is False
assert subscription.should_be_billed(incorrect_billing_date_2) is False
assert subscription.should_be_billed(incorrect_billing_date_3) is False
def test_already_billed_sub_wa_cb(self):
plan = PlanFactory.create(generate_after=100)
subscription = SubscriptionFactory.create(
plan=plan,
state=Subscription.STATES.ACTIVE,
start_date=datetime.date(2015, 1, 1)
)
correct_billing_date = datetime.date(2015, 10, 1)
incorrect_billing_date_1 = datetime.date(2015, 9, 3)
incorrect_billing_date_2 = datetime.date(2015, 9, 12)
incorrect_billing_date_3 = datetime.date(2015, 9, 30)
false_property = PropertyMock(return_value=False)
mocked_on_trial = MagicMock(return_value=True)
mocked_last_billing_date = PropertyMock(
return_value=datetime.date(2015, 9, 2)
)
mocked_bucket_end_date = MagicMock(
return_value=datetime.date(2015, 9, 30)
)
with patch.multiple(
Subscription,
is_billed_first_time=false_property,
on_trial=mocked_on_trial,
last_billing_date=mocked_last_billing_date,
_has_existing_customer_with_consolidated_billing=false_property,
bucket_end_date=mocked_bucket_end_date
):
assert subscription.should_be_billed(correct_billing_date) is True
assert subscription.should_be_billed(incorrect_billing_date_1) is False
assert subscription.should_be_billed(incorrect_billing_date_2) is False
assert subscription.should_be_billed(incorrect_billing_date_3) is False
def test_create_subscription_mf_units_log(self):
subscription = SubscriptionFactory.create()
metered_feature = MeteredFeatureFactory.create()
subscription.plan.metered_features.add(metered_feature)
subscription.activate()
subscription.save()
url = reverse('mf-log-units',
kwargs={'subscription_pk': subscription.pk,
'customer_pk': subscription.customer.pk,
'mf_product_code': metered_feature.product_code})
date = str(datetime.date.today())
response = self.client.patch(url, json.dumps({
"count": 150,
"date": date,
"update_type": "absolute"
}), content_type='application/json')
assert response.status_code == status.HTTP_200_OK
assert response.data == {'count': 150}
response = self.client.patch(url, json.dumps({
"count": 29,
"date": date,
"update_type": "relative"
}), content_type='application/json')
assert response.status_code == status.HTTP_200_OK
assert response.data == {'count': 179}
def test_create_subscription_mf_units_log_with_insufficient_data(self):
subscription = SubscriptionFactory.create()
metered_feature = MeteredFeatureFactory.create()
subscription.plan.metered_features.add(metered_feature)
subscription.activate()
subscription.save()
url = reverse('mf-log-units',
kwargs={'subscription_pk': subscription.pk,
'customer_pk': subscription.customer.pk,
'mf_product_code': metered_feature.product_code})
data = {
"count": 150,
"date": "2008-12-24",
"update_type": "absolute"
}
for field in data:
data_copy = data.copy()
data_copy.pop(field)
response = self.client.patch(url, json.dumps(data_copy),
content_type='application/json')
assert response.status_code == status.HTTP_400_BAD_REQUEST
assert response.data == {field: ['This field is required.']}
def test_activate_subscription(self):
subscription = SubscriptionFactory.create()
url = reverse('sub-activate',
kwargs={'subscription_pk': subscription.pk,
'customer_pk': subscription.customer.pk})
response = self.client.post(url, content_type='application/json')
assert response.status_code == status.HTTP_200_OK
assert response.data == {'state': 'active'}
def test_new_active_sub_with_smaller_billing_date_than_start_date(self):
plan = PlanFactory.create(generate_after=120)
subscription = SubscriptionFactory.create(
plan=plan,
state=Subscription.STATES.ACTIVE,
start_date=datetime.date(2015, 8, 22)
)
billing_date = datetime.date(2015, 8, 10)
assert subscription.should_be_billed(billing_date) is False
def test_get_subscription_detail(self):
subscription = SubscriptionFactory.create()
url = reverse('subscription-detail',
kwargs={'subscription_pk': subscription.pk,
'customer_pk': subscription.customer.pk})
response = self.client.get(url)
assert response.status_code == status.HTTP_200_OK
assert response.data != []
def setUp(self):
# Setup simple subscription
self.plan = PlanFactory.create(interval=Plan.INTERVALS.MONTH,
interval_count=1, generate_after=120,
enabled=True, amount=Decimal('200.00'),
trial_period_days=0)
self.subscription = SubscriptionFactory.create(plan=self.plan,
start_date=self.date)
self.subscription.activate()
self.subscription.save()
def test_canceled_sub_w_date_before_cancel_date(self):
plan = PlanFactory.create(generate_after=120)
subscription = SubscriptionFactory.create(
plan=plan,
state=Subscription.STATES.CANCELED,
cancel_date=datetime.date(2015, 8, 22),
start_date=datetime.date(2015, 8, 1)
)
incorrect_billing_date = datetime.date(2015, 8, 10)
assert subscription.should_be_billed(incorrect_billing_date) is False
def test_updateable_buckets_active_subscription(self):
plan = PlanFactory.create(generate_after=24 * 60,
interval=Plan.INTERVALS.MONTH,
interval_count=1)
subscription = SubscriptionFactory.create(
plan=plan,
state=Subscription.STATES.ACTIVE,
start_date=datetime.date(2015, 1, 1)
)
assert subscription.updateable_buckets() == [
{'start_date': datetime.date(2015, 1, 1), 'end_date': datetime.date(2015, 1, 31)},
]
def test_subscription_mf_units_log_intervals_3(self):
# Every 2 weeks, 8 days of trial
subscription = SubscriptionFactory.create()
metered_feature = MeteredFeatureFactory.create()
subscription.plan.metered_features.add(metered_feature)
subscription.start_date = datetime.date(year=2015, month=2, day=17)
subscription.activate()
subscription.save()
subscription.plan.interval = Plan.INTERVALS.WEEK
subscription.plan.interval_count = 2
subscription.plan.separate_cycles_during_trial = True
subscription.plan.save()
subscription.start_date = datetime.date(year=2015, month=5, day=31)
subscription.trial_end = (subscription.start_date +
datetime.timedelta(days=7))
subscription.save()
start_date = datetime.date(year=2015, month=5, day=31)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=5, day=31))
end_date = datetime.date(year=2015, month=5, day=31)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=5, day=31))
start_date = datetime.date(year=2015, month=6, day=1)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=6, day=1))
end_date = datetime.date(year=2015, month=6, day=7)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=6, day=1))
start_date = datetime.date(year=2015, month=6, day=8)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=6, day=8))
end_date = datetime.date(year=2015, month=6, day=14)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=6, day=8))
start_date = datetime.date(year=2015, month=6, day=15)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=6, day=15))
end_date = datetime.date(year=2015, month=6, day=28)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=6, day=28))
def test_activate_subscription(self):
subscription = SubscriptionFactory.create()
url = reverse('sub-activate',
kwargs={
'subscription_pk': subscription.pk,
'customer_pk': subscription.customer.pk
})
response = self.client.post(url, content_type='application/json')
assert response.status_code == status.HTTP_200_OK
assert response.data == {'state': 'active'}
def test_subscription_billing_cycle_intervals_3(self):
"""
Every 2 weeks, 8 days of trial
separate_cycles_during_trial = True
generate_documents_on_trial_end = True
"""
subscription = SubscriptionFactory.create()
metered_feature = MeteredFeatureFactory.create()
subscription.plan.metered_features.add(metered_feature)
subscription.plan.interval = Plan.INTERVALS.WEEK
subscription.plan.interval_count = 2
subscription.plan.separate_cycles_during_trial = True
subscription.plan.generate_documents_on_trial_end = True
subscription.plan.save()
subscription.start_date = datetime.date(year=2015, month=5, day=31)
subscription.trial_end = (subscription.start_date +
datetime.timedelta(days=7))
subscription.activate()
subscription.save()
start_date = subscription.start_date
reference_date = start_date
assert start_date == subscription.cycle_start_date(reference_date)
end_date = datetime.date(year=2015, month=5,
day=31) # billing cycle alignment
assert end_date == subscription.cycle_end_date(reference_date)
start_date = datetime.date(year=2015, month=6, day=1)
reference_date = start_date
assert start_date == subscription.cycle_start_date(reference_date)
end_date = datetime.date(year=2015, month=6, day=7) # trial end
assert end_date == subscription.cycle_end_date(reference_date)
start_date = datetime.date(year=2015, month=6, day=8)
reference_date = start_date
assert start_date == subscription.cycle_start_date(reference_date)
end_date = datetime.date(year=2015, month=6,
day=14) # cycle realignment after trial
assert end_date == subscription.cycle_end_date(reference_date)
start_date = datetime.date(year=2015, month=6, day=15)
reference_date = start_date
assert start_date == subscription.cycle_start_date(reference_date)
end_date = datetime.date(year=2015, month=6, day=28)
assert end_date == subscription.cycle_end_date(reference_date)
def test_post_proforma_without_proforma_entries(self):
CustomerFactory.create()
ProviderFactory.create()
SubscriptionFactory.create()
url = reverse('proforma-list')
data = {
'provider': 'http://testserver/providers/1/',
'customer': 'http://testserver/customers/1/',
'series': "",
'number': "",
'currency': 'RON',
'proforma_entries': []
}
response = self.client.post(url, data=data)
assert response.status_code == status.HTTP_201_CREATED
assert response.data == {
"id": 1,
"series": "ProformaSeries",
"number": None,
"provider": "http://testserver/providers/1/",
"customer": "http://testserver/customers/1/",
"archived_provider": {},
"archived_customer": {},
"due_date": None,
"issue_date": None,
"paid_date": None,
"cancel_date": None,
"sales_tax_name": "VAT",
"sales_tax_percent": '1.00',
"currency": "RON",
'pdf_url': None,
"state": "draft",
"invoice": None,
"proforma_entries": [],
"total": Decimal('0.00'),
}
def setUp(self):
# Setup simple subscription
self.plan = PlanFactory.create(interval=Plan.INTERVALS.MONTH,
interval_count=1,
generate_after=120,
enabled=True,
amount=Decimal('200.00'),
trial_period_days=0)
self.subscription = SubscriptionFactory.create(plan=self.plan,
start_date=self.date)
self.subscription.activate()
self.subscription.save()
def test_get_subscription_detail(self):
subscription = SubscriptionFactory.create()
url = reverse('subscription-detail',
kwargs={
'subscription_pk': subscription.pk,
'customer_pk': subscription.customer.pk
})
response = self.client.get(url)
assert response.status_code == status.HTTP_200_OK
assert response.data != []
def test_post_invoice_with_invoice_entries(self):
CustomerFactory.create()
ProviderFactory.create()
SubscriptionFactory.create()
url = reverse('invoice-list')
data = {
'provider': 'http://testserver/providers/1/',
'customer': 'http://testserver/customers/1/',
'series': None,
'number': None,
'currency': 'RON',
'invoice_entries': [{
"description": "Page views",
"unit_price": 10.0,
"quantity": 20}]
}
response = self.client.post(url, data=json.dumps(data),
content_type='application/json')
assert response.status_code == status.HTTP_201_CREATED
def test_updateable_buckets_2_months_canceled_subscription_at_end_of_month(self):
plan = PlanFactory.create(generate_after=24 * 60,
interval=Plan.INTERVALS.MONTH,
interval_count=1)
subscription = SubscriptionFactory.create(
plan=plan,
state=Subscription.STATES.CANCELED,
start_date=datetime.date(2015, 1, 1),
cancel_date=datetime.date(2015, 1, 31)
)
assert subscription.updateable_buckets() == [
{'start_date': datetime.date(2015, 1, 1), 'end_date': datetime.date(2015, 1, 31)},
]
def test_post_proforma_without_proforma_entries(self):
customer = CustomerFactory.create()
provider = ProviderFactory.create()
SubscriptionFactory.create()
url = reverse('proforma-list')
data = {
'provider': 'http://testserver/providers/%s/' % provider.pk,
'customer': 'http://testserver/customers/%s/' % customer.pk,
'series': "",
'number': "",
'currency': 'RON',
'proforma_entries': []
}
response = self.client.post(url, data=data)
assert response.status_code == status.HTTP_201_CREATED
assert response.data == {
"id": response.data["id"],
"series": "ProformaSeries",
"number": None,
"provider": "http://testserver/providers/%s/" % provider.pk,
"customer": "http://testserver/customers/%s/" % customer.pk,
"archived_provider": {},
"archived_customer": {},
"due_date": None,
"issue_date": None,
"paid_date": None,
"cancel_date": None,
"sales_tax_name": "VAT",
"sales_tax_percent": '1.00',
"currency": "RON",
'pdf_url': None,
"state": "draft",
"invoice": None,
"proforma_entries": [],
"total": Decimal('0.00'),
}
def test_subscription_mf_units_log_intervals_1(self):
# Every month, 16 days of trial
subscription = SubscriptionFactory.create()
metered_feature = MeteredFeatureFactory.create()
subscription.plan.metered_features.add(metered_feature)
subscription.start_date = datetime.date(year=2015, month=2, day=17)
subscription.activate()
subscription.save()
subscription.plan.interval = Plan.INTERVALS.MONTH
subscription.plan.interval_count = 1
subscription.plan.save()
subscription.plan.separate_cycles_during_trial = True
subscription.trial_end = (subscription.start_date +
datetime.timedelta(days=15))
start_date = subscription.start_date
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=2, day=17))
end_date = datetime.date(year=2015, month=2, day=28)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=2, day=23))
start_date = datetime.date(year=2015, month=3, day=1)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=3, day=1))
end_date = datetime.date(year=2015, month=3, day=4)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=3, day=1))
start_date = datetime.date(year=2015, month=3, day=5)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=3, day=5))
end_date = datetime.date(year=2015, month=3, day=31)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=3, day=22))
start_date = datetime.date(year=2015, month=4, day=1)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=4, day=5))
end_date = datetime.date(year=2015, month=4, day=30)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=4, day=22))
def test_end_subscription_from_terminal_state(self):
subscription = SubscriptionFactory.create()
url = reverse('sub-cancel',
kwargs={'subscription_pk': subscription.pk,
'customer_pk': subscription.customer.pk})
response = self.client.post(url, json.dumps({
"when": "now"}), content_type='application/json')
assert response.status_code == status.HTTP_400_BAD_REQUEST
assert response.data == {
'error': u'Cannot cancel subscription from inactive state.'
}
def test_reactivate_subscription(self):
subscription = SubscriptionFactory.create()
subscription.activate()
subscription.cancel(when=Subscription.CANCEL_OPTIONS.NOW)
subscription.save()
url = reverse('sub-reactivate',
kwargs={'subscription_pk': subscription.pk,
'customer_pk': subscription.customer.pk})
response = self.client.post(url, content_type='application/json')
assert response.status_code == status.HTTP_200_OK
assert response.data == {'state': Subscription.STATES.ACTIVE}
def test_post_invoice_with_invoice_entries(self):
customer = CustomerFactory.create()
provider = ProviderFactory.create()
SubscriptionFactory.create()
url = reverse('invoice-list')
data = {
'provider': 'http://testserver/providers/%s/' % provider.pk,
'customer': 'http://testserver/customers/%s/' % customer.pk,
'series': None,
'number': None,
'currency': 'RON',
'transaction_xe_rate': 1,
'invoice_entries': [{
"description": "Page views",
"unit_price": 10.0,
"quantity": 20}]
}
response = self.client.post(url, data=json.dumps(data),
content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_cancel_subscription(self):
subscription = SubscriptionFactory.create()
subscription.activate()
subscription.save()
url = reverse('sub-cancel',
kwargs={'subscription_pk': subscription.pk,
'customer_pk': subscription.customer.pk})
response = self.client.post(url, json.dumps({
"when": "end_of_billing_cycle"}), content_type='application/json')
assert response.status_code == status.HTTP_200_OK
assert response.data == {'state': Subscription.STATES.CANCELED}
def test_create_subscription_mf_units_log_with_unactivated_sub(self):
subscription = SubscriptionFactory.create()
metered_feature = MeteredFeatureFactory.create()
subscription.plan.metered_features.add(metered_feature)
url = reverse('mf-log-units',
kwargs={'subscription_pk': subscription.pk,
'customer_pk': subscription.customer.pk,
'mf_product_code': metered_feature.product_code})
response = self.client.patch(url)
assert response.status_code == status.HTTP_403_FORBIDDEN
assert response.data == {'detail': 'Subscription is not active.'}
def test_post_proforma_with_proforma_entries(self):
CustomerFactory.create()
ProviderFactory.create()
SubscriptionFactory.create()
url = reverse('proforma-list')
data = {
'provider': 'http://testserver/providers/1/',
'customer': 'http://testserver/customers/1/',
'series': None,
'number': None,
'currency': 'RON',
'proforma_entries': [{
"description": "Page views",
"unit_price": 10.0,
"quantity": 20
}]
}
response = self.client.post(url, data=json.dumps(data),
content_type='application/json')
assert response.status_code == status.HTTP_201_CREATED
def test_post_invoice_with_invoice_entries(self):
customer = CustomerFactory.create()
provider = ProviderFactory.create()
SubscriptionFactory.create()
url = reverse('invoice-list')
provider_url = build_absolute_test_url(
reverse('provider-detail', [provider.pk]))
customer_url = build_absolute_test_url(
reverse('customer-detail', [customer.pk]))
data = {
'provider':
provider_url,
'customer':
customer_url,
'series':
None,
'number':
None,
'currency':
'RON',
'transaction_xe_rate':
1,
'invoice_entries': [{
"description": "Page views",
"unit_price": 10.0,
"quantity": 20
}]
}
response = self.client.post(url,
data=json.dumps(data),
content_type='application/json')
print(response.data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_create_subscription_mf_units_log_with_unexisting_mf(self):
subscription = SubscriptionFactory.create()
subscription.activate()
subscription.save()
url = reverse('mf-log-units',
kwargs={'subscription_pk': subscription.pk,
'customer_pk': subscription.customer.pk,
'mf_product_code': '1234'})
response = self.client.patch(url)
assert response.status_code == status.HTTP_404_NOT_FOUND
assert response.data == {'detail': 'Metered Feature Not found.'}
def test_canceled_sub_wa_consolidated_billing(self):
plan = PlanFactory.create(generate_after=120)
subscription = SubscriptionFactory.create(
plan=plan,
state=Subscription.STATES.CANCELED,
start_date=datetime.date(2015, 8, 10),
cancel_date=datetime.date(2015, 8, 22))
correct_billing_date = datetime.date(2015, 8, 23)
false_property = PropertyMock(return_value=False)
with patch.multiple(
Subscription,
_has_existing_customer_with_consolidated_billing=false_property
):
assert subscription.should_be_billed(correct_billing_date) is True
def test_canceled_sub_wa_consolidated_billing(self):
plan = PlanFactory.create(generate_after=120)
subscription = SubscriptionFactory.create(
plan=plan,
state=Subscription.STATES.CANCELED,
start_date=datetime.date(2015, 8, 10),
cancel_date=datetime.date(2015, 8, 22)
)
correct_billing_date = datetime.date(2015, 8, 23)
false_property = PropertyMock(return_value=False)
with patch.multiple(
Subscription,
_has_existing_customer_with_consolidated_billing=false_property
):
assert subscription.should_be_billed(correct_billing_date) is True
def test_activate_subscription_from_terminal_state(self):
subscription = SubscriptionFactory.create()
subscription.activate()
subscription.cancel(when=Subscription.CANCEL_OPTIONS.NOW)
subscription.save()
url = reverse('sub-activate',
kwargs={'subscription_pk': subscription.pk,
'customer_pk': subscription.customer.pk})
response = self.client.post(url, content_type='application/json')
assert response.status_code == status.HTTP_400_BAD_REQUEST
assert response.data == {
'error': u'Cannot activate subscription from canceled state.'
}
def test_sub_canceled_now_w_consolidated_billing(self):
plan = PlanFactory.create(generate_after=120)
subscription = SubscriptionFactory.create(
plan=plan,
state=Subscription.STATES.CANCELED,
start_date=datetime.date(2015, 8, 10),
cancel_date=datetime.date(2015, 8, 22))
billing_date_1 = datetime.date(2015, 9, 1)
billing_date_2 = datetime.date(2015, 8, 23)
true_property = PropertyMock(return_value=True)
with patch.multiple(
Subscription,
_has_existing_customer_with_consolidated_billing=true_property
):
assert subscription.should_be_billed(billing_date_1, NOW) is True
assert subscription.should_be_billed(billing_date_2, NOW) is True
def test_subscription_mf_units_log_intervals_4(self):
# Every year, 3 months (90 days) of trial
subscription = SubscriptionFactory.create()
metered_feature = MeteredFeatureFactory.create()
subscription.plan.metered_features.add(metered_feature)
subscription.start_date = datetime.date(year=2015, month=2, day=17)
subscription.activate()
subscription.save()
subscription.plan.interval = Plan.INTERVALS.YEAR
subscription.plan.interval_count = 1
subscription.plan.save()
subscription.start_date = datetime.date(year=2015, month=2, day=2)
subscription.trial_end = (subscription.start_date +
datetime.timedelta(days=90))
subscription.save()
start_date = subscription.start_date
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=2, day=2)
)
end_date = datetime.date(year=2015, month=5, day=3)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=2, day=2))
start_date = datetime.date(year=2015, month=5, day=4)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=5, day=4))
end_date = datetime.date(year=2015, month=12, day=31)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=5, day=5))
start_date = datetime.date(year=2016, month=1, day=1)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2016, month=1, day=1))
end_date = datetime.date(year=2016, month=12, day=31)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2016, month=12, day=31))
def test_subscription_billing_cycle_intervals_1(self):
"""
Every month, 16 days of trial
separate_cycles_during_trial = True
generate_documents_on_trial_end = False
"""
subscription = SubscriptionFactory.create()
metered_feature = MeteredFeatureFactory.create()
subscription.plan.metered_features.add(metered_feature)
start_date = datetime.date(year=2015, month=2, day=17)
subscription.start_date = start_date
subscription.trial_end = (subscription.start_date +
datetime.timedelta(days=15))
subscription.activate()
subscription.save()
subscription.plan.interval = Plan.INTERVALS.MONTH
subscription.plan.interval_count = 1
subscription.plan.separate_cycles_during_trial = True
subscription.plan.generate_documents_on_trial_end = False
subscription.plan.save()
reference_date = start_date
assert start_date == subscription.cycle_start_date(reference_date)
end_date = datetime.date(year=2015, month=2, day=28)
assert end_date == subscription.cycle_end_date(reference_date)
start_date = datetime.date(year=2015, month=3, day=1)
reference_date = start_date
assert start_date == subscription.cycle_start_date(reference_date)
end_date = datetime.date(year=2015, month=3, day=31)
assert end_date == subscription.cycle_end_date(reference_date)
start_date = datetime.date(year=2015, month=4, day=1)
reference_date = start_date
assert start_date == subscription.cycle_start_date(reference_date)
end_date = datetime.date(year=2015, month=4, day=30)
assert end_date == subscription.cycle_end_date(reference_date)
def test_sub_canceled_at_end_of_bc_w_consolidated_billing(self):
plan = PlanFactory.create(generate_after=120)
subscription = SubscriptionFactory.create(
plan=plan,
state=Subscription.STATES.CANCELED,
start_date=datetime.date(2015, 8, 22),
cancel_date=datetime.date(2015, 9, 1))
correct_billing_date = datetime.date(2015, 9, 2)
incorrect_billing_date = datetime.date(2015, 8, 22)
true_property = PropertyMock(return_value=True)
with patch.multiple(
Subscription,
_has_existing_customer_with_consolidated_billing=true_property
):
assert subscription.should_be_billed(correct_billing_date,
NOW) is True
assert subscription.should_be_billed(incorrect_billing_date,
NOW) is False
def test_new_active_sub_no_trial_wa_consolidated_billing(self):
plan = PlanFactory.create(generate_after=120)
subscription = SubscriptionFactory.create(
plan=plan,
state=Subscription.STATES.ACTIVE,
start_date=datetime.date(2015, 8, 12)
)
correct_billing_date_1 = datetime.date(2015, 8, 12)
correct_billing_date_2 = datetime.date(2015, 8, 20)
true_property = PropertyMock(return_value=True)
false_property = PropertyMock(return_value=False)
with patch.multiple(
Subscription,
is_billed_first_time=true_property,
_has_existing_customer_with_consolidated_billing=false_property,
):
assert subscription.should_be_billed(correct_billing_date_1) is True
assert subscription.should_be_billed(correct_billing_date_2) is True
def test_create_subscription_mf_units_log_sub_canceled_at_end_of_month(
self):
subscription = SubscriptionFactory.create(
state=Subscription.STATES.CANCELED,
start_date=datetime.date(2016, 1, 1),
cancel_date=datetime.date(2017, 1, 31))
metered_feature = MeteredFeatureFactory.create()
subscription.plan.metered_features.add(metered_feature)
subscription.activate()
subscription.save()
url = reverse('mf-log-units',
kwargs={
'subscription_pk': subscription.pk,
'customer_pk': subscription.customer.pk,
'mf_product_code': metered_feature.product_code
})
date = str(datetime.date.today())
response = self.client.patch(url,
json.dumps({
"count": 150,
"date": date,
"update_type": "absolute"
}),
content_type='application/json')
assert response.status_code == status.HTTP_200_OK
assert response.data == {'count': 150}
response = self.client.patch(url,
json.dumps({
"count": 29,
"date": date,
"update_type": "relative"
}),
content_type='application/json')
assert response.status_code == status.HTTP_200_OK
assert response.data == {'count': 179}
def test_new_active_sub_no_trial_wa_consolidated_billing(self):
plan = PlanFactory.create(generate_after=120)
subscription = SubscriptionFactory.create(
plan=plan,
state=Subscription.STATES.ACTIVE,
start_date=datetime.date(2015, 8, 12)
)
correct_billing_date_1 = datetime.date(2015, 8, 12)
correct_billing_date_2 = datetime.date(2015, 8, 20)
true_property = PropertyMock(return_value=True)
false_property = PropertyMock(return_value=False)
with patch.multiple(
Subscription,
is_billed_first_time=true_property,
_has_existing_customer_with_consolidated_billing=false_property,
):
assert subscription.should_be_billed(correct_billing_date_1) is True
assert subscription.should_be_billed(correct_billing_date_2) is True
def test_new_active_sub_no_trial_w_consolidated_billing(self):
plan = PlanFactory.create(generate_after=120)
subscription = SubscriptionFactory.create(
plan=plan,
state=Subscription.STATES.ACTIVE,
start_date=datetime.date(2015, 8, 12))
incorrect_billing_date = datetime.date(2015, 8, 23)
correct_billing_date = datetime.date(2015, 9, 1)
true_property = PropertyMock(return_value=True)
mocked_bucket_end_date = MagicMock(
return_value=datetime.date(2015, 8, 31))
with patch.multiple(
Subscription,
_has_existing_customer_with_consolidated_billing=true_property,
is_billed_first_time=true_property,
bucket_end_date=mocked_bucket_end_date,
):
assert subscription.should_be_billed(correct_billing_date) is True
assert subscription.should_be_billed(
incorrect_billing_date) is False
def test_create_subscription_mf_units_log_with_sub_canceled_before(self):
subscription = SubscriptionFactory.create(state=Subscription.STATES.CANCELED,
start_date=datetime.date(2016, 1, 1),
cancel_date=datetime.date(2016, 12, 31))
metered_feature = MeteredFeatureFactory.create()
subscription.plan.metered_features.add(metered_feature)
url = reverse('mf-log-units',
kwargs={'subscription_pk': subscription.pk,
'customer_pk': subscription.customer.pk,
'mf_product_code': metered_feature.product_code})
date = str(datetime.date.today())
response = self.client.patch(url, json.dumps({
"count": 150,
"date": date,
"update_type": "absolute"
}), content_type='application/json')
assert response.status_code == status.HTTP_400_BAD_REQUEST
assert response.data == {"detail": "Date is out of bounds."}
def test_create_subscription_mf_units_log_with_invalid_date(self):
subscription = SubscriptionFactory.create()
metered_feature = MeteredFeatureFactory.create()
subscription.plan.metered_features.add(metered_feature)
subscription.activate()
subscription.save()
url = reverse('mf-log-units',
kwargs={'subscription_pk': subscription.pk,
'customer_pk': subscription.customer.pk,
'mf_product_code': metered_feature.product_code})
response = self.client.patch(url, json.dumps({
"count": 150,
"date": "2008-12-24",
"update_type": "absolute"
}), content_type='application/json')
assert response.status_code == status.HTTP_400_BAD_REQUEST
assert response.data == {'detail': 'Date is out of bounds.'}
def test_already_billed_sub_wa_cb(self):
plan = PlanFactory.create(generate_after=100,
interval=Plan.INTERVALS.MONTH,
interval_count=1)
subscription = SubscriptionFactory.create(
plan=plan,
state=Subscription.STATES.ACTIVE,
start_date=datetime.date(2015, 1, 1)
)
correct_billing_date = datetime.date(2015, 10, 1)
incorrect_billing_date_1 = datetime.date(2015, 9, 3)
incorrect_billing_date_2 = datetime.date(2015, 9, 12)
incorrect_billing_date_3 = datetime.date(2015, 9, 30)
BillingLog.objects.create(subscription=subscription,
billing_date=datetime.date(2015, 9, 2),
plan_billed_up_to=datetime.date(2015, 9, 30),
metered_features_billed_up_to=datetime.date(2015, 9, 2))
assert subscription.should_be_billed(correct_billing_date) is True
assert subscription.should_be_billed(incorrect_billing_date_1) is False
assert subscription.should_be_billed(incorrect_billing_date_2) is False
assert subscription.should_be_billed(incorrect_billing_date_3) is False
def test_new_active_sub_trial_end_same_month_as_start_date_w_cb(self):
plan = PlanFactory.create(generate_after=100)
subscription = SubscriptionFactory.create(
plan=plan,
state=Subscription.STATES.ACTIVE,
start_date=datetime.date(2015, 8, 12),
trial_end=datetime.date(2015, 8, 26)
)
correct_billing_date_1 = datetime.date(2015, 9, 1)
correct_billing_date_2 = datetime.date(2015, 8, 12)
incorrect_billing_date_1 = datetime.date(2015, 8, 11)
incorrect_billing_date_2 = datetime.date(2015, 7, 11)
true_property = PropertyMock(return_value=True)
with patch.multiple(
Subscription,
is_billed_first_time=true_property,
_has_existing_customer_with_consolidated_billing=true_property,
):
assert subscription.should_be_billed(correct_billing_date_1) is True
assert subscription.should_be_billed(correct_billing_date_2) is True
assert subscription.should_be_billed(incorrect_billing_date_1) is False
assert subscription.should_be_billed(incorrect_billing_date_2) is False
def test_subscription_billing_cycle_intervals(self):
subscription = SubscriptionFactory.create()
metered_feature = MeteredFeatureFactory.create()
subscription.plan.metered_features.add(metered_feature)
start_date = datetime.date(year=2015, month=2, day=17)
subscription.start_date = start_date
subscription.activate()
subscription.save()
with patch('silver.models.timezone') as mock_timezone:
# Every month, 16 days of trial
subscription.plan.interval = Plan.INTERVALS.MONTH
subscription.plan.interval_count = 1
subscription.plan.save()
subscription.trial_end = (subscription.start_date +
datetime.timedelta(days=15))
mock_timezone.now.return_value = datetime.datetime.combine(
start_date, datetime.datetime.min.time())
assert start_date == subscription.current_start_date
end_date = datetime.date(year=2015, month=2, day=28)
assert end_date == subscription.current_end_date
start_date = datetime.date(year=2015, month=3, day=1)
mock_timezone.now.return_value = datetime.datetime.combine(
start_date, datetime.datetime.min.time())
assert start_date == subscription.current_start_date
end_date = datetime.date(year=2015, month=3, day=31)
assert end_date == subscription.current_end_date
start_date = datetime.date(year=2015, month=4, day=1)
mock_timezone.now.return_value = datetime.datetime.combine(
start_date, datetime.datetime.min.time())
assert start_date == subscription.current_start_date
end_date = datetime.date(year=2015, month=4, day=30)
assert end_date == subscription.current_end_date
# Every 2 months, 5 months of trial (2015-05-30)
subscription.plan.interval = Plan.INTERVALS.MONTH
subscription.plan.interval_count = 2
subscription.plan.save()
subscription.start_date = datetime.date(year=2014, month=12, day=31)
subscription.trial_end = (subscription.start_date +
datetime.timedelta(days=150))
subscription.save()
start_date = subscription.start_date
mock_timezone.now.return_value = datetime.datetime.combine(
start_date, datetime.datetime.min.time())
assert start_date == subscription.current_start_date
end_date = datetime.date(year=2014, month=12, day=31)
assert end_date == subscription.current_end_date
start_date = datetime.date(year=2015, month=1, day=1)
mock_timezone.now.return_value = datetime.datetime.combine(
start_date, datetime.datetime.min.time())
assert start_date == subscription.current_start_date
end_date = datetime.date(year=2015, month=2, day=28)
assert end_date == subscription.current_end_date
start_date = datetime.date(year=2015, month=3, day=1)
mock_timezone.now.return_value = datetime.datetime.combine(
start_date, datetime.datetime.min.time())
assert start_date == subscription.current_start_date
end_date = datetime.date(year=2015, month=4, day=30)
assert end_date == subscription.current_end_date
start_date = datetime.date(year=2015, month=5, day=1)
mock_timezone.now.return_value = datetime.datetime.combine(
start_date, datetime.datetime.min.time())
assert start_date == subscription.current_start_date
end_date = datetime.date(year=2015, month=6, day=30)
assert end_date == subscription.current_end_date
start_date = datetime.date(year=2015, month=7, day=1)
mock_timezone.now.return_value = datetime.datetime.combine(
start_date, datetime.datetime.min.time())
assert start_date == subscription.current_start_date
end_date = datetime.date(year=2015, month=8, day=31)
assert end_date == subscription.current_end_date
# Every 2 weeks, 8 days of trial
subscription.plan.interval = Plan.INTERVALS.WEEK
subscription.plan.interval_count = 2
subscription.plan.save()
subscription.start_date = datetime.date(year=2015, month=5, day=31)
subscription.trial_end = (subscription.start_date +
datetime.timedelta(days=7))
subscription.save()
start_date = subscription.start_date
mock_timezone.now.return_value = datetime.datetime.combine(
start_date, datetime.datetime.min.time())
assert start_date == subscription.current_start_date
end_date = datetime.date(year=2015, month=5, day=31)
assert end_date == subscription.current_end_date
start_date = datetime.date(year=2015, month=6, day=1)
mock_timezone.now.return_value = datetime.datetime.combine(
start_date, datetime.datetime.min.time())
assert start_date == subscription.current_start_date
end_date = datetime.date(year=2015, month=6, day=14)
assert end_date == subscription.current_end_date
start_date = datetime.date(year=2015, month=6, day=15)
mock_timezone.now.return_value = datetime.datetime.combine(
start_date, datetime.datetime.min.time())
assert start_date == subscription.current_start_date
end_date = datetime.date(year=2015, month=6, day=28)
assert end_date == subscription.current_end_date
# Every year, 3 months (90 days) of trial
subscription.plan.interval = Plan.INTERVALS.YEAR
subscription.plan.interval_count = 1
subscription.plan.save()
subscription.start_date = datetime.date(year=2015, month=2, day=2)
subscription.trial_end = (subscription.start_date +
datetime.timedelta(days=90))
subscription.save()
start_date = subscription.start_date
mock_timezone.now.return_value = datetime.datetime.combine(
start_date, datetime.datetime.min.time())
assert start_date == subscription.current_start_date
end_date = datetime.date(year=2015, month=12, day=31)
assert end_date == subscription.current_end_date
start_date = datetime.date(year=2016, month=1, day=1)
mock_timezone.now.return_value = datetime.datetime.combine(
start_date, datetime.datetime.min.time())
assert start_date == subscription.current_start_date
end_date = datetime.date(year=2016, month=12, day=31)
assert end_date == subscription.current_end_date
def test_subscription_mf_units_log_intervals(self):
subscription = SubscriptionFactory.create()
metered_feature = MeteredFeatureFactory.create()
subscription.plan.metered_features.add(metered_feature)
subscription.start_date = datetime.date(year=2015, month=2, day=17)
subscription.activate()
subscription.save()
# Every month, 16 days of trial
subscription.plan.interval = Plan.INTERVALS.MONTH
subscription.plan.interval_count = 1
subscription.plan.save()
subscription.trial_end = (subscription.start_date +
datetime.timedelta(days=15))
start_date = subscription.start_date
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=2, day=17))
end_date = datetime.date(year=2015, month=2, day=28)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=2, day=23))
start_date = datetime.date(year=2015, month=3, day=1)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=3, day=1))
end_date = datetime.date(year=2015, month=3, day=4)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=3, day=1))
start_date = datetime.date(year=2015, month=3, day=5)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=3, day=5))
end_date = datetime.date(year=2015, month=3, day=31)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=3, day=22))
start_date = datetime.date(year=2015, month=4, day=1)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=4, day=5))
end_date = datetime.date(year=2015, month=4, day=30)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=4, day=22))
# Every 2 months, 5 months of trial (2015-05-30)
subscription.plan.interval = Plan.INTERVALS.MONTH
subscription.plan.interval_count = 2
subscription.plan.save()
subscription.start_date = datetime.date(year=2014, month=12, day=31)
subscription.trial_end = (subscription.start_date +
datetime.timedelta(days=150))
subscription.save()
start_date = datetime.date(year=2014, month=12, day=31)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2014, month=12, day=31))
end_date = datetime.date(year=2014, month=12, day=31)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2014, month=12, day=31))
start_date = datetime.date(year=2015, month=1, day=1)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=1, day=1))
end_date = datetime.date(year=2015, month=1, day=31)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=1, day=1))
start_date = datetime.date(year=2015, month=3, day=1)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=3, day=23))
end_date = datetime.date(year=2015, month=4, day=30)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=4, day=30))
start_date = datetime.date(year=2015, month=5, day=1)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=5, day=23))
end_date = datetime.date(year=2015, month=5, day=30)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=5, day=30))
start_date = datetime.date(year=2015, month=6, day=1)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=6, day=1))
end_date = datetime.date(year=2015, month=6, day=30)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=6, day=1))
# Every 2 weeks, 8 days of trial
subscription.plan.interval = Plan.INTERVALS.WEEK
subscription.plan.interval_count = 2
subscription.plan.save()
subscription.start_date = datetime.date(year=2015, month=5, day=31)
subscription.trial_end = (subscription.start_date +
datetime.timedelta(days=7))
subscription.save()
start_date = datetime.date(year=2015, month=5, day=31)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=5, day=31))
end_date = datetime.date(year=2015, month=5, day=31)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=5, day=31))
start_date = datetime.date(year=2015, month=6, day=1)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=6, day=1))
end_date = datetime.date(year=2015, month=6, day=7)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=6, day=1))
start_date = datetime.date(year=2015, month=6, day=8)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=6, day=8))
end_date = datetime.date(year=2015, month=6, day=14)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=6, day=8))
start_date = datetime.date(year=2015, month=6, day=15)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=6, day=15))
end_date = datetime.date(year=2015, month=6, day=28)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=6, day=28))
# Every year, 3 months (90 days) of trial
subscription.plan.interval = Plan.INTERVALS.YEAR
subscription.plan.interval_count = 1
subscription.plan.save()
subscription.start_date = datetime.date(year=2015, month=2, day=2)
subscription.trial_end = (subscription.start_date +
datetime.timedelta(days=90))
subscription.save()
start_date = subscription.start_date
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=2, day=2)
)
end_date = datetime.date(year=2015, month=5, day=3)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=2, day=2))
start_date = datetime.date(year=2015, month=5, day=4)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2015, month=5, day=4))
end_date = datetime.date(year=2015, month=12, day=31)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2015, month=5, day=5))
start_date = datetime.date(year=2016, month=1, day=1)
assert start_date == subscription.bucket_start_date(
reference_date=datetime.date(year=2016, month=1, day=1))
end_date = datetime.date(year=2016, month=12, day=31)
assert end_date == subscription.bucket_end_date(
reference_date=datetime.date(year=2016, month=12, day=31))
