def test_add_tags(self):
"""Test that tags are properly added"""
self.pho_execute(['tape', 'add', '-t', 'LTO6', '--fs', 'LTFS',
'TAGGED0', '--tags', 'tag-foo'])
self.pho_execute(['tape', 'add', '-t', 'LTO6', '--fs', 'LTFS',
'TAGGED1', '--tags', 'tag-foo,tag-bar'])
# Check that tags have successfully been added
client = Client()
client.connect()
tagged0, = client.media.get(id='TAGGED0')
tagged1, = client.media.get(id='TAGGED1')
self.assertItemsEqual(tagged0.tags, ['tag-foo'])
self.assertItemsEqual(tagged1.tags, ['tag-foo', 'tag-bar'])
def test_getset(self):
"""GET / SET an object to validate the whole chain."""
with Client() as client:
insert_list = []
for _ in range(10):
rid = Id(PHO_RSC_DIR,
name='__TEST_MAGIC_%d' % randint(0, 1000000))
rsc = Resource(id=rid, model='')
dev = DevInfo(rsc=rsc,
path='/tmp/test_%d' % randint(0, 1000000),
host='localhost')
insert_list.append(dev)
client.devices.insert(insert_list)
# now retrieve them one by one and check serials
for dev in insert_list:
res = client.devices.get(serial=dev.rsc.id.name)
for retrieved_dev in res:
# replace with assertIsInstance when we drop pre-2.7 support
self.assertTrue(isinstance(retrieved_dev, dev.__class__))
self.assertEqual(retrieved_dev.rsc.id.name,
dev.rsc.id.name)
client.devices.delete(res)
def test_list_media_by_tags(self):
"""List media with tags."""
with Client() as client:
blank_medium = MediaInfo(family=PHO_RSC_DIR, name='m0', model=None)
client.media.add(blank_medium, 'POSIX')
blank_medium.name = 'm1'
client.media.add(blank_medium, 'POSIX', tags=['foo'])
blank_medium.name = 'm2'
client.media.add(blank_medium, 'POSIX', tags=['foo', 'bar'])
blank_medium.name = 'm3'
client.media.add(blank_medium, 'POSIX', tags=['goo', 'foo'])
blank_medium.name = 'm4'
client.media.add(blank_medium, 'POSIX', tags=['bar', 'goo'])
blank_medium.name = 'm5'
client.media.add(blank_medium, 'POSIX', tags=['foo', 'bar', 'goo'])
n_tags = {'foo': 4, 'bar': 3, 'goo': 3}
n_bar_foo = 2
for tag, n_tag in n_tags.items():
num = 0
for medium in client.media.get(tags=tag):
self.assertTrue(tag in medium.tags)
num += 1
self.assertEqual(num, n_tag)
num = 0
for medium in client.media.get(tags=['bar', 'foo']):
self.assertTrue('bar' in medium.tags)
self.assertTrue('foo' in medium.tags)
num += 1
self.assertEqual(num, n_bar_foo)
def test_media_lock_unlock(self):
"""Test media lock and unlock wrappers"""
with Client() as client:
# Create a dummy media in db
medium = MediaInfo(name='/some/path_%d' % randint(0, 1000000),
family=PHO_RSC_DIR, model=None,
is_adm_locked=False)
client.media.add(medium, 'POSIX')
# Get the created media from db
media = client.media.get(id=medium.name)[0]
# It should not be locked yet
self.assertFalse(media.is_locked())
# Lock it in db
client.media.lock([media])
# Media cannot be locked twice
with self.assertRaises(EnvironmentError):
client.media.lock([media])
# Retrieve an up-to-date version
media = client.media.get(id=medium.name)[0]
# This one should be locked
self.assertTrue(media.is_locked())
# Unlock it
client.media.unlock([media])
# The up-to-date version isn't locked anymore
media = client.media.get(id=medium.name)[0]
self.assertFalse(media.is_locked())
class DSSInteractHandler(BaseOptHandler):
"""Option handler for actions that interact with the DSS."""
def __init__(self, params, **kwargs):
"""Initialize a new instance."""
super(DSSInteractHandler, self).__init__(params, **kwargs)
self.client = None
def __enter__(self):
"""Initialize a DSS Client."""
self.client = DSSClient()
self.client.connect()
return self
def __exit__(self, exc_type, exc_value, traceback):
"""Release resources associated to a DSS handle."""
self.client.disconnect()
def test_add_sqli(self): # pylint: disable=no-self-use
"""The input data is sanitized and does not cause an SQL injection."""
# Not the best place to test SQL escaping, but most convenient one.
with Client() as client:
medium = MediaInfo(family=PHO_RSC_TAPE, name="TAPE_SQLI_0'; <sqli>",
model="lto8")
client.media.add(medium, "LTFS")
def test_getset(self):
"""GET / SET an object to validate the whole chain."""
with Client() as client:
insert_list = []
for i in range(10):
dev = DevInfo()
dev.family = PHO_DEV_DIR
dev.model = ''
dev.path = '/tmp/test_%d' % randint(0, 1000000)
dev.host = 'localhost'
dev.serial = '__TEST_MAGIC_%d' % randint(0, 1000000)
insert_list.append(dev)
client.devices.insert(insert_list)
# now retrieve them one by one and check serials
for dev in insert_list:
res = client.devices.get(serial=dev.serial)
for retrieved_dev in res:
# replace with assertIsInstance when we drop pre-2.7 support
self.assertTrue(isinstance(retrieved_dev, dev.__class__))
self.assertEqual(retrieved_dev.serial, dev.serial)
client.devices.delete(res)
def test_media_lock_unlock(self):
"""Test media lock and unlock wrappers"""
with Client() as client:
# Create a dummy media in db
label = '/some/path_%d' % randint(0, 1000000)
client.media.add(PHO_DEV_DIR, 'POSIX', None, label, locked=False)
# Get the created media from db
media = client.media.get(id=label)[0]
# It should not be locked yet
self.assertFalse(media.is_locked())
# Lock it in db
client.media.lock([media])
# Media cannot be locked twice
with self.assertRaises(EnvironmentError):
client.media.lock([media])
# Retrieve an up-to-date version
media = client.media.get(id=label)[0]
# This one should be locked
self.assertTrue(media.is_locked())
# Unlock it
client.media.unlock([media])
# Unlocking twice works
client.media.unlock([media])
# The up-to-date version isn't locked anymore
media = client.media.get(id=label)[0]
self.assertFalse(media.is_locked())
def test_client_connect_refused(self):
"""Connect to backend with invalid parameters."""
cli = Client()
environ_save = os.environ['PHOBOS_DSS_connect_string']
os.environ['PHOBOS_DSS_connect_string'] = \
"dbname='tata', user='******', password='******'"
self.assertRaises(EnvironmentError, cli.connect)
os.environ['PHOBOS_DSS_connect_string'] = environ_save
def test_media_update(self):
"""test updating media."""
client = Client()
client.connect()
self.pho_execute(['tape', 'add', '-t', 'LTO6', '--fs', 'LTFS',
'update0', '--tags', 'tag-foo'])
self.pho_execute(['tape', 'add', '-t', 'LTO6', '--fs', 'LTFS',
'update1', '--tags', 'tag-foo,tag-bar'])
# Check inserted media
update0, = client.media.get(id="update0")
update1, = client.media.get(id="update1")
self.assertItemsEqual(update0.tags, ['tag-foo'])
self.assertItemsEqual(update1.tags, ['tag-foo', 'tag-bar'])
# Update media
self.pho_execute(['tape', 'update', '-T', 'new-tag1,new-tag2',
'update[0-1]'])
# Check updated media
for med_id in "update0", "update1":
media, = client.media.get(id=med_id)
self.assertItemsEqual(media.tags, ['new-tag1', 'new-tag2'])
# No '-T' argument does nothing
self.pho_execute(['tape', 'update', 'update0'])
update0, = client.media.get(id=med_id)
self.assertItemsEqual(update0.tags, ['new-tag1', 'new-tag2'])
# Test a failed update
def failed_update(*args, **kwargs):
"""Emulates a failed update by raising EnvironmentError"""
raise EnvironmentError(errno.ENOENT, "Expected failed")
old_update = MediaManager.update
MediaManager.update = failed_update
try:
self.pho_execute(['tape', 'update', '-T', '', 'update0'],
code=os.EX_DATAERR)
finally:
MediaManager.update = old_update
# Ensure that the tape is unlocked after failure
client = Client()
client.connect()
# Exactly one media should be returned
media, = client.media.get(id='update0')
self.assertFalse(media.is_locked())
# Check that locked tapes cannot be updated
client.media.lock([media])
try:
self.pho_execute(['tape', 'update', '-T', '', 'update0'],
code=os.EX_DATAERR)
finally:
client.media.unlock([media])
def test_dir_update(self):
"""Test updating a directory."""
tmp_f = tempfile.NamedTemporaryFile()
tmp_path = tmp_f.name
client = Client()
client.connect()
self.pho_execute(['dir', 'add', tmp_path, '--tags', 'tag-baz'])
# Check inserted media
media, = client.media.get(id=tmp_path)
self.assertItemsEqual(media.tags, ['tag-baz'])
# Update media
self.pho_execute(['dir', 'update', '-T', '', tmp_path])
# Check updated media
media, = client.media.get(id=tmp_path)
self.assertItemsEqual(media.tags, [])
def test_add_sqli(self):
"""The input data is sanitized and does not cause an SQL injection."""
# Not the best place to test SQL escaping, but most convenient one.
with Client() as client:
client.media.add(
PHO_DEV_TAPE,
"LTFS",
"lto8",
"TAPE_SQLI_0'; <sqli>",
)
def test_list_media(self):
"""List media."""
with Client() as client:
for mda in client.media.get():
# replace with assertIsInstance when we drop pre-2.7 support
self.assertTrue(isinstance(mda, MediaInfo))
# Check negative indexation
medias = client.media.get()
self.assertEqual(medias[0].name, medias[-len(medias)].name)
self.assertEqual(medias[len(medias) - 1].name, medias[-1].name)
def test_manipulate_empty(self): # pylint: disable=no-self-use
"""SET/DEL empty and None objects."""
with Client() as client:
client.devices.insert([])
client.devices.insert(None)
client.devices.delete([])
client.devices.delete(None)
client.media.insert([])
client.media.insert(None)
client.media.delete([])
client.media.delete(None)
def test_list_devices_by_family(self):
"""List devices family by family."""
with Client() as client:
for fam in ('tape', 'disk', 'dir'):
for dev in client.devices.get(family=fam):
self.assertEqual(rsc_family2str(dev.family), fam)
def test_client_connect(self): # pylint: disable=no-self-use
"""Connect to backend with valid parameters."""
cli = Client()
cli.connect()
cli.disconnect()
def __enter__(self):
"""Initialize a DSS Client."""
self.client = DSSClient()
self.client.connect()
return self
def test_client_connect(self):
"""Connect to backend with valid parameters."""
cli = Client()
cli.connect()
cli.disconnect()
