def setUp(self): super(TestCopyImageTask, self).setUp() self.db = unit_test_utils.FakeDB(initialize=False) self._create_images() self.image_repo = mock.MagicMock() self.task_repo = mock.MagicMock() self.image_id = UUID1 self.staging_store = mock.MagicMock() self.task_factory = domain.TaskFactory() task_input = { "import_req": { 'method': { 'name': 'copy-image', }, 'stores': ['fast'] } } task_ttl = CONF.task.task_time_to_live self.task_type = 'import' self.task = self.task_factory.new_task(self.task_type, TENANT1, task_time_to_live=task_ttl, task_input=task_input) stores = {'cheap': 'file', 'fast': 'file'} self.config(enabled_backends=stores) store_api.register_store_opts(CONF, reserved_stores=RESERVED_STORES) self.config(default_backend='fast', group='glance_store') store_api.create_multi_stores(CONF, reserved_stores=RESERVED_STORES)
def _get_image(self, location_count=1, image_size=10): context = FakeContext() db_api = unit_test_utils.FakeDB() store_api = unit_test_utils.FakeStoreAPI() store = unit_test_utils.FakeStoreUtils(store_api) base_image = FakeImage() base_image.image_id = 'xyz' base_image.size = image_size image = glance.quota.ImageProxy(base_image, context, db_api, store) locations = [] for i in range(location_count): locations.append({ 'url': 'file:///g/there/it/is%d' % i, 'metadata': {}, 'status': 'active' }) image_values = { 'id': 'xyz', 'owner': context.owner, 'status': 'active', 'size': image_size, 'locations': locations } db_api.image_create(context, image_values) return image
def setUp(self): super(TestImageLoaderPlugin, self).setUp() self.db = unit_test_utils.FakeDB(initialize=False) self._create_images() self.plugin = images_plugin.ImageIndex()
def setUp(self): super(TestMetadefRepo, self).setUp() self.db = unit_test_utils.FakeDB(initialize=False) self.context = glance.context.RequestContext(user=USER1, tenant=TENANT1) self.namespace_repo = glance.db.MetadefNamespaceRepo(self.context, self.db) self.property_repo = glance.db.MetadefPropertyRepo(self.context, self.db) self.object_repo = glance.db.MetadefObjectRepo(self.context, self.db) self.tag_repo = glance.db.MetadefTagRepo(self.context, self.db) self.resource_type_repo = glance.db.\ MetadefResourceTypeRepo(self.context, self.db) self.namespace_factory = glance.domain.MetadefNamespaceFactory() self.property_factory = glance.domain.MetadefPropertyFactory() self.object_factory = glance.domain.MetadefObjectFactory() self.tag_factory = glance.domain.MetadefTagFactory() self.resource_type_factory = glance.domain.MetadefResourceTypeFactory() self._create_namespaces() self._create_properties() self._create_objects() self._create_tags() self._create_resource_types()
def setUp(self): super(TestImagesController, self).setUp() self.config(verbose=True, debug=True) self.controller = glance.api.v2.image_data.ImageDataController( db_api=unit_test_utils.FakeDB(), store_api=unit_test_utils.FakeStoreAPI())
def setUp(self): super(TestImagesController, self).setUp() self.db = unit_test_utils.FakeDB() self.policy = unit_test_utils.FakePolicyEnforcer() self._create_images() self.controller = glance.api.v2.images.ImagesController( self.db, self.policy) glance.store.create_stores()
def setUp(self): super(TestImageMemberQuotas, self).setUp() db_api = unit_test_utils.FakeDB() context = FakeContext() self.image = mock.Mock() self.base_image_member_factory = mock.Mock() self.image_member_factory = glance.quota.ImageMemberFactoryProxy( self.base_image_member_factory, context, db_api)
def setUp(self): super(TestTasksController, self).setUp() self.db = unit_test_utils.FakeDB() self.policy = unit_test_utils.FakePolicyEnforcer() self.notifier = unit_test_utils.FakeNotifier() self.store = unit_test_utils.FakeStoreAPI() self._create_tasks() self.controller = glance.api.v2.tasks.TasksController( self.db, self.policy, self.notifier, self.store)
def setUp(self): super(TestImageRepo, self).setUp() self.db = unit_test_utils.FakeDB(initialize=False) self.context = glance.context.RequestContext(user=USER1, tenant=TENANT1) self.image_repo = glance.db.ImageRepo(self.context, self.db) self.image_factory = glance.domain.ImageFactory() self._create_images() self._create_image_members()
def setUp(self): super(TestImagesController, self).setUp() conf = glance.tests.utils.TestConfigOpts({ 'verbose': True, 'debug': True, }) self.controller = glance.api.v2.image_data.ImageDataController(conf, db_api=test_utils.FakeDB(), store_api=test_utils.FakeStoreAPI())
def setUp(self): super(TestEncryptedLocations, self).setUp() self.db = unit_test_utils.FakeDB() self.db.reset() self.context = glance.context.RequestContext( user=USER1, tenant=TENANT1) self.image_repo = glance.db.ImageRepo(self.context, self.db) self.image_factory = glance.domain.ImageFactory() self.crypt_key = '0123456789abcdef' self.config(metadata_encryption_key=self.crypt_key)
def setUp(self): super(TestImagesController, self).setUp() self.config(verbose=True, debug=True) self.notifier = unit_test_utils.FakeNotifier() self.controller = glance.api.v2.image_data.ImageDataController( db_api=unit_test_utils.FakeDB(), store_api=unit_test_utils.FakeStoreAPI(), policy_enforcer=unit_test_utils.FakePolicyEnforcer(), notifier=self.notifier)
def setUp(self): super(TestImageMembersController, self).setUp() self.db = unit_test_utils.FakeDB() self.store = unit_test_utils.FakeStoreAPI() self.policy = unit_test_utils.FakePolicyEnforcer() self.notifier = unit_test_utils.FakeNotifier() self._create_images() self._create_image_members() self.controller = glance.api.v2.image_members.ImageMembersController( self.db, self.policy, self.notifier, self.store) glance_store.create_stores()
def _test_quota_allowed_unit(self, data_length, config_quota): self.config(user_storage_quota=config_quota) context = FakeContext() db_api = unit_test_utils.FakeDB() base_image = FakeImage() base_image.image_id = 'id' image = glance.quota.ImageProxy(base_image, context, db_api) data = '*' * data_length base_image.set_data(data, size=None) image.set_data(data) self.assertEqual(data_length, base_image.size)
def setUp(self): super(TestTaskRepo, self).setUp() self.db = unit_test_utils.FakeDB(initialize=False) self.context = glance.context.RequestContext(user=USER1, tenant=TENANT1) self.task_repo = glance.db.TaskRepo(self.context, self.db) self.task_factory = glance.domain.TaskFactory() self.fake_task_input = ('{"import_from": ' '"swift://cloud.foo/account/mycontainer/path"' ',"import_from_format": "qcow2"}') self._create_tasks()
def test_quota_allowed(self): quota = 10 self.config(user_storage_quota=str(quota)) context = FakeContext() db_api = unit_test_utils.FakeDB() base_image = FakeImage() base_image.image_id = 'id' image = glance.quota.ImageProxy(base_image, context, db_api) data = '*' * quota base_image.set_data(data, size=None) image.set_data(data) self.assertEqual(quota, base_image.size)
def setUp(self): super(TestMetadefLoaderPlugin, self).setUp() self.db = unit_test_utils.FakeDB(initialize=False) self._create_resource_types() self._create_namespaces() self._create_namespace_resource_types() self._create_properties() self._create_tags() self._create_objects() self.plugin = metadefs_plugin.MetadefIndex()
def setUp(self): super(TestMultiBackendImagesController, self).setUp() self.config(debug=True) self.image_repo = FakeImageRepo() db = unit_test_utils.FakeDB() policy = unit_test_utils.FakePolicyEnforcer() notifier = unit_test_utils.FakeNotifier() store = unit_test_utils.FakeStoreAPI() self.controller = glance.api.v2.image_data.ImageDataController() self.controller.gateway = FakeGateway(db, store, notifier, policy, self.image_repo)
def setUp(self): super(TestImageMemberRepo, self).setUp() self.db = unit_test_utils.FakeDB() self.db.reset() self.context = glance.context.RequestContext(user=USER1, tenant=TENANT1) self.image_repo = glance.db.ImageRepo(self.context, self.db) self.image_member_factory = glance.domain.ImageMemberFactory() self._create_images() self._create_image_members() image = self.image_repo.get(UUID1) self.image_member_repo = glance.db.ImageMemberRepo( self.context, self.db, image)
def test_iadd_location_for_queued_image(self): context = FakeContext() db_api = unit_test_utils.FakeDB() base_image = FakeImage() base_image.image_id = str(uuid.uuid4()) image = glance.quota.ImageProxy(base_image, context, db_api) self.assertIsNone(image.size) self.stubs.Set(glance.store, 'get_size_from_backend', unit_test_utils.fake_get_size_from_backend) image.locations += [{'url': 'file:///fake.img.tar.gz', 'metadata': {}}] self.assertIn({'url': 'file:///fake.img.tar.gz', 'metadata': {}}, image.locations)
def setUp(self): super(TestEncryptedLocations, self).setUp() self.db = unit_test_utils.FakeDB(initialize=False) self.context = glance.context.RequestContext( user=USER1, tenant=TENANT1) self.image_repo = glance.db.ImageRepo(self.context, self.db) self.image_factory = glance.domain.ImageFactory() self.crypt_key = '0123456789abcdef' self.config(metadata_encryption_key=self.crypt_key) self.foo_bar_location = [{'url': 'foo', 'metadata': {}, 'status': 'active'}, {'url': 'bar', 'metadata': {}, 'status': 'active'}]
def setUp(self): super(TestImageActionsController, self).setUp() self.db = unit_test_utils.FakeDB(initialize=False) self.policy = unit_test_utils.FakePolicyEnforcer() self.notifier = unit_test_utils.FakeNotifier() self.store = unit_test_utils.FakeStoreAPI() for i in range(1, 4): self.store.data['%s/fake_location_%i' % (BASE_URI, i)] = ('Z', 1) self.store_utils = unit_test_utils.FakeStoreUtils(self.store) self.controller = image_actions.ImageActionsController( self.db, self.policy, self.notifier, self.store) self.controller.gateway.store_utils = self.store_utils store.create_stores()
def setUp(self): super(TestImageKeystoneQuota, self).setUp() default_limits = { ks_quota.QUOTA_IMAGE_SIZE_TOTAL: 500, 'another_limit': 2, } ksqf = glance_fixtures.KeystoneQuotaFixture(**default_limits) self.useFixture(ksqf) self.db_api = unit_test_utils.FakeDB() self.useFixture( fixtures.MockPatch('glance.quota.keystone.db', self.db_api))
def test_set_location_for_queued_image(self): context = FakeContext() db_api = unit_test_utils.FakeDB() store_api = unit_test_utils.FakeStoreAPI() store = unit_test_utils.FakeStoreUtils(store_api) base_image = FakeImage() base_image.image_id = str(uuid.uuid4()) image = glance.quota.ImageProxy(base_image, context, db_api, store) self.assertIsNone(image.size) self.mock_object(store_api, 'get_size_from_backend', unit_test_utils.fake_get_size_from_backend) image.locations = [{'url': 'file:///fake.img.tar.gz', 'metadata': {}}] self.assertEqual([{'url': 'file:///fake.img.tar.gz', 'metadata': {}}], image.locations)
def setUp(self): super(TestMetadefsControllers, self).setUp() self.db = unit_test_utils.FakeDB() self.policy = unit_test_utils.FakePolicyEnforcer() self._create_namespaces() self._create_properties() self._create_objects() self._create_resource_types() self._create_namespaces_resource_types() self.namespace_controller = namespaces.NamespaceController( self.db, self.policy) self.property_controller = \ properties.NamespacePropertiesController(self.db, self.policy) self.object_controller = objects.MetadefObjectsController( self.db, self.policy) self.rt_controller = resource_types.ResourceTypeController( self.db, self.policy)
def setUp(self): super(TestImageMembersController, self).setUp() self.db = unit_test_utils.FakeDB(initialize=False) self.store = unit_test_utils.FakeStoreAPI() self.policy = unit_test_utils.FakePolicyEnforcer() self.notifier = unit_test_utils.FakeNotifier() self._create_images() self._create_image_members() self.controller = glance.api.v2.image_members.ImageMembersController( self.db, self.policy, self.notifier, self.store) glance_store.register_opts(CONF) self.config(default_store='filesystem', filesystem_store_datadir=self.test_dir, group="glance_store") glance_store.create_stores()
def _quota_exceeded_size(self, quota, data, deleted=True, size=None): self.config(user_storage_quota=quota) context = FakeContext() db_api = unit_test_utils.FakeDB() base_image = FakeImage() base_image.image_id = 'id' image = glance.quota.ImageProxy(base_image, context, db_api) if deleted: with patch.object(glance.store, 'safe_delete_from_backend'): glance.store.safe_delete_from_backend( context, base_image.locations[0]['url'], image.image_id) self.assertRaises(exception.StorageQuotaFull, image.set_data, data, size=size)
def setUp(self): super(TestImagesController, self).setUp() self.config(debug=True) self.image_repo = FakeImageRepo() db = unit_test_utils.FakeDB() policy = unit_test_utils.FakePolicyEnforcer() notifier = unit_test_utils.FakeNotifier() store = unit_test_utils.FakeStoreAPI() self.controller = glance.api.v2.image_data.ImageDataController() self.controller.gateway = FakeGateway(db, store, notifier, policy, self.image_repo) # FIXME(abhishekk): Everything is fake in this test, so mocked the # image mutable_check, Later we need to fix these tests to use # some realistic data patcher = mock.patch('glance.api.v2.policy.check_is_image_mutable') patcher.start() self.addCleanup(patcher.stop)
def _test_prefetcher(self, mock_get_db): self.config(enabled_backends={'cheap': 'file'}) store.register_store_opts(CONF) self.config(filesystem_store_datadir='/tmp', group='cheap') store.create_multi_stores(CONF) tempf = tempfile.NamedTemporaryFile() tempf.write(b'foo') db = unit_test_utils.FakeDB(initialize=False) mock_get_db.return_value = db ctx = context.RequestContext(is_admin=True, roles=['admin']) gateway = glance_gateway.Gateway() image_factory = gateway.get_image_factory(ctx, authorization_layer=False) image_repo = gateway.get_repo(ctx, authorization_layer=False) fetcher = prefetcher.Prefetcher() # Create an image with no values set and queue it image = image_factory.new_image() image_repo.add(image) fetcher.cache.queue_image(image.image_id) # Image is not active, so it should fail to cache, but remain queued self.assertFalse(fetcher.run()) self.assertFalse(fetcher.cache.is_cached(image.image_id)) self.assertTrue(fetcher.cache.is_queued(image.image_id)) # Set the disk/container format and give it a location image.disk_format = 'raw' image.container_format = 'bare' image.status = 'active' loc = {'url': 'file://%s' % tempf.name, 'metadata': {'store': 'cheap'}} with mock.patch('glance.location._check_image_location'): # FIXME(danms): Why do I have to do this? image.locations = [loc] image_repo.save(image) # Image is now active and has a location, so it should cache self.assertTrue(fetcher.run()) self.assertTrue(fetcher.cache.is_cached(image.image_id)) self.assertFalse(fetcher.cache.is_queued(image.image_id))
def setUp(self): super(TestStagingStoreHousekeeping, self).setUp() self.config(enabled_backends={'store1': 'file'}) glance_store.register_store_opts( CONF, reserved_stores={'os_glance_staging_store': 'file'}) self.config(default_backend='store1', group='glance_store') self.config(filesystem_store_datadir=self._store_dir('store1'), group='store1') self.config(filesystem_store_datadir=self._store_dir('staging'), group='os_glance_staging_store') glance_store.create_multi_stores( CONF, reserved_stores={'os_glance_staging_store': 'file'}) self.db = unit_test_utils.FakeDB(initialize=False) self.cleaner = housekeeping.StagingStoreCleaner(self.db) self.context = context.get_admin_context()