def test_create_missing_support_offerings(self):
offering = support_factories.OfferingFactory()
category = marketplace_factories.CategoryFactory()
customer = structure_factories.CustomerFactory()
marketplace_support_utils.init_offerings_and_resources(category, customer)
self.assertTrue(marketplace_models.Resource.objects.filter(scope=offering, project=offering.project).exists())
def setUp(self):
self.fixture = structure_fixtures.UserFixture()
self.offering_1 = support_factories.OfferingFactory(
backend_id='backend_id')
self.offering_2 = support_factories.OfferingFactory(
backend_id='backend_id')
self.offering_3 = support_factories.OfferingFactory(
backend_id='other_backend_id')
ct = ContentType.objects.get_for_model(support_models.Offering)
self.resource_1 = factories.ResourceFactory(
object_id=self.offering_1.id, content_type=ct)
factories.ResourceFactory(object_id=self.offering_3.id,
content_type=ct)
self.url = factories.ResourceFactory.get_list_url()
def create_issue(self):
self.issue = support_factories.IssueFactory(backend_id='', key='')
support_offering = support_factories.OfferingFactory(issue=self.issue)
resource = marketplace_factories.ResourceFactory(scope=support_offering)
self.order_item = marketplace_factories.OrderItemFactory(resource=resource, offering=self.offering)
self.issue.backend_id = 'TST-1'
self.issue.save()
def test_order_item_set_state_done_if_offering_set_state_ok(self):
fixture = fixtures.ProjectFixture()
offering = support_factories.OfferingFactory()
resource = marketplace_factories.ResourceFactory(
project=fixture.project, scope=offering)
order_item = marketplace_factories.OrderItemFactory(resource=resource)
order_item.set_state_executing()
order_item.save()
order_item.order.state = marketplace_models.Order.States.EXECUTING
order_item.order.save()
offering.state = support_models.Offering.States.OK
offering.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 setUp(self):
self.fixture = structure_fixtures.UserFixture()
self.resource = marketplace_factories.ResourceFactory()
marketplace_factories.ResourceFactory()
self.request = support_factories.OfferingFactory(
backend_id='offering_backend_id')
self.resource.scope = self.request
self.resource.save()
self.url = marketplace_factories.ResourceFactory.get_list_url()
def test_offering_items_are_serialized(self):
offering = support_factories.OfferingFactory(
template__name='OFFERING-001', project=self.fixture.project)
offering.state = offering.__class__.States.OK
offering.save()
report = format_invoice_csv(self.invoice)
lines = report.splitlines()
self.assertEqual(3, len(lines))
self.assertTrue('OFFERING-001' in ''.join(lines))
def test_order_item_set_state_done(self):
offering = support_factories.OfferingFactory()
order_item = marketplace_factories.OrderItemFactory(scope=offering)
order_item.set_state('executing')
order_item.order.state = marketplace_models.Order.States.EXECUTING
order_item.order.save()
offering.state = support_models.Offering.States.OK
offering.save()
order_item.refresh_from_db()
self.assertEqual(order_item.state, order_item.States.DONE)
def test_invoice_item_with_half_monthly_price_with_start_in_second_half(self):
start_date = timezone.datetime(2017, 7, 16)
offering = support_factories.OfferingFactory(unit=common_mixins.UnitPriceMixin.Units.PER_HALF_MONTH)
with freeze_time(start_date):
offering.state = support_models.Offering.States.OK
offering.save(update_fields=['state'])
expected_price = offering.unit_price
offering_item = models.GenericInvoiceItem.objects.get(scope=offering)
self.assertEqual(offering_item.price, expected_price)
def test_invoice_item_with_daily_price(self):
start_date = timezone.datetime(2017, 7, 14)
end_date = timezone.datetime(2017, 7, 31, 23, 59, 59)
offering = support_factories.OfferingFactory(unit=common_mixins.UnitPriceMixin.Units.PER_DAY)
with freeze_time(start_date):
offering.state = support_models.Offering.States.OK
offering.save(update_fields=['state'])
expected_price = utils.get_full_days(start_date, end_date) * offering.unit_price
offering_item = models.GenericInvoiceItem.objects.get(scope=offering)
self.assertEqual(offering_item.price, expected_price)
def test_create_missing_support_offerings_with_offering_plan(self):
offering = support_factories.OfferingFactory()
category = marketplace_factories.CategoryFactory()
customer = structure_factories.CustomerFactory()
offering_plan = support_factories.OfferingPlanFactory(template=offering.template,
unit_price=offering.unit_price)
marketplace_support_utils.init_offerings_and_resources(category, customer)
self.assertTrue(marketplace_models.Plan.objects.filter(scope=offering_plan).exists())
self.assertEqual(marketplace_models.Plan.objects.count(), 1)
self.assertTrue(marketplace_models.Resource.objects.filter(scope=offering).exists())
def test_invoice_is_not_created_for_pending_offering(self):
issue = support_factories.IssueFactory(customer=self.fixture.customer, project=self.fixture.project)
pending_offering = support_factories.OfferingFactory(issue=issue)
offering = self.fixture.offering
offering.state = offering.States.OK
offering.save()
self.assertEqual(models.Invoice.objects.count(), 1)
invoice = models.Invoice.objects.first()
self.assertTrue(invoice.offering_items.filter(offering=offering).exists())
self.assertFalse(invoice.offering_items.filter(offering=pending_offering).exists())
def test_invoice_item_with_half_monthly_price_with_start_in_first_half(self):
start_date = timezone.datetime(2017, 7, 14)
usage_days = 2
offering = support_factories.OfferingFactory(unit=common_mixins.UnitPriceMixin.Units.PER_HALF_MONTH)
with freeze_time(start_date):
offering.state = support_models.Offering.States.OK
offering.save(update_fields=['state'])
month_days = monthrange(2017, 7)[1]
expected_price = offering.unit_price * decimal.Decimal(1 + (usage_days / (month_days / 2)))
offering_item = models.GenericInvoiceItem.objects.get(scope=offering)
self.assertEqual(offering_item.price, expected_price)
def _start_end_offering(self, start_date, end_date):
offering = support_factories.OfferingFactory(unit=common_mixins.UnitPriceMixin.Units.PER_HALF_MONTH)
with freeze_time(start_date):
offering.state = support_models.Offering.States.OK
offering.save(update_fields=['state'])
offering_item = models.GenericInvoiceItem.objects.get(scope=offering)
with freeze_time(end_date):
offering.state = support_models.Offering.States.TERMINATED
offering.save(update_fields=['state'])
offering_item.refresh_from_db()
return offering, offering_item
def test_invoice_item_with_monthly_price(self):
start_date = timezone.datetime(2017, 7, 20)
month_days = monthrange(2017, 7)[1]
usage_days = month_days - start_date.day + 1
offering = support_factories.OfferingFactory(
unit=common_mixins.UnitPriceMixin.Units.PER_MONTH)
with freeze_time(start_date):
offering.state = support_models.Offering.States.OK
offering.save(update_fields=['state'])
expected_price = offering.unit_price * quantize_price(
decimal.Decimal((usage_days / month_days)))
offering_item = models.InvoiceItem.objects.get(scope=offering)
self.assertEqual(offering_item.price, expected_price)
def test_invoice_item_with_half_monthly_price_with_end_in_first_half(self):
start_date = timezone.datetime(2017, 7, 10)
end_date = timezone.datetime(2017, 7, 14)
offering = support_factories.OfferingFactory(
unit=common_mixins.UnitPriceMixin.Units.PER_HALF_MONTH)
with freeze_time(start_date):
offering.state = support_models.Offering.States.OK
offering.save(update_fields=['state'])
offering_item = models.OfferingItem.objects.get(offering=offering)
with freeze_time(end_date):
offering.state = support_models.Offering.States.TERMINATED
offering.save(update_fields=['state'])
offering_item.refresh_from_db()
expected_price = offering.unit_price
self.assertEqual(offering_item.price, expected_price)
def test_offering_set_state_done(self):
offering = support_factories.OfferingFactory()
resource = marketplace_factories.ResourceFactory(scope=offering)
order_item = marketplace_factories.OrderItemFactory(resource=resource)
order_item.set_state_executing()
order_item.save()
order_item.order.state = marketplace_models.Order.States.EXECUTING
order_item.order.save()
offering.issue.status = 'Completed'
offering.issue.resolution = 'Done'
offering.issue.save()
order_item.refresh_from_db()
self.assertEqual(order_item.state, order_item.States.DONE)
offering.refresh_from_db()
self.assertEqual(offering.state, offering.States.OK)
def setUp(self):
super(RequestActionBaseTest, self).setUp()
self.fixture = fixtures.ProjectFixture()
self.project = self.fixture.project
self.user = self.fixture.staff
self.offering = marketplace_factories.OfferingFactory(
state=marketplace_models.Offering.States.ACTIVE, type=PLUGIN_NAME
)
self.request = support_factories.OfferingFactory(
template=self.offering.scope, project=self.project, name='test_request'
)
self.current_plan = marketplace_factories.PlanFactory(
offering=self.offering, unit_price=10
)
self.offering_component = marketplace_factories.OfferingComponentFactory(
offering=self.offering,
billing_type=marketplace_models.OfferingComponent.BillingTypes.FIXED,
)
self.plan_component = marketplace_factories.PlanComponentFactory(
plan=self.current_plan, component=self.offering_component
)
self.resource = marketplace_factories.ResourceFactory(
project=self.project,
scope=self.request,
offering=self.offering,
plan=self.current_plan,
)
self.resource.scope.state = support_models.Offering.States.OK
self.resource.scope.save()
self.success_issue_status = 'ok'
support_factories.IssueStatusFactory(
name=self.success_issue_status,
type=support_models.IssueStatus.Types.RESOLVED,
)
self.error_issue_status = 'error'
support_factories.IssueStatusFactory(
name=self.error_issue_status, type=support_models.IssueStatus.Types.CANCELED
)
self.start = datetime.datetime.now()
def setUp(self):
super(RequestDeleteTest, self).setUp()
self.fixture = fixtures.ProjectFixture()
self.offering = marketplace_factories.OfferingFactory(type=PLUGIN_NAME)
self.request = support_factories.OfferingFactory(
state=support_models.Offering.States.TERMINATED)
self.resource = marketplace_factories.ResourceFactory(
project=self.fixture.project,
scope=self.request,
offering=self.offering,
)
self.order = marketplace_factories.OrderFactory(
project=self.fixture.project,
state=marketplace_models.Order.States.EXECUTING,
)
self.order_item = marketplace_factories.OrderItemFactory(
resource=self.resource,
type=marketplace_models.RequestTypeMixin.Types.TERMINATE,
)
def setUp(self):
super(SupportOfferingTest, self).setUp()
self.success_issue_status = 'Completed'
support_factories.IssueStatusFactory(
name=self.success_issue_status,
type=support_models.IssueStatus.Types.RESOLVED)
self.fail_issue_status = 'Cancelled'
support_factories.IssueStatusFactory(
name=self.fail_issue_status,
type=support_models.IssueStatus.Types.CANCELED)
self.offering = support_factories.OfferingFactory()
resource = marketplace_factories.ResourceFactory(scope=self.offering)
self.order_item = marketplace_factories.OrderItemFactory(
resource=resource)
self.order_item.set_state_executing()
self.order_item.save()
self.order_item.order.state = marketplace_models.Order.States.EXECUTING
self.order_item.order.save()
def setUp(self):
self.provider = marketplace_factories.ServiceProviderFactory()
self.provider_2 = marketplace_factories.ServiceProviderFactory()
self.offering = marketplace_factories.OfferingFactory(
type=PACKAGE_TYPE, customer=self.provider.customer)
self.offering_component = marketplace_factories.OfferingComponentFactory(
offering=self.offering)
self.plan = marketplace_factories.PlanFactory(
offering=self.offering,
unit=UnitPriceMixin.Units.PER_DAY,
)
self.component = marketplace_factories.PlanComponentFactory(
component=self.offering_component,
price=Decimal(5),
plan=self.plan)
self.offering_2 = marketplace_factories.OfferingFactory(
type=PACKAGE_TYPE, customer=self.provider_2.customer)
self.offering_component_2 = marketplace_factories.OfferingComponentFactory(
offering=self.offering_2)
self.plan_2 = marketplace_factories.PlanFactory(
offering=self.offering_2,
unit=UnitPriceMixin.Units.PER_DAY,
)
self.component_2 = marketplace_factories.PlanComponentFactory(
component=self.offering_component_2,
price=Decimal(7),
plan=self.plan_2)
self.resource_1 = marketplace_factories.ResourceFactory(
state=marketplace_models.Resource.States.OK,
offering=self.offering,
plan=self.plan,
limits={'cpu': 1},
)
self.resource_2 = marketplace_factories.ResourceFactory(
state=marketplace_models.Resource.States.OK,
offering=self.offering,
project=self.resource_1.project,
plan=self.plan,
limits={'cpu': 1},
)
self.resource_3 = marketplace_factories.ResourceFactory(
state=marketplace_models.Resource.States.OK,
offering=self.offering_2,
project=self.resource_1.project,
plan=self.plan_2,
limits={'cpu': 1},
)
self.customer = self.resource_1.project.customer
self.support_template = support_factories.OfferingTemplateFactory()
self.support_plan = support_factories.OfferingPlanFactory(
template=self.support_template,
unit_price=7,
)
self.support_offering = support_factories.OfferingFactory(
project=self.resource_1.project,
template=self.support_template,
plan=self.support_plan,
state=support_models.Offering.States.OK,
)
