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))