def get_issue(self):
response = self.request_switch_plan()
order = marketplace_models.Order.objects.get(
uuid=response.data['order_uuid'])
order_item = order.items.first()
process_order_item(order_item, self.user)
return get_order_item_issue(order_item)
def _switch_plan(self, price, unit):
new_plan = self._create_plan(price, unit)
new_plan_url = marketplace_factories.PlanFactory.get_url(new_plan)
user = self.fixture.staff
self.client.force_login(user)
url = marketplace_factories.ResourceFactory.get_url(
self.resource, 'switch_plan')
self.client.post(url, {
'plan': new_plan_url,
})
update_order_item = marketplace_models.OrderItem.objects.get(
resource=self.resource,
type=marketplace_models.OrderItem.Types.UPDATE)
marketplace_utils.process_order_item(update_order_item, user)
new_template = update_order_item.plan.scope
packages_serializers._set_tenant_quotas(self.tenant, new_template)
packages_serializers._set_related_service_settings_quotas(
self.tenant, new_template)
packages_serializers._set_tenant_extra_configuration(
self.tenant, new_template)
self.package.delete()
package_models.OpenStackPackage.objects.create(
template=new_template,
service_settings=self.package.service_settings,
tenant=self.tenant)
callbacks.resource_update_succeeded(self.resource)
def test_volume_type_quotas_are_propagated(self):
del self.quotas['storage']
self.quotas['gigabytes_lvmdriver-1'] = 10
self.quotas['gigabytes_backup'] = 30
marketplace_utils.process_order_item(self.order_item, self.fixture.staff)
_, quotas = self.mock_get_backend().push_tenant_quotas.call_args[0]
self.assertTrue('gigabytes_lvmdriver-1' in quotas)
self.assertEqual(quotas['storage'], 40 * 1024)
def get_issue(self):
response = self.request_limit_update()
self.assertEqual(response.status_code, status.HTTP_200_OK)
order = marketplace_models.Order.objects.get(
uuid=response.data['order_uuid'])
order_item = order.items.first()
process_order_item(order_item, self.user)
return get_order_item_issue(order_item)
def _init(self, price, unit):
self.fixture = package_fixtures.PackageFixture()
self.project_url = structure_factories.ProjectFactory.get_url(
self.fixture.project)
self.offering = marketplace_factories.OfferingFactory(
scope=self.fixture.openstack_service_settings,
type=PACKAGE_TYPE,
state=marketplace_models.Offering.States.ACTIVE,
)
self.offering_url = marketplace_factories.OfferingFactory.get_url(
self.offering)
plan = self._create_plan(price=price, unit=unit)
plan_url = marketplace_factories.PlanFactory.get_url(plan)
# Create SPL
self.fixture.openstack_spl
attributes = dict(
name='My first VPC',
description='Database cluster',
user_username='******',
)
payload = {
'project':
self.project_url,
'items': [
{
'offering': self.offering_url,
'plan': plan_url,
'attributes': attributes,
},
]
}
user = self.fixture.staff
self.client.force_login(user)
url = marketplace_factories.OrderFactory.get_list_url()
response = self.client.post(url, payload)
order_item = marketplace_models.OrderItem.objects.get(
uuid=response.data['items'][0]['uuid'])
marketplace_utils.process_order_item(order_item, user)
self.resource = order_item.resource
callbacks.resource_creation_succeeded(self.resource)
self.tenant = plan.scope.openstack_packages.first().tenant
self.tenant.state = openstack_models.Tenant.States.OK
self.tenant.backend_id = 'tenant id'
self.tenant.save()
self.package = package_models.OpenStackPackage.objects.get(
tenant=self.tenant)
self.invoice = invoices_models.Invoice.objects.get(
customer=self.fixture.customer)
def test_resource_limits_have_been_updated_if_backend_does_not_raise_exception(
self):
marketplace_utils.process_order_item(self.order_item,
self.fixture.staff)
self.resource.refresh_from_db()
self.assertEqual(self.resource.limits, self.quotas)
self.order_item.refresh_from_db()
self.assertEqual(self.order_item.state,
marketplace_models.OrderItem.States.DONE)
def test_update_limit_process(self):
response = self.update_limits(self.fixture.staff, self.resource)
self.assertEqual(response.status_code, status.HTTP_200_OK)
order_item = models.OrderItem.objects.get(
type=models.OrderItem.Types.UPDATE, resource=self.resource,
)
utils.process_order_item(order_item, self.fixture.staff)
self.resource.refresh_from_db()
self.assertEqual(self.resource.limits['vcpu'], 10)
def get_issue(self):
response = self.request_switch_plan()
order = marketplace_models.Order.objects.get(uuid=response.data['order_uuid'])
order_item = order.items.first()
process_order_item(order_item, self.user)
order_item_content_type = ContentType.objects.get_for_model(order_item)
return support_models.Issue.objects.get(
resource_object_id=order_item.id,
resource_content_type=order_item_content_type,
)
def test_resource_limits_have_been_not_updated_if_backend_raises_exception(
self):
self.mock_get_backend().push_tenant_quotas = mock.Mock(
side_effect=Exception('foo'))
marketplace_utils.process_order_item(self.order_item,
self.fixture.staff)
self.resource.refresh_from_db()
self.assertEqual(self.resource.limits, {})
self.order_item.refresh_from_db()
self.assertEqual(self.order_item.state,
marketplace_models.OrderItem.States.ERRED)
self.assertEqual(self.order_item.error_message, 'foo')
def approve_order(self):
self.get_response(self.owner,
'marketplace-order-detail',
action='approve',
uuid=self.order.uuid)
process_order_item(self.order_item, self.owner)
self.stdout('A %s order has been approved.' % self.get_request_type())
self.stdout('Order UUID: %s' % self.order.uuid)
self.stdout('Request UUID: %s' % self.order_item.resource.scope.uuid)
issue = self.get_issue()
self.stdout('Issue UUID: %s, PK: %s' % (issue.uuid.hex, issue.pk))
def get_order_item(self, issue_status):
response = self.request_switch_plan()
order = marketplace_models.Order.objects.get(
uuid=response.data['order_uuid'])
order_item = order.items.first()
process_order_item(order_item, self.user)
issue = get_order_item_issue(order_item)
issue.status = issue_status
issue.save()
order_item.refresh_from_db()
return order_item
def get_order_item(self, issue_status):
response = self.request_limit_update()
self.assertEqual(response.status_code, status.HTTP_200_OK)
order = marketplace_models.Order.objects.get(
uuid=response.data['order_uuid'])
order_item = order.items.first()
process_order_item(order_item, self.user)
issue = get_order_item_issue(order_item)
issue.status = issue_status
issue.save()
order_item.refresh_from_db()
return order_item
def get_order_item(self, issue_status):
self.request_resource_termination()
order = marketplace_models.Order.objects.get(project=self.project)
order_item = order.items.first()
if order_item.order.state != marketplace_models.Order.States.EXECUTING:
order_item.order.approve()
order_item.order.save()
process_order_item(order_item, self.user)
issue = get_order_item_issue(order_item)
issue.status = issue_status
issue.save()
return marketplace_models.OrderItem.objects.first()
def get_order_item(self, issue_status):
self.request_switch_plan()
order = marketplace_models.Order.objects.get(project=self.project)
order_item = order.items.first()
process_order_item(order_item, self.user)
order_item_content_type = ContentType.objects.get_for_model(order_item)
issue = support_models.Issue.objects.get(resource_object_id=order_item.id,
resource_content_type=order_item_content_type)
issue.status = issue_status
issue.save()
order_item.refresh_from_db()
return order_item
def get_order_item(self, issue_status):
self.request_resource_termination()
order = marketplace_models.Order.objects.get(project=self.project)
order_item = order.items.first()
if order_item.order.state != marketplace_models.Order.States.EXECUTING:
order_item.order.approve()
order_item.order.save()
process_order_item(order_item, self.user)
order_item_content_type = ContentType.objects.get_for_model(order_item)
issue = support_models.Issue.objects.get(resource_object_id=order_item.id,
resource_content_type=order_item_content_type)
issue.status = issue_status
issue.save()
return marketplace_models.OrderItem.objects.first()
def process_order(serialized_order, serialized_user):
order = core_utils.deserialize_instance(serialized_order)
user = core_utils.deserialize_instance(serialized_user)
for item in order.items.all():
process_order_item(item, user)
