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)
