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 setUp(self):
self.fixture1 = structure_fixtures.ServiceFixture()
self.service_provider1 = self.fixture1.customer
self.offering1 = factories.OfferingFactory(
customer=self.service_provider1)
self.resource1 = factories.ResourceFactory(
offering=self.offering1, project=self.fixture1.project)
self.fixture2 = structure_fixtures.ServiceFixture()
self.service_provider2 = self.fixture2.customer
factories.OfferingFactory(customer=self.service_provider2)
def submit_public_and_private(self, role):
provider_fixture = fixtures.ProjectFixture()
consumer_fixture = fixtures.ProjectFixture()
private_offering = factories.OfferingFactory(
state=models.Offering.States.ACTIVE,
shared=False,
billable=False,
customer=provider_fixture.customer,
type='TEST_TYPE',
scope=self.service_settings,
project=consumer_fixture.project,
)
public_offering = factories.OfferingFactory(
state=models.Offering.States.ACTIVE,
shared=True,
billable=True,
customer=provider_fixture.customer,
type='TEST_TYPE',
scope=self.service_settings,
)
self.client.force_authenticate(getattr(consumer_fixture, role))
self.client.post(
factories.CartItemFactory.get_list_url(),
{
'offering':
factories.OfferingFactory.get_url(private_offering),
'project':
structure_factories.ProjectFactory.get_url(
consumer_fixture.project),
'attributes': {
'name': 'test'
},
},
)
self.client.post(
factories.CartItemFactory.get_list_url(),
{
'offering':
factories.OfferingFactory.get_url(public_offering),
'project':
structure_factories.ProjectFactory.get_url(
consumer_fixture.project),
'attributes': {
'name': 'test'
},
},
)
return self.submit(consumer_fixture.project)
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):
fixture = package_fixtures.OpenStackFixture()
offering = marketplace_factories.OfferingFactory(
type=PACKAGE_TYPE, scope=fixture.openstack_service_settings
)
create_offering_components(offering)
for name in 'Basic', 'Advanced':
plan = marketplace_factories.PlanFactory(offering=offering, name=name)
prices = {
CORES_TYPE: 1,
RAM_TYPE: 0.1,
STORAGE_TYPE: 0.01,
}
for key, value in prices.items():
component = marketplace_models.OfferingComponent.objects.get(
offering=offering, type=key,
)
marketplace_models.PlanComponent.objects.create(
plan=plan, component=component, price=value,
)
resource = marketplace_factories.ResourceFactory(
offering=offering, plan=plan,
)
marketplace_factories.OrderItemFactory(
offering=offering, plan=plan, resource=resource,
)
self.offering = offering
def setUp(self):
fixture = structure_fixtures.ProjectFixture()
service_settings = structure_factories.ServiceSettingsFactory(type='SLURM')
offering = marketplace_factories.OfferingFactory(type=PLUGIN_NAME, scope=service_settings)
plan = marketplace_factories.PlanFactory(offering=offering)
self.allocation = slurm_factories.AllocationFactory()
self.resource = marketplace_models.Resource.objects.create(
scope=self.allocation,
offering=offering,
plan=plan,
project=fixture.project,
)
self.plan_period = marketplace_models.ResourcePlanPeriod.objects.create(
resource=self.resource,
plan=plan,
start=timezone.make_aware(datetime.datetime.now())
)
for component in manager.get_components(PLUGIN_NAME):
offering_component = marketplace_models.OfferingComponent.objects.create(
offering=offering,
type=component.type,
name=component.name,
measured_unit=component.measured_unit,
billing_type=marketplace_models.OfferingComponent.BillingTypes.USAGE,
)
marketplace_models.PlanComponent.objects.create(
component=offering_component,
plan=plan,
price=3
)
marketplace_models.ResourcePlanPeriod.objects.create(
start=datetime.date(2017, 1, 1),
resource=self.resource,
plan=plan)
def test_add_backlink_to_order_item_details_into_created_service_desk_ticket(
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'
})
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)
self.assertTrue(
support_models.Offering.objects.filter(name='item_name').exists())
offering = support_models.Offering.objects.get(name='item_name')
link_template = settings.WALDUR_MARKETPLACE['ORDER_ITEM_LINK_TEMPLATE']
order_item_url = link_template.format(
order_item_uuid=order_item.uuid,
project_uuid=order_item.order.project.uuid)
self.assertTrue(order_item_url in offering.issue.description)
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.fixture = fixtures.ProjectFixture()
self.project = self.fixture.project
self.user = self.fixture.admin
self.offering = marketplace_factories.OfferingFactory(
type=PLUGIN_NAME,
attributes={
'schedules': [
{
'start': '2018-11-01T00:00:00.000000Z',
'end': '2018-11-01T23:59:59.000000Z',
},
{
'start': '2019-01-01T00:00:00.000000Z',
'end': '2019-01-01T23:59:59.000000Z',
},
{
'start': '2019-01-02T00:00:00.000000Z',
'end': '2019-01-02T23:59:59.000000Z',
},
{
'start': '2019-01-03T00:00:00.000000Z',
'end': '2019-01-03T23:59:59.000000Z',
},
]
},
state=marketplace_models.Offering.States.ACTIVE,
)
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 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_volume_creation(self, **kwargs):
image = openstack_tenant_factories.ImageFactory(
settings=self.service_settings, min_disk=10240, min_ram=1024)
attributes = {
'image': openstack_tenant_factories.ImageFactory.get_url(image),
'name': 'Volume',
'size': 10 * 1024,
}
attributes.update(kwargs)
offering = marketplace_factories.OfferingFactory(
type=VOLUME_TYPE, scope=self.service_settings)
order_item = marketplace_factories.OrderItemFactory(
offering=offering,
attributes=attributes,
order__project=self.fixture.project,
)
order_item.order.approve()
order_item.order.save()
process_order(order_item.order, self.fixture.staff)
order_item.refresh_from_db()
return order_item
def test_order_gets_approved_if_all_offerings_are_private(
self, role, mocked_task):
fixture = fixtures.ProjectFixture()
offering = factories.OfferingFactory(
state=models.Offering.States.ACTIVE,
shared=False,
billable=False,
customer=fixture.customer,
type='TEST_TYPE',
scope=self.service_settings,
)
self.client.force_authenticate(getattr(fixture, role))
self.client.post(
factories.CartItemFactory.get_list_url(),
{
'offering':
factories.OfferingFactory.get_url(offering),
'project':
structure_factories.ProjectFactory.get_url(fixture.project),
'attributes': {
'name': 'test'
},
},
)
response = self.submit(fixture.project)
self.assertEqual(response.data['state'], 'executing')
mocked_task.delay.assert_not_called()
def test_create_confirmation_comment_if_offering_template_is_defined(self):
mock.patch.stopall()
fixture = fixtures.ProjectFixture()
offering = marketplace_factories.OfferingFactory(
type=PLUGIN_NAME,
options={'order': []},
secret_options={
'template_confirmation_comment':
'template_confirmation_comment'
},
)
order_item = marketplace_factories.OrderItemFactory(
offering=offering,
attributes={
'name': 'item_name',
'description': 'Description'
},
)
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)
self.mock_get_active_backend(
).create_confirmation_comment.assert_called_once_with(
mock.ANY, 'template_confirmation_comment')
def test_set_creation_ticket_id_as_backend_id_of_resource(self):
def mock_create_issue(issue):
issue.backend_id = 'WAL TEST'
issue.save()
self.mock_get_active_backend().create_issue = mock_create_issue
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'
},
)
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)
resource = marketplace_models.Resource.objects.get(name='item_name')
issue = support_models.Issue.objects.get(
resource_object_id=order_item.id)
self.assertEqual(issue.backend_id, resource.backend_id)
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 test_user_cannot_create_order_if_terms_of_service_have_been_not_accepted(
self):
user = self.fixture.admin
offering = factories.OfferingFactory(
state=models.Offering.States.ACTIVE)
offering.terms_of_service = 'Terms of service'
offering.save()
add_payload = {
'items': [
{
'offering': factories.OfferingFactory.get_url(offering),
'attributes': {},
},
]
}
response = self.create_order(user,
offering=offering,
add_payload=add_payload)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(
str(response.content, 'utf-8'),
'{"items":["Terms of service for offering \'%s\' have not been accepted."]}'
% offering,
)
self.assertFalse(models.Order.objects.filter(created_by=user).exists())
def test_user_can_not_create_order_with_invalid_limits(self):
limits = {
'storage': 1000,
'ram': 30,
'cpu_count': 5,
}
offering = factories.OfferingFactory(
state=models.Offering.States.ACTIVE)
plan = factories.PlanFactory(offering=offering)
for key in limits.keys():
models.OfferingComponent.objects.create(
offering=offering,
type=key,
billing_type=models.OfferingComponent.BillingTypes.FIXED,
)
add_payload = {
'items': [
{
'offering': factories.OfferingFactory.get_url(offering),
'plan': factories.PlanFactory.get_url(plan),
'limits': limits,
'attributes': {},
},
]
}
response = self.create_order(self.fixture.staff,
offering,
add_payload=add_payload)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def setUp(self):
super(VpcExternalFilterTest, self).setUp()
self.fixture = package_fixtures.OpenStackFixture()
self.offering = marketplace_factories.OfferingFactory(
category=self.tenant_category
)
self.url = marketplace_factories.OfferingFactory.get_list_url()
def trigger_volume_creation(self, **kwargs):
image = openstack_tenant_factories.ImageFactory(
settings=self.service_settings, min_disk=10240, min_ram=1024)
attributes = {
'image': openstack_tenant_factories.ImageFactory.get_url(image),
'name': 'Volume',
'size': 10 * 1024
}
attributes.update(kwargs)
offering = marketplace_factories.OfferingFactory(
type=VOLUME_TYPE, scope=self.service_settings)
order_item = marketplace_factories.OrderItemFactory(
offering=offering, attributes=attributes)
order_item.order.approve()
order_item.order.save()
service = openstack_tenant_models.OpenStackTenantService.objects.create(
customer=order_item.order.project.customer,
settings=self.service_settings,
)
openstack_tenant_models.OpenStackTenantServiceProjectLink.objects.create(
project=order_item.order.project,
service=service,
)
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)
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 = 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 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 setUp(self):
fixture = structure_fixtures.ProjectFixture()
offering = marketplace_factories.OfferingFactory(type=PLUGIN_NAME)
self.order_item = marketplace_factories.OrderItemFactory(
offering=offering,
attributes={
'schedules': [
{
'start': '2019-01-03T00:00:00.000000Z',
'end': '2019-01-05T23:59:59.000000Z',
},
],
'name':
'booking',
},
)
serialized_order = core_utils.serialize_instance(self.order_item.order)
serialized_user = core_utils.serialize_instance(fixture.staff)
marketplace_tasks.process_order(serialized_order, serialized_user)
self.resource = marketplace_models.Resource.objects.get(name='booking')
self.resource.state = marketplace_models.Resource.States.OK
self.resource.save()
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 setUp(self):
self.fixture = openstack_tenant_fixtures.OpenStackTenantFixture()
self.offering = marketplace_factories.OfferingFactory(
type=PACKAGE_TYPE)
self.plan = marketplace_factories.PlanFactory(offering=self.offering)
self.resource = marketplace_factories.ResourceFactory(
offering=self.offering,
project=self.fixture.project,
plan=self.plan,
state=marketplace_models.Resource.States.OK)
tenant = self.fixture.tenant
self.mock_get_backend = mock.MagicMock()
tenant.get_backend = self.mock_get_backend
self.resource.scope = tenant
self.resource.save()
self.quotas = {
'network_count': 100,
'cores': 4,
'ram': 1024,
'storage': 1024,
'snapshots': 50,
'instances': 30,
'floating_ip_count': 50,
'subnet_count': 100,
'volumes': 50,
'security_group_rule_count': 100,
'security_group_count': 100
}
def test_resource_is_created_when_order_item_is_processed(self):
fixture = fixtures.ProjectFixture()
offering = marketplace_factories.OfferingFactory(type=PLUGIN_NAME)
order_item = marketplace_factories.OrderItemFactory(
offering=offering,
attributes={
'name':
'item_name',
'description':
'Description',
'schedules': [{
'start': '2021-02-05T10:00:00.000000+00:00',
'end': '2021-02-05T15:00:00.000000+00:00',
}],
},
)
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)
self.assertTrue(
marketplace_models.Resource.objects.filter(
name='item_name').exists())
resource = marketplace_models.Resource.objects.get(name='item_name')
self.assertEqual(resource.state,
marketplace_models.Resource.States.CREATING)
def test_request_is_created_when_order_item_is_processed(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'
},
)
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)
self.assertTrue(
support_models.Offering.objects.filter(name='item_name').exists())
support_offering = support_models.Offering.objects.get(
name='item_name')
resource = marketplace_models.Resource.objects.get(
scope=support_offering)
order_item = marketplace_models.OrderItem.objects.get(
resource=resource)
self.assertTrue(
support_models.Issue.objects.filter(
resource_object_id=order_item.id).exists())
def setUp(self):
self.offering = marketplace_factories.OfferingFactory(
type=PLUGIN_NAME, options={'order': []}
)
self.service_provider = marketplace_factories.ServiceProviderFactory(
customer=self.offering.customer, lead_email='*****@*****.**'
)
