class test_bes_project_cli_args(program_unit_test):
_program = program_unit_test.resolve_program(__file__,
'../../../../bin/best.py')
def test_ensure(self):
tester = _bes_project_tester(self)
requirements_content = '''\
# Requests
beautifulsoup4==4.9.3 # https://github.com/waylan/beautifulsoup
'''
requirements_tmp = self.make_temp_file(content=requirements_content)
rv = tester.ensure(requirements_tmp)
self.assertEqual(0, rv.exit_code)
def test_activate_script(self):
tester = _bes_project_tester(self)
requirements_content = '''\
# Requests
beautifulsoup4==4.9.3 # https://github.com/waylan/beautifulsoup
'''
requirements_tmp = self.make_temp_file(content=requirements_content)
version = str(python_exe.default_exe_version())
rv = tester.ensure(requirements_tmp, versions=[version])
self.assertEqual(0, rv.exit_code)
rv = tester.activate_script(version)
self.assertEqual(0, rv.exit_code)
expected = path.join(tester.root_dir, version, 'bin/activate')
self.assertEqual(expected, rv.output)
class test_dir_split_cli_args(program_unit_test):
_program = program_unit_test.resolve_program(__file__, '../../../../bin/best.py')
def test_split_chunks_of_two(self):
t = self._split_test([
multiplied_temp_content('apple', 5),
multiplied_temp_content('kiwi', 2),
multiplied_temp_content('lemon', 3),
multiplied_temp_content('blueberry', 1),
], 1, 2)
expected = [
'chunk-1',
'chunk-1/apple1.txt',
'chunk-1/apple2.txt',
'chunk-2',
'chunk-2/apple3.txt',
'chunk-2/apple4.txt',
'chunk-3',
'chunk-3/apple5.txt',
'chunk-3/blueberry1.txt',
'chunk-4',
'chunk-4/kiwi1.txt',
'chunk-4/kiwi2.txt',
'chunk-5',
'chunk-5/lemon1.txt',
'chunk-5/lemon2.txt',
'chunk-6',
'chunk-6/lemon3.txt',
]
self.assertEqual( 0, t.result.exit_code )
self.assert_filename_list_equal( expected, t.dst_files )
self.assert_filename_list_equal( [], t.src_files )
def _split_test(self, multiplied_content_items, content_multiplier, chunk_size, extra_content_items = None):
with dir_operation_tester(multiplied_content_items = multiplied_content_items,
content_multiplier = content_multiplier,
extra_content_items = extra_content_items) as test:
args = [
'dir_split',
'split',
'--prefix', 'chunk-',
'--dst-dir', test.dst_dir,
'--chunk-size', str(chunk_size),
test.src_dir,
]
test.result = self.run_program(self._program, args)
return test
class test_git_cli_args(program_unit_test):
_program = program_unit_test.resolve_program(__file__, '..', '..', '..', '..', 'bin', 'best.py')
@git_temp_home_func()
def test_greatest_tag(self):
config = '''\
add commit1 commit1
kiwi.txt: kiwi.txt
tag rel/1.0.0 tag1 @commit1
add commit2 commit2
lemon.txt: lemon.txt
tag rel/1.0.1 tag2 @commit2
add commit3 commit3
melon.txt: melon.txt
tag rel/1.0.2 tag3 @commit3
'''
r = git_temp_repo(remote = True, debug = self.DEBUG)
r.apply_config_text(config)
args = [
'git_repo',
'greatest_tag',
r.root,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assertEqual( 'rel/1.0.2', rv.output.strip() )
@git_temp_home_func()
def test_bump_tag(self):
config = '''\
add commit1 commit1
kiwi.txt: kiwi.txt
tag 1.0.0 tag1 @commit1
'''
r = git_temp_repo(remote = True, debug = self.DEBUG)
r.apply_config_text(config)
args = [
'git_repo',
'bump_tag',
r.root,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
args = [
'git_repo',
'greatest_tag',
r.root,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assertEqual( '1.0.1', rv.output.strip() )
@git_temp_home_func()
def test_bump_tag_component_major(self):
config = '''\
add commit1 commit1
kiwi.txt: kiwi.txt
tag 1.0.0 tag1 @commit1
'''
r = git_temp_repo(remote = True, debug = self.DEBUG)
r.apply_config_text(config)
args = [
'git_repo',
'bump_tag',
'--component', 'major',
r.root,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
args = [
'git_repo',
'greatest_tag',
r.root,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assertEqual( '2.0.0', rv.output.strip() )
@git_temp_home_func()
def test_bump_tag_component_minor(self):
config = '''\
add commit1 commit1
kiwi.txt: kiwi.txt
tag 1.0.0 tag1 @commit1
'''
r = git_temp_repo(remote = True, debug = self.DEBUG)
r.apply_config_text(config)
args = [
'git_repo',
'bump_tag',
'--component', 'minor',
r.root,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
args = [
'git_repo',
'greatest_tag',
r.root,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assertEqual( '1.1.0', rv.output.strip() )
@git_temp_home_func()
def test_bump_tag_component_revision(self):
config = '''\
add commit1 commit1
kiwi.txt: kiwi.txt
tag 1.0.0 tag1 @commit1
'''
r = git_temp_repo(remote = True, debug = self.DEBUG)
r.apply_config_text(config)
args = [
'git_repo',
'bump_tag',
'--component', 'revision',
r.root,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
args = [
'git_repo',
'greatest_tag',
r.root,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assertEqual( '1.0.1', rv.output.strip() )
@git_temp_home_func()
def test_bump_tag_component_major_reset_lower(self):
config = '''\
add commit1 commit1
kiwi.txt: kiwi.txt
tag 1.0.1 tag1 @commit1
'''
r = git_temp_repo(remote = True, debug = self.DEBUG)
r.apply_config_text(config)
args = [
'git_repo',
'bump_tag',
'--component', 'major',
'--reset-lower',
r.root,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
args = [
'git_repo',
'greatest_tag',
r.root,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assertEqual( '2.0.0', rv.output.strip() )
@git_temp_home_func()
def test_clone(self):
config = '''\
add commit1 commit1
kiwi.txt: kiwi.txt
tag 1.0.1 tag1 @commit1
push origin master
'''
r1 = git_temp_repo(remote = True, debug = self.DEBUG)
r1.apply_config_text(config)
tmp_dir = self.make_temp_dir(suffix = '-tmp-clone-dir')
args = [
'git_repo',
'clone',
r1.address,
tmp_dir,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
r2 = git_repo(tmp_dir)
self.assertEqual( '1.0.1', r2.greatest_local_tag().name )
self.assertEqual( [
'kiwi.txt',
], r2.find_all_files() )
@git_temp_home_func()
def test_sync(self):
config = '''\
add commit1 commit1
kiwi.txt: kiwi.txt
tag 1.0.1 tag1 @commit1
push origin master
'''
r1 = git_temp_repo(remote = True, debug = self.DEBUG)
r1.apply_config_text(config)
tmp_dir = self.make_temp_dir(suffix = '-tmp-sync-dir')
args = [
'git_repo',
'sync',
r1.address,
tmp_dir,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
r2 = git_repo(tmp_dir)
self.assertEqual( '1.0.1', r2.greatest_local_tag().name )
self.assertEqual( [
'kiwi.txt',
], r2.find_all_files() )
class test_computer_setup_cli_args(program_unit_test):
_program = program_unit_test.resolve_program(__file__, '..', '..', '..',
'..', 'bin', 'best.py')
@git_temp_home_func()
def test_update(self):
config = '''\
add commit1 commit1
kiwi.txt: kiwi.txt
tag 1.0.0 tag1 @commit1
'''
r = git_temp_repo(remote=True, config=config, debug=self.DEBUG)
self.assertEqual('1.0.0', r.greatest_local_tag().name)
args = [
'git',
'tag',
'--root-dir',
r.root,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assert_string_equal_strip('''\
local: 1.0.0
remote: 1.0.0
''',
rv.output,
native_line_breaks=True)
@git_temp_home_func()
def test_bump_tag_revision(self):
'Just a smoke test bes.git has more test cases for bump_tag'
content = [
'file foo.txt "this is foo.txt" 644',
'file bar.txt "this is bar.txt" 644',
]
r1 = git_temp_repo(content=content, debug=self.DEBUG)
r2 = r1.make_temp_cloned_repo()
self.assertEqual(None, r1.greatest_local_tag())
args = [
'git',
'bump_tag',
'--root-dir',
r1.root,
'--component',
'revision',
'--reset-lower',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
r2.pull()
self.assertEqual('1.0.0', r2.greatest_local_tag().name)
args = [
'git',
'bump_tag',
'--root-dir',
r1.root,
'--component',
'revision',
'--reset-lower',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
r2.pull()
self.assertEqual('1.0.1', r2.greatest_local_tag().name)
@git_temp_home_func()
def test_bump_tag_major(self):
'Just a smoke test bes.git has more test cases for bump_tag'
content = [
'file foo.txt "this is foo.txt" 644',
'file bar.txt "this is bar.txt" 644',
]
r1 = git_temp_repo(content=content, debug=self.DEBUG)
r2 = r1.make_temp_cloned_repo()
self.assertEqual(None, r1.greatest_local_tag())
args = [
'git',
'bump_tag',
'--root-dir',
r1.root,
'--component',
'revision',
'--reset-lower',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
r2.pull()
self.assertEqual('1.0.0', r2.greatest_local_tag().name)
args = [
'git',
'bump_tag',
'--root-dir',
r1.root,
'--component',
'major',
'--reset-lower',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
r2.pull()
self.assertEqual('2.0.0', r2.greatest_local_tag().name)
@git_temp_home_func()
def test_tags(self):
config = '''\
add commit1 commit1
kiwi.txt: kiwi.txt
tag rel/1.0.0 tag1 @commit1
add commit2 commit2
lemon.txt: lemon.txt
tag rel/1.0.1 tag2 @commit2
add commit3 commit3
melon.txt: melon.txt
tag rel/1.0.2 tag3 @commit3
'''
r = git_temp_repo(remote=True, config=config, debug=self.DEBUG)
tmp_output_file = self.make_temp_file(suffix='.txt')
args = [
'git',
'tags',
'--root-dir',
r.root,
'--output',
tmp_output_file,
'--style',
'brief',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assert_text_file_equal_fuzzy(
'''\
rel/1.0.0
rel/1.0.1
rel/1.0.2
''', tmp_output_file)
@git_temp_home_func()
def test_bump_tag_with_prefix(self):
config = '''\
add commit1 commit1
kiwi.txt: kiwi.txt
tag rel/v2/1.0.0 tag1 @commit1
add commit2 commit2
lemon.txt: lemon.txt
tag rel/v2/1.0.1 tag2 @commit2
add commit3 commit3
melon.txt: melon.txt
tag rel/v2/1.0.2 tag3 @commit3
add commit4 commit4
potato.txt: potato.txt
tag test/v3/1.0.0 tag4 @commit4
tag test/v3/1.0.1 tag5 @commit4
'''
r = git_temp_repo(remote=True, config=config, debug=self.DEBUG)
args = [
'git',
'bump_tag',
'--root-dir',
r.root,
'--component',
'revision',
'--prefix',
'rel/v2/',
]
self.assertEqual('rel/v2/1.0.2',
r.greatest_local_tag(prefix='rel/v2/').name)
self.assertEqual('test/v3/1.0.1',
r.greatest_local_tag(prefix='test/v3/').name)
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assertEqual('rel/v2/1.0.3',
r.greatest_local_tag(prefix='rel/v2/').name)
self.assertEqual('test/v3/1.0.1',
r.greatest_local_tag(prefix='test/v3/').name)
@git_temp_home_func()
def test_delete_tags(self):
config = '''\
add commit1 commit1
kiwi.txt: kiwi.txt
tag rel/1.0.0 tag1 @commit1
add commit2 commit2
lemon.txt: lemon.txt
tag rel/1.0.1 tag2 @commit2
add commit3 commit3
melon.txt: melon.txt
tag rel/1.0.2 tag3 @commit3
'''
r = git_temp_repo(remote=True, config=config, debug=self.DEBUG)
self.assertEqual(['rel/1.0.0', 'rel/1.0.1', 'rel/1.0.2'],
r.list_local_tags().names())
self.assertEqual(['rel/1.0.0', 'rel/1.0.1', 'rel/1.0.2'],
r.list_remote_tags().names())
args = [
'git',
'delete_tags',
'--root-dir',
r.root,
'rel/1.0.1',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assertEqual(['rel/1.0.0', 'rel/1.0.2'],
r.list_local_tags().names())
self.assertEqual(['rel/1.0.0', 'rel/1.0.2'],
r.list_remote_tags().names())
@git_temp_home_func()
def test_remote_print(self):
r = git_temp_repo(remote=True)
args = [
'git',
'remote_print',
'--root-dir',
r.root,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assertEqual(r.address, rv.output.strip())
@git_temp_home_func()
def test_remote_replace(self):
new_url = git_temp_repo(remote=True, debug=self.DEBUG).address
r = git_temp_repo(remote=True, debug=self.DEBUG)
args = [
'git',
'remote_replace',
'--root-dir',
r.root,
new_url,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
args = [
'git',
'remote_print',
'--root-dir',
r.root,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assert_filename_equal(new_url, rv.output.strip())
class test_files_cli_args(program_unit_test):
_program = program_unit_test.resolve_program(__file__,
'../../../../bin/best.py')
def test_move_files(self):
items = [
'file src/readme.md "readme.md" 0644',
'file src/a/kiwi-10.txt "kiwi-10.txt" 0644',
'file src/a/kiwi-20.txt "kiwi-20.txt" 0644',
'file src/a/kiwi-30.txt "kiwi-30.txt" 0644',
'file src/b/lemon-10.txt "lemon-10.txt" 0644',
'file src/b/lemon-20.txt "lemon-20.txt" 0644',
'file src/b/lemon-30.txt "lemon-30.txt" 0644',
'file src/c/cheese-10.txt "cheese-10.txt" 0644',
'file src/icons/foo.note "foo.note" 0644',
]
t = self._move_files_test(extra_content_items=items, recursive=True)
dst_after_expected = [
'a',
'a/kiwi-10.txt',
'a/kiwi-20.txt',
'a/kiwi-30.txt',
'b',
'b/lemon-10.txt',
'b/lemon-20.txt',
'b/lemon-30.txt',
'c',
'c/cheese-10.txt',
'icons',
'icons/foo.note',
'readme.md',
]
self.assert_filename_list_equal(dst_after_expected, t.dst_files)
src_after_expected = []
self.assert_filename_list_equal(src_after_expected, t.src_files)
def test_move_files_with_duplicate_file_conflicts(self):
items = [
'file src/readme.md "readme.md" 0644',
'file src/a/kiwi-10.txt "kiwi-10.txt" 0644',
'file src/a/kiwi-20.txt "kiwi-20.txt" 0644',
'file src/a/kiwi-30.txt "kiwi-30.txt" 0644',
'file src/b/lemon-10.txt "lemon-10.txt" 0644',
'file src/b/lemon-20.txt "lemon-20.txt" 0644',
'file src/b/lemon-30.txt "lemon-30.txt" 0644',
'file src/c/cheese-10.txt "cheese-10.txt" 0644',
'file src/icons/foo.note "foo.note" 0644',
'file dst/readme.md "readme.md" 0644',
'file dst/icons/foo.note "foo.note" 0644',
]
t = self._move_files_test(extra_content_items=items, recursive=True)
dst_after_expected = [
'a',
'a/kiwi-10.txt',
'a/kiwi-20.txt',
'a/kiwi-30.txt',
'b',
'b/lemon-10.txt',
'b/lemon-20.txt',
'b/lemon-30.txt',
'c',
'c/cheese-10.txt',
'icons',
'icons/foo.note',
'readme.md',
]
self.assert_filename_list_equal(dst_after_expected, t.dst_files)
src_after_expected = []
self.assert_filename_list_equal(src_after_expected, t.src_files)
def test_move_files_with_non_duplicate_file_conflicts(self):
items = [
'file src/readme.md "src readme.md" 0644',
'file src/a/kiwi-10.txt "kiwi-10.txt" 0644',
'file src/a/kiwi-20.txt "kiwi-20.txt" 0644',
'file src/a/kiwi-30.txt "kiwi-30.txt" 0644',
'file src/b/lemon-10.txt "lemon-10.txt" 0644',
'file src/b/lemon-20.txt "lemon-20.txt" 0644',
'file src/b/lemon-30.txt "lemon-30.txt" 0644',
'file src/c/cheese-10.txt "cheese-10.txt" 0644',
'file src/icons/foo.note "src foo.note" 0644',
'file dst/readme.md "dst readme.md" 0644',
'file dst/icons/foo.note "dst foo.note" 0644',
]
t = self._move_files_test(extra_content_items=items,
recursive=True,
dup_file_timestamp='timestamp',
dup_file_count=1)
dst_after_expected = [
'a',
'a/kiwi-10.txt',
'a/kiwi-20.txt',
'a/kiwi-30.txt',
'b',
'b/lemon-10.txt',
'b/lemon-20.txt',
'b/lemon-30.txt',
'c',
'c/cheese-10.txt',
'icons',
'icons/foo-timestamp-1.note',
'icons/foo.note',
'readme-timestamp-2.md',
'readme.md',
]
self.assert_filename_list_equal(dst_after_expected, t.dst_files)
src_after_expected = []
self.assert_filename_list_equal(src_after_expected, t.src_files)
def test_move_files_with_dry_run(self):
items = [
'file src/readme.md "readme.md" 0644',
'file src/a/kiwi-10.txt "kiwi-10.txt" 0644',
'file src/a/kiwi-20.txt "kiwi-20.txt" 0644',
'file src/a/kiwi-30.txt "kiwi-30.txt" 0644',
'file src/b/lemon-10.txt "lemon-10.txt" 0644',
'file src/b/lemon-20.txt "lemon-20.txt" 0644',
'file src/b/lemon-30.txt "lemon-30.txt" 0644',
'file src/c/cheese-10.txt "cheese-10.txt" 0644',
'file src/icons/foo.note "foo.note" 0644',
]
t = self._move_files_test(extra_content_items=items,
recursive=True,
dry_run=True)
src_after_expected = [
'a',
'a/kiwi-10.txt',
'a/kiwi-20.txt',
'a/kiwi-30.txt',
'b',
'b/lemon-10.txt',
'b/lemon-20.txt',
'b/lemon-30.txt',
'c',
'c/cheese-10.txt',
'icons',
'icons/foo.note',
'readme.md',
]
self.assert_filename_list_equal(src_after_expected, t.src_files)
dst_after_expected = []
self.assert_filename_list_equal(dst_after_expected, t.dst_files)
self.assert_string_equal_fuzzy(
f'''\
DRY_RUN: {t.src_dir}/a/kiwi-10.txt => {t.dst_dir}/a/kiwi-10.txt
DRY_RUN: {t.src_dir}/a/kiwi-20.txt => {t.dst_dir}/a/kiwi-20.txt
DRY_RUN: {t.src_dir}/a/kiwi-30.txt => {t.dst_dir}/a/kiwi-30.txt
DRY_RUN: {t.src_dir}/b/lemon-10.txt => {t.dst_dir}/b/lemon-10.txt
DRY_RUN: {t.src_dir}/b/lemon-20.txt => {t.dst_dir}/b/lemon-20.txt
DRY_RUN: {t.src_dir}/b/lemon-30.txt => {t.dst_dir}/b/lemon-30.txt
DRY_RUN: {t.src_dir}/c/cheese-10.txt => {t.dst_dir}/c/cheese-10.txt
DRY_RUN: {t.src_dir}/icons/foo.note => {t.dst_dir}/icons/foo.note
DRY_RUN: {t.src_dir}/readme.md => {t.dst_dir}/readme.md
''', t.result.output)
def xtest_partition_with_prefix_dry_run(self):
items = [
temp_content('file', 'src/readme.md', 'readme.md', 0o0644),
temp_content('file', 'src/a/kiwi-10.txt', 'kiwi-10.txt', 0o0644),
temp_content('file', 'src/a/kiwi-20.txt', 'kiwi-20.txt', 0o0644),
temp_content('file', 'src/a/kiwi-30.txt', 'kiwi-30.txt', 0o0644),
temp_content('file', 'src/b/lemon-10.txt', 'lemon-10.txt', 0o0644),
temp_content('file', 'src/b/lemon-20.txt', 'lemon-20.txt', 0o0644),
temp_content('file', 'src/b/lemon-30.txt', 'lemon-30.txt', 0o0644),
temp_content('file', 'src/c/cheese-10.txt', 'cheese-10.txt',
0o0644),
temp_content('file', 'src/icons/foo.note', 'foo.note', 0o0644),
]
t = self._move_files_test(extra_content_items=items,
recursive=True,
dry_run=True)
dst_after_expected = []
self.assert_filename_list_equal(dst_after_expected, t.dst_files)
src_after_expected = [
'a',
'a/kiwi-10.txt',
'a/kiwi-20.txt',
'a/kiwi-30.txt',
'b',
'b/lemon-10.txt',
'b/lemon-20.txt',
'b/lemon-30.txt',
'c',
'c/cheese-10.txt',
'icons',
'icons/foo.note',
'readme.md',
]
self.assert_filename_list_equal(src_after_expected, t.src_files)
self.assert_string_equal_fuzzy(
f'''\
{t.src_dir}/a/kiwi-10.txt => {t.dst_dir}/kiwi/kiwi-10.txt
{t.src_dir}/a/kiwi-20.txt => {t.dst_dir}/kiwi/kiwi-20.txt
{t.src_dir}/a/kiwi-30.txt => {t.dst_dir}/kiwi/kiwi-30.txt
{t.src_dir}/b/lemon-10.txt => {t.dst_dir}/lemon/lemon-10.txt
{t.src_dir}/b/lemon-20.txt => {t.dst_dir}/lemon/lemon-20.txt
{t.src_dir}/b/lemon-30.txt => {t.dst_dir}/lemon/lemon-30.txt
{t.src_dir}/c/cheese-10.txt => {t.dst_dir}/cheese/cheese-10.txt
''', t.result.output)
def _move_files_test(self,
extra_content_items=None,
recursive=False,
dry_run=False,
dup_file_timestamp=None,
dup_file_count=None):
with dir_operation_tester(
extra_content_items=extra_content_items) as test:
file_util.mkdir(test.dst_dir)
args = [
'files',
'move',
test.src_dir,
test.dst_dir,
]
if recursive:
args.append('--recursive')
if dry_run:
args.append('--dry-run')
if dup_file_timestamp:
args.extend(['--dup-file-timestamp', dup_file_timestamp])
if dup_file_count:
args.extend(['--dup-file-count', str(dup_file_count)])
test.result = self.run_program(self._program, args)
return test
class test_file_split_cli_args(program_unit_test):
_program = program_unit_test.resolve_program(__file__,
'../../../../bin/best.py')
def test_find_and_unsplit(self):
items = [
temp_content('file', 'src/a/foo/kiwi.txt', 'this is kiwi', 0o0644),
temp_content('file', 'src/a/parts/xfoo.txt.001', 'garbage',
0o0644),
temp_content('file', 'src/a/parts/foo.txt.001', 'foo001', 0o0644),
temp_content('file', 'src/a/parts/foo.txt.002', 'foo002', 0o0644),
temp_content('file', 'src/a/parts/foo.txt.003', 'foo003', 0o0644),
temp_content('file', 'src/a/parts/foo.txt.xx4', 'garbage', 0o0644),
temp_content('file', 'src/a/parts/foo.txt.003.garbage', 'garbage',
0o0644),
temp_content('file', 'src/b/icons/lemon.jpg.01', 'lemon01',
0o0644),
temp_content('file', 'src/b/icons/lemon.jpg.02', 'lemon02',
0o0644),
temp_content('file', 'src/b/icons/lemon.jpg.03', 'lemon03',
0o0644),
]
t = self._find_and_unsplit_test(extra_content_items=items,
recursive=True)
self.assertEqual([
'a',
'a/foo',
'a/foo/kiwi.txt',
'a/parts',
'a/parts/foo.txt',
'a/parts/foo.txt.003.garbage',
'a/parts/foo.txt.xx4',
'a/parts/xfoo.txt.001',
'b',
'b/icons',
'b/icons/lemon.jpg',
], t.src_files)
self.assert_text_file_equal('foo001foo002foo003',
f'{t.src_dir}/a/parts/foo.txt')
self.assert_text_file_equal('lemon01lemon02lemon03',
f'{t.src_dir}/b/icons/lemon.jpg')
def test_find_and_unsplit_dry_run(self):
items = [
temp_content('file', 'src/a/foo/kiwi.txt', 'this is kiwi', 0o0644),
temp_content('file', 'src/a/parts/xfoo.txt.001', 'garbage',
0o0644),
temp_content('file', 'src/a/parts/foo.txt.001', 'foo001', 0o0644),
temp_content('file', 'src/a/parts/foo.txt.002', 'foo002', 0o0644),
temp_content('file', 'src/a/parts/foo.txt.003', 'foo003', 0o0644),
temp_content('file', 'src/a/parts/foo.txt.xx4', 'garbage', 0o0644),
temp_content('file', 'src/a/parts/foo.txt.003.garbage', 'garbage',
0o0644),
temp_content('file', 'src/b/icons/lemon.jpg.01', 'lemon01',
0o0644),
temp_content('file', 'src/b/icons/lemon.jpg.02', 'lemon02',
0o0644),
temp_content('file', 'src/b/icons/lemon.jpg.03', 'lemon03',
0o0644),
]
t = self._find_and_unsplit_test(extra_content_items=items,
recursive=True,
dry_run=True)
self.assertEqual([
'a',
'a/foo',
'a/foo/kiwi.txt',
'a/parts',
'a/parts/foo.txt.001',
'a/parts/foo.txt.002',
'a/parts/foo.txt.003',
'a/parts/foo.txt.003.garbage',
'a/parts/foo.txt.xx4',
'a/parts/xfoo.txt.001',
'b',
'b/icons',
'b/icons/lemon.jpg.01',
'b/icons/lemon.jpg.02',
'b/icons/lemon.jpg.03',
], t.src_files)
self.assert_string_equal_fuzzy(
f'''\
{t.src_dir}/a/parts/foo.txt:
{t.src_dir}/a/parts/foo.txt.001
{t.src_dir}/a/parts/foo.txt.002
{t.src_dir}/a/parts/foo.txt.003
{t.src_dir}/b/icons/lemon.jpg:
{t.src_dir}/b/icons/lemon.jpg.01
{t.src_dir}/b/icons/lemon.jpg.02
{t.src_dir}/b/icons/lemon.jpg.03
''', t.result.output)
return
def _find_and_unsplit_test(
self,
extra_content_items=None,
recursive=False,
check_downloading=_DEFAULT_FILE_SPLIT_OPTIONS.check_downloading,
check_modified=_DEFAULT_FILE_SPLIT_OPTIONS.check_modified,
check_modified_interval=_DEFAULT_FILE_SPLIT_OPTIONS.
check_modified_interval,
dry_run=False):
options = file_split_options(recursive=recursive,
check_downloading=check_downloading)
with dir_operation_tester(
extra_content_items=extra_content_items) as test:
args = [
'file_split',
'unsplit',
test.src_dir,
]
if recursive:
args.append('--recursive')
if check_downloading:
args.append('--check-downloading')
if dry_run:
args.append('--dry-run')
test.result = self.run_program(self._program, args)
return test
class test_vm_builder_cli_args(program_unit_test):
_program = program_unit_test.resolve_program(__file__, '..', '..', '..',
'..', 'bin', 'best.py')
@unit_test_function_skip.skip_if(not host.is_unix(), 'not unix')
def test_vm_builder_ssh_setup(self):
git_access_ssh_public_key_content = r'''
ssh-rsa test_public_bitbucket_key fred@bedrock
'''
git_access_ssh_private_key_content = r'''
-----BEGIN RSA PRIVATE KEY-----
test_private_bitbucket_key
-----END RSA PRIVATE KEY-----
'''
git_access_ssh_public_key = self.make_temp_file(
content=git_access_ssh_public_key_content)
git_access_ssh_private_key = self.make_temp_file(
content=git_access_ssh_private_key_content)
vm_builder_access_ssh_public_key_content = r'''
ssh-rsa test_public_access_key sally@bedrock
'''
vm_builder_access_ssh_private_key_content = r'''
-----BEGIN RSA PRIVATE KEY-----
test_private_access_key
-----END RSA PRIVATE KEY-----
'''
vm_builder_access_ssh_public_key = self.make_temp_file(
content=vm_builder_access_ssh_public_key_content)
tmp_dir = self.make_temp_dir(suffix='.ssh')
args = [
'vm_builder',
'vm_builder_ssh_setup',
'--dont-include-ip-address',
'--dont-include-comment',
tmp_dir,
'fred',
git_access_ssh_public_key,
git_access_ssh_private_key,
'bitbucket.org',
vm_builder_access_ssh_public_key,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
files = file_find.find(tmp_dir)
self.assertEqual([
'authorized_keys',
'config',
'id_rsa_bitbucket_org',
'id_rsa_bitbucket_org.pub',
'known_hosts',
'vm_builder_access_key.pub',
], files)
private_key = path.join(tmp_dir, 'id_rsa_bitbucket_org')
config_text = file_util.read(path.join(tmp_dir, 'config'),
codec='utf-8').strip()
expected_config = '''
Host bitbucket.org
Hostname bitbucket.org
IdentityFile {private_key}
User fred
'''.format(private_key=private_key)
self.assert_string_equal(expected_config,
config_text,
strip=True,
multi_line=True,
native_line_breaks=True)
known_hosts_text = file_util.read(path.join(tmp_dir, 'known_hosts'),
codec='utf-8').strip()
expected_known_hosts = '''
bitbucket.org ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAubiN81eDcafrgMeLzaFPsw2kNvEcqTKl/VqLat/MaB33pZy0y3rJZtnqwR2qOOvbwKZYKiEO1O6VqNEBxKvJJelCq0dTXWT5pbO2gDXC6h6QDXCaHo6pOHGPUy+YBaGQRGuSusMEASYiWunYN0vCAI8QaXnWMXNMdFP3jHAJH0eDsoiGnLPBlBp4TNm6rYI74nMzgz3B9IikW4WVK+dc8KZJZWYjAuORU3jc1c/NPskD2ASinf8v3xnfXeukU0sJ5N6m5E8VLjObPEO+mN2t/FZTMZLiFqPWc/ALSqnMnnhwrNi2rbfg/rd/IpL8Le3pSBne8+seeFVBoGqzHM9yXw==
'''
self.assert_string_equal(expected_known_hosts,
known_hosts_text,
strip=True,
multi_line=True,
native_line_breaks=True)
abs_files = [path.join(tmp_dir, f) for f in files]
if host.is_unix():
for filename in abs_files:
self.assertEqual(0o0600, file_util.mode(filename))
def test_vm_host_ssh_setup(self):
vm_builder_access_ssh_public_key_content = r'''
ssh-rsa test_public_access_key sally@bedrock
'''
vm_builder_access_ssh_private_key_content = r'''
-----BEGIN RSA PRIVATE KEY-----
test_private_access_key
-----END RSA PRIVATE KEY-----
'''
vm_builder_access_ssh_public_key = self.make_temp_file(
content=vm_builder_access_ssh_public_key_content)
vm_builder_access_ssh_private_key = self.make_temp_file(
content=vm_builder_access_ssh_private_key_content)
tmp_dir = self.make_temp_dir(suffix='.ssh')
args = [
'vm_builder',
'vm_host_ssh_setup',
'--dont-include-ip-address',
'--dont-include-comment',
tmp_dir,
'vm_host_access_key',
'fred',
vm_builder_access_ssh_public_key,
vm_builder_access_ssh_private_key,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
files = file_find.find(tmp_dir)
print(files)
self.assertEqual([
'vm_host_access_key',
'vm_host_access_key.pub',
], files)
return
private_key = path.join(tmp_dir, 'id_rsa_bitbucket_org')
expected_config = '''
Host bitbucket.org
Hostname bitbucket.org
IdentityFile {private_key}
User fred
'''.format(private_key=private_key)
self.assert_text_file_equal(expected_config,
path.join(tmp_dir, 'config'),
codec='utf-8',
strip=True,
native_line_breaks=True)
expected_known_hosts = '''
bitbucket.org ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAubiN81eDcafrgMeLzaFPsw2kNvEcqTKl/VqLat/MaB33pZy0y3rJZtnqwR2qOOvbwKZYKiEO1O6VqNEBxKvJJelCq0dTXWT5pbO2gDXC6h6QDXCaHo6pOHGPUy+YBaGQRGuSusMEASYiWunYN0vCAI8QaXnWMXNMdFP3jHAJH0eDsoiGnLPBlBp4TNm6rYI74nMzgz3B9IikW4WVK+dc8KZJZWYjAuORU3jc1c/NPskD2ASinf8v3xnfXeukU0sJ5N6m5E8VLjObPEO+mN2t/FZTMZLiFqPWc/ALSqnMnnhwrNi2rbfg/rd/IpL8Le3pSBne8+seeFVBoGqzHM9yXw==
'''
self.assert_text_file_equal(expected_known_hosts,
path.join(tmp_dir, 'known_hosts'),
codec='utf-8',
strip=True,
native_line_breaks=True)
abs_files = [path.join(tmp_dir, f) for f in files]
if host.is_unix():
for filename in abs_files:
self.assertEqual(0o0600, file_util.mode(filename))
class test_properties_file_cli_args(program_unit_test):
_program = program_unit_test.resolve_program(__file__, '..', '..', '..',
'..', 'bin', 'best.py')
def test_set_non_existing_file(self):
tmp_dir = self.make_temp_dir()
tmp_file = path.join(tmp_dir, 'foo.yml')
args = [
'properties_file',
'set',
tmp_file,
'fruit',
'kiwi',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
expected = '''\
fruit: kiwi
'''
self.assert_text_file_equal(expected, tmp_file)
def test_set_existing_file(self):
content = '''\
fruit: kiwi
'''
tmp_file = self.make_temp_file(content=content)
args = [
'properties_file',
'set',
tmp_file,
'fruit',
'apple',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
expected = '''\
fruit: apple
'''
self.assert_text_file_equal(expected, tmp_file)
def test_set_value_nonexistent_file(self):
tmp = self.make_temp_file(suffix='.yml')
args = [
'properties_file',
'set',
tmp,
'fruit',
'kiwi',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
expected = '''\
fruit: kiwi
'''
self.assert_text_file_equal(expected, tmp)
def test_set_value_existing_file(self):
content = '''\
fruit: kiwi
'''
tmp = self.make_temp_file(content=content, suffix='.yml')
args = [
'properties_file',
'set',
tmp,
'fruit',
'apple',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
expected = '''\
fruit: apple
'''
self.assert_text_file_equal(expected, tmp)
def test_get_value_existing_file(self):
content = '''\
fruit: kiwi
'''
tmp = self.make_temp_file(content=content, suffix='.yml')
args = [
'properties_file',
'get',
tmp,
'fruit',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assertEqual('kiwi', rv.output.strip())
def test_bump_version(self):
content = '''\
ver: 1.2.3
'''
tmp = self.make_temp_file(content=content, suffix='.yml')
args = [
'properties_file',
'bump_version',
tmp,
'ver',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
expected = '''\
ver: 1.2.4
'''
self.assert_text_file_equal(expected, tmp)
def test_bump_version_major(self):
content = '''\
ver: 1.2.3
'''
tmp = self.make_temp_file(content=content, suffix='.yml')
args = [
'properties_file',
'bump_version',
'--component',
'major',
tmp,
'ver',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
expected = '''\
ver: 2.2.3
'''
self.assert_text_file_equal(expected, tmp)
class test_file_duplicates_cli_args(program_unit_test):
_program = program_unit_test.resolve_program(__file__,
'../../../../bin/best.py')
def test_find_duplicates(self):
items = [
temp_content('file', 'src/a/kiwi.jpg', 'this is kiwi', 0o0644),
temp_content('file', 'src/a/apple.jpg', 'this is apple', 0o0644),
temp_content('file', 'src/a/lemon.jpg', 'this is lemon', 0o0644),
temp_content('file', 'src/b/kiwi_dup1.jpg', 'this is kiwi',
0o0644),
temp_content('file', 'src/c/kiwi_dup2.jpg', 'this is kiwi',
0o0644),
]
t = self._find_dups_test(extra_content_items=items, recursive=True)
self.assert_string_equal_fuzzy(
f'''\
{t.src_dir}/a/kiwi.jpg:
{t.src_dir}/b/kiwi_dup1.jpg
{t.src_dir}/c/kiwi_dup2.jpg
''', t.result.output)
def test_find_duplicates_delete(self):
items = [
temp_content('file', 'src/a/kiwi.jpg', 'this is kiwi', 0o0644),
temp_content('file', 'src/a/apple.jpg', 'this is apple', 0o0644),
temp_content('file', 'src/a/lemon.jpg', 'this is lemon', 0o0644),
temp_content('file', 'src/b/kiwi_dup1.jpg', 'this is kiwi',
0o0644),
temp_content('file', 'src/c/kiwi_dup2.jpg', 'this is kiwi',
0o0644),
]
t = self._find_dups_test(extra_content_items=items,
recursive=True,
delete=True)
self.assert_string_equal_fuzzy(
f'''\
{t.src_dir}/a/kiwi.jpg:
{t.src_dir}/b/kiwi_dup1.jpg
{t.src_dir}/c/kiwi_dup2.jpg
''', t.result.output)
src_after_expected = [
'a',
'a/apple.jpg',
'a/kiwi.jpg',
'a/lemon.jpg',
]
self.assert_filename_list_equal(src_after_expected, t.src_files)
def test_find_duplicates_delete_with_keep_empty_dirs(self):
items = [
temp_content('file', 'src/a/kiwi.jpg', 'this is kiwi', 0o0644),
temp_content('file', 'src/a/apple.jpg', 'this is apple', 0o0644),
temp_content('file', 'src/a/lemon.jpg', 'this is lemon', 0o0644),
temp_content('file', 'src/b/kiwi_dup1.jpg', 'this is kiwi',
0o0644),
temp_content('file', 'src/c/kiwi_dup2.jpg', 'this is kiwi',
0o0644),
]
t = self._find_dups_test(extra_content_items=items,
recursive=True,
delete=True,
keep_empty_dirs=True)
self.assert_string_equal_fuzzy(
f'''\
{t.src_dir}/a/kiwi.jpg:
{t.src_dir}/b/kiwi_dup1.jpg
{t.src_dir}/c/kiwi_dup2.jpg
''', t.result.output)
src_after_expected = [
'a',
'a/apple.jpg',
'a/kiwi.jpg',
'a/lemon.jpg',
'b',
'c',
]
self.assert_filename_list_equal(src_after_expected, t.src_files)
def _find_dups_test(self,
extra_content_items=None,
recursive=False,
small_checksum_size=1024 * 1024,
prefer_prefixes=None,
delete=False,
keep_empty_dirs=False):
with dir_operation_tester(
extra_content_items=extra_content_items) as test:
args = [
'file_duplicates',
'dups',
test.src_dir,
]
if recursive:
args.append('--recursive')
if delete:
args.append('--delete')
if keep_empty_dirs:
args.append('--keep')
test.result = self.run_program(self._program, args)
return test
class test_dirs_cli_args(program_unit_test):
_program = program_unit_test.resolve_program(__file__,
'../../../../bin/best.py')
def test_remove_empty(self):
t = self._test([
'dir src/empty1 "" 700',
'file src/readme.md "readme.md" 644',
'file src/a/kiwi-30.jpg "kiwi-30.txt" 644',
'dir src/a/empty2 "" 700',
'file src/b/lemon-10.jpg "lemon-10.txt" 644',
'file src/c/cheese-10.jpg "cheese-10.jpg" 644',
'file src/icons/foo.png "foo.png" 644',
'file src/lemon-40.jpg "lemon-40.txt" 644',
'dir src/a/empty2 "" 700',
'dir src/foo/bar/baz/empty3 "lemon-40.txt" 700',
],
recursive=False)
expected = [
'a',
'a/empty2',
'b',
'c',
'foo',
'foo/bar',
'foo/bar/baz',
'foo/bar/baz/empty3',
'icons',
]
self.assertEqual(0, t.result.exit_code)
self.assert_filename_list_equal(expected, t.src_dirs)
def test_remove_empty_recursive(self):
t = self._test([
'dir src/empty1 "" 700',
'file src/readme.md "readme.md" 644',
'file src/a/kiwi-30.jpg "kiwi-30.txt" 644',
'dir src/a/empty2 "" 700',
'file src/b/lemon-10.jpg "lemon-10.txt" 644',
'file src/c/cheese-10.jpg "cheese-10.jpg" 644',
'file src/icons/foo.png "foo.png" 644',
'file src/lemon-40.jpg "lemon-40.txt" 644',
'dir src/a/empty2 "" 700',
'dir src/foo/bar/baz/empty3 "lemon-40.txt" 700',
],
recursive=True)
expected = [
'a',
'b',
'c',
'icons',
]
self.assertEqual(0, t.result.exit_code)
self.assert_filename_list_equal(expected, t.src_dirs)
def test_remove_empty_dry_run(self):
t = self._test([
'dir src/empty1 "" 700',
'file src/readme.md "readme.md" 644',
'file src/a/kiwi-30.jpg "kiwi-30.txt" 644',
'dir src/a/empty2 "" 700',
'file src/b/lemon-10.jpg "lemon-10.txt" 644',
'file src/c/cheese-10.jpg "cheese-10.jpg" 644',
'file src/icons/foo.png "foo.png" 644',
'file src/lemon-40.jpg "lemon-40.txt" 644',
'dir src/a/empty2 "" 700',
'dir src/foo/bar/baz/empty3 "lemon-40.txt" 700',
],
recursive=True,
dry_run=True)
expected = [
'a',
'a/empty2',
'b',
'c',
'empty1',
'foo',
'foo/bar',
'foo/bar/baz',
'foo/bar/baz/empty3',
'icons',
]
self.assertEqual(0, t.result.exit_code)
self.assert_filename_list_equal(expected, t.src_dirs)
self.assert_string_equal_fuzzy(
f'''
DRY_RUN: would remove {t.src_dir}/a/empty2
DRY_RUN: would remove {t.src_dir}/empty1
DRY_RUN: would remove {t.src_dir}/foo/bar/baz/empty3
''', t.result.output)
def _test(self, items, recursive=False, dry_run=False):
with dir_operation_tester(extra_content_items=items) as test:
args = [
'dirs',
'remove_empty',
test.src_dir,
]
if recursive:
args.append('--recursive')
if dry_run:
args.append('--dry-run')
test.result = self.run_program(self._program, args)
return test
class test_git_repo_document_cli_args(program_unit_test):
_program = program_unit_test.resolve_program(__file__, '..', '..', '..',
'..', 'bin', 'best.py')
@git_temp_home_func()
def test_basic(self):
# This is the document to write to the repository.
tmp_source_doc = self.make_temp_file(content='abc', suffix='-doc.txt')
# Here's a repository to put it in.
r = git_temp_repo(debug=self.DEBUG)
r.add_file('dummy.txt', content='dummy')
r.push('origin', 'master')
tmp_db_dir = self.make_temp_dir()
args = [
'git_repo_document',
'update',
tmp_source_doc,
r.address,
'master',
'--working-dir',
tmp_db_dir,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
# Also check doc is in repo. It will have the same name as the source doc.
filename = path.basename(tmp_source_doc)
r.pull()
contents = r.read_file(filename)
self.assertEqual(contents, 'abc')
# Since we now have a file in the repo, let's also test whether load_document can read it.
# Here's an auto-delete temp directory for the document DB's local repository.
tmp_db_dir2 = temp_file.make_temp_dir(delete=not self.DEBUG)
# By default, the CLI will put the output file in a file with the same name as the file in
# the repo, in the current directory.
tmp_target_filepath = path.join(getcwd(), filename)
if path.exists(tmp_target_filepath):
remove(tmp_target_filepath)
# Run the CLI.
args = [
'git_repo_document',
'load',
filename,
r.address,
'master',
'--working-dir',
tmp_db_dir2,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
# See if the file and contents are there.
actual = file_util.read(tmp_target_filepath)
self.assertEqual(actual, b'abc')
# This will cause an exception and fail the test if the file wasn't created by the CLI.
remove(tmp_target_filepath)
class test_git_identity_cli_args(program_unit_test):
_program = program_unit_test.resolve_program(__file__, '..', '..', '..', '..', 'bin', 'best.py')
@env_override_temp_home_func()
def test_git_identity_get_never_set(self):
args = [
'git_identity',
'get',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assertEqual( '', rv.output.strip() )
@env_override_temp_home_func()
def test_git_identity_set(self):
args = [
'git_identity',
'set',
'Foo Bar',
'*****@*****.**',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
args = [
'git_identity',
'get',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assertEqual( 'Foo Bar:[email protected]', rv.output.strip() )
args = [
'git_identity',
'get',
'--name',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assertEqual( 'Foo Bar', rv.output.strip() )
args = [
'git_identity',
'get',
'--email',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assertEqual( '*****@*****.**', rv.output.strip() )
@env_override_temp_home_func()
def xtest_git_identity_ensure(self):
args = [
'git_identity',
'ensure',
'Foo Bar',
'*****@*****.**',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
args = [
'git_identity',
'get',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assertEqual( 'Foo Bar:[email protected]', rv.output.strip() )
class test_pip_project_cli_args(program_unit_test):
_program = program_unit_test.resolve_program(__file__,
'../../../../bin/best.py')
def test_create(self):
tester = _pip_project_tester(self)
rv = tester.create()
self.assertEqual(0, rv.exit_code)
def test_install(self):
tester = _pip_project_tester(self)
rv = tester.create()
self.assertEqual(0, rv.exit_code)
installed1 = tester.installed()
rv = self.run_program(self._program,
tester.make_args('install', 'chardet'))
self.assertEqual(0, rv.exit_code)
installed2 = tester.installed()
actual = set(installed2) - set(installed1)
expected = {'chardet'}
self.assertEqual(expected, actual)
def test_outdated(self):
tester = _pip_project_tester(self)
rv = tester.create()
self.assertEqual(0, rv.exit_code)
rv = self.run_program(
self._program,
tester.make_args('install', 'chardet', '--version', '3.0.4'))
self.assertEqual(0, rv.exit_code)
self.assertTrue('chardet' in set(tester.outdated()))
def test_upgrade_one_package(self):
tester = _pip_project_tester(self)
rv = tester.create()
self.assertEqual(0, rv.exit_code)
old_version = semantic_version('3.0.4')
rv = self.run_program(
self._program,
tester.make_args('install', 'chardet', '--version',
str(old_version)))
self.assertEqual(0, rv.exit_code)
installed_before = tester.installed_dict()
self.assertEqual(str(old_version), installed_before['chardet'])
rv = self.run_program(self._program,
tester.make_args('upgrade', 'chardet'))
self.assertEqual(0, rv.exit_code)
installed_after = tester.installed_dict()
new_version = semantic_version(installed_after['chardet'])
self.assertTrue(new_version > old_version)
def test_upgrade_many_packages(self):
requirements_content = '''\
idna == 2.7
chardet == 3.0.4
certifi == 2021.5.30
'''
tmp_requirements = self.make_temp_file(content=requirements_content)
tester = _pip_project_tester(self)
rv = tester.create()
self.assertEqual(0, rv.exit_code)
rv = self.run_program(
self._program,
tester.make_args('install_requirements', tmp_requirements))
self.assertEqual(0, rv.exit_code)
installed_before = tester.installed_dict()
self.assertEqual('2.7', installed_before['idna'])
self.assertEqual('3.0.4', installed_before['chardet'])
self.assertEqual('2021.5.30', installed_before['certifi'])
rv = self.run_program(
self._program,
tester.make_args('upgrade', 'idna', 'chardet', 'certifi'))
self.assertEqual(0, rv.exit_code)
installed_after = tester.installed_dict()
self.assertTrue(
semantic_version(installed_after['idna']) > semantic_version('2.7')
)
self.assertTrue(
semantic_version(installed_after['chardet']) > semantic_version(
'3.0.4'))
self.assertTrue(
semantic_version(installed_after['certifi']) > semantic_version(
'2021.5.30'))
def test_install_requirements(self):
requirements_content = '''\
idna == 2.7
chardet == 3.0.4
certifi == 2021.5.30
'''
tmp_requirements = self.make_temp_file(content=requirements_content)
tester = _pip_project_tester(self)
rv = tester.create()
self.assertEqual(0, rv.exit_code)
rv = self.run_program(
self._program,
tester.make_args('install_requirements', tmp_requirements))
self.assertEqual(0, rv.exit_code)
installed = tester.installed_dict()
self.assertEqual('2.7', installed['idna'])
self.assertEqual('3.0.4', installed['chardet'])
self.assertEqual('2021.5.30', installed['certifi'])
class test_dir_combine_cli_args(program_unit_test):
_program = program_unit_test.resolve_program(__file__,
'../../../../bin/best.py')
def test_combine_recursive(self):
t = self._test([
'file src/a/kiwi-30.txt "kiwi-30.txt" 644',
'file src/a/lemon-30.txt "lemon-30.txt" 644',
'file src/a/grape-30.txt "grape-30.txt" 644',
'file src/b/brie-30.txt "brie-30.txt" 644',
'file src/b/cheddar-30.txt "cheddar-30.txt" 644',
'file src/b/gouda-30.txt "gouda-30.txt" 644',
'file src/c/barolo-10.txt "barolo-10.txt" 644',
'file src/c/chablis-10.txt "chablis-10.txt" 644',
'file src/d/steak-10.txt "steak-10.txt" 644',
],
recursive=True,
files=['a', 'b', 'c', 'd'],
flatten=True)
expected = [
'a',
'a/barolo-10.txt',
'a/brie-30.txt',
'a/chablis-10.txt',
'a/cheddar-30.txt',
'a/gouda-30.txt',
'a/grape-30.txt',
'a/kiwi-30.txt',
'a/lemon-30.txt',
'a/steak-10.txt',
]
self.assertEqual(0, t.result.exit_code)
self.assert_filename_list_equal(expected, t.src_files)
def test_combine_recursive_with_conflicts(self):
t = self._test([
'file src/a/kiwi-30.txt "kiwi-30.txt" 644',
'file src/a/lemon-30.txt "lemon-30.txt" 644',
'file src/a/grape-30.txt "grape-30.txt" 644',
'file src/b/brie-30.txt "brie-30.txt" 644',
'file src/b/kiwi-30.txt "kiwi-30-dup1.txt" 644',
'file src/b/gouda-30.txt "gouda-30.txt" 644',
'file src/c/barolo-10.txt "barolo-10.txt" 644',
'file src/c/kiwi-30.txt "kiwi-30-dup2.txt" 644',
'file src/d/steak-10.txt "steak-10.txt" 644',
],
recursive=True,
files=['a', 'b', 'c', 'd'],
flatten=True)
expected = [
'a',
'a/barolo-10.txt',
'a/brie-30.txt',
'a/gouda-30.txt',
'a/grape-30.txt',
'a/kiwi-30-dup-timestamp-42.txt',
'a/kiwi-30-dup-timestamp-43.txt',
'a/kiwi-30.txt',
'a/lemon-30.txt',
'a/steak-10.txt',
]
self.assertEqual(0, t.result.exit_code)
self.assert_filename_list_equal(expected, t.src_files)
def xtest_remove_empty_recursive(self):
t = self._test([
'dir src/empty1 "" 700',
'file src/readme.md "readme.md" 644',
'file src/a/kiwi-30.txt "kiwi-30.txt" 644',
'dir src/a/empty2 "" 700',
'file src/b/lemon-10.txt "lemon-10.txt" 644',
'file src/c/cheese-10.txt "cheese-10.txt" 644',
'file src/icons/foo.note "foo.note" 644',
'file src/lemon-40.txt "lemon-40.txt" 644',
'dir src/a/empty2 "" 700',
'dir src/foo/bar/baz/empty3 "lemon-40.txt" 700',
],
recursive=True,
flatten=True)
expected = [
'a',
'b',
'c',
'icons',
]
self.assertEqual(0, t.result.exit_code)
self.assert_filename_list_equal(expected, t.src_dirs)
def xtest_remove_empty_dry_run(self):
t = self._test([
'dir src/empty1 "" 700',
'file src/readme.md "readme.md" 644',
'file src/a/kiwi-30.txt "kiwi-30.txt" 644',
'dir src/a/empty2 "" 700',
'file src/b/lemon-10.txt "lemon-10.txt" 644',
'file src/c/cheese-10.txt "cheese-10.txt" 644',
'file src/icons/foo.note "foo.note" 644',
'file src/lemon-40.txt "lemon-40.txt" 644',
'dir src/a/empty2 "" 700',
'dir src/foo/bar/baz/empty3 "lemon-40.txt" 700',
],
recursive=True,
dry_run=True,
flatten=True)
expected = [
'a',
'a/empty2',
'b',
'c',
'empty1',
'foo',
'foo/bar',
'foo/bar/baz',
'foo/bar/baz/empty3',
'icons',
]
self.assertEqual(0, t.result.exit_code)
self.assert_filename_list_equal(expected, t.src_dirs)
self.assert_string_equal_fuzzy(
f'''
DRY_RUN: would remove {t.src_dir}/a/empty2
DRY_RUN: would remove {t.src_dir}/empty1
DRY_RUN: would remove {t.src_dir}/foo/bar/baz/empty3
''', t.result.output)
def _test(self,
items,
files=[],
recursive=False,
dry_run=False,
flatten=dir_combine_defaults.FLATTEN,
delete_empty_dirs=dir_combine_defaults.DELETE_EMPTY_DIRS):
with dir_operation_tester(extra_content_items=items) as test:
if files:
files_args = [path.join(test.src_dir, f) for f in files]
else:
files_args = [test.src_dir]
args = [
'dir_combine',
'combine',
'--dup-file-timestamp',
'dup-timestamp',
'--dup-file-count',
'42',
] + files_args
if recursive:
args.append('--recursive')
if dry_run:
args.append('--dry-run')
if flatten:
args.append('--flatten')
if delete_empty_dirs:
args.append('--delete-empty-dirs')
test.result = self.run_program(self._program, args)
return test
class test_dir_partition_cli_args(program_unit_test):
_program = program_unit_test.resolve_program(__file__, '../../../../bin/best.py')
def test_partition_with_prefix(self):
items = [
temp_content('file', 'src/readme.md', 'readme.md', 0o0644),
temp_content('file', 'src/a/kiwi-10.jpg', 'kiwi-10.txt', 0o0644),
temp_content('file', 'src/a/kiwi-20.jpg', 'kiwi-20.txt', 0o0644),
temp_content('file', 'src/a/kiwi-30.jpg', 'kiwi-30.txt', 0o0644),
temp_content('file', 'src/b/lemon-10.jpg', 'lemon-10.txt', 0o0644),
temp_content('file', 'src/b/lemon-20.jpg', 'lemon-20.txt', 0o0644),
temp_content('file', 'src/b/lemon-30.jpg', 'lemon-30.txt', 0o0644),
temp_content('file', 'src/c/cheese-10.jpg', 'cheese-10.jpg', 0o0644),
temp_content('file', 'src/icons/foo.png', 'foo.png', 0o0644),
]
t = self._partition_test(extra_content_items = items,
dst_dir_same_as_src = False,
recursive = True,
partition_type = 'prefix',
delete_empty_dirs = True,
flatten = True)
dst_after_expected = [
'cheese',
'cheese/cheese-10.jpg',
'kiwi',
'kiwi/kiwi-10.jpg',
'kiwi/kiwi-20.jpg',
'kiwi/kiwi-30.jpg',
'lemon',
'lemon/lemon-10.jpg',
'lemon/lemon-20.jpg',
'lemon/lemon-30.jpg',
]
self.assert_filename_list_equal( dst_after_expected, t.dst_files )
src_after_expected = [
'icons',
'icons/foo.png',
'readme.md',
]
self.assert_filename_list_equal( src_after_expected, t.src_files )
def test_partition_with_prefix_dry_run(self):
items = [
temp_content('file', 'src/readme.md', 'readme.md', 0o0644),
temp_content('file', 'src/a/kiwi-10.jpg', 'kiwi-10.txt', 0o0644),
temp_content('file', 'src/a/kiwi-20.jpg', 'kiwi-20.txt', 0o0644),
temp_content('file', 'src/a/kiwi-30.jpg', 'kiwi-30.txt', 0o0644),
temp_content('file', 'src/b/lemon-10.jpg', 'lemon-10.txt', 0o0644),
temp_content('file', 'src/b/lemon-20.jpg', 'lemon-20.txt', 0o0644),
temp_content('file', 'src/b/lemon-30.jpg', 'lemon-30.txt', 0o0644),
temp_content('file', 'src/c/cheese-10.jpg', 'cheese-10.jpg', 0o0644),
temp_content('file', 'src/icons/foo.png', 'foo.png', 0o0644),
]
t = self._partition_test(extra_content_items = items,
dst_dir_same_as_src = False,
recursive = True,
partition_type = 'prefix',
dry_run = True,
delete_empty_dirs = True,
flatten = True)
dst_after_expected = [
]
self.assert_filename_list_equal( dst_after_expected, t.dst_files )
src_after_expected = [
'a',
'a/kiwi-10.jpg',
'a/kiwi-20.jpg',
'a/kiwi-30.jpg',
'b',
'b/lemon-10.jpg',
'b/lemon-20.jpg',
'b/lemon-30.jpg',
'c',
'c/cheese-10.jpg',
'icons',
'icons/foo.png',
'readme.md',
]
self.assert_filename_list_equal( src_after_expected, t.src_files )
self.assert_string_equal_fuzzy(f'''\
{t.src_dir}/a/kiwi-10.jpg => {t.dst_dir}/kiwi/kiwi-10.jpg
{t.src_dir}/a/kiwi-20.jpg => {t.dst_dir}/kiwi/kiwi-20.jpg
{t.src_dir}/a/kiwi-30.jpg => {t.dst_dir}/kiwi/kiwi-30.jpg
{t.src_dir}/b/lemon-10.jpg => {t.dst_dir}/lemon/lemon-10.jpg
{t.src_dir}/b/lemon-20.jpg => {t.dst_dir}/lemon/lemon-20.jpg
{t.src_dir}/b/lemon-30.jpg => {t.dst_dir}/lemon/lemon-30.jpg
{t.src_dir}/c/cheese-10.jpg => {t.dst_dir}/cheese/cheese-10.jpg
''', t.result.output )
def _partition_test(self,
extra_content_items = None,
dst_dir_same_as_src = False,
recursive = False,
partition_type = dir_partition_defaults.PARTITION_TYPE,
dry_run = False,
delete_empty_dirs = dir_partition_defaults.DELETE_EMPTY_DIRS,
threshold = dir_partition_defaults.THRESHOLD,
flatten = dir_partition_defaults.FLATTEN):
with dir_operation_tester(extra_content_items = extra_content_items,
dst_dir_same_as_src = dst_dir_same_as_src) as test:
args = [
'dir_partition',
'partition',
'--type', partition_type,
'--dst-dir', test.dst_dir,
test.src_dir,
]
if recursive:
args.append('--recursive')
if dry_run:
args.append('--dry-run')
if delete_empty_dirs:
args.append('--delete-empty-dirs')
if threshold:
args.extend([ '--threshold', str(threshold) ])
if flatten:
args.append('--flatten')
test.result = self.run_program(self._program, args)
return test
class test_archive_cli_args(program_unit_test):
_program = program_unit_test.resolve_program(__file__, '..', '..', '..', '..', 'bin', 'best.py')
@git_temp_home_func()
def test_create_git_zip(self):
content = [
'file a/b/c/foo.txt "foo content" 755',
'file d/e/bar.txt "bar content" 644',
'dir baz "" 700',
]
r = git_temp_repo(content = content, prefix = 'test_archive_', debug = self.DEBUG)
commit = r.last_commit_hash(short_hash = True)
tmp_archive = self.make_temp_file(suffix = '.zip')
prefix = 'foo-{}'.format(commit)
args = [
'archive',
'create_git',
'--root-dir', r.root,
'--format', 'zip',
prefix,
commit,
tmp_archive,
]
rv = self.run_program(self._program, args)
self.assertEqual( 0, rv.exit_code )
self.assertEqual( 'zip', archiver.format_name(tmp_archive) )
expected = [
'{}/a/b/c/foo.txt'.format(prefix),
'{}/d/e/bar.txt'.format(prefix),
]
actual = archiver.members(tmp_archive)
self.assert_filename_list_equal( expected, actual )
@git_temp_home_func()
def test_create_git_tgz(self):
content = [
'file a/b/c/foo.txt "foo content" 755',
'file d/e/bar.txt "bar content" 644',
'dir baz "" 700',
]
r = git_temp_repo(content = content, prefix = 'test_archive_', debug = self.DEBUG)
commit = r.last_commit_hash(short_hash = True)
tmp_archive = self.make_temp_file(suffix = '.tgz')
prefix = 'foo-{}'.format(commit)
args = [
'archive',
'create_git',
'--root-dir', r.root,
'--format', 'tgz',
prefix,
commit,
tmp_archive,
]
rv = self.run_program(self._program, args)
self.assertEqual( 0, rv.exit_code )
self.assertEqual( 'tgz', archiver.format_name(tmp_archive) )
expected = [
'{}/a/b/c/foo.txt'.format(prefix),
'{}/d/e/bar.txt'.format(prefix),
]
actual = archiver.members(tmp_archive)
self.assert_filename_list_equal( expected, actual )
