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)