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.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.offering = marketplace_factories.OfferingFactory(
type=PLUGIN_NAME, options={'order': []}
)
self.service_provider = marketplace_factories.ServiceProviderFactory(
customer=self.offering.customer, lead_email='*****@*****.**'
)
def setUp(self):
self.fixture = fixtures.ProjectFixture()
service_provider = marketplace_factories.ServiceProviderFactory(
customer=self.fixture.customer)
google_credentials = google_factories.GoogleCredentialsFactory(
service_provider=service_provider)
self.url = factories.GoogleCredentialsFactory.get_url(
google_credentials)
def setUp(self):
super(InvoicesTest, self).setUp()
self.fixture = fixtures.SupportFixture()
self.order_item = self.fixture.order_item
marketplace_factories.ServiceProviderFactory(
customer=self.order_item.offering.customer,
description='ServiceProvider\'s description')
self.order_item_process(self.order_item)
def test_google_calendar_sync_validators(self):
marketplace_factories.ServiceProviderFactory(
customer=self.offering.customer)
self.client.force_authenticate(self.fixture.staff)
response = self.client.post(
f'/api/marketplace-bookings/{self.offering.uuid.hex}/google_calendar_sync/'
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_filter_customer_keyword(self):
list_url = factories.ServiceProviderFactory.get_list_url()
provider_1 = factories.ServiceProviderFactory()
factories.ServiceProviderFactory()
provider_1.customer.name = 'It is test_name.'
provider_1.customer.abbreviation = 'test abbr'
provider_1.customer.save()
self.client.force_authenticate(self.fixture1.staff)
response = self.client.get(list_url, {'customer_keyword': 'test_name'})
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual(1, len(response.data))
self.assertEqual(response.data[0]['uuid'], provider_1.uuid.hex)
response = self.client.get(list_url, {'customer_keyword': 'abbr'})
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual(1, len(response.data))
self.assertEqual(response.data[0]['uuid'], provider_1.uuid.hex)
def setUp(self):
self.fixture = structure_fixtures.CustomerFixture()
self.service_provider = marketplace_factories.ServiceProviderFactory(
customer=self.fixture.customer)
self.credentials = factories.GoogleCredentialsFactory(
service_provider=self.service_provider,
calendar_token='calendar_token',
calendar_refresh_token='calendar_refresh_token',
)
self.url = factories.GoogleCredentialsFactory.get_authorize_url(
self.credentials)
def setUp(self):
self.service_provider = factories.ServiceProviderFactory()
self.secret_code = self.service_provider.api_secret_code
self.plan = factories.PlanFactory(unit=UnitPriceMixin.Units.PER_DAY)
self.offering_component = factories.OfferingComponentFactory(
offering=self.plan.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.plan.offering,
plan=self.plan,
project=structure_factories.ProjectFactory())
def test_user_can_sync_bookings_to_calendar(self, user):
service_provider = marketplace_factories.ServiceProviderFactory(
customer=self.offering.customer)
google_factories.GoogleCredentialsFactory(
service_provider=service_provider,
calendar_token='calendar_token',
calendar_refresh_token='calendar_refresh_token',
)
self.client.force_authenticate(getattr(self.fixture, user))
response = self.client.post(
f'/api/marketplace-bookings/{self.offering.uuid.hex}/google_calendar_sync/'
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_item_details(self):
sp = factories.ServiceProviderFactory(
customer=self.resource.offering.customer)
component = factories.OfferingComponentFactory(
offering=self.resource.offering,
billing_type=models.OfferingComponent.BillingTypes.LIMIT,
type='storage',
)
factories.ComponentUsageFactory(
resource=self.resource,
billing_period=core_utils.month_start(timezone.now()),
component=component,
)
item = self._create_items().first()
self.assertDictEqual(
item.details,
{
'resource_name':
item.resource.name,
'resource_uuid':
item.resource.uuid.hex,
'service_provider_name':
self.resource.offering.customer.name,
'service_provider_uuid':
sp.uuid.hex,
'offering_name':
self.offering.name,
'offering_type':
TENANT_TYPE,
'offering_uuid':
self.offering.uuid.hex,
'plan_name':
self.resource.plan.name,
'plan_uuid':
self.resource.plan.uuid.hex,
'plan_component_id':
self.plan_component.id,
'offering_component_type':
self.plan_component.component.type,
'offering_component_name':
self.plan_component.component.name,
'resource_limit_periods': [{
'end': '2020-03-31T23:59:59.999999+00:00',
'start': '2020-03-01T00:00:00+00:00',
'total': '31',
'quantity': 1,
'billing_periods': 31,
}],
},
)
def test_bookings_sync(self, mock_build):
mock_build().events().list().execute().get.return_value = []
service_provider = marketplace_factories.ServiceProviderFactory(
customer=self.offering.customer)
google_factories.GoogleCredentialsFactory(
service_provider=service_provider)
sync_bookings = calendar.SyncBookings(self.offering)
need_to_add, need_to_delete, need_to_update = sync_bookings.get_bookings(
)
self.assertEqual(len(need_to_add), 1)
self.assertEqual(need_to_add[0].id, self.schedules[1]['id'])
self.assertEqual(len(need_to_delete), 0)
self.assertEqual(len(need_to_update), 0)
mock_build().events().list().execute().get.return_value = [{
'start': {
'dateTime': self.schedules[1]['start']
},
'end': {
'dateTime': self.schedules[1]['end']
},
'id':
self.schedules[1]['id'],
}]
self.resource_2.attributes['schedules'][0][
'start'] = '2020-03-02T02:00:00+03:00'
self.resource_2.save()
need_to_add, need_to_delete, need_to_update = sync_bookings.get_bookings(
)
self.assertEqual(len(need_to_add), 0)
self.assertEqual(len(need_to_delete), 0)
self.assertEqual(len(need_to_update), 1)
self.assertEqual(need_to_update[0].id, self.schedules[1]['id'])
self.resource_2.attributes['schedules'][0][
'start'] = '2020-02-02T02:00:00+03:00'
self.resource_2.save()
need_to_add, need_to_delete, need_to_update = sync_bookings.get_bookings(
)
self.assertEqual(len(need_to_add), 0)
self.assertEqual(len(need_to_delete), 1)
self.assertEqual(need_to_delete.pop(), self.schedules[1]['id'])
self.assertEqual(len(need_to_update), 0)
def service_provider(self):
return marketplace_factories.ServiceProviderFactory(
customer=self.order_item.offering.customer,
description='ServiceProvider\'s description',
)
def provider(self):
return marketplace_factories.ServiceProviderFactory(
customer=self.provider_customer)
