def setUp(self): self.fixture = ServiceFixture() self.project = self.fixture.project self.resource = marketplace_factories.ResourceFactory( project=self.project) self.resource.scope = self.fixture.volume self.resource.save() resource_offering = self.resource.offering resource_offering.scope = self.fixture.service_settings resource_offering.save() self.order = marketplace_factories.OrderFactory(project=self.project) marketplace_factories.OrderItemFactory(resource=self.resource, order=self.order) self.new_project = structure_factories.ProjectFactory() self.start_invoice = invoices_factories.InvoiceFactory( customer=self.project.customer, year=2020, month=1, state=invoices_models.Invoice.States.PENDING, ) invoices_factories.InvoiceItemFactory( invoice=self.start_invoice, project=self.project, resource=self.resource, ) self.target_invoice = invoices_factories.InvoiceFactory( customer=self.new_project.customer, year=2020, month=1, state=invoices_models.Invoice.States.PENDING, )
def trigger_resource_creation(self, **kwargs): fixture = azure_fixtures.AzureFixture() service_settings = fixture.settings attributes = { 'name': 'database-server', 'location': azure_factories.LocationFactory.get_url(), } attributes.update(kwargs) offering = marketplace_factories.OfferingFactory( type=SQL_SERVER_TYPE, scope=service_settings) order = marketplace_factories.OrderFactory( project=fixture.project, state=marketplace_models.Order.States.EXECUTING, ) order_item = marketplace_factories.OrderItemFactory( offering=offering, attributes=attributes, order=order, ) 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) order_item.refresh_from_db() return order_item
def setUp(self): fixture = slurm_fixtures.SlurmFixture() service_settings = fixture.service.settings offering = marketplace_factories.OfferingFactory( type=PLUGIN_NAME, scope=service_settings) plan = marketplace_factories.PlanFactory(offering=offering) order = marketplace_factories.OrderFactory( project=fixture.project, state=marketplace_models.Order.States.EXECUTING) order_item = marketplace_factories.OrderItemFactory( order=order, offering=offering, limits={ component.type: 10 for component in manager.get_components(PLUGIN_NAME) }) for component in manager.get_components(PLUGIN_NAME): component = marketplace_models.OfferingComponent.objects.create( offering=offering, type=component.type, name=component.name, measured_unit=component.measured_unit, ) marketplace_models.PlanComponent.objects.create( plan=plan, component=component, ) # Create SPL fixture.spl self.fixture = fixture self.order_item = order_item self.offering = offering
def setUp(self): self.fixture = fixtures.ProjectFixture() self.project = self.fixture.project self.manager = self.fixture.manager self.order = factories.OrderFactory(project=self.project, created_by=self.manager) self.url = factories.OrderFactory.get_url(self.order, 'approve')
def test_when_order_item_is_approved_openstack_tenant_is_created(self): # Arrange fixture = package_fixtures.PackageFixture() offering = marketplace_factories.OfferingFactory( scope=fixture.openstack_service_settings, type=PLUGIN_NAME) order = marketplace_factories.OrderFactory( state=marketplace_models.Order.States.REQUESTED_FOR_APPROVAL, project=fixture.project, ) plan = marketplace_factories.PlanFactory( scope=fixture.openstack_template) attributes = dict( name='My first VPC', description='Database cluster', user_username='******', ) order_item = marketplace_factories.OrderItemFactory( order=order, offering=offering, attributes=attributes, plan=plan) serialized_order = core_utils.serialize_instance(order) serialized_user = core_utils.serialize_instance(fixture.staff) marketplace_tasks.process_order(serialized_order, serialized_user) # Assert order_item.refresh_from_db() self.assertTrue(isinstance(order_item.scope, openstack_models.Tenant))
def trigger_virtual_machine_creation(self, **kwargs): fixture = azure_fixtures.AzureFixture() service_settings = fixture.settings azure_models.SizeAvailabilityZone.objects.create( size=fixture.size, location=fixture.location, zone=1) attributes = { 'size': azure_factories.SizeFactory.get_url(fixture.size), 'image': azure_factories.ImageFactory.get_url(fixture.image), 'name': 'virtual-machine', 'location': azure_factories.LocationFactory.get_url(fixture.location), } attributes.update(kwargs) offering = marketplace_factories.OfferingFactory( type=VIRTUAL_MACHINE_TYPE, scope=service_settings) order = marketplace_factories.OrderFactory( project=fixture.project, state=marketplace_models.Order.States.EXECUTING, ) order_item = marketplace_factories.OrderItemFactory( offering=offering, attributes=attributes, order=order, ) 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) order_item.refresh_from_db() return order_item
def setUp(self): self.fixture = structure_fixtures.ProjectFixture() self.project = self.fixture.project self.manager = self.fixture.manager self.order = factories.OrderFactory(project=self.project, created_by=self.manager) self.offering = factories.OfferingFactory()
def test_when_order_item_is_approved_openstack_tenant_is_created(self): # Arrange order = marketplace_factories.OrderFactory( state=marketplace_models.Order.States.REQUESTED_FOR_APPROVAL, project=self.fixture.project, ) attributes = dict( name='My first VPC', description='Database cluster', user_username='******', ) order_item = marketplace_factories.OrderItemFactory( order=order, offering=self.offering, attributes=attributes, plan=self.plan) serialized_order = core_utils.serialize_instance(order) serialized_user = core_utils.serialize_instance(self.fixture.staff) marketplace_tasks.process_order(serialized_order, serialized_user) # Assert order_item.refresh_from_db() self.assertTrue( isinstance(order_item.resource.scope, openstack_models.Tenant))
def setUp(self): self.fixture = structure_fixtures.ProjectFixture() self.project = self.fixture.project self.manager = self.fixture.manager self.order = factories.OrderFactory(project=self.project, created_by=self.manager) self.order_item = factories.OrderItemFactory(order=self.order)
def setUp(self): self.tenant = openstack_factories.TenantFactory() self.project = self.tenant.service_project_link.project self.resource = marketplace_factories.ResourceFactory( project=self.project) self.resource.scope = self.tenant self.resource.save() self.order = marketplace_factories.OrderFactory(project=self.project) marketplace_factories.OrderItemFactory(resource=self.resource, order=self.order) self.new_project = structure_factories.ProjectFactory() self.start_invoice = invoices_factories.InvoiceFactory( customer=self.project.customer, year=2020, month=1, state=invoices_models.Invoice.States.PENDING, ) invoices_factories.InvoiceItemFactory( invoice=self.start_invoice, project=self.project, scope=self.resource, ) self.target_invoice = invoices_factories.InvoiceFactory( customer=self.new_project.customer, year=2020, month=1, state=invoices_models.Invoice.States.PENDING, )
def setUp(self): self.fixture = fixtures.ProjectFixture() self.project = self.fixture.project self.manager = self.fixture.manager self.order = factories.OrderFactory(project=self.project, created_by=self.manager) self.order_item_1 = factories.OrderItemFactory(order=self.order) self.order_item_2 = factories.OrderItemFactory(order=self.order) self.url = factories.OrderFactory.get_url(self.order, 'reject')
def setUp(self): self.fixture = package_fixtures.PackageFixture() self.offering = marketplace_factories.OfferingFactory(type=PACKAGE_TYPE) self.order = marketplace_factories.OrderFactory(project=self.fixture.project) self.order_item = marketplace_factories.OrderItemFactory( order=self.order, offering=self.offering, attributes=dict(user_username='******', user_userpassword='******'), )
def test_resource_is_created_when_order_item_is_processed(self): service_settings = rancher_factories.RancherServiceSettingsFactory() offering = marketplace_factories.OfferingFactory( type=PLUGIN_NAME, scope=service_settings) openstack_tenant_factories.FlavorFactory( settings=self.fixture.openstack_tenant_service_settings, ram=1024 * 8, cores=8, ) image = openstack_tenant_factories.ImageFactory( settings=self.fixture.openstack_tenant_service_settings) openstack_tenant_factories.SecurityGroupFactory( name='default', settings=self.fixture.openstack_tenant_service_settings) service_settings.options['base_image_name'] = image.name service_settings.save() order = marketplace_factories.OrderFactory( project=self.fixture.project, created_by=self.fixture.owner) ssh_public_key = SshPublicKeyFactory(user=self.fixture.staff) order_item = marketplace_factories.OrderItemFactory( order=order, offering=offering, attributes={ 'name': 'name', 'tenant_settings': openstack_tenant_factories. OpenStackTenantServiceSettingsFactory.get_url( self.fixture.openstack_tenant_service_settings), 'project': ProjectFactory.get_url(self.fixture.project), 'ssh_public_key': SshPublicKeyFactory.get_url(ssh_public_key), 'nodes': [{ 'subnet': openstack_tenant_factories.SubNetFactory.get_url( self.fixture.subnet), 'system_volume_size': 1024, 'memory': 1, 'cpu': 1, 'roles': ['controlplane', 'etcd', 'worker'], }], }, ) serialized_order = core_utils.serialize_instance(order_item.order) serialized_user = core_utils.serialize_instance(self.fixture.staff) marketplace_tasks.process_order(serialized_order, serialized_user) self.assertTrue( marketplace_models.Resource.objects.filter(name='name').exists()) self.assertTrue( rancher_models.Cluster.objects.filter(name='name').exists())
def setUp(self): self.fixture = structure_fixtures.ProjectFixture() self.project = self.fixture.project self.manager = self.fixture.manager self.offering = factories.OfferingFactory( type='Support.OfferingTemplate') self.order = factories.OrderFactory(project=self.project, created_by=self.manager) self.order_item = factories.OrderItemFactory(order=self.order, offering=self.offering)
def setUp(self): self.fixture = azure_fixtures.AzureFixture() self.virtual_machine = self.fixture.virtual_machine self.offering = marketplace_factories.OfferingFactory(type=VIRTUAL_MACHINE_TYPE) self.resource = marketplace_factories.ResourceFactory(scope=self.virtual_machine, 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): self.fixture = azure_fixtures.AzureFixture() self.sql_server = self.fixture.sql_server self.offering = marketplace_factories.OfferingFactory(type=SQL_SERVER_TYPE) self.resource = marketplace_factories.ResourceFactory(scope=self.sql_server, 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): self.fixture = openstack_tenant_fixtures.OpenStackTenantFixture() self.instance = self.fixture.instance self.offering = marketplace_factories.OfferingFactory(type=INSTANCE_TYPE) self.resource = marketplace_factories.ResourceFactory(scope=self.instance, 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): self.fixture = slurm_fixtures.SlurmFixture() self.allocation = self.fixture.allocation self.offering = marketplace_factories.OfferingFactory(type=PLUGIN_NAME) self.resource = marketplace_factories.ResourceFactory(scope=self.allocation, 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 trigger_instance_creation(self, **kwargs): image = openstack_tenant_factories.ImageFactory( settings=self.service_settings, min_disk=10240, min_ram=1024) flavor = openstack_tenant_factories.FlavorFactory( settings=self.service_settings) subnet_url = openstack_tenant_factories.SubNetFactory.get_url( self.fixture.subnet) attributes = { 'flavor': openstack_tenant_factories.FlavorFactory.get_url(flavor), 'image': openstack_tenant_factories.ImageFactory.get_url(image), 'name': 'Virtual machine', 'system_volume_size': image.min_disk, 'internal_ips_set': [{ 'subnet': subnet_url }], 'ssh_public_key': structure_factories.SshPublicKeyFactory.get_url( structure_factories.SshPublicKeyFactory( user=self.fixture.manager)), } attributes.update(kwargs) offering = marketplace_factories.OfferingFactory( type=INSTANCE_TYPE, scope=self.service_settings) marketplace_factories.OfferingFactory(type=VOLUME_TYPE, scope=self.service_settings) # Ensure that SPL exists self.fixture.spl order = marketplace_factories.OrderFactory( project=self.fixture.project, state=marketplace_models.Order.States.EXECUTING, ) order_item = marketplace_factories.OrderItemFactory( offering=offering, attributes=attributes, order=order, ) serialized_order = core_utils.serialize_instance(order_item.order) serialized_user = core_utils.serialize_instance(self.fixture.owner) marketplace_tasks.process_order(serialized_order, serialized_user) order_item.refresh_from_db() return order_item
def setUp(self): self.fixture = structure_fixtures.ProjectFixture() self.project = self.fixture.project self.manager = self.fixture.manager self.offering = factories.OfferingFactory( type='Support.OfferingTemplate', customer=self.fixture.customer) self.order = factories.OrderFactory(project=self.project, created_by=self.manager) resource = factories.ResourceFactory(offering=self.offering) self.order_item = factories.OrderItemFactory( resource=resource, order=self.order, offering=self.offering, state=models.OrderItem.States.EXECUTING, )
def update_resource_limits(self, resource, new_limits): order = marketplace_factories.OrderFactory( project=resource.project, state=marketplace_models.Order.States.EXECUTING, ) order_item = marketplace_factories.OrderItemFactory( order=order, offering=self.offering, resource=resource, type=marketplace_models.OrderItem.Types.UPDATE, state=marketplace_models.OrderItem.States.EXECUTING, limits=new_limits, ) resource_limit_update_succeeded.send(sender=resource.__class__, order_item=order_item)
def setUp(self): super(TenantMutateTest, self).setUp() self.fixture = package_fixtures.MarketplaceOpenStackFixture() self.tenant = self.fixture.openstack_tenant self.offering = marketplace_factories.OfferingFactory(type=TENANT_TYPE) self.plan = marketplace_factories.PlanFactory(offering=self.offering) self.resource = marketplace_factories.ResourceFactory( scope=self.tenant, offering=self.offering, plan=self.plan, project=self.fixture.project, ) self.order = marketplace_factories.OrderFactory( project=self.fixture.project, state=marketplace_models.Order.States.EXECUTING, )
def test_resource_is_created_when_order_item_is_processed(self): service = rancher_factories.RancherServiceFactory( customer=self.fixture.customer) spl = rancher_factories.RancherServiceProjectLinkFactory( project=self.fixture.project, service=service) service_settings = spl.service.settings offering = marketplace_factories.OfferingFactory( type=PLUGIN_NAME, scope=service_settings) openstack_tenant_factories.FlavorFactory( settings=self.fixture.spl.service.settings) 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() order = marketplace_factories.OrderFactory( project=self.fixture.project, created_by=self.fixture.owner) order_item = marketplace_factories.OrderItemFactory( order=order, offering=offering, attributes={ 'name': 'name', 'nodes': [{ 'subnet': openstack_tenant_factories.SubNetFactory.get_url( self.fixture.subnet), 'storage': 1024, 'memory': 1, 'cpu': 1, 'roles': ['controlplane', 'etcd', 'worker'] }], }) serialized_order = core_utils.serialize_instance(order_item.order) serialized_user = core_utils.serialize_instance(self.fixture.staff) marketplace_tasks.process_order(serialized_order, serialized_user) self.assertTrue( marketplace_models.Resource.objects.filter(name='name').exists()) self.assertTrue( rancher_models.Cluster.objects.filter(name='name').exists())
def test_update_invoice_if_added_new_offering(self): self.order_2 = marketplace_factories.OrderFactory( project=self.order_item.order.project) self.order_item_2 = marketplace_factories.OrderItemFactory( offering=self.offering, attributes={ 'name': 'item_name_2', 'description': 'Description_2' }, plan=self.order_item.plan, order=self.order_2) self.order_item_process(self.order_item_2) invoice = self.get_invoice() self.assertTrue(invoice.total) self.assertEqual( invoice.total, (self.plan_component.price * self.plan_component.amount) * 2)
def setUp(self): self.fixture = openstack_tenant_fixtures.OpenStackTenantFixture() self.volume = self.fixture.volume self.volume.runtime_state = 'available' self.volume.save() self.offering = marketplace_factories.OfferingFactory(type=VOLUME_TYPE) self.resource = marketplace_factories.ResourceFactory(scope=self.volume, 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(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 test_when_resource_is_updated_invoice_is_updated(self): marketplace_signals.resource_creation_succeeded.send( sender=self.resource.__class__, instance=self.resource, ) self.resource.limits = { RAM_TYPE: 10 * 1024, CORES_TYPE: 20, STORAGE_TYPE: 30 * 1024, } self.resource.save() order = marketplace_factories.OrderFactory( project=self.resource.project, state=marketplace_models.Order.States.EXECUTING, ) order_item = marketplace_factories.OrderItemFactory( order=order, offering=self.offering, resource=self.resource, state=marketplace_models.OrderItem.States.EXECUTING, limits=self.resource.limits, ) marketplace_signals.limit_update_succeeded.send( sender=self.resource.__class__, order_item=order_item, ) invoice_items = invoices_models.InvoiceItem.objects.filter( scope=self.resource) self.assertEqual(invoice_items.count(), 2) self.assertNotEqual(invoice_items.last().unit_price, invoice_items.first().unit_price) self.assertEqual( invoice_items.last().unit_price, self.resource.limits[RAM_TYPE] * self.prices[RAM_TYPE] / 1024 + self.resource.limits[CORES_TYPE] * self.prices[CORES_TYPE] + self.resource.limits[STORAGE_TYPE] * self.prices[STORAGE_TYPE] / 1024, )
def order(self): return marketplace_factories.OrderFactory( state=marketplace_models.Order.States.EXECUTING, project=self.project)
def _create_usage(self, mock_executors): order = marketplace_factories.OrderFactory( project=self.fixture.project, created_by=self.fixture.owner) order_item = marketplace_factories.OrderItemFactory( order=order, offering=self.offering, attributes={ 'name': 'name', 'tenant_settings': openstack_tenant_factories. OpenStackTenantServiceSettingsFactory.get_url( self.fixture.openstack_tenant_service_settings), 'nodes': [{ 'subnet': openstack_tenant_factories.SubNetFactory.get_url( self.fixture.subnet), 'system_volume_size': 1024, 'memory': 1, 'cpu': 1, 'roles': ['controlplane', 'etcd', 'worker'], }], }, ) serialized_order = core_utils.serialize_instance(order_item.order) serialized_user = core_utils.serialize_instance(self.fixture.staff) marketplace_tasks.process_order(serialized_order, serialized_user) self.assertTrue( marketplace_models.Resource.objects.filter(name='name').exists()) self.assertTrue( rancher_models.Cluster.objects.filter(name='name').exists()) self.cluster = rancher_models.Cluster.objects.get(name='name') self.cluster.backend_id = 'cluster_backend_id' self.cluster.save() create_node_task = tasks.CreateNodeTask() create_node_task.execute( mock_executors.ClusterCreateExecutor.execute.mock_calls[0][1] [0].node_set.first(), user_id=mock_executors.ClusterCreateExecutor.execute.mock_calls[0] [2]['user'].id, ) self.assertTrue( self.cluster.node_set.filter(cluster=self.cluster).exists()) today = datetime.date.today() self.resource = marketplace_models.Resource.objects.get( scope=self.cluster) self.plan_period = marketplace_models.ResourcePlanPeriod.objects.create( start=today, end=None, resource=self.resource, plan=self.plan, ) invoices_tasks.create_monthly_invoices() tasks.pull_cluster_nodes(self.cluster.id) utils.update_cluster_nodes_states(self.cluster.id)
def order(self): return marketplace_factories.OrderFactory(project=self.project)