def test_package_price_is_calculated_properly_if_it_was_used_only_for_one_day(
self):
cheap_package_template = self.create_package_template(
component_price=10)
medium_package_template = self.create_package_template(
component_price=15)
expensive_package_template = self.create_package_template(
component_price=20)
customer = structure_factories.CustomerFactory()
date = timezone.datetime(2017, 1, 26)
month_end = timezone.datetime(2017, 1, 31, 23, 59, 59)
full_days = utils.get_full_days(date, month_end)
# at first user has bought cheap package
with freeze_time(date):
cheap_package = packages_factories.OpenStackPackageFactory(
template=cheap_package_template,
tenant__service_project_link__project__customer=customer)
invoice = models.Invoice.objects.get(customer=customer)
cheap_item = invoice.openstack_items.get(package=cheap_package)
self.assertEqual(cheap_item.unit_price, cheap_package_template.price)
self.assertEqual(cheap_item.usage_days, full_days)
# later at the same day he switched to the expensive one
with freeze_time(date + timezone.timedelta(hours=2)):
cheap_package.delete()
expensive_package = packages_factories.OpenStackPackageFactory(
template=expensive_package_template,
tenant=cheap_package.tenant)
expensive_item = invoice.openstack_items.get(package=expensive_package)
self.assertEqual(expensive_item.unit_price,
expensive_package_template.price)
self.assertEqual(expensive_item.usage_days, full_days)
# cheap item price should become 0, because it was replaced by expensive one
cheap_item.refresh_from_db()
self.assertEqual(cheap_item.price, 0)
self.assertEqual(cheap_item.usage_days, 0)
# at last he switched to the medium one
with freeze_time(date + timezone.timedelta(hours=4)):
expensive_package.delete()
medium_package = packages_factories.OpenStackPackageFactory(
template=medium_package_template,
tenant=expensive_package.tenant)
medium_item = invoice.openstack_items.get(package=medium_package)
# medium item usage days should start from tomorrow,
# because expensive item should be calculated for current day
self.assertEqual(medium_item.usage_days, full_days - 1)
# expensive item should be calculated for one day
expensive_item.refresh_from_db()
# cheap item price should remain zero
cheap_item.refresh_from_db()
self.assertEqual(cheap_item.usage_days, 0)
self.assertEqual(cheap_item.price, 0)
def test_order_item_set_state_done(self):
tenant = package_factories.OpenStackPackageFactory().tenant
resource = marketplace_factories.ResourceFactory(scope=tenant)
order_item = marketplace_factories.OrderItemFactory(resource=resource)
order_item.set_state_executing()
order_item.save()
order_item.order.approve()
order_item.order.save()
tenant.state = openstack_models.Tenant.States.CREATING
tenant.save()
tenant.state = openstack_models.Tenant.States.OK
tenant.save()
order_item.refresh_from_db()
self.assertEqual(order_item.state, order_item.States.DONE)
order_item.resource.refresh_from_db()
self.assertEqual(order_item.resource.state,
marketplace_models.Resource.States.OK)
order_item.order.refresh_from_db()
self.assertEqual(order_item.order.state,
marketplace_models.Order.States.DONE)
def test_invoice_is_created_in_new_month_when_single_item_is_terminated(
self):
start_date = timezone.datetime(2014, 2, 27, tzinfo=pytz.UTC)
next_month = timezone.datetime(2014, 3, 2, tzinfo=pytz.UTC)
with freeze_time(start_date):
offering = self.fixture.offering
offering.state = offering.States.OK
offering.save()
self.assertEqual(models.Invoice.objects.count(), 1)
invoice = models.Invoice.objects.first()
packages_factories.OpenStackPackageFactory(
tenant__service_project_link__project__customer=offering.
project.customer)
self.assertEqual(models.Invoice.objects.count(), 1)
self.assertEqual(self.get_openstack_items(invoice).count(), 1)
self.assertEqual(self.get_offering_items(invoice).count(), 1)
with freeze_time(next_month):
offering.delete()
self.assertEqual(
models.Invoice.objects.count(),
2,
"New invoice has to be created in new month.",
)
new_invoice = models.Invoice.objects.exclude(pk=invoice.pk).first()
self.assertEqual(self.get_openstack_items(new_invoice).count(), 1)
self.assertEqual(self.get_offering_items(new_invoice).count(), 1)
self.assertEqual(
self.get_offering_items(new_invoice).first().end, next_month)
def test_package_creation_does_not_increase_price_for_cheaper_1_day_long_old_package_in_the_same_day(
self):
old_component_price = 10
new_component_price = old_component_price + 5
start_date = timezone.datetime(2014, 2, 26, tzinfo=pytz.UTC)
package_change_date = start_date
end_of_the_month = core_utils.month_end(package_change_date)
with freeze_time(start_date):
old_package = fixtures.create_package(
component_price=old_component_price)
customer = old_package.tenant.service_project_link.project.customer
with freeze_time(package_change_date):
old_package.delete()
new_template = fixtures.create_package_template(
component_price=new_component_price)
new_package = packages_factories.OpenStackPackageFactory(
template=new_template,
tenant__service_project_link__project__customer=customer,
)
old_components_price = old_package.template.price * (
package_change_date - start_date).days
second_component_usage_days = utils.get_full_days(
package_change_date, end_of_the_month)
new_components_price = new_package.template.price * second_component_usage_days
expected_price = old_components_price + new_components_price
# assert
self.assertEqual(models.Invoice.objects.count(), 1)
self.assertEqual(Decimal(expected_price),
models.Invoice.objects.first().price)
def test_package_creation_increases_price_from_old_package_if_it_is_more_expensive_in_the_end_of_the_month(
self):
old_component_price = 15
new_component_price = old_component_price - 5
start_date = timezone.datetime(2014, 2, 20, tzinfo=pytz.UTC)
package_change_date = timezone.datetime(2014, 2, 28, tzinfo=pytz.UTC)
end_of_the_month = core_utils.month_end(package_change_date)
with freeze_time(start_date):
old_package = fixtures.create_package(
component_price=old_component_price)
customer = old_package.tenant.service_project_link.project.customer
tenant = old_package.tenant
with freeze_time(package_change_date):
old_package.delete()
new_template = fixtures.create_package_template(
component_price=new_component_price)
new_package = packages_factories.OpenStackPackageFactory(
template=new_template,
tenant=tenant,
)
old_components_price = old_package.template.price * (
(package_change_date - start_date).days + 1)
second_component_usage_days = utils.get_full_days(
package_change_date, end_of_the_month) - 1
new_components_price = new_package.template.price * second_component_usage_days
expected_price = old_components_price + new_components_price
# assert
self.assertEqual(models.Invoice.objects.count(), 1)
self.assertEqual(Decimal(expected_price),
models.Invoice.objects.first().price)
def test_package_creation_does_not_increase_price_for_cheaper_1_day_long_old_package_in_the_end_of_the_month(
self):
old_component_price = 5
new_component_price = old_component_price + 5
start_date = timezone.datetime(2014, 2, 27, tzinfo=pytz.UTC)
package_change_date = timezone.datetime(2014, 2, 28, tzinfo=pytz.UTC)
end_of_the_month = core_utils.month_end(package_change_date)
with freeze_time(start_date):
old_package = invoices_fixtures.create_package(
component_price=old_component_price)
tenant = old_package.tenant
with freeze_time(package_change_date):
old_package.delete()
new_template = invoices_fixtures.create_package_template(
component_price=new_component_price)
new_package = packages_factories.OpenStackPackageFactory(
template=new_template,
tenant=tenant,
)
old_components_price = old_package.template.price * (
package_change_date - start_date).days
second_component_usage_days = invoices_utils.get_full_days(
package_change_date, end_of_the_month)
new_components_price = new_package.template.price * second_component_usage_days
expected_price = old_components_price + new_components_price
# assert
self.assertEqual(invoices_models.Invoice.objects.count(), 1)
self.assertEqual(Decimal(expected_price),
invoices_models.Invoice.objects.first().price)
def create_package(component_price, tenant=None):
template = create_package_template(component_price=component_price)
if not tenant:
tenant = packages_factories.TenantFactory()
package = packages_factories.OpenStackPackageFactory(template=template, tenant=tenant)
return package
def test_order_item_set_state_done(self):
openstack_package = package_factories.OpenStackPackageFactory()
order_item = marketplace_factories.OrderItemFactory(
scope=openstack_package)
order_item.set_state('executing')
order_item.order.state = marketplace_models.Order.States.EXECUTING
order_item.order.save()
openstack_package.tenant.state = openstack_models.Tenant.States.CREATION_SCHEDULED
openstack_package.tenant.save()
openstack_package.tenant.state = openstack_models.Tenant.States.OK
openstack_package.tenant.save()
order_item.refresh_from_db()
self.assertEqual(order_item.state, order_item.States.DONE)
def test_existing_invoice_is_update_on_offering_creation_if_it_has_package_item_for_same_customer(self):
start_date = timezone.datetime(2014, 2, 27, tzinfo=pytz.UTC)
end_date = core_utils.month_end(start_date)
usage_days = utils.get_full_days(start_date, end_date)
with freeze_time(start_date):
packages_factories.OpenStackPackageFactory(
tenant__service_project_link__project__customer=self.fixture.customer)
self.assertEqual(models.Invoice.objects.count(), 1)
invoice = models.Invoice.objects.first()
components_price = invoice.price
offering = self.fixture.offering
offering.state = offering.States.OK
offering.save()
self.assertEqual(models.Invoice.objects.count(), 1)
self.assertTrue(invoice.offering_items.filter(offering=offering).exists())
expected_price = offering.unit_price * usage_days + components_price
self.assertEqual(invoice.price, Decimal(expected_price))
