def check_extract(self, test_function, test_file, expected, expected_warnings=None, check_all=False):
"""
Run the extraction `test_function` on `test_file` checking that a map of
expected paths --> size exist in the extracted target directory.
Does not test the presence of all files unless `check_all` is True.
"""
from extractcode import archive
test_file = self.get_test_loc(test_file)
test_dir = self.get_temp_dir()
warnings = test_function(test_file, test_dir)
if expected_warnings is not None:
assert expected_warnings == warnings
if check_all:
len_test_dir = len(test_dir)
extracted = {path[len_test_dir:]: filetype.get_size(path) for path in fileutils.resource_iter(test_dir, with_dirs=False)}
expected = {os.path.join(test_dir, exp_path): exp_size for exp_path, exp_size in expected.items()}
assert sorted(expected.items()) == sorted(extracted.items())
else:
for exp_path, exp_size in expected.items():
exp_loc = os.path.join(test_dir, exp_path)
msg = '''When extracting: %(test_file)s
With function: %(test_function)r
Failed to find expected path: %(exp_loc)s'''
assert os.path.exists(exp_loc), msg % locals()
if exp_size is not None:
res_size = os.stat(exp_loc).st_size
msg = '''When extracting: %(test_file)s
With function: %(test_function)r
Failed to assert the correct size %(exp_size)d
Got instead: %(res_size)d
for expected path: %(exp_loc)s'''
assert exp_size == res_size, msg % locals()
def size(self):
"""
Return the size of a file or directory
"""
if self._size is None:
self._size = 0
if self.is_file or self.is_dir:
self._size = filetype.get_size(self.location)
return self._size
def size(self):
"""
Return the size of a file or directory
"""
if self._size is None:
self._size = 0
if self.is_file or self.is_dir:
self._size = filetype.get_size(self.location)
return self._size
def test_get_file_size(self):
test_dir = self.get_test_count_dir()
tests = (
('dir/a.txt', 2),
('dir/b.txt', 2),
('dir/c.txt', 2),
('dir/sub1/a.txt', 2),
('dir/sub1/b.txt', 2),
('dir/sub1/c.txt', 2),
('dir/sub1/subsub/a.txt', 2),
('dir/sub1/subsub/b.txt', 2),
('dir/sub1/subsub', 4),
('dir/sub1', 10),
('dir/sub2/a.txt', 2),
('dir/sub2', 2),
('dir/sub3', 0),
('dir/', 18),
('', 18),
)
for test_file, size in tests:
result = filetype.get_size(os.path.join(test_dir, test_file))
assert size == result
def test_get_size_on_directory(self):
test_dir = self.get_test_loc('filetype/size', copy=True)
assert 12400 == filetype.get_size(test_dir)
def test_get_size_on_file(self):
test_file = self.get_test_loc('filetype/size/Image1.eps')
assert 12388 == filetype.get_size(test_file)
def test_get_file_size_and_count(self):
test_dir = self.get_test_count_dir()
result = filetype.get_size(test_dir)
assert 18 == result
def load_layer(cls, layer_dir, verbose=True):
"""
Return a Layer object built from layer metadata in the layer_dir.
Raise an exception on errors.
"""
if not layer_dir:
return
# infer from the directory
layer_id = fileutils.file_name(layer_dir)
if not isdir(layer_dir):
print('NOT A layer dir:', layer_dir)
return Layer(layer_id=layer_id)
files = listdir(layer_dir)
assert files
logger_debug('load_layer: Layer files: ', files, 'layer_dir: ', layer_dir)
# check that all the files we expect to be in the layer dir are present note:
# we ignore any other files (such as extracted tars, etc)
if LAYER_VERSION_FILE in files:
layer_format_version_file = join(layer_dir, LAYER_VERSION_FILE)
supported_format_version = cls.format_version
with open(layer_format_version_file) as lv:
layer_format_version = lv.read().strip()
assert supported_format_version == layer_format_version, (
'Unknown layer format version: %(layer_format_version)r '
'in: %(layer_format_version_file)r. '
'Supported version: %(supported_format_version)r') % locals()
else:
print('Missing layer VERSION for:', layer_dir)
if not LAYER_JSON_FILE in files:
print('Missing layer json for:', layer_dir)
return Layer(layer_id=layer_id)
# load data
with open(join(layer_dir, LAYER_JSON_FILE)) as layer_json:
layer_data = json.load(layer_json, object_pairs_hook=OrderedDict)
# Note: it is possible to have an EMPTY layer.tar that is a link to another
# non-empty layer.tar
if LAYER_TAR_FILE in files:
layer_tar = join(layer_dir, LAYER_TAR_FILE)
layer_digest = sha256_digest(layer_tar)
layer_size = filetype.get_size(layer_tar)
else:
layer_digest = None
layer_size = 0
# do not rely on this
if 'Size' in layer_data:
del layer_data['Size']
# do not rely on this
if 'id' in layer_data:
lid = layer_data.pop('id')
# make some basic checks
assert layer_id == lid
ccnf = layer_data.pop('container_config', {})
cnf = layer_data.pop('config', {})
config, warns = merge_configs(ccnf, cnf)
if warns and verbose:
print('Warning when loading: %(config_file)r' % locals())
for w in warns:
print(w)
layer = Layer(layer_id=layer_id, layer_digest=layer_digest, layer_size=layer_size, config=config, **layer_data)
layer.command = get_command(config.get('Cmd'))
layer.labels = config.get('Labels')
if not layer.author:
layer.author = config.get('Author') or config.get('author')
return layer
