def setUp(self):
self.expert_fixture = structure_fixtures.ProjectFixture()
self.expert_manager = self.expert_fixture.owner
self.expert_provider = factories.ExpertProviderFactory(
customer=self.expert_fixture.customer)
self.project_fixture = structure_fixtures.ProjectFixture()
self.project = self.project_fixture.project
self.expert_request = factories.ExpertRequestFactory(
project=self.project)
self.expert = self.project_fixture.admin
def submit_public_and_private(self, role):
provider_fixture = fixtures.ProjectFixture()
consumer_fixture = fixtures.ProjectFixture()
service = structure_factories.TestServiceFactory(
settings=self.service_settings, customer=consumer_fixture.customer
)
structure_factories.TestServiceProjectLinkFactory(
service=service, project=consumer_fixture.project
)
private_offering = factories.OfferingFactory(
state=models.Offering.States.ACTIVE,
shared=False,
billable=False,
customer=provider_fixture.customer,
type='TEST_TYPE',
scope=self.service_settings,
)
private_offering.allowed_customers.add(consumer_fixture.customer)
public_offering = factories.OfferingFactory(
state=models.Offering.States.ACTIVE,
shared=True,
billable=True,
customer=provider_fixture.customer,
type='TEST_TYPE',
scope=self.service_settings,
)
public_offering.allowed_customers.add(consumer_fixture.customer)
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 setUp(self):
self.project_fixture = structure_fixtures.ProjectFixture()
self.project_manager = self.project_fixture.manager
self.customer_owner = self.project_fixture.owner
self.project = self.project_fixture.project
self.expert_fixture = structure_fixtures.ProjectFixture()
self.expert_provider = factories.ExpertProviderFactory(customer=self.expert_fixture.customer)
self.expert_manager = self.expert_fixture.owner
self.backend_patcher = mock.patch('waldur_mastermind.support.backend.get_active_backend')
self.backend_patcher.start()
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 setUp(self):
self.fixture = fixtures.ProjectFixture()
self.admin = self.fixture.admin
self.manager = self.fixture.manager
self.project = self.fixture.project
self.url = factories.ProjectFactory.get_url(self.project,
action='users')
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 setUp(self):
self.fixture = structure_fixtures.ProjectFixture()
self.offering = factories.OfferingFactory(
shared=True, customer=self.fixture.customer)
OfferingUser.objects.create(offering=self.offering,
user=self.fixture.user,
username='******')
def test_cart_item_limits_are_propagated_to_order_item(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.USAGE)
payload = {
'offering': factories.OfferingFactory.get_url(offering),
'plan': factories.PlanFactory.get_url(plan),
'limits': limits,
}
fixture = fixtures.ProjectFixture()
self.client.force_authenticate(fixture.staff)
url = factories.CartItemFactory.get_list_url()
response = self.client.post(url, payload)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
response = self.submit(fixture.project)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
order_item = models.OrderItem.objects.last()
self.assertEqual(order_item.limits['cpu_count'], 5)
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.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 setUp(self):
self.fixture = fixtures.ProjectFixture()
self.customer = self.fixture.customer
self.provider = factories.ServiceProviderFactory(
customer=self.customer)
self.category = factories.CategoryFactory()
self.url = factories.CategoryFactory.get_url(self.category)
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_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 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.offering = factories.OfferingFactory()
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 = factories.OrderItemFactory(order=self.order)
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 create_offering(self, components=True):
fixture = structure_fixtures.ProjectFixture()
url = marketplace_factories.OfferingFactory.get_list_url()
self.client.force_authenticate(fixture.owner)
payload = {
'name': 'offering',
'category': marketplace_factories.CategoryFactory.get_url(self.category),
'customer': structure_factories.CustomerFactory.get_url(fixture.customer),
'type': PACKAGE_TYPE,
'service_attributes': {
'backend_url': 'http://example.com/',
'username': '******',
'password': '******',
'tenant_name': 'admin',
'external_network_id': uuid.uuid4(),
},
'plans': [
{
'name': 'small',
'description': 'CPU 1',
'unit': UnitPriceMixin.Units.PER_DAY,
'unit_price': 1010100,
}
],
}
if components:
payload['plans'][0]['prices'] = self.prices
payload['plans'][0]['quotas'] = self.quotas
with mock.patch('waldur_core.structure.models.ServiceSettings.get_backend'):
return self.client.post(url, payload)
def setUp(self):
self.fixture = fixtures.ProjectFixture()
self.offering = factories.OfferingFactory(
shared=True, customer=self.fixture.customer
)
self.permission = factories.OfferingPermissionFactory(offering=self.offering)
self.url = factories.OfferingPermissionFactory.get_url(self.permission)
def test_order_gets_approved_if_all_offerings_are_private(self, role, mocked_task):
fixture = fixtures.ProjectFixture()
service = structure_factories.TestServiceFactory(
settings=self.service_settings, customer=fixture.customer
)
structure_factories.TestServiceProjectLinkFactory(
service=service, project=fixture.project
)
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 setUp(self):
self.fixture = fixtures.ProjectFixture()
self.customer = self.fixture.customer
factories.ServiceProviderFactory(customer=self.customer)
self.offering = factories.OfferingFactory(customer=self.customer, shared=True)
self.url = factories.OfferingFactory.get_url(self.offering)
def test_limits_are_not_allowed_for_components_with_disabled_quotas(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.USAGE,
disable_quotas=True,
)
payload = {
'offering': factories.OfferingFactory.get_url(offering),
'plan': factories.PlanFactory.get_url(plan),
'limits': limits,
}
fixture = fixtures.ProjectFixture()
self.client.force_authenticate(fixture.staff)
url = factories.CartItemFactory.get_list_url()
response = self.client.post(url, payload)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_order_item_set_state_done_if_offering_set_state_ok(self):
fixture = fixtures.ProjectFixture()
offering = support_factories.OfferingFactory()
resource = marketplace_factories.ResourceFactory(
project=fixture.project, scope=offering)
order_item = marketplace_factories.OrderItemFactory(resource=resource)
order_item.set_state_executing()
order_item.save()
order_item.order.state = marketplace_models.Order.States.EXECUTING
order_item.order.save()
offering.state = support_models.Offering.States.OK
offering.save()
order_item.refresh_from_db()
self.assertEqual(order_item.state, order_item.States.DONE)
order_item.resource.refresh_from_db()
self.assertEqual(order_item.resource.state,
marketplace_models.Resource.States.OK)
order_item.order.refresh_from_db()
self.assertEqual(order_item.order.state,
marketplace_models.Order.States.DONE)
def test_private_offerings_are_available_for_users_in_allowed_projects(self):
fixture = fixtures.ProjectFixture()
self.offering.allowed_customers.add(fixture.customer)
self.client.force_authenticate(fixture.manager)
response = self.client.get(self.url)
self.assertEqual(len(response.data), 1)
def setUp(self):
self.fixture = fixtures.ProjectFixture()
self.customer = self.fixture.customer
self.provider = factories.ServiceProviderFactory(
customer=self.customer)
self.offering = factories.OfferingFactory(customer=self.customer)
self.screenshot = factories.ScreenshotFactory(offering=self.offering)
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 test_other_expert_manager_can_not_see_expert_bid(self):
fixture = structure_fixtures.ProjectFixture()
factories.ExpertProviderFactory(customer=fixture.customer)
self.client.force_authenticate(fixture.owner)
response = self.client.get(factories.ExpertBidFactory.get_list_url())
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 0)
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 setUp(self):
fixture = fixtures.ProjectFixture()
self.customer1 = fixture.customer
self.project1 = fixture.project
self.staff = fixture.staff
self.owner1 = fixture.owner
self.manager1 = fixture.manager
fixture2 = fixtures.ProjectFixture()
self.customer2 = fixture2.customer
self.project2 = fixture2.project
self.owner2 = fixture2.owner
self.manager2 = fixture2.manager
self.client.force_authenticate(self.staff)
self.url = factories.UserFactory.get_list_url()
def setUp(self):
self.fixture = structure_fixtures.ProjectFixture()
self.offering = factories.OfferingFactory(
shared=True, customer=self.fixture.customer)
self.offering.secret_options[
'service_provider_can_create_offering_user'] = True
self.offering.save()
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)
