def get_mock_dfs_superblock_obj(self):
dkey_sb = DKey(key="DFS_SB_METADATA", overhead=Overhead.META)
dkey_sb.add_value(self._create_sb_akey(key="DFS_MAGIC", size=8))
dkey_sb.add_value(
self._create_sb_akey(key="DFS_SB_VERSION", size=2))
dkey_sb.add_value(
self._create_sb_akey(key="DFS_LAYOUT_VERSION", size=2))
dkey_sb.add_value(
self._create_sb_akey(key="DFS_CHUNK_SIZE", size=8))
dkey_sb.add_value(self._create_sb_akey(key="DFS_OBJ_CLASS",
size=2))
inode_value = VosValue(size=64)
akey_inode = AKey(key="DFS_INODE",
overhead=Overhead.META,
value_type=ValType.ARRAY)
akey_inode.add_value(inode_value)
dkey_root = DKey(key="/")
dkey_root.add_value(akey_inode)
superblock_obj = VosObject()
superblock_obj.add_value(dkey_sb)
superblock_obj.add_value(dkey_root)
return superblock_obj
def _create_default_inode_akey(self, key='DFS_INODE', size=64):
value = VosValue(size=size)
akey = AKey(key=key,
overhead=Overhead.META,
value_type=ValType.ARRAY)
akey.add_value(value)
return akey
def _create_sb_akey(self, key, size):
value = VosValue(size=size)
akey = AKey(key=key,
overhead=Overhead.META,
value_type=ValType.SINGLE)
akey.add_value(value)
return akey
def test_add_value(self):
with pytest.raises(VosValueError) as err:
dkey = DKey(key="D-key 1")
dkey.dump()
assert "list of akeys must not be empty" in str(err.value) # nosec
with pytest.raises(TypeError) as err:
dkey = DKey(key="D-key 1")
dkey.add_value("rubbish")
assert "must be of type" in str(err.value) # nosec
dkey = DKey(key="D-key 1")
akey = AKey(
key="A-key 1",
value_type="single_value",
values=self.test_data.create_values())
dkey.add_value(akey)
akey = AKey(
key="A-key 2",
value_type="array",
values=self.test_data.create_values())
dkey.add_value(akey)
want = self.test_data.create_default_dkey()
assert want == dkey.dump() # nosec
def setUp(self):
akey1 = AKey(key="A-key 1",
value_type="single_value",
values=self.test_data.create_values())
akey2 = AKey(key="A-key 2",
value_type="array",
values=self.test_data.create_values())
self.dkey1 = DKey(key="D-key 1", akeys=[akey1, akey2])
self.dkey2 = DKey(key="D-key 2", akeys=[akey1, akey2])
def _parse_dfs_akey_inode(dfs_entry_key_size, dfs_entry_size):
key = 'x' * dfs_entry_key_size
overhead = Overhead.META
value_type = ValType.ARRAY
akey = AKey(key=key, overhead=overhead, value_type=value_type)
value = VosValue(size=dfs_entry_size)
akey.add_value(value)
return akey
def _create_default_dkey0(self):
akey = AKey(key_type=KeyType.INTEGER,
overhead=Overhead.META,
value_type=ValType.SINGLE)
value = VosValue(count=3, size=64)
akey.add_value(value)
dkey = DKey(key_type=KeyType.INTEGER,
overhead=Overhead.META,
akeys=[akey])
return dkey
def setUp(self):
akey1 = AKey(key="A-key 1",
value_type="single_value",
values=self.test_data.create_values())
akey2 = AKey(key="A-key 2",
value_type="array",
values=self.test_data.create_values())
self.dkey1 = DKey(key="D-key 1", akeys=[akey1, akey2])
self.dkey2 = DKey(key="D-key 2", akeys=[akey1, akey2])
self.vos_object1 = VosObject(count=100, dkeys=[self.dkey1, self.dkey2])
self.vos_object2 = VosObject(count=200, dkeys=[self.dkey1, self.dkey2])
def test_constructor(self):
akey1 = AKey(key="A-key 1",
value_type="single_value",
values=self.test_data.create_values())
akey2 = AKey(key="A-key 2",
value_type="array",
values=self.test_data.create_values())
dkey = DKey(key="D-key 1", akeys=[akey1, akey2])
want = self.test_data.create_default_dkey()
assert want == dkey.dump()
def _create_default_file_dkey(self, size=None):
akey = AKey(key_type=KeyType.INTEGER,
overhead=Overhead.USER,
value_type=ValType.ARRAY)
if size:
value = VosValue(size=size)
else:
value = VosValue(size=self._chunk_size)
akey.add_value(value)
dkey = DKey(key_type=KeyType.INTEGER,
overhead=Overhead.USER,
akeys=[akey])
return dkey
def _create_akey(iod):
iov_buf = iod.iod_name.iov_buf
iov_buf_len = iod.iod_name.iov_buf_len
key = ctypes.string_at(iov_buf, iov_buf_len)
if iod.iod_type == 1:
iod_type = ValType.SINGLE
if iod.iod_type == 2:
iod_type = ValType.ARRAY
overhead = Overhead.META
akey = AKey(key=key.decode('utf-8'),
value_type=iod_type,
overhead=overhead)
value = VosValue(count=int(iod.iod_nr), size=int(iod.iod_size))
akey.add_value(value)
return akey
def test_invalid_parameters(self):
with pytest.raises(ValueError) as err:
akey = AKey()
assert "value_type parameter is required" in str(err.value) # nosec
with pytest.raises(TypeError) as err:
akey = AKey(value_type="rubbish")
assert "value_type parameter must be of type" in str(
err.value) # nosec
with pytest.raises(TypeError) as err:
akey = AKey(value_type="single_value", count="rubbish")
assert "count parameter must be of type int" in str(err.value) # nosec
with pytest.raises(TypeError) as err:
akey = AKey(value_type="single_value", key_type="rubbish")
assert "key_type parameter must be of type" in str(err.value) # nosec
with pytest.raises(TypeError) as err:
akey = AKey(value_type="single_value", overhead="rubbish")
assert "overhead parameter must be of type" in str(err.value) # nosec
with pytest.raises(TypeError) as err:
akey = AKey(value_type="single_value", values=["rubbish"])
assert "must be of type" in str(err.value) # nosec
def _create_file_akey(self, size):
self._check_positive_number(size)
count = size // self._io_size
remainder = size % self._io_size
akey = AKey(key_type=KeyType.INTEGER,
overhead=Overhead.USER,
value_type=ValType.ARRAY)
if count > 0:
value = VosValue(count=count, size=self._io_size)
akey.add_value(value)
if remainder > 0:
value = VosValue(size=remainder)
akey.add_value(value)
return akey
def test_add_value(self):
with pytest.raises(VosValueError) as err:
akey = AKey(key="A-key 1", value_type="single_value")
akey.dump()
assert "list of values must not be empty" in str(err.value)
with pytest.raises(TypeError) as err:
akey = AKey(key="A-key 1", value_type="single_value")
akey.add_value("rubbish")
assert "must be of type" in str(err.value)
akey = AKey(key="A-key 1", value_type="single_value")
value = VosValue(size=10, aligned="Yes")
akey.add_value(value)
value = VosValue(size=20, aligned="No")
akey.add_value(value)
want = self.test_data.create_default_akey()
assert want == akey.dump()
def test_constructor(self):
values = self.test_data.create_values()
akey = AKey(key="A-key 1", value_type="single_value", values=values)
want = self.test_data.create_default_akey()
assert want == akey.dump()
akey = AKey(key="A-key 1",
key_type="hashed",
value_type="single_value",
values=values)
want = self.test_data.create_default_akey(key="A-key 1",
key_type="hashed",
value_type="single_value")
assert want == akey.dump()
akey = AKey(key_type="integer",
value_type="single_value",
values=values)
want = self.test_data.create_default_akey(key_type="integer",
value_type="single_value")
assert want == akey.dump()
akey = AKey(key_type="integer",
value_type="single_value",
count=20,
values=values)
want = self.test_data.create_default_akey(key_type="integer",
value_type="single_value",
count=20)
assert want == akey.dump()
akey = AKey(key_type="integer",
value_type="single_value",
overhead="user",
values=values)
want = self.test_data.create_default_akey(key_type="integer",
value_type="single_value",
overhead="user")
assert want == akey.dump()
akey = AKey(key_type="integer",
value_type="single_value",
overhead="meta",
values=values)
want = self.test_data.create_default_akey(key_type="integer",
value_type="single_value",
overhead="meta")
assert want == akey.dump()
akey = AKey(key="A-key 1",
value_type="array",
overhead="user",
values=values)
want = self.test_data.create_default_akey(key="A-key 1",
value_type="array",
overhead="user")
assert want == akey.dump()
akey = AKey(key="A-key 1",
value_type="array",
overhead="meta",
values=values)
want = self.test_data.create_default_akey(key="A-key 1",
value_type="array",
overhead="meta")
assert want == akey.dump()
akey = AKey(key="A-key 1", value_type="array", values=values)
want = self.test_data.create_default_akey(key="A-key 1",
key_type=None,
value_type="array")
assert want == akey.dump()
