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()
