def setUp(self):
self.fixture = packages_fixtures.PackageFixture()
self.package = self.fixture.openstack_package
self.item = models.InvoiceItem.objects.get(object_id=self.package.id)
self.item.start = parse_datetime('2018-10-11')
self.item.end = parse_datetime('2018-10-15')
self.item.save()
def test_validate_duration(self):
downtime = models.ServiceDowntime(
resource=self.resource,
start=parse_datetime('2018-10-16'),
end=parse_datetime('2018-12-20'),
)
self.assertRaises(ValidationError, downtime.clean)
def setUp(self):
self.resource = marketplace_factories.ResourceFactory()
self.downtime = models.ServiceDowntime.objects.create(
resource=self.resource,
start=parse_datetime('2018-10-05'),
end=parse_datetime('2018-10-15'),
)
def test_validate_intersection_right(self):
downtime = models.ServiceDowntime(
package=self.package,
start=parse_datetime('2018-10-10'),
end=parse_datetime('2018-10-20'),
)
self.assertRaises(ValidationError, downtime.clean)
def test_when_resource_is_terminated_old_period_is_closed(self):
# Arrange
start = parse_datetime('2018-10-01')
end = parse_datetime('2018-11-01')
plan = factories.PlanFactory()
resource = factories.ResourceFactory(plan=plan)
period = models.ResourcePlanPeriod.objects.create(resource=resource,
plan=plan,
start=start,
end=None)
order_item = factories.OrderItemFactory(
state=models.OrderItem.States.EXECUTING,
type=models.OrderItem.Types.TERMINATE,
resource=resource,
plan=plan,
)
# Act
callbacks.resource_deletion_succeeded(resource)
# Assert
order_item.refresh_from_db()
self.assertEqual(order_item.state, models.OrderItem.States.DONE)
period.refresh_from_db()
self.assertEqual(period.end, end)
def test_when_plan_is_changed_old_period_is_closed_new_is_opened(self):
# Arrange
old_start = parse_datetime('2018-10-01')
new_start = parse_datetime('2018-11-01')
old_plan = factories.PlanFactory()
new_plan = factories.PlanFactory()
resource = factories.ResourceFactory(plan=old_plan)
old_period = models.ResourcePlanPeriod.objects.create(
resource=resource, plan=old_plan, start=old_start, end=None)
order_item = factories.OrderItemFactory(
state=models.OrderItem.States.EXECUTING,
type=models.OrderItem.Types.UPDATE,
resource=resource,
plan=new_plan,
)
# Act
callbacks.resource_update_succeeded(resource)
# Assert
order_item.refresh_from_db()
self.assertEqual(order_item.state, models.OrderItem.States.DONE)
old_period.refresh_from_db()
self.assertEqual(old_period.end, new_start)
self.assertTrue(
models.ResourcePlanPeriod.objects.filter(resource=resource,
plan=new_plan,
start=new_start,
end=None).exists())
def test_validate_intersection_left(self):
downtime = models.ServiceDowntime(
resource=self.resource,
start=parse_datetime('2018-10-01'),
end=parse_datetime('2018-10-10'),
)
self.assertRaises(ValidationError, downtime.clean)
def test_offering_and_resource_cannot_be_defined(self):
downtime = models.ServiceDowntime(
resource=self.resource,
offering=self.resource.offering,
start=parse_datetime('2018-10-10'),
end=parse_datetime('2018-10-20'),
)
self.assertRaises(ValidationError, downtime.clean)
def test_factor_for_month_is_equal_to_fraction_of_days(self):
item = factories.InvoiceItemFactory(
start=parse_datetime('2016-11-1 14:00:00'),
end=parse_datetime('2016-11-8 14:00:00'),
unit=models.InvoiceItem.Units.PER_MONTH,
)
self.assertEqual(item.get_factor(),
quantize_price(decimal.Decimal(8.0 / 30)))
def setUp(self):
self.fixture = packages_fixtures.PackageFixture()
self.package = self.fixture.openstack_package
self.downtime = models.ServiceDowntime.objects.create(
package=self.package,
start=parse_datetime('2018-10-05'),
end=parse_datetime('2018-10-15'),
)
def test_positive(self):
downtime = models.ServiceDowntime(
package=self.package,
start=parse_datetime('2018-10-17'),
end=parse_datetime('2018-10-20'),
)
# It is expected that validation error is not raised in this case
downtime.clean()
def test_usage_days_and_current_factor_cannot_be_larger_than_end_field(
self):
item = factories.InvoiceItemFactory(
start=parse_datetime('2016-11-17 14:00:00'),
end=parse_datetime('2016-12-1 14:00:00'),
)
self.assertEqual(item.usage_days, 14)
self.assertEqual(item.get_factor(current=True), 14)
def test_hourly_invoicing(self):
item = factories.InvoiceItemFactory(
start=parse_datetime('2019-08-09 10:00:00'),
end=parse_datetime('2019-08-09 14:00:00'),
unit_price=10,
unit=models.InvoiceItem.Units.PER_HOUR,
)
self.assertEqual(item.get_factor(), 4)
self.assertEqual(item.price, 4 * 10)
def test_downtime_at_the_end_of_invoice_item_billing_period(self):
downtime = models.ServiceDowntime.objects.create(
package=self.package,
start=parse_datetime('2018-10-12'),
end=parse_datetime('2018-10-20'),
)
self.assertTrue(
models.GenericInvoiceItem.objects.filter(
start=downtime.start, end=self.item.end).exists())
def test_hourly_invoicing(self):
self.assertEqual(
models.get_quantity(
start=parse_datetime('2019-08-09 10:00:00'),
end=parse_datetime('2019-08-09 14:00:00'),
unit=models.InvoiceItem.Units.PER_HOUR,
),
4,
)
def test_usage_days_and_current_factor_cannot_be_larger_than_end_field(
self):
self.assertEqual(
models.get_quantity(
start=parse_datetime('2016-11-17 14:00:00'),
end=parse_datetime('2016-12-1 14:00:00'),
unit=models.InvoiceItem.Units.PER_DAY,
),
14,
)
def test_compensation_is_not_created_if_downtime_and_item_do_not_intersect(
self):
models.ServiceDowntime.objects.create(
package=self.package,
start=parse_datetime('2018-10-01'),
end=parse_datetime('2018-10-07'),
)
self.assertFalse(
models.GenericInvoiceItem.objects.filter(
scope__isnull=True).exists())
def test_component_usages_are_rendered_for_current_month(self):
models.ComponentUsage.objects.create(
resource=self.resource,
plan_period=self.plan_period,
component=self.component,
usage=100,
date=parse_datetime('2019-06-11'),
billing_period=parse_datetime('2019-06-01'))
response = self.client.get(self.url)
self.assertEqual(response.data[0]['components'][0]['usage'], 100)
def test_component_usages_are_filtered_by_current_month(self):
models.ComponentUsage.objects.create(
resource=self.resource,
plan_period=self.plan_period,
component=self.component,
usage=100,
date=parse_datetime('2019-05-10'),
billing_period=parse_datetime('2019-05-01'),
)
response = self.client.get(self.url)
self.assertEqual(len(response.data[0]['components']), 0)
def test_compensation_is_not_created_if_downtime_and_item_do_not_intersect(
self):
models.ServiceDowntime.objects.create(
resource=self.resource,
start=parse_datetime('2018-10-01'),
end=parse_datetime('2018-10-07'),
)
self.assertFalse(
models.InvoiceItem.objects.filter(
scope__isnull=True,
details__icontains='compensation').exists())
def test_downtime_at_the_start_of_invoice_item_billing_period(self):
downtime = models.ServiceDowntime.objects.create(
package=self.package,
start=parse_datetime('2018-10-01'),
end=parse_datetime('2018-10-12'),
)
self.assertTrue(
models.InvoiceItem.objects.filter(
start=self.item.start,
end=downtime.end,
details__icontains='compensation').exists())
def test_compensation_is_not_created_if_item_does_not_have_package(self):
self.item.package = None
self.item.save()
models.ServiceDowntime.objects.create(
package=self.package,
start=parse_datetime('2018-10-01'),
end=parse_datetime('2018-10-20'),
)
self.assertFalse(
models.GenericInvoiceItem.objects.filter(
scope__isnull=True).exists())
def test_downtime_inside_of_invoice_item_billing_period(self):
downtime = models.ServiceDowntime.objects.create(
resource=self.resource,
start=parse_datetime('2018-10-12'),
end=parse_datetime('2018-10-14'),
)
self.assertTrue(
models.InvoiceItem.objects.filter(
start=downtime.start,
end=downtime.end,
details__icontains='compensation',
).exists())
def test_downtime_outside_of_invoice_item_billing_period(self):
models.ServiceDowntime.objects.create(
package=self.package,
start=parse_datetime('2018-10-01'),
end=parse_datetime('2018-10-20'),
)
compensation = models.GenericInvoiceItem.objects.filter(
start=self.item.start, end=self.item.end).get()
self.assertEqual(compensation.price, -1 * self.item.price)
self.assertEqual(
compensation.details['name'],
'Compensation for downtime. Resource name: %s' % self.item.name)
def test_compensation_is_not_created_if_item_does_not_have_package(self):
self.item.scope = None
self.item.save()
models.ServiceDowntime.objects.create(
resource=self.resource,
start=parse_datetime('2018-10-01'),
end=parse_datetime('2018-10-20'),
)
self.assertFalse(
models.InvoiceItem.objects.filter(
scope__isnull=True,
details__icontains='compensation').exists())
def test_delete_compensation_if_downtime_has_been_deleted(self):
downtime = models.ServiceDowntime.objects.create(
resource=self.resource,
start=parse_datetime('2018-10-01'),
end=parse_datetime('2018-10-20'),
)
compensation = models.InvoiceItem.objects.filter(
start=self.item.start,
end=self.item.end,
details__icontains='compensation').get()
downtime.delete()
self.assertRaises(models.InvoiceItem.DoesNotExist,
compensation.refresh_from_db)
def test_downtime_outside_of_invoice_item_billing_period(self):
models.ServiceDowntime.objects.create(
resource=self.resource,
start=parse_datetime('2018-10-01'),
end=parse_datetime('2018-10-20'),
)
compensation = models.InvoiceItem.objects.filter(
start=self.item.start,
end=self.item.end,
details__icontains='compensation').get()
self.assertEqual(compensation.price, -1 * self.item.price)
self.assertEqual(
compensation.details['name'],
'Compensation. %s' % self.item.name,
)
def _backend_template_to_template(self, backend_template):
library_item = backend_template['library_item']
template = backend_template['template']
total_disk = self._get_total_disk(template['disks'])
return models.Template(
settings=self.settings,
backend_id=library_item['id'],
name=library_item['name'],
description=library_item['description'],
created=parse_datetime(library_item['creation_time']),
modified=parse_datetime(library_item['last_modified_time']),
cores=template['cpu']['count'],
cores_per_socket=template['cpu']['cores_per_socket'],
ram=template['memory']['size_MiB'],
disk=total_disk,
guest_os=template['guest_OS'],
)
def fix_resource_limit_periods(apps, schema_editor):
InvoiceItem = apps.get_model('invoices', 'InvoiceItem')
for item in InvoiceItem.objects.filter(resource__state=TERMINATED):
if not item.details:
continue
resource_limit_periods = item.details.get('resource_limit_periods')
if not resource_limit_periods:
continue
changed = False
for period in resource_limit_periods:
if parse_datetime(period['end']) > item.end:
period['end'] = item.end.isoformat()
period['billing_periods'] = get_full_days(
parse_datetime(period['start']), item.end
)
if changed:
item.save(update_fields=['details'])
def setUp(self):
self.offering = marketplace_factories.OfferingFactory(
type=PACKAGE_TYPE, )
self.offering_component = marketplace_factories.OfferingComponentFactory(
offering=self.offering)
self.plan = marketplace_factories.PlanFactory(offering=self.offering)
self.component = marketplace_factories.PlanComponentFactory(
component=self.offering_component)
self.resource = marketplace_factories.ResourceFactory(
state=marketplace_models.Resource.States.OK,
offering=self.offering,
plan=self.plan,
)
tasks.create_monthly_invoices()
self.item = models.InvoiceItem.objects.get(object_id=self.resource.id)
self.item.start = parse_datetime('2018-10-11')
self.item.end = parse_datetime('2018-10-15')
self.item.save()
