def test_new_resource_unlinked_immediately(self): vm = factories.TestNewInstanceFactory(state=NewResource.States.OK) url = factories.TestNewInstanceFactory.get_url(vm, 'unlink') response = self.client.post(url) self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT, response.data)
def test_vm_unlinked_immediately_anyway(self): vm = factories.TestNewInstanceFactory(state=States.UPDATING) url = factories.TestNewInstanceFactory.get_url(vm, 'unlink') response = self.client.post(url) self.assertEqual( response.status_code, status.HTTP_204_NO_CONTENT, response.data )
def test_price_estimate_of_resource_is_keeped_up_to_date(self): start_time = datetime.datetime(2016, 8, 8, 11, 0) with freeze_time(start_time): today = timezone.now() old_disk = 20 * 1024 resource = structure_factories.TestNewInstanceFactory( state=TestNewInstance.States.OK, runtime_state='online', disk=old_disk) price_estimate = models.PriceEstimate.objects.get( scope=resource, month=today.month, year=today.year) # after resource creation price estimate should be calculate for whole month month_end = datetime.datetime(2016, 8, 31, 23, 59, 59) expected = (int((month_end - start_time).total_seconds() / 60) * self.price_list_item.minute_rate * old_disk) self.assertAlmostEqual(price_estimate.total, expected) # after some time resource disk was updated - resource price should be recalculated change_time = datetime.datetime(2016, 8, 9, 13, 0) with freeze_time(change_time): new_disk = 40 * 1024 resource.disk = new_disk resource.save() price_estimate.refresh_from_db() expected = (int((change_time - start_time).total_seconds() / 60) * self.price_list_item.minute_rate * old_disk + int( (month_end - change_time).total_seconds() / 60) * self.price_list_item.minute_rate * new_disk) self.assertAlmostEqual(price_estimate.total, expected)
def test_if_resource_becomes_offline_start_time_is_resetted(self): vm = factories.TestNewInstanceFactory(runtime_state='paused', start_time=timezone.now()) vm.runtime_state = 'offline' vm.save() vm.refresh_from_db() self.assertEqual(vm.start_time, None)
def test_service_settings_should_be_disabled_if_offering_is_archived( self, ): marketplace_handlers.connect_resource_metadata_handlers( structure_tests_models.TestNewInstance) instance = structure_factories.TestNewInstanceFactory() resource: marketplace_models.Resource = factories.ResourceFactory( scope=instance) offering: marketplace_models.Offering = resource.offering service_settings = structure_factories.ServiceSettingsFactory() offering.scope = service_settings offering.save() resource.set_state_terminated() resource.save() service_settings.refresh_from_db() self.assertTrue(service_settings.is_active) offering.archive() offering.save() service_settings.refresh_from_db() self.assertFalse(service_settings.is_active)
def test_consumed_is_recalculated_properly_for_ancestors(self): with freeze_time(self.start_time): self.second_resource = structure_factories.TestNewInstanceFactory( disk=10 * 1024, service_project_link=self.spl) calculation_time = datetime.datetime(2016, 8, 8, 15, 0) with freeze_time(calculation_time): tasks.recalculate_estimate() price_estimates = [ models.PriceEstimate.objects.get_current(scope=ancestor) for ancestor in (self.customer, self.service, self.spl, self.project) ] working_minutes = (calculation_time - self.start_time).total_seconds() / 60 # each ancestor is connected with 2 resources expected = working_minutes * self.price_list_item.minute_rate * ( self.resource.disk + self.second_resource.disk) for price_estimate in price_estimates: message = 'Price estimate "consumed" is calculated wrongly for "%s". Real value: %s, expected: %s.' % ( price_estimate.scope, price_estimate.consumed, expected) self.assertAlmostEqual(price_estimate.consumed, expected, msg=message)
def test_when_virtual_machine_is_deleted_descendant_resources_unlinked(self): # Arrange vm = factories.TestNewInstanceFactory() settings = factories.ServiceSettingsFactory(scope=vm) service = factories.TestServiceFactory(settings=settings) link = factories.TestServiceProjectLinkFactory(service=service) child_vm = factories.TestNewInstanceFactory(service_project_link=link) other_vm = factories.TestNewInstanceFactory() # Act vm.delete() # Assert self.assertFalse(test_models.TestNewInstance.objects.filter(id=child_vm.id).exists()) self.assertFalse(test_models.TestService.objects.filter(id=service.id).exists()) self.assertFalse(ServiceSettings.objects.filter(id=settings.id).exists()) self.assertTrue(test_models.TestNewInstance.objects.filter(id=other_vm.id).exists())
def test_resource_can_be_filtered_by_tag(self): self.fixture.resource.tags.add('tag1') resource2 = factories.TestNewInstanceFactory(service_project_link=self.fixture.service_project_link) resource2.tags.add('tag2') url = factories.TestNewInstanceFactory.get_list_url() response = self.client.get(url, {'tag': 'tag1'}) self.assertEqual(len(response.data), 1)
def create_resource(self, customer, project): settings = factories.ServiceSettingsFactory(customer=customer) service = factories.TestServiceFactory(customer=customer, settings=settings) spl = factories.TestServiceProjectLinkFactory(service=service, project=project) resource = factories.TestNewInstanceFactory(service_project_link=spl) return resource
def test_if_runtime_state_changed_to_other_state_start_time_is_not_modified( self): vm = factories.TestNewInstanceFactory(runtime_state='online', start_time=None) vm.runtime_state = 'extending' vm.save() vm.refresh_from_db() self.assertEqual(vm.start_time, None)
def setUp(self): super(CustomerFilterTest, self).setUp() resource = structure_factories.TestNewInstanceFactory() link = resource.service_project_link customer = link.customer project = link.project service = link.service scopes = {link, customer, project, service, resource} self.estimates = { models.PriceEstimate.objects.get(scope=scope) for scope in scopes } self.customer = customer resource2 = structure_factories.TestNewInstanceFactory() resource2_estimate = factories.PriceEstimateFactory(scope=resource2) resource2_estimate.create_ancestors()
def test_task_does_not_set_coordinates_if_response_is_not_ok(self, mock_request_get): instance = factories.TestNewInstanceFactory() mock_request_get.return_value.ok = False tasks.detect_vm_coordinates(utils.serialize_instance(instance)) instance.refresh_from_db() self.assertIsNone(instance.latitude) self.assertIsNone(instance.longitude)
def instance(self): settings = structure_factories.ServiceSettingsFactory( customer=self.customer) service = structure_factories.TestServiceFactory( customer=self.customer, settings=settings) spl = structure_factories.TestServiceProjectLinkFactory( service=service, project=self.project) return structure_factories.TestNewInstanceFactory( service_project_link=spl)
def test_if_resource_becomes_online_start_time_is_initialized(self): now = timezone.now() with freeze_time(now): vm = factories.TestNewInstanceFactory(runtime_state='in-progress', start_time=None) vm.runtime_state = 'online' vm.save() vm.refresh_from_db() self.assertEqual(vm.start_time, now)
def test_marketplace_resource_name_should_be_updated_if_resource_name_in_plugin_is_updated( self, ): marketplace_handlers.connect_resource_metadata_handlers( structure_tests_models.TestNewInstance) instance = structure_factories.TestNewInstanceFactory() resource = factories.ResourceFactory(scope=instance) instance.name = 'New name' instance.save() resource.refresh_from_db() self.assertEqual(resource.name, 'New name')
def test_user_cannot_create_node_if_instance_is_not_available(self): self.client.force_authenticate(self.fixture.owner) cluster = self.fixture.cluster instance = structure_factories.TestNewInstanceFactory() response = self.client.post(self.node_url, {'cluster': factories.ClusterFactory.get_url(cluster), 'instance': structure_factories.TestNewInstanceFactory.get_url(instance), }) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) self.assertTrue('Can\'t restore object from' in response.data['instance'][0])
def setUp(self): plugins.manager.register( offering_type='TEST_TYPE', create_resource_processor=test_utils.TestCreateProcessor, ) self.fixture = fixtures.MarketplaceFixture() self.fixture.offering.type = 'TEST_TYPE' self.fixture.offering.save() self.url = factories.ResourceFactory.get_list_url() self.scope = structure_factories.TestNewInstanceFactory()
def test_when_service_is_unlinked_all_related_resources_are_unlinked_too( self): resource = factories.TestNewInstanceFactory() service = resource.service_project_link.service unlink_url = factories.TestServiceFactory.get_url(service, 'unlink') self.client.force_authenticate(factories.UserFactory(is_staff=True)) response = self.client.post(unlink_url) self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) self.assertRaises(models.ObjectDoesNotExist, service.refresh_from_db)
def test_stuck_resource_becomes_erred(self): with freeze_time(timezone.now() - timedelta(hours=4)): stuck_vm = factories.TestNewInstanceFactory(state=models.TestNewInstance.States.CREATING) stuck_volume = factories.TestVolumeFactory(state=models.TestVolume.States.CREATING) tasks.SetErredStuckResources().run() stuck_vm.refresh_from_db() stuck_volume.refresh_from_db() self.assertEqual(stuck_vm.state, models.TestNewInstance.States.ERRED) self.assertEqual(stuck_volume.state, models.TestVolume.States.ERRED)
def test_historical_estimates_are_initialized(self): creation_time = timezone.make_aware( datetime.datetime(2016, 7, 15, 11, 0)) import_time = timezone.make_aware(datetime.datetime(2016, 9, 2, 10, 0)) with freeze_time(import_time): resource = structure_factories.TestNewInstanceFactory( state=TestNewInstance.States.OK, runtime_state='online', disk=20 * 1024, created=creation_time, ) ancestors = [ resource.service_project_link, resource.service_project_link.service, resource.service_project_link.project, resource.service_project_link.project.customer, ] # signal should init estimates for resource and its ancestors for previous months for scope in [resource] + ancestors: self.assertTrue( models.PriceEstimate.objects.filter(scope=scope, month=7, year=2016)) self.assertTrue( models.PriceEstimate.objects.filter(scope=scope, month=8, year=2016)) # Check price estimates total calculation for month #7 month_end = timezone.make_aware( datetime.datetime(2016, 7, 31, 23, 59, 59)) work_minutes = int((month_end - creation_time).total_seconds() / 60) expected = work_minutes * self.price_list_item.minute_rate * resource.disk for scope in [resource] + ancestors: estimate = models.PriceEstimate.objects.get(scope=scope, month=7, year=2016) self.assertAlmostEqual(estimate.total, expected) # Check price estimates total calculation for month #8 month_start = timezone.make_aware(datetime.datetime(2016, 8, 1)) month_end = timezone.make_aware( datetime.datetime(2016, 8, 31, 23, 59, 59)) work_minutes = int((month_end - month_start).total_seconds() / 60) expected = work_minutes * self.price_list_item.minute_rate * resource.disk for scope in [resource] + ancestors: estimate = models.PriceEstimate.objects.get(scope=scope, month=8, year=2016) self.assertAlmostEqual(estimate.total, expected)
def test_visible_name_populated_from_scope(self): vm = structure_factories.TestNewInstanceFactory() data = { 'service_project_link': factories.ZabbixServiceProjectLinkFactory.get_url(self.spl), 'name': 'Valid host name', 'scope': structure_factories.TestNewInstanceFactory.get_url(vm), } response = self.client.post(factories.HostFactory.get_list_url(), data) self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.assertEqual(response.data['visible_name'], models.Host.get_visible_name_from_scope(vm))
def setUp(self): self.customer = factories.CustomerFactory() self.settings = factories.ServiceSettingsFactory(shared=True) self.service = factories.TestServiceFactory(customer=self.customer, settings=self.settings) self.user1 = factories.UserFactory() self.project1 = factories.ProjectFactory(customer=self.customer) self.project1.add_user(self.user1, ProjectRole.ADMINISTRATOR) self.spl1 = factories.TestServiceProjectLinkFactory( service=self.service, project=self.project1) self.vm1 = factories.TestNewInstanceFactory( service_project_link=self.spl1) self.user2 = factories.UserFactory() self.project2 = factories.ProjectFactory(customer=self.customer) self.project2.add_user(self.user2, ProjectRole.ADMINISTRATOR) self.spl2 = factories.TestServiceProjectLinkFactory( service=self.service, project=self.project2) self.vm2 = factories.TestNewInstanceFactory( service_project_link=self.spl2) self.service_url = factories.TestServiceFactory.get_url(self.service)
def test_task_sets_coordinates(self, mock_request_get): ip_address = "127.0.0.1" expected_latitude = 20 expected_longitude = 20 instance = factories.TestNewInstanceFactory() mock_request_get.return_value.ok = True response = {"ip": ip_address, "latitude": expected_latitude, "longitude": expected_longitude} mock_request_get.return_value.json.return_value = response tasks.detect_vm_coordinates(utils.serialize_instance(instance)) instance.refresh_from_db() self.assertEqual(instance.latitude, expected_latitude) self.assertEqual(instance.longitude, expected_longitude)
def test_ok_vm_unchanged(self): ok_vm = factories.TestNewInstanceFactory( state=models.TestNewInstance.States.CREATING, modified=timezone.now() - timedelta(minutes=1)) ok_volume = factories.TestVolumeFactory( state=models.TestVolume.States.CREATING, modified=timezone.now() - timedelta(minutes=1)) tasks.SetErredStuckResources().run() ok_vm.refresh_from_db() ok_volume.refresh_from_db() self.assertEqual(ok_vm.state, models.TestNewInstance.States.CREATING) self.assertEqual(ok_volume.state, models.TestVolume.States.CREATING)
def test_stuck_resource_becomes_erred(self): with mock.patch('model_utils.fields.now') as mocked_now: mocked_now.return_value = timezone.now() - timedelta(hours=4) stuck_vm = factories.TestNewInstanceFactory( state=models.TestNewInstance.States.CREATING) stuck_volume = factories.TestVolumeFactory( state=models.TestVolume.States.CREATING) tasks.SetErredStuckResources().run() stuck_vm.refresh_from_db() stuck_volume.refresh_from_db() self.assertEqual(stuck_vm.state, models.TestNewInstance.States.ERRED) self.assertEqual(stuck_volume.state, models.TestVolume.States.ERRED)
def setUp(self): super(ScopeTypeFilterTest, self).setUp() resource = structure_factories.TestNewInstanceFactory( service_project_link=self.service_project_link) self.estimates = { 'customer': models.PriceEstimate.objects.get(scope=self.customer), 'service': models.PriceEstimate.objects.get(scope=self.service), 'project': models.PriceEstimate.objects.get(scope=self.project), 'service_project_link': models.PriceEstimate.objects.get(scope=self.service_project_link), 'resource': models.PriceEstimate.objects.get(scope=resource), }
def test_consumption_details_of_resource_is_keeped_up_to_date_on_quota_change( self): today = timezone.now() resource = structure_factories.TestNewInstanceFactory() quota_item = ConsumableItem('quotas', 'test_quota') price_estimate = models.PriceEstimate.objects.get(scope=resource, month=today.month, year=today.year) consumption_details = price_estimate.consumption_details self.assertEqual(consumption_details.configuration[quota_item], 0) resource.set_quota_usage(TestNewInstance.Quotas.test_quota, 5) consumption_details.refresh_from_db() self.assertEqual(consumption_details.configuration[quota_item], 5)
def test_if_limit_is_reached_provisioning_is_delayed(self, params): link = factories.TestServiceProjectLinkFactory() factories.TestNewInstanceFactory.create_batch( size=params['size'], state=models.TestNewInstance.States.CREATING, service_project_link=link) vm = factories.TestNewInstanceFactory( state=models.TestNewInstance.States.CREATION_SCHEDULED, service_project_link=link) serialized_vm = utils.serialize_instance(vm) mocked_retry = mock.Mock() tasks.ThrottleProvisionTask.retry = mocked_retry tasks.ThrottleProvisionTask().si( serialized_vm, 'create', state_transition='begin_starting').apply() self.assertEqual(mocked_retry.called, params['retried'])
def setUp(self): resource_content_type = ContentType.objects.get_for_model( TestNewInstance) self.price_list_item = models.DefaultPriceListItem.objects.create( item_type='storage', key='1 MB', resource_content_type=resource_content_type, value=2) CostTrackingRegister.register_strategy( factories.TestNewInstanceCostTrackingStrategy) self.start_time = datetime.datetime(2016, 8, 8, 11, 0) with freeze_time(self.start_time): self.resource = structure_factories.TestNewInstanceFactory( disk=20 * 1024) self.spl = self.resource.service_project_link self.project = self.spl.project self.customer = self.project.customer self.service = self.spl.service
def test_consumption_details_of_resource_is_keeped_up_to_date(self): today = timezone.now() configuration = dict(ram=2048, disk=20 * 1024, cores=2) resource = structure_factories.TestNewInstanceFactory( state=TestNewInstance.States.OK, runtime_state='online', **configuration) price_estimate = models.PriceEstimate.objects.get(scope=resource, month=today.month, year=today.year) consumption_details = price_estimate.consumption_details expected = { ConsumableItem('ram', '1 MB'): 2048, ConsumableItem('storage', '1 MB'): 20 * 1024, ConsumableItem('cores', '1 core'): 2, ConsumableItem('quotas', 'test_quota'): 0, } self.assertDictEqual(consumption_details.configuration, expected) resource.ram = 1024 resource.save() consumption_details.refresh_from_db() self.assertEqual( consumption_details.configuration[ConsumableItem('ram', '1 MB')], resource.ram, ) resource.runtime_state = 'offline' resource.save() # test resource uses only storage and quota when it is offline expected = { ConsumableItem('storage', '1 MB'): 20 * 1024, ConsumableItem('quotas', 'test_quota'): 0, } consumption_details.refresh_from_db() self.assertDictEqual(consumption_details.configuration, expected) resource.flavor_name = 'small' resource.save() consumption_details.refresh_from_db() self.assertEqual( consumption_details.configuration[ConsumableItem( 'flavor', 'small')], 1)