def test_initialization_cost_is_added_to_cost_estimate_for_creation_request(self):
# Arrange
offering = factories.OfferingFactory(type='Support.OfferingTemplate')
one_time_offering_component = factories.OfferingComponentFactory(
offering=offering,
billing_type=models.OfferingComponent.BillingTypes.ONE_TIME,
type='signup',
)
usage_offering_component = factories.OfferingComponentFactory(
offering=offering,
billing_type=models.OfferingComponent.BillingTypes.USAGE,
type='cpu',
)
plan = factories.PlanFactory()
factories.PlanComponentFactory(
plan=plan, component=one_time_offering_component, price=100
)
factories.PlanComponentFactory(
plan=plan, component=usage_offering_component, price=10
)
order_item = factories.OrderItemFactory(offering=offering, plan=plan,)
order_item.init_cost()
self.assertEqual(order_item.cost, 100)
def test_plan_switch_cost_is_added_to_cost_estimate_for_order_item(self):
# Arrange
offering = factories.OfferingFactory(type='Support.OfferingTemplate')
switch_offering_component = factories.OfferingComponentFactory(
offering=offering,
billing_type=models.OfferingComponent.BillingTypes.ON_PLAN_SWITCH,
type='plan_switch',
)
usage_offering_component = factories.OfferingComponentFactory(
offering=offering,
billing_type=models.OfferingComponent.BillingTypes.USAGE,
type='cpu',
)
plan = factories.PlanFactory()
factories.PlanComponentFactory(
plan=plan, component=switch_offering_component, price=50
)
factories.PlanComponentFactory(
plan=plan, component=usage_offering_component, price=10
)
order_item = factories.OrderItemFactory(
offering=offering, plan=plan, type=models.OrderItem.Types.UPDATE,
)
order_item.init_cost()
self.assertEqual(order_item.cost, 50)
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
def new_plan(self):
new_plan = marketplace_factories.PlanFactory(
offering=self.offering,
unit_price=5,
name='Small plan',
unit=marketplace_models.Plan.Units.PER_MONTH,
)
marketplace_factories.PlanComponentFactory(
plan=new_plan, component=self.offering_component_cpu, price=3)
marketplace_factories.PlanComponentFactory(
plan=new_plan, component=self.offering_component_ram, price=2)
return new_plan
def test_when_limits_are_updated_estimate_is_recalculated(self):
# Arrange
oc = factories.OfferingComponentFactory(
offering=self.cart_item.offering,
billing_type=models.OfferingComponent.BillingTypes.LIMIT,
type='cpu',
)
plan = factories.PlanFactory(offering=self.cart_item.offering)
factories.PlanComponentFactory(
plan=plan,
component=oc,
price=10,
)
self.cart_item.limits = {'cpu': 2}
self.cart_item.plan = plan
self.cart_item.save()
# Act
self.client.force_authenticate(self.cart_item.user)
url = factories.CartItemFactory.get_url(item=self.cart_item)
response = self.client.patch(url, {'limits': {'cpu': 4}})
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
self.cart_item.refresh_from_db()
# Assert
self.assertEqual(self.cart_item.cost, 4 * 10)
def plan_component_cpu(self):
return marketplace_factories.PlanComponentFactory(
plan=self.plan,
component=self.offering_component_cpu,
price=4,
amount=1,
)
def plan_component_ram(self):
return marketplace_factories.PlanComponentFactory(
plan=self.plan,
component=self.offering_component_ram,
price=3,
amount=2,
)
def setUp(self):
self.fixture = structure_fixtures.ProjectFixture()
self.service_provider = factories.ServiceProviderFactory()
self.secret_code = self.service_provider.api_secret_code
self.offering = factories.OfferingFactory(
customer=self.fixture.customer)
self.plan = factories.PlanFactory(unit=UnitPriceMixin.Units.PER_DAY,
offering=self.offering)
self.offering_component = factories.OfferingComponentFactory(
offering=self.offering,
billing_type=models.OfferingComponent.BillingTypes.USAGE,
)
self.component = factories.PlanComponentFactory(
plan=self.plan, component=self.offering_component)
self.resource = models.Resource.objects.create(
offering=self.offering,
plan=self.plan,
project=self.fixture.project,
)
factories.OrderItemFactory(
resource=self.resource,
type=models.RequestTypeMixin.Types.CREATE,
state=models.OrderItem.States.EXECUTING,
plan=self.plan,
)
callbacks.resource_creation_succeeded(self.resource)
self.plan_period = models.ResourcePlanPeriod.objects.get(
resource=self.resource)
def setUp(self):
self.offering = marketplace_factories.OfferingFactory(
type=PACKAGE_TYPE)
self.plan = marketplace_factories.PlanFactory(offering=self.offering)
self.limits = {
RAM_TYPE: 1 * 1024,
CORES_TYPE: 2,
STORAGE_TYPE: 3 * 1024,
}
self.prices = {
RAM_TYPE: 10,
CORES_TYPE: 100,
STORAGE_TYPE: 1,
}
for ct in self.prices.keys():
marketplace_factories.PlanComponentFactory(
plan=self.plan,
component=marketplace_factories.OfferingComponentFactory(
offering=self.offering,
type=ct,
),
price=self.prices[ct],
)
self.resource = marketplace_factories.ResourceFactory(
offering=self.offering,
plan=self.plan,
limits=self.limits,
state=marketplace_models.Resource.States.OK,
)
def setUp(self):
super(RequestSwitchPlanTest, self).setUp()
self.plan = marketplace_factories.PlanFactory(offering=self.offering,
unit_price=50)
marketplace_factories.PlanComponentFactory(
plan=self.plan,
component=self.offering_component,
price=Decimal(50))
def create_plan(self, prices, unit=marketplace_models.Plan.Units.PER_DAY):
plan = marketplace_factories.PlanFactory(offering=self.offering,
unit=unit)
for ct in prices.keys():
marketplace_factories.PlanComponentFactory(
plan=plan,
component=self.offering.components.get(type=ct),
price=prices[ct],
)
return plan
def plan(self):
plan = marketplace_factories.PlanFactory(
offering=self.offering,
name='Standard plan',
unit_price=10,
unit=marketplace_models.Plan.Units.PER_MONTH,
)
marketplace_factories.PlanComponentFactory(
plan=plan,
component=self.offering_component_cpu,
price=4,
amount=1,
)
marketplace_factories.PlanComponentFactory(
plan=plan,
component=self.offering_component_ram,
price=3,
amount=2,
)
return plan
def setUp(self):
super(RequestSwitchPlanTest, self).setUp()
self.plan = marketplace_factories.PlanFactory(
offering=self.offering, unit_price=50
)
marketplace_factories.PlanComponentFactory(
plan=self.plan, component=self.offering_component, price=Decimal(50)
)
self.order_item = marketplace_factories.OrderItemFactory(resource=self.resource)
self.order_item.set_state_executing()
self.order_item.set_state_done()
self.order_item.save()
def setUp(self):
super(StatsTest, self).setUp()
self.date = parse_date('2019-01-01')
self.plan = factories.PlanFactory(offering=self.offering)
self.plan_component = factories.PlanComponentFactory(
plan=self.plan, component=self.offering_component, amount=10)
self.resource = factories.ResourceFactory(project=self.project,
offering=self.offering,
plan=self.plan)
def setUp(self):
self.service_provider = factories.ServiceProviderFactory()
self.secret_code = self.service_provider.api_secret_code
self.plan = factories.PlanFactory(unit=UnitPriceMixin.Units.PER_DAY)
self.offering_component = factories.OfferingComponentFactory(
offering=self.plan.offering,
billing_type=models.OfferingComponent.BillingTypes.USAGE)
self.component = factories.PlanComponentFactory(
plan=self.plan, component=self.offering_component)
self.resource = models.Resource.objects.create(
offering=self.plan.offering,
plan=self.plan,
project=structure_factories.ProjectFactory())
def _create_plan(self, price, unit):
plan = marketplace_factories.PlanFactory(offering=self.offering,
unit=unit)
components = package_models.PackageTemplate.get_required_component_types(
)
for component_type in components:
offering_component, _ = marketplace_models.OfferingComponent.objects.get_or_create(
offering=self.offering, type=component_type)
marketplace_factories.PlanComponentFactory(
component=offering_component,
plan=plan,
price=Decimal(price) / len(components))
return plan
def setUp(self):
self.fixture = openstack_tenant_fixtures.OpenStackTenantFixture()
self.patcher = mock.patch(
'waldur_rancher.backend.RancherBackend.get_cluster_nodes')
self.mocked_get_cluster_nodes = self.patcher.start()
self.mocked_get_cluster_nodes.return_value = [{
'backend_id':
'node_backend_id',
'name':
'name-rancher-node-1'
}]
self.patcher_client = mock.patch(
'waldur_rancher.backend.RancherBackend.client')
self.mock_client = self.patcher_client.start()
self.mock_client.get_node.return_value = backend_node_response
service = rancher_factories.RancherServiceFactory(
customer=self.fixture.customer)
spl = rancher_factories.RancherServiceProjectLinkFactory(
project=self.fixture.project, service=service)
service_settings = spl.service.settings
self.offering = marketplace_factories.OfferingFactory(
type=PLUGIN_NAME, scope=service_settings)
self.plan = marketplace_factories.PlanFactory(offering=self.offering, )
self.offering_component = marketplace_factories.OfferingComponentFactory(
offering=self.offering,
type='node',
billing_type=marketplace_models.OfferingComponent.BillingTypes.
USAGE,
)
self.plan_component = marketplace_factories.PlanComponentFactory(
plan=self.plan,
component=self.offering_component,
)
openstack_tenant_factories.FlavorFactory(
settings=self.fixture.spl.service.settings, ram=1024 * 8, cores=8)
image = openstack_tenant_factories.ImageFactory(
settings=self.fixture.spl.service.settings)
openstack_tenant_factories.SecurityGroupFactory(
name='default', settings=self.fixture.spl.service.settings)
service_settings.options['base_image_name'] = image.name
service_settings.save()
self.resource = None
self.cluster = None
self.plan_period = None
def setUp(self):
self.fixture = support_fixtures.SupportFixture()
self.offering = marketplace_factories.OfferingFactory(type=PLUGIN_NAME)
offering_component = marketplace_factories.OfferingComponentFactory(
offering=self.offering)
self.plan = marketplace_factories.PlanFactory(
unit=marketplace_models.Plan.Units.PER_MONTH)
self.plan_component = marketplace_factories.PlanComponentFactory(
plan=self.plan,
component=offering_component,
price=7,
)
self.resource = marketplace_factories.ResourceFactory(
offering=self.offering,
project=self.fixture.project,
plan=self.plan,
)
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(ComponentStatsTest, self).setUp()
self.url = factories.OfferingFactory.get_url(self.offering,
action='component_stats')
self.plan = factories.PlanFactory(
offering=self.offering,
unit=UnitPriceMixin.Units.PER_DAY,
)
self.plan_component = factories.PlanComponentFactory(
plan=self.plan, component=self.offering_component, amount=10)
self.resource = factories.ResourceFactory(
offering=self.offering,
state=models.Resource.States.OK,
plan=self.plan,
limits={'cores': 1},
)
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()
def setUp(self):
super(InvoicesTest, self).setUp()
self.offering = marketplace_factories.OfferingFactory(
type=PLUGIN_NAME, options={'order': []})
self.order_item = marketplace_factories.OrderItemFactory(
offering=self.offering,
attributes={
'name': 'item_name',
'description': 'Description'
})
self.offering_component = marketplace_factories.OfferingComponentFactory(
offering=self.offering,
billing_type=marketplace_models.OfferingComponent.BillingTypes.
FIXED)
self.plan_component = marketplace_factories.PlanComponentFactory(
plan=self.order_item.plan, component=self.offering_component)
self.order_item_process(self.order_item)
def setUp(self):
super(UpdateLimitsTest, self).setUp()
self.old_limits = {'cpu': 10}
self.new_limits = {'cpu': 20}
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.offering_component = marketplace_factories.OfferingComponentFactory(
offering=self.offering,
billing_type=marketplace_models.OfferingComponent.BillingTypes.
LIMIT,
)
self.plan = marketplace_factories.PlanFactory(offering=self.offering,
unit_price=10)
self.plan_component = marketplace_factories.PlanComponentFactory(
plan=self.plan, component=self.offering_component)
self.resource = marketplace_factories.ResourceFactory(
name='test_request',
project=self.project,
offering=self.offering,
plan=self.plan,
limits=self.old_limits,
)
self.resource.set_state_ok()
self.resource.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)
def submit_order_item(self):
fixture = fixtures.ProjectFixture()
offering = marketplace_factories.OfferingFactory(type=PLUGIN_NAME,
options={'order': []})
order_item = marketplace_factories.OrderItemFactory(
offering=offering,
attributes={
'name': 'item_name',
'description': 'Description'
},
)
offering_component = marketplace_factories.OfferingComponentFactory(
name='CORES')
marketplace_factories.PlanComponentFactory(
component=offering_component, plan=order_item.plan)
serialized_order = core_utils.serialize_instance(order_item.order)
serialized_user = core_utils.serialize_instance(fixture.staff)
marketplace_tasks.process_order(serialized_order, serialized_user)
return order_item
def setUp(self):
self.offering = marketplace_factories.OfferingFactory(
type=VIRTUAL_MACHINE_TYPE)
self.plan = marketplace_factories.PlanFactory(
offering=self.offering,
unit=UnitPriceMixin.Units.PER_DAY,
)
for component_type in ('cpu', 'ram', 'disk'):
marketplace_factories.PlanComponentFactory(
plan=self.plan,
component=marketplace_factories.OfferingComponentFactory(
offering=self.offering, type=component_type))
self.fixture = VMwareFixture()
self.vm = self.fixture.virtual_machine
self.resource = marketplace_factories.ResourceFactory(
offering=self.offering,
plan=self.plan,
scope=self.vm,
project=self.fixture.project,
)
def plan_component(self):
return marketplace_factories.PlanComponentFactory(
plan=self.plan,
component=self.offering_component,
)
def create_plan_component(self, type, price):
return marketplace_factories.PlanComponentFactory(
component=self.offering.components.get(type=type),
plan=self.plan,
price=price)
def new_plan_component_ram(self):
return marketplace_factories.PlanComponentFactory(
plan=self.new_plan, component=self.offering_component_ram, price=2)
def test_handler(self):
self.resource.offering.type = PLUGIN_NAME
self.resource.offering.save()
# add usage-based component to the offering and plan
COMPONENT_TYPE = 'storage'
new_component = factories.OfferingComponentFactory(
offering=self.resource.offering,
billing_type=models.OfferingComponent.BillingTypes.USAGE,
type=COMPONENT_TYPE,
)
factories.PlanComponentFactory(
plan=self.plan,
component=new_component,
)
self._create_items()
plan_period = factories.ResourcePlanPeriodFactory(
resource=self.resource,
plan=self.plan,
start=core_utils.month_start(timezone.now()),
)
factories.ComponentUsageFactory(
resource=self.resource,
date=timezone.now(),
billing_period=core_utils.month_start(timezone.now()),
component=new_component,
plan_period=plan_period,
usage=2,
)
self.client.force_authenticate(self.fixture.staff)
result = self.client.get(self.url, {
'start': '2020-03',
'end': '2020-03'
})
component_cores = self.resource.offering.components.get(type='cores')
component_storage = self.resource.offering.components.get(
type='storage')
self.assertEqual(len(result.data), 2)
self.assertEqual(
[r for r in result.data if r['type'] == component_cores.type][0],
{
'description': component_cores.description,
'measured_unit': component_cores.measured_unit,
'name': component_cores.name,
'period': '2020-03',
'date': '2020-03-31T00:00:00+00:00',
'type': component_cores.type,
'usage': 31, # days in March of 1 core usage with per-day plan
},
)
self.assertEqual(
[r for r in result.data if r['type'] == component_storage.type][0],
{
'description': component_storage.description,
'measured_unit': component_storage.measured_unit,
'name': component_storage.name,
'period': '2020-03',
'date': '2020-03-31T00:00:00+00:00',
'type': component_storage.type,
'usage': 2,
},
)
