class test_which(unit_test): @unit_test_function_skip.skip_if(not host.is_unix(), 'not unix') def test_which_unix(self): 'Test which() in unix.' tmp_dir = self.make_temp_dir() bin_dir = path.join(tmp_dir, 'bin') content = '!#/bin/bash\nechoecho kiwi\nexit 0\n' temp_exe = file_util.save(path.join(bin_dir, 'fruit_kiwi_tool'), content=content, mode=0o0755) self.assertEqual(None, which.which('fruit_kiwi_tool')) with env_override.path_append(bin_dir) as env: expected_path = path.join(bin_dir, 'fruit_kiwi_tool') self.assertEqual(expected_path, which.which('fruit_kiwi_tool')) @unit_test_function_skip.skip_if(not host.is_windows(), 'not windows') def test_which_windows(self): 'Test which() in unix.' tmp_dir = self.make_temp_dir() bin_dir = path.join(tmp_dir, 'bin') content = '@echo off\n\recho kiwi\n\rexit 0\n\r' temp_bat = file_util.save(path.join(bin_dir, 'fruit_kiwi_tool.bat'), content=content, mode=0o0755) self.assertEqual(None, which.which('fruit_kiwi_tool.bat')) with env_override.path_append(bin_dir) as env: expected_path = path.join(bin_dir, 'fruit_kiwi_tool.bat') self.assertEqual(expected_path, which.which('fruit_kiwi_tool.bat')) self.assertEqual(expected_path, which.which('fruit_kiwi_tool'))
def xp_filename(clazz, p, sep=None): if host.is_windows(): return clazz._xp_filename_windows(p, sep=sep) elif host.is_unix(): return clazz._xp_filename_unix(p, sep=sep) else: host.raise_unsupported_system()
def test_one_script_with_dry_run(self): r = git_temp_repo(debug = self.DEBUG) if host.is_windows(): script = self.native_filename('fruits/kiwi.bat') content = '''\ @echo off echo {} %* exit 0 '''.format(script) elif host.is_unix(): script = self.native_filename('fruits/kiwi.sh') content = '''\ #!/bin/bash echo {} ${{1+"$@"}} exit 0 '''.format(script) else: assert False xp_script = self.native_filename(script) r.add_file(self.native_filename(xp_script), content, mode = 0o0755) r.push('origin', 'master') r.tag('1.0.0') r.push_tag('1.0.0') options = git_repo_script_options(dry_run = True) scripts = [ git_util.script(xp_script, [ 'arg1', 'arg2' ]), ] rv = git_util.repo_run_scripts(r.address, scripts, options = options) self.assertEqual( [ None ], rv.results )
def program_path(self, program): 'Return the abs path for program in the venv' check.check_string(program) if host.is_windows(): if not filename_util.has_extension(program, 'exe', ignore_case = True): program = filename_util.add_extension(program, 'exe') return path.join(self.bin_dir, program)
def site_packages_dir(self): if host.is_windows(): site_packages_dir = path.join(self.user_base_install_dir, 'site-packages') elif host.is_unix(): site_packages_dir = path.join(self.user_base_install_dir, 'lib/python/site-packages') else: host.raise_unsupported_system() return site_packages_dir
def _find_section_delimiter_index(clazz, config): if host.is_windows(): _, filename = path.splitdrive(config) else: filename = config if ':' not in filename: return -1 return config.rfind(':')
def _git_exe_name(clazz): 'Return the platform specific name of the git exe.' if host.is_unix(): return 'git' elif host.is_windows(): return 'git.exe' else: host.raise_unsupported_system()
def bin_dir(self): if host.is_windows(): bin_dir = path.join(self.user_base_install_dir, 'Scripts') elif host.is_unix(): bin_dir = path.join(self.user_base_install_dir, 'bin') else: host.raise_unsupported_system() return bin_dir
def find_exe_for_python(clazz, python_exe): 'Find pip executable for a specific python exe' bes_python_exe.check_exe(python_exe) if host.is_windows(): result = clazz._find_exe_for_python_windows(python_exe) elif host.is_unix(): result = clazz._find_exe_for_python_unix(python_exe) else: host.raise_unsupported_system() return result
def test_many_scripts_with_push(self): r1 = git_temp_repo(debug = self.DEBUG) if host.is_windows(): script1 = self.native_filename('scripts/script1.bat') script2 = self.native_filename('scripts/script2.bat') content1 = '''\ @echo off echo %1% > color.txt git add color.txt git commit -madd color.txt exit 0 ''' content2 = '''\ @echo off echo %1% > fruit.txt git add fruit.txt git commit -madd fruit.txt exit 0 ''' elif host.is_unix(): script1 = self.native_filename('scripts/script1.sh') script2 = self.native_filename('scripts/script2.sh') content1 = '''\ #!/bin/bash echo ${1} > color.txt git add color.txt git commit -madd color.txt exit 0 ''' content2 = '''\ #!/bin/bash echo ${1} > fruit.txt git add fruit.txt git commit -madd fruit.txt exit 0 ''' else: assert False r1.add_file(script1, content1, mode = 0o0755) r1.add_file(script2, content2, mode = 0o0755) r1.push('origin', 'master') r1.tag('1.0.0') r1.push_tag('1.0.0') scripts = [ git_util.script(script1, [ 'yellow' ]), git_util.script(script2, [ 'kiwi' ]), ] options = git_repo_script_options(push = True) rv = git_util.repo_run_scripts(r1.address, scripts, options = options) r2 = r1.make_temp_cloned_repo() self.assertEqual( 'yellow', r2.read_file('color.txt').strip() ) self.assertEqual( 'kiwi', r2.read_file('fruit.txt').strip() )
def test_push_conflict(self): r1 = git_temp_repo(debug = self.DEBUG) if host.is_windows(): script = self.native_filename('fruits/kiwi.bat') content = '''\ @echo off echo %1 > %1 git add %1 git commit -m"add %1" %1 exit 0 ''' elif host.is_unix(): script = self.native_filename('fruits/kiwi.sh') content = '''\ #!/bin/bash echo ${1} > ${1} git add ${1} git commit -m"add ${1}" ${1} exit 0 ''' else: assert False xp_script = self.native_filename(script) r1.add_file(self.native_filename(xp_script), content, mode = 0o0755) r1.push('origin', 'master') jobs = [] for fruit in self._FRUITS: p = multiprocessing.Process(target = self._worker_test_push_conflict, args = ( fruit, r1.address, xp_script ) ) jobs.append(p) p.start() for job in jobs: job.join() r2 = git_repo(self.make_temp_dir(), address = r1.address) r2.clone_or_pull() self.assertEqual( { xp_script, 'apple', 'blueberry', 'kiwi', 'lemon', 'melon', 'orange', 'papaya', 'pineapple', 'watermelon', }, set(r2.find_all_files()) ) '''
def _find_impl_class(): from bes.system.host import host if host.is_linux(): from .vmware_app_linux import vmware_app_linux return vmware_app_linux elif host.is_macos(): from .vmware_app_macos import vmware_app_macos return vmware_app_macos elif host.is_windows(): from .vmware_app_windows import vmware_app_windows return vmware_app_windows else: host.raise_unsupported_system()
def _fix_output(output): 'For some reason python3 unit tests print the output as bytes. Fix it' if host.is_windows(): marker = "\r\nb'" else: marker = "\nb'" i = output.find(marker) if i < 0: return output j = output.find(line_break.DEFAULT_LINE_BREAK, i + len(marker)) traceback_str = output[i:j] traceback_str_fixed = traceback_str.replace( line_break.DEFAULT_LINE_BREAK_RAW, line_break.DEFAULT_LINE_BREAK) return output.replace(traceback_str, traceback_str_fixed)
class test_python_exe_filename(unit_test): @unit_test_function_skip.skip_if(not host.is_unix(), 'not unix') def test_name_unix(self): self.assertEqual('python', python_exe_filename.name('/usr/bin/python')) self.assertEqual('python2', python_exe_filename.name('/usr/bin/python2')) self.assertEqual('python2.7', python_exe_filename.name('/usr/bin/python2.7')) @unit_test_function_skip.skip_if(not host.is_windows(), 'not windows') def test_name_windows(self): self.assertEqual( 'python', python_exe_filename.name(r'C:\Program Files\Python38\python.exe'))
class best_cli(cli): def __init__(self): super(best_cli, self).__init__('best') from bes.system.host import host COMMAND_GROUPS = [] if host.is_macos(): from .best_cli_macos import MACOS_COMMAND_GROUPS COMMAND_GROUPS.extend(MACOS_COMMAND_GROUPS) if host.is_unix(): from .best_cli_unix import UNIX_COMMAND_GROUPS COMMAND_GROUPS.extend(UNIX_COMMAND_GROUPS) if host.is_windows(): from .best_cli_windows import WINDOWS_COMMAND_GROUPS COMMAND_GROUPS.extend(WINDOWS_COMMAND_GROUPS) from .best_cli_common import COMMON_COMMAND_GROUPS COMMAND_GROUPS.extend(COMMON_COMMAND_GROUPS) #@abstractmethod def command_group_list(self): 'Return a list of command groups for this cli.' return self.COMMAND_GROUPS from bes.cli.cli_env_cli_args import cli_env_cli_args from bes.cli.cli_version_cli_args import cli_version_cli_args from bes.cli.cli_help_cli_args import cli_help_cli_args cli_version_cli_args.version_module_name = 'bes' cli_version_cli_args.version_dependencies = None COMMANDS = [ cli_command('env', 'env_add_args', 'Print env information', cli_env_cli_args), cli_command('help', 'help_add_args', 'Print help', cli_help_cli_args), cli_command('version', 'version_add_args', 'Print version information', cli_version_cli_args), ] #@abstractmethod def command_list(self): 'Return a list of commands for this cli.' return self.COMMANDS @classmethod def run(clazz): raise SystemExit(best_cli().main())
def _make_read_only_temp_file(self): from bes.fs.file_util import file_util tmp = self._make_temp_file('this is foo\n') print('B4: tmp={} mode={}'.format(tmp, file_util.mode(tmp))) import os # os.chmod(tmp, stat.S_IREAD) os.chmod(tmp, 0o0400) print('AF: tmp={} mode={}'.format(tmp, file_util.mode(tmp))) return tmp if host.is_unix(): return file_symlink.resolve('/bin/sh') elif host.is_windows(): return r'C:\Windows\System32\cmd.exe' else: host.raise_unsupported_system()
class test_program_unit_test_true(program_unit_test): if host.is_unix(): _program = program_unit_test.file_path(__file__, 'true.sh') elif host.is_windows(): _program = program_unit_test.file_path(__file__, 'true.bat') else: host.raise_unsupported_system() def test_true(self): rv = self.run_program(self._program, ['foo', 'bar']) self.assertEqual(0, rv.exit_code) self.assert_string_equal_strip('foo bar', rv.output) def test_true_raw(self): rv = self.run_program_raw(self._program, ['foo', 'bar']) self.assertEqual(0, rv.exit_code) self.assert_string_equal_strip(b'foo bar', rv.output)
def _make_test_program(self): tmp_dir = self.make_temp_dir() file_util.save(path.join(tmp_dir, 'farm_cli.py'), content=self._FARM_CLI_DOT_PY) file_util.save(path.join(tmp_dir, 'fruit_cli_args.py'), content=self._FRUIT_CLI_ARGS_DOT_PY) file_util.save(path.join(tmp_dir, 'cheese_cli_args.py'), content=self._CHEESE_CLI_ARGS_DOT_PY) unix_program = file_util.save(path.join(tmp_dir, 'farm.py'), content=self._FARM_DOT_PY) if host.is_unix(): program = unix_program elif host.is_windows(): content = self._FARM_DOT_BAT.format(executable=sys.executable) program = file_util.save(path.join(tmp_dir, 'farm.bat'), content=content) else: host.raise_unsupported_system() return program
def filename_info(clazz, pip_exe): 'Return info about the pip exe filename' check.check_string(pip_exe) if host.is_windows(): pip_exe_lower = pip_exe.lower() ext = filename_util.extension(pip_exe_lower) if ext in ( 'cmd', 'exe', 'bat', 'ps1' ): basename = filename_util.without_extension(path.basename(pip_exe_lower)) else: basename = path.basename(pip_exe_lower) else: basename = path.basename(pip_exe) if not basename.startswith('pip'): return clazz._pip_filename_info(None, None) version = string_util.remove_head(basename, 'pip') version_parts = [ p for p in version.split('.') if p ] num_version_parts = len(version_parts) if num_version_parts not in ( 1, 2 ): version = None libdir = clazz._pip_exe_determine_libdir(pip_exe, version) return clazz._pip_filename_info(version, libdir)
def test_one_script_with_bump_tag(self): r1 = git_temp_repo(debug = self.DEBUG) if host.is_windows(): script = 'nothing.bat' content = '''\ @echo off exit 0 '''.format(script) elif host.is_unix(): script = './nothing.sh' content = '''\ #!/bin/bash exit 0 '''.format(script) else: assert False xp_script = self.native_filename(script) r1.add_file(xp_script, content, mode = 0o0755) r1.push('origin', 'master') r1.tag('1.0.0') r1.push_tag('1.0.0') options = git_repo_script_options(bump_tag_component = 'revision') scripts = [ git_util.script(xp_script, []), ] rv = git_util.repo_run_scripts(r1.address, scripts, options = options) self.assertEqual( 1, len(rv.results) ) r2 = r1.make_temp_cloned_repo() self.assertEqual( '1.0.1', r2.greatest_local_tag().name ) options = git_repo_script_options(bump_tag_component = 'major') scripts = [ git_util.script(xp_script, []), ] rv = git_util.repo_run_scripts(r1.address, scripts, options = options) self.assertEqual( 1, len(rv.results) ) self.assertEqual( '2.0.1', r2.greatest_remote_tag().name )
def test_one_script_with_push(self): r1 = git_temp_repo(debug = self.DEBUG) if host.is_windows(): script = self.native_filename('fruits/kiwi.bat') content = '''\ @echo off echo yellow > color.txt git add color.txt git commit -madd color.txt exit 0 ''' elif host.is_unix(): script = self.native_filename('fruits/kiwi.sh') content = '''\ #!/bin/bash echo yellow > color.txt git add color.txt git commit -madd color.txt exit 0 ''' else: assert False xp_script = self.native_filename(script) r1.add_file(xp_script, content, mode = 0o0755) r1.push('origin', 'master') r1.tag('1.0.0') r1.push_tag('1.0.0') options = git_repo_script_options(push = True) scripts = [ git_util.script(xp_script, [ 'arg1', 'arg2' ]), ] rv = git_util.repo_run_scripts(r1.address, scripts, options = options) self.assertEqual( 1, len(rv.results) ) r2 = r1.make_temp_cloned_repo() self.assertEqual( 'yellow', r2.read_file('color.txt').strip() )
#-*- coding:utf-8; mode:python; indent-tabs-mode: nil; c-basic-offset: 2; tab-width: 2 -*- from ..system.check import check from bes.system.host import host if host.is_macos(): from .native_package_macos import native_package_macos as native_package elif host.is_linux(): from .native_package_linux import native_package_linux as native_package elif host.is_windows(): from .native_package_windows import native_package_windows as native_package else: host.raise_unsupported_system() check.register_class(native_package, name = 'native_package', include_seq = False)
def _binary_filename(clazz, script_filename): basename = path.basename(filename_util.without_extension(script_filename)) if host.is_windows(): return basename + '.exe' return basename
class test_execute(unit_test): @unit_test_function_skip.skip_if(not host.is_windows(), 'not windows') def test_windows_batch_file_success(self): script = '''\ @echo off echo %* exit 0 ''' bat = self.make_temp_file(content=script, suffix='.bat') cmd = [bat, 'foo', 'bar'] rv = execute.execute(cmd, shell=False) self.assertEqual(0, rv.exit_code) self.assertEqual('foo bar', rv.stdout.strip()) @unit_test_function_skip.skip_if(not host.is_windows(), 'not windows') def test_windows_batch_file_success_flat(self): script = '''\ @echo off echo %* exit 0 ''' bat = self.make_temp_file(content=script, suffix='.bat') cmd = f'{bat} foo bar' rv = execute.execute(cmd, shell=False) self.assertEqual(0, rv.exit_code) self.assertEqual('foo bar', rv.stdout.strip()) @unit_test_function_skip.skip_if(not host.is_windows(), 'not windows') def test_windows_batch_file_success_shell(self): script = '''\ @echo off echo %* exit 0 ''' bat = self.make_temp_file(content=script, suffix='.bat') cmd = [bat, 'foo', 'bar'] rv = execute.execute(cmd, shell=True, quote=True) self.assertEqual(0, rv.exit_code) self.assertEqual('foo bar', rv.stdout.strip()) @unit_test_function_skip.skip_if(not host.is_windows(), 'not windows') def test_windows_batch_file_success_flat_shell(self): script = '''\ @echo off echo %* exit 0 ''' bat = self.make_temp_file(content=script, suffix='.bat') cmd = f'"{bat}" foo bar' rv = execute.execute(cmd, shell=True, quote=True) self.assertEqual(0, rv.exit_code) self.assertEqual('foo bar', rv.stdout.strip()) @unit_test_function_skip.skip_if(not host.is_windows(), 'not windows') def test_windows_batch_file_failure(self): script = '''\ @echo off echo %* exit 1 ''' bat = self.make_temp_file(content=script, suffix='.bat') cmd = [bat, 'foo', 'bar'] rv = execute.execute(cmd, shell=False, raise_error=False) self.assertEqual(1, rv.exit_code) @unit_test_function_skip.skip_if(not host.is_windows(), 'not windows') def test_windows_batch_file_failure_flat(self): script = '''\ @echo off echo %* exit 1 ''' bat = self.make_temp_file(content=script, suffix='.bat') cmd = f'"{bat}" foo bar' rv = execute.execute(cmd, shell=False, raise_error=False) self.assertEqual(1, rv.exit_code) self.assertEqual('foo bar', rv.stdout.strip()) @unit_test_function_skip.skip_if(not host.is_windows(), 'not windows') def test_windows_batch_file_failure_shell(self): script = '''\ @echo off echo %* exit 1 ''' bat = self.make_temp_file(content=script, suffix='.bat') cmd = [bat, 'foo', 'bar'] rv = execute.execute(cmd, shell=True, raise_error=False, quote=True) self.assertEqual(1, rv.exit_code) @unit_test_function_skip.skip_if(not host.is_windows(), 'not windows') def test_windows_batch_file_failure_flat_shell(self): script = '''\ @echo off echo %* exit 1 ''' bat = self.make_temp_file(content=script, suffix='.bat') cmd = f'"{bat}" foo bar' rv = execute.execute(cmd, shell=True, raise_error=False, quote=True) self.assertEqual(1, rv.exit_code) @unit_test_function_skip.skip_if(not host.is_unix(), 'not unix') def test_unix_shell_script_success(self): script = '''\ #!/bin/sh echo "$@" exit 0 ''' bat = self.make_temp_file(content=script, perm=0o0755, suffix='.sh') cmd = [bat, 'foo', 'bar'] rv = execute.execute(cmd, shell=False) self.assertEqual(0, rv.exit_code) self.assertEqual('foo bar', rv.stdout.strip()) @unit_test_function_skip.skip_if(not host.is_unix(), 'not unix') def test_unix_shell_script_success_flat(self): script = '''\ #!/bin/sh echo "$@" exit 0 ''' bat = self.make_temp_file(content=script, perm=0o0755, suffix='.sh') cmd = f'"{bat}" foo bar' rv = execute.execute(cmd, shell=False) self.assertEqual(0, rv.exit_code) self.assertEqual('foo bar', rv.stdout.strip()) @unit_test_function_skip.skip_if(not host.is_unix(), 'not unix') def test_unix_shell_script_success_shell(self): script = '''\ #!/bin/sh echo "$@" exit 0 ''' bat = self.make_temp_file(content=script, perm=0o0755, suffix='.sh') cmd = [bat, 'foo', 'bar'] rv = execute.execute(cmd, shell=True, quote=True) self.assertEqual(0, rv.exit_code) self.assertEqual('foo bar', rv.stdout.strip()) @unit_test_function_skip.skip_if(not host.is_unix(), 'not unix') def test_unix_shell_script_success_flat_shell(self): script = '''\ #!/bin/sh echo "$@" exit 0 ''' bat = self.make_temp_file(content=script, perm=0o0755, suffix='.sh') cmd = f'"{bat}" foo bar' rv = execute.execute(cmd, shell=True, quote=True) self.assertEqual(0, rv.exit_code) self.assertEqual('foo bar', rv.stdout.strip()) @unit_test_function_skip.skip_if(not host.is_unix(), 'not unix') def test_unix_shell_script_failure(self): script = '''\ #!/bin/sh echo "$@" exit 1 ''' bat = self.make_temp_file(content=script, perm=0o0755, suffix='.sh') cmd = [bat, 'foo', 'bar'] rv = execute.execute(cmd, shell=False, raise_error=False) self.assertEqual(1, rv.exit_code) @unit_test_function_skip.skip_if(not host.is_unix(), 'not unix') def test_unix_shell_script_failure_flat(self): script = '''\ #!/bin/sh echo "$@" exit 1 ''' bat = self.make_temp_file(content=script, perm=0o0755, suffix='.sh') cmd = f'"{bat}" foo bar' rv = execute.execute(cmd, shell=False, raise_error=False) self.assertEqual(1, rv.exit_code) self.assertEqual('foo bar', rv.stdout.strip()) @unit_test_function_skip.skip_if(not host.is_unix(), 'not unix') def test_unix_shell_script_failure_shell(self): script = '''\ #!/bin/sh echo "$@" exit 1 ''' bat = self.make_temp_file(content=script, perm=0o0755, suffix='.sh') cmd = [f'"{bat}"', 'foo', 'bar'] rv = execute.execute(cmd, shell=True, raise_error=False, quote=True) self.assertEqual(1, rv.exit_code) @unit_test_function_skip.skip_if(not host.is_unix(), 'not unix') def test_unix_shell_script_failure_flat_shell(self): script = '''\ #!/bin/sh echo "$@" exit 1 ''' bat = self.make_temp_file(content=script, perm=0o0755, suffix='.sh') cmd = f'"{bat}" foo bar' rv = execute.execute(cmd, shell=True, raise_error=False, quote=True) self.assertEqual(1, rv.exit_code) def test_python_script_success(self): content = '''\ import sys print(f'success:{sys.argv[1]}') raise SystemExit(0) ''' script = self.make_temp_file(content=content, perm=0o0755, suffix='.py') cmd = [script, 'foo'] rv = execute.execute(cmd, shell=True, raise_error=False, quote=True) self.assertEqual(0, rv.exit_code) self.assertEqual('success:foo', rv.stdout.strip()) def test_python_script_failure(self): content = '''\ import sys print(f'failure:{sys.argv[1]}') raise SystemExit(1) ''' script = self.make_temp_file(content=content, perm=0o0755, suffix='.py') cmd = [script, 'foo'] rv = execute.execute(cmd, shell=True, raise_error=False, quote=True) self.assertEqual(1, rv.exit_code) def test_python_script_uppercase_extension(self): content = '''\ import sys print(f'success:{sys.argv[1]}') raise SystemExit(0) ''' script = self.make_temp_file(content=content, perm=0o0755, suffix='.PY') cmd = [script, 'foo'] rv = execute.execute(cmd, shell=True, raise_error=False, quote=True) self.assertEqual(0, rv.exit_code) self.assertEqual('success:foo', rv.stdout.strip()) @unit_test_function_skip.skip_if(not host.is_unix(), 'not unix') def test_execute_stdout_stderr(self): script = '''\ #!/bin/sh echo "this_is_stderr 1" >&2 echo "this_is_stdout 1" >&1 echo "this_is_stderr 2" >&2 echo "this_is_stdout 2" >&1 echo "this_is_stdout 3" >&1 echo "this_is_stdout 4" >&1 echo "this_is_stderr 3" >&2 echo "this_is_stderr 4" >&2 exit 0 ''' bat = self.make_temp_file(content=script, perm=0o0755) rv = execute.execute(bat, shell=False, raise_error=False) self.assertEqual(0, rv.exit_code) self.assert_string_equal_fuzzy( r''' this_is_stdout 1 this_is_stdout 2 this_is_stdout 3 this_is_stdout 4 ''', rv.stdout) self.assert_string_equal_fuzzy( r''' this_is_stderr 1 this_is_stderr 2 this_is_stderr 3 this_is_stderr 4 ''', rv.stderr) @unit_test_function_skip.skip_if(not host.is_unix(), 'not unix') def test_execute_stdout_stderr_non_blocking(self): script = '''\ #!/bin/sh echo "this_is_stderr 1" >&2 echo "this_is_stdout 1" >&1 echo "this_is_stderr 2" >&2 echo "this_is_stdout 2" >&1 echo "this_is_stdout 3" >&1 echo "this_is_stdout 4" >&1 echo "this_is_stderr 3" >&2 echo "this_is_stderr 4" >&2 exit 0 ''' bat = self.make_temp_file(content=script, perm=0o0755) rv = execute.execute(bat, shell=False, raise_error=False, non_blocking=True) self.assertEqual(0, rv.exit_code) self.assert_string_equal_fuzzy( r''' this_is_stdout 1 this_is_stdout 2 this_is_stdout 3 this_is_stdout 4 ''', rv.stdout) self.assert_string_equal_fuzzy( r''' this_is_stderr 1 this_is_stderr 2 this_is_stderr 3 this_is_stderr 4 ''', rv.stderr) @unit_test_function_skip.skip_if(not host.is_unix(), 'not unix') def test_execute_stderr_to_stdout_non_blocking(self): script = '''\ #!/bin/sh echo "this_is_stderr 1" >&2 echo "this_is_stdout 1" >&1 echo "this_is_stderr 2" >&2 echo "this_is_stdout 2" >&1 echo "this_is_stdout 3" >&1 echo "this_is_stdout 4" >&1 echo "this_is_stderr 3" >&2 echo "this_is_stderr 4" >&2 exit 0 ''' bat = self.make_temp_file(content=script, perm=0o0755) rv = execute.execute(bat, shell=False, raise_error=False, non_blocking=True, stderr_to_stdout=True) self.assertEqual(0, rv.exit_code) self.assert_string_equal_fuzzy( r''' this_is_stderr 1 this_is_stdout 1 this_is_stderr 2 this_is_stdout 2 this_is_stdout 3 this_is_stdout 4 this_is_stderr 3 this_is_stderr 4 ''', rv.stdout) self.assert_string_equal_fuzzy('', rv.stderr) @unit_test_function_skip.skip_if(not host.is_unix(), 'not unix') def test_execute_output_function_non_blocking(self): script = '''\ #!/bin/sh echo "this_is_stderr 1" >&2 echo "this_is_stdout 1" >&1 echo "this_is_stderr 2" >&2 echo "this_is_stdout 2" >&1 echo "this_is_stdout 3" >&1 echo "this_is_stdout 4" >&1 echo "this_is_stderr 3" >&2 echo "this_is_stderr 4" >&2 exit 0 ''' stdout_lines = [] stderr_lines = [] def _func(output): stdout_lines.append(output.stdout) stderr_lines.append(output.stderr) bat = self.make_temp_file(content=script, perm=0o0755) rv = execute.execute(bat, shell=False, raise_error=False, non_blocking=True, output_function=_func) self.assertEqual(0, rv.exit_code) self.assert_string_equal_fuzzy( r''' this_is_stdout 1 this_is_stdout 2 this_is_stdout 3 this_is_stdout 4 ''', rv.stdout) self.assert_string_equal_fuzzy( r''' this_is_stderr 1 this_is_stderr 2 this_is_stderr 3 this_is_stderr 4 ''', rv.stderr) self.assert_string_equal_fuzzy( r''' this_is_stdout 1 this_is_stdout 2 this_is_stdout 3 this_is_stdout 4 ''', os.linesep.join(stdout_lines)) self.assert_string_equal_fuzzy( r''' this_is_stderr 1 this_is_stderr 2 this_is_stderr 3 this_is_stderr 4 ''', os.linesep.join(stderr_lines)) @unit_test_function_skip.skip_if(not host.is_unix(), 'not unix') def test_execute_output_function_non_blocking_with_stderr_to_stdout(self): script = '''\ #!/bin/sh echo "this_is_stderr 1" >&2 echo "this_is_stdout 1" >&1 echo "this_is_stderr 2" >&2 echo "this_is_stdout 2" >&1 echo "this_is_stdout 3" >&1 echo "this_is_stdout 4" >&1 echo "this_is_stderr 3" >&2 echo "this_is_stderr 4" >&2 exit 0 ''' stdout_lines = [] stderr_lines = [] def _func(output): if output.stdout: stdout_lines.append(output.stdout) if output.stderr: stderr_lines.append(output.stderr) bat = self.make_temp_file(content=script, perm=0o0755) rv = execute.execute(bat, shell=False, raise_error=False, non_blocking=True, output_function=_func, stderr_to_stdout=True) self.assertEqual(0, rv.exit_code) self.assert_string_equal_fuzzy( r''' this_is_stderr 1 this_is_stdout 1 this_is_stderr 2 this_is_stdout 2 this_is_stdout 3 this_is_stdout 4 this_is_stderr 3 this_is_stderr 4 ''', rv.stdout) self.assert_string_equal_fuzzy('', rv.stderr) self.assert_string_equal_fuzzy( r''' this_is_stderr 1 this_is_stdout 1 this_is_stderr 2 this_is_stdout 2 this_is_stdout 3 this_is_stdout 4 this_is_stderr 3 this_is_stderr 4 ''', os.linesep.join(stdout_lines)) self.assert_string_equal_fuzzy('', os.linesep.join(stderr_lines))
class test_python_installation(unit_test): @unit_test_function_skip.skip_if(not host.is_macos(), 'not macos') def test_macos_xcode_38(self): tmp_dir = python_testing.make_temp_fake_python_installation('3.8', '19.2.3', 'xcode', system = 'macos', debug = self.DEBUG) piv = python_installation(path.join(tmp_dir, 'bin/python3'), system = 'macos') self.assertEqual( '3.8', piv.python_version ) self.assert_filename_equal( path.join(tmp_dir, 'bin/python3'), piv.python_exe ) self.assert_filename_equal( path.join(tmp_dir, 'bin/pip3'), piv.pip_exe ) self.assert_filename_list_equal( [ path.join(tmp_dir, 'bin') ], piv.PATH ) @unit_test_function_skip.skip_if(not host.is_macos(), 'not macos') def test_macos_system_27(self): tmp_dir = python_testing.make_temp_fake_python_installation('2.7', None, 'system', system = 'macos', debug = self.DEBUG) piv = python_installation(path.join(tmp_dir, 'bin/python'), system = 'macos') self.assertEqual( '2.7', piv.python_version ) self.assert_filename_equal( path.join(tmp_dir, 'bin/python2.7'), piv.python_exe ) self.assert_filename_equal( None, piv.pip_exe ) self.assert_filename_list_equal( [ path.join(tmp_dir, 'bin') ], piv.PATH ) @unit_test_function_skip.skip_if(not host.is_macos(), 'not macos') def test_macos_brew_37(self): tmp_dir = python_testing.make_temp_fake_python_installation('3.7', '21.0.1', 'brew', system = 'macos', debug = self.DEBUG) piv = python_installation(path.join(tmp_dir, 'bin/python3.7'), system = 'macos') self.assertEqual( '3.7', piv.python_version ) self.assert_filename_equal( path.join(tmp_dir, 'bin/python3.7'), piv.python_exe ) self.assert_filename_equal( path.join(tmp_dir, 'bin/pip3.7'), piv.pip_exe ) self.assert_filename_list_equal( [ path.join(tmp_dir, 'bin') ], piv.PATH ) @unit_test_function_skip.skip_if(not host.is_windows(), 'not windows') def test_windows_python_38(self): tmp_dir = python_testing.make_temp_fake_python_installation('3.8', '19.2.3', None, system = 'windows', debug = self.DEBUG) piv = python_installation(path.join(tmp_dir, 'python.bat'), system = 'windows') self.assertEqual( '3.8', piv.python_version ) self.assert_filename_equal( path.join(tmp_dir, 'python.bat'), piv.python_exe ) self.assert_filename_equal( path.join(tmp_dir, 'Scripts', 'pip3.8.bat'), piv.pip_exe ) self.assert_filename_list_equal( [ tmp_dir, path.join(tmp_dir, 'Scripts'), ], piv.PATH ) @unit_test_function_skip.skip_if(not host.is_windows(), 'not windows') def test_windows_python_27(self): tmp_dir = python_testing.make_temp_fake_python_installation('2.7', '20.3.4', None, system = 'windows', debug = self.DEBUG) piv = python_installation(path.join(tmp_dir, 'python.bat'), system = 'windows') self.assertEqual( '2.7', piv.python_version ) self.assert_filename_equal( path.join(tmp_dir, 'python.bat'), piv.python_exe ) self.assert_filename_equal( path.join(tmp_dir, 'Scripts', 'pip2.7.bat'), piv.pip_exe )
def skip_if_not_windows(warning = False): return unit_test_function_skip.skip_if(not host.is_windows(), 'not windows', warning = warning)