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 test_invalid_parameters(self):
with pytest.raises(ValueError) as err:
value = VosValue()
assert "size parameter is required" in str(err.value)
with pytest.raises(TypeError) as err:
value = VosValue(size="rubbish")
assert "size parameter must be of type int" in str(err.value)
with pytest.raises(TypeError) as err:
value = VosValue(size=5, count="rubbish")
assert "count parameter must be of type int" in str(err.value)
with pytest.raises(TypeError) as err:
value = VosValue(size=5, count=10, aligned="rubbish")
assert "aligned parameter must be of type" in str(err.value)
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_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 _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_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 _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 test_constructor(self):
value = VosValue(size=10, aligned="Yes")
want = {"size": 10, "count": 1, "aligned": "Yes"}
got = value.dump()
assert want == got
value = VosValue(size=10, aligned="No")
want = {"size": 10, "count": 1, "aligned": "No"}
got = value.dump()
assert want == got
value = VosValue(size=10, count=20, aligned="No")
want = {"size": 10, "count": 20, "aligned": "No"}
got = value.dump()
assert want == got
def add_symlink(self, oid, name, link_size, dkey_count=1):
akey = copy.deepcopy(self._dfs_inode_akey)
value = VosValue(size=link_size)
akey.add_value(value)
dkey = DKey(key=name)
dkey.set_count(dkey_count)
dkey.add_value(akey)
self._objects[oid].add_value(dkey)
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 _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 create_values(self):
value1 = VosValue(size=10, aligned="Yes")
value2 = VosValue(size=20, aligned="No")
return [value1, value2]
def test_default_parameters(self):
value = VosValue(size=10)
want = {"size": 10, "count": 1, "aligned": "Yes"}
got = value.dump()
assert want == got
