def test_utilio_ls_valid_directory_empty(self):
with redirect_stdout() as stream:
with prepare_workdir() as empty_dir:
listed = ls(empty_dir)
self.assertTrue(listed)
self.assertEqual(stream.getvalue(), '')
def test_utilio_copy(self):
check_dir_01 = os.path.join(self.assets_dir, 'copy-check-01')
check_dir_02 = os.path.join(self.assets_dir, 'copy-check-02')
with prepare_workdir() as work_dir:
# (directories)
# copy the first batch of assets into the working directory
result = path_copy(check_dir_01, work_dir, critical=False)
self.assertTrue(result)
self.assertExists(work_dir, 'test-file-a')
self.assertExists(work_dir, 'test-file-b')
self.assertExists(work_dir, 'test-file-x')
cc1 = compare_contents(os.path.join(check_dir_01, 'test-file-b'),
os.path.join(work_dir, 'test-file-b'))
self.assertIsNone(cc1, cc1)
# override the working directory with the second batch
result = path_copy(check_dir_02, work_dir, critical=False)
self.assertTrue(result)
self.assertExists(work_dir, 'test-file-a')
self.assertExists(work_dir, 'test-file-b')
self.assertExists(work_dir, 'test-file-c')
self.assertExists(work_dir, 'test-file-x')
cc2 = compare_contents(os.path.join(check_dir_02, 'test-file-b'),
os.path.join(work_dir, 'test-file-b'))
self.assertIsNone(cc2, cc2)
# (files)
sub_dir = os.path.join(work_dir, 'sub', 'dir', 'xyz', '')
copied_file_a = os.path.join(work_dir, 'test-file-a')
copied_file_b = os.path.join(work_dir, 'test-file-b')
target_ow = os.path.join(sub_dir, 'test-file-a')
# copy individual files (file to new directory)
result = path_copy(copied_file_a, sub_dir, critical=False)
self.assertTrue(result)
self.assertExists(target_ow)
cc3 = compare_contents(copied_file_a, target_ow)
self.assertIsNone(cc3, cc3)
# copy individual files (overwrite)
result = path_copy(copied_file_b, target_ow, critical=False)
self.assertTrue(result)
cc4 = compare_contents(copied_file_b, target_ow)
self.assertIsNone(cc4, cc4)
# force a directory target with a non-trailing path separator
force_src = os.path.join(work_dir, 'test-file-a')
self.assertExists(force_src)
force1 = os.path.join(work_dir, 'force1')
result = path_copy(force_src, force1, critical=False)
self.assertTrue(result)
self.assertTrue(os.path.isfile(force1))
force2 = os.path.join(work_dir, 'force2')
result = path_copy(force_src, force2, critical=False, dst_dir=True)
self.assertTrue(result)
self.assertTrue(os.path.isdir(force2))
def test_utilio_cat_invalid_file(self):
with redirect_stdout() as stream:
with prepare_workdir() as test_dir:
output = cat(test_dir)
self.assertFalse(output)
self.assertEqual(stream.getvalue(), '')
def run(self, result=None):
self.opts = RelengExtractOptions()
self.opts.strip_count = 0
with prepare_workdir() as work_dir:
self.opts.work_dir = work_dir
super(TestExtractArchive, self).run(result)
def test_engine_run_args_out_dir(self):
with prepare_workdir() as out_dir:
config = {
'out_dir': out_dir,
}
with prepare_testenv(config=config) as engine:
self.assertEqual(engine.opts.out_dir, out_dir)
def test_engine_run_args_cache_dir(self):
with prepare_workdir() as cache_dir:
config = {
'cache_dir': cache_dir,
}
with prepare_testenv(config=config) as engine:
self.assertEqual(engine.opts.cache_dir, cache_dir)
def test_engine_run_args_dl_dir(self):
with prepare_workdir() as dl_dir:
config = {
'dl_dir': dl_dir,
}
with prepare_testenv(config=config) as engine:
self.assertEqual(engine.opts.dl_dir, dl_dir)
def test_engine_run_args_images_dir(self):
with prepare_workdir() as images_dir:
config = {
'images_dir': images_dir,
}
with prepare_testenv(config=config) as engine:
self.assertEqual(engine.opts.images_dir, images_dir)
def test_ff_create(self):
with prepare_workdir() as work_dir:
file = os.path.join(work_dir, 'flag-create')
self.assertTrue(not os.path.exists(file))
state = process_file_flag(True, file)
self.assertEqual(state, FileFlag.CONFIGURED)
self.assertTrue(os.path.exists(file))
def test_ff_read_existence(self):
with prepare_workdir() as work_dir:
file = os.path.join(work_dir, 'flag-exists')
open(file, 'ab').close()
state = process_file_flag(None, file)
self.assertEqual(state, FileFlag.EXISTS)
self.assertTrue(os.path.exists(file))
def test_engine_run_args_mode_localsrcs_overload_package(self):
with prepare_workdir() as dir_a, prepare_workdir() as dir_b:
config = {
'local_sources': [
# --local-sources set to a specific path
dir_a,
# overriding path for the `multiple-b` package
'multiple-b@{}'.format(dir_b),
],
}
with prepare_testenv(config=config, template='multiple') as engine:
self.assertTrue(isinstance(engine.opts.local_srcs, dict))
self.assertTrue(GBL_LSRCS in engine.opts.local_srcs)
self.assertEqual(engine.opts.local_srcs[GBL_LSRCS], dir_a)
self.assertTrue('multiple-b' in engine.opts.local_srcs)
self.assertEqual(engine.opts.local_srcs['multiple-b'], dir_b)
def test_ff_read_not_exists(self):
with prepare_workdir() as work_dir:
file = os.path.join(work_dir, 'flag-no-exist')
self.assertTrue(not os.path.exists(file))
state = process_file_flag(None, file)
self.assertEqual(state, FileFlag.NO_EXIST)
self.assertTrue(not os.path.exists(file))
def test_utilio_cat_missing_file(self):
with redirect_stdout() as stream:
with prepare_workdir() as test_dir:
test_file = os.path.join(test_dir, 'missing-file')
output = cat(test_file)
self.assertFalse(output)
self.assertEqual(stream.getvalue(), '')
def test_engine_run_environ_cfg_assets_dir(self):
with prepare_workdir() as assets_dir:
os.environ['RELENG_ASSETS_DIR'] = assets_dir
with prepare_testenv() as engine:
expected_cache_dir = os.path.join(assets_dir, 'cache')
expected_dl_dir = os.path.join(assets_dir, 'dl')
self.assertEqual(engine.opts.cache_dir, expected_cache_dir)
self.assertEqual(engine.opts.dl_dir, expected_dl_dir)
def test_utilio_copy_missing(self):
with prepare_workdir() as work_dir:
# attempt to copy a missing path
missing_path = os.path.join(work_dir, 'test-path-missing')
target = os.path.join(work_dir, 'container')
result = path_copy(missing_path, target, critical=False)
self.assertFalse(result)
# attempt to copy a missing path (critical)
with self.assertRaises(SystemExit):
path_copy(missing_path, target)
def test_engine_run_args_assets_dir(self):
with prepare_workdir() as assets_dir:
config = {
'assets_dir': assets_dir,
}
with prepare_testenv(config=config) as engine:
expected_cache_dir = os.path.join(assets_dir, 'cache')
expected_dl_dir = os.path.join(assets_dir, 'dl')
self.assertEqual(engine.opts.cache_dir, expected_cache_dir)
self.assertEqual(engine.opts.dl_dir, expected_dl_dir)
def test_engine_run_args_mode_localsrcs_per_package(self):
with prepare_workdir() as dir_a, prepare_workdir() as dir_b:
config = {
'local_sources': [
# explicit path set for `multiple-a` package
'multiple-a@{}'.format(dir_a),
# explicit path set for `multiple-b` package
'multiple-b@{}'.format(dir_b),
],
}
with prepare_testenv(config=config, template='multiple') as engine:
self.assertTrue(isinstance(engine.opts.local_srcs, dict))
self.assertFalse(GBL_LSRCS in engine.opts.local_srcs)
self.assertTrue('multiple-a' in engine.opts.local_srcs)
self.assertEqual(engine.opts.local_srcs['multiple-a'], dir_a)
self.assertTrue(engine.opts.local_srcs)
self.assertTrue('multiple-b' in engine.opts.local_srcs)
self.assertEqual(engine.opts.local_srcs['multiple-b'], dir_b)
self.assertTrue(engine.opts.local_srcs)
def test_utilio_touch(self):
with prepare_workdir() as work_dir:
test_file = os.path.join(work_dir, 'test-file')
created = touch(test_file)
self.assertTrue(created)
exists = os.path.isfile(test_file)
self.assertTrue(exists)
updated = touch(test_file)
self.assertTrue(updated)
def test_utilio_cat_valid_contents_single(self):
with redirect_stdout() as stream:
with prepare_workdir() as test_dir:
test_file = os.path.join(test_dir, 'test')
with open(test_file, 'w') as f:
f.write('this is a test')
output = cat(test_file)
self.assertTrue(output)
self.assertEqual(stream.getvalue(), 'this is a test')
def test_utilio_cat_valid_empty(self):
with redirect_stdout() as stream:
with prepare_workdir() as test_dir:
test_file = os.path.join(test_dir, 'test')
with open(test_file, 'w'):
pass # empty
output = cat(test_file)
self.assertTrue(output)
self.assertEqual(stream.getvalue(), '')
def test_engine_run_args_mode_localsrcs_single_path(self):
with prepare_workdir() as test_dir:
config = {
'local_sources': [
# explicit path set
test_dir,
],
}
with prepare_testenv(config=config, template='multiple') as engine:
self.assertTrue(isinstance(engine.opts.local_srcs, dict))
self.assertTrue(GBL_LSRCS in engine.opts.local_srcs)
self.assertEqual(engine.opts.local_srcs[GBL_LSRCS], test_dir)
def test_ff_forced(self):
with prepare_workdir() as work_dir:
file = os.path.join(work_dir, 'flag-forced')
self.assertTrue(not os.path.exists(file))
state = process_file_flag(False, file)
self.assertEqual(state, FileFlag.NO_EXIST)
self.assertTrue(not os.path.exists(file))
open(file, 'ab').close()
self.assertTrue(os.path.exists(file))
state = process_file_flag(False, file)
self.assertEqual(state, FileFlag.NO_EXIST)
self.assertTrue(os.path.exists(file))
def test_utilio_copy_self(self):
src_dir = os.path.join(self.assets_dir, 'copy-check-01')
src_file = os.path.join(src_dir, 'test-file-a')
with prepare_workdir() as work_dir:
dst_file = os.path.join(work_dir, 'test-file')
shutil.copyfile(src_file, dst_file)
# attempt to copy a directory to itself
with self.assertRaises(SystemExit):
path_copy(work_dir, work_dir)
# attempt to copy a file to itself
with self.assertRaises(SystemExit):
path_copy(dst_file, dst_file)
def test_engine_run_args_config_file(self):
test_filename = 'test-config'
# test full configuration path
with prepare_workdir() as misc_dir:
mock_config = os.path.join(misc_dir, test_filename)
config = {
'config': mock_config,
}
with prepare_testenv(config=config) as engine:
self.assertEqual(engine.opts.conf_point, mock_config)
# test relative to working directory path
with prepare_workdir() as root_dir:
config = {
'config': test_filename,
'root_dir': root_dir,
}
with prepare_testenv(config=config) as engine:
mock_config = os.path.join(os.getcwd(), test_filename)
self.assertEqual(engine.opts.conf_point, mock_config)
def test_engine_run_args_mode_localsrcs_specific_package(self):
with prepare_workdir() as test_dir:
config = {
'local_sources': [
# explicit path set for a single package
'multiple-b@{}'.format(test_dir),
],
}
with prepare_testenv(config=config, template='multiple') as engine:
self.assertTrue(isinstance(engine.opts.local_srcs, dict))
self.assertFalse(GBL_LSRCS in engine.opts.local_srcs)
self.assertTrue('multiple-b' in engine.opts.local_srcs)
self.assertEqual(engine.opts.local_srcs['multiple-b'],
test_dir)
self.assertTrue(engine.opts.local_srcs)
def test_utilio_runscript(self):
with prepare_workdir() as work_dir:
valid_script = os.path.join(work_dir, 'valid')
with open(valid_script, 'a') as f:
f.write('test=1\n')
result = run_script(valid_script, {})
self.assertEqual(result['test'], 1)
invalid_script = os.path.join(work_dir, 'invalid')
with open(invalid_script, 'a') as f:
f.write('bad-line\n')
result = run_script(invalid_script, {})
self.assertIsNone(result)
with self.assertRaises(NameError):
run_script(invalid_script, {}, catch=False)
def test_utilio_cat_valid_contents_multiple(self):
with redirect_stdout() as stream:
with prepare_workdir() as test_dir:
test_file1 = os.path.join(test_dir, 'test1')
with open(test_file1, 'w') as f:
f.write('1')
test_file2 = os.path.join(test_dir, 'test2')
with open(test_file2, 'w') as f:
f.write('2')
test_file3 = os.path.join(test_dir, 'test3')
with open(test_file3, 'w') as f:
f.write('3')
output = cat(test_file1, test_file2, test_file3)
self.assertTrue(output)
self.assertEqual(stream.getvalue(), '123')
def test_utilio_copy_symlink_file(self):
if sys.platform == 'win32':
raise unittest.SkipTest('symlink test skipped for win32')
src_dir = os.path.join(self.assets_dir, 'copy-check-01')
src_file = os.path.join(src_dir, 'test-file-a')
with prepare_workdir() as work_dir:
dst_file = os.path.join(work_dir, 'test-file')
shutil.copyfile(src_file, dst_file)
lnka_file = os.path.join(work_dir, 'test-file-link-a')
os.symlink(dst_file, lnka_file)
lnkb_file = os.path.join(work_dir, 'test-file-link-b')
path_copy(lnka_file, lnkb_file)
read_lnk = os.readlink(lnkb_file)
self.assertEqual(read_lnk, dst_file)
def test_utilio_copyinto(self):
check_dir_01 = os.path.join(self.assets_dir, 'copy-check-01')
check_dir_02 = os.path.join(self.assets_dir, 'copy-check-02')
with prepare_workdir() as work_dir:
# (directories)
# copy the first batch of assets into the working directory
single_file = os.path.join(check_dir_01, 'test-file-a')
result = path_copy_into(single_file, work_dir, critical=False)
self.assertTrue(result)
self.assertExists(work_dir, 'test-file-a')
# copy the first batch of assets into the working directory
result = path_copy_into(check_dir_01, work_dir, critical=False)
self.assertTrue(result)
self.assertExists(work_dir, 'test-file-a')
self.assertExists(work_dir, 'test-file-b')
self.assertExists(work_dir, 'test-file-x')
cc1 = compare_contents(os.path.join(check_dir_01, 'test-file-b'),
os.path.join(work_dir, 'test-file-b'))
self.assertIsNone(cc1, cc1)
# override the working directory with the second batch
result = path_copy_into(check_dir_02, work_dir, critical=False)
self.assertTrue(result)
self.assertExists(work_dir, 'test-file-a')
self.assertExists(work_dir, 'test-file-b')
self.assertExists(work_dir, 'test-file-c')
self.assertExists(work_dir, 'test-file-x')
cc2 = compare_contents(os.path.join(check_dir_02, 'test-file-b'),
os.path.join(work_dir, 'test-file-b'))
self.assertIsNone(cc2, cc2)
# attempt to copy to a file
bad_target = os.path.join(work_dir, 'test-file-a')
result = path_copy_into(check_dir_01, bad_target, critical=False)
self.assertFalse(result)
with self.assertRaises(SystemExit):
path_copy_into(check_dir_02, bad_target)
def test_utilio_copy_symlink_directory(self):
if platform.system() != 'Linux':
raise unittest.SkipTest('symlink test skipped for non-Linux')
src_dir = os.path.join(self.assets_dir, 'copy-check-01')
src_file = os.path.join(src_dir, 'test-file-a')
with prepare_workdir() as work_dir:
subdir = os.path.join(work_dir, 'subdir')
os.mkdir(subdir)
dst_file = os.path.join(subdir, 'test-file')
shutil.copyfile(src_file, dst_file)
lnka_file = os.path.join(subdir, 'test-file-link-a')
os.symlink(dst_file, lnka_file)
subdir2 = os.path.join(work_dir, 'subdir2')
path_copy(subdir, subdir2)
lnkb_file = os.path.join(subdir2, 'test-file-link-a')
read_lnk = os.readlink(lnkb_file)
self.assertEqual(read_lnk, dst_file)
