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