def test_env_and_gradle(self):
cm = credentials_manager()
cm.add_source(
credentials_source_env({
'username': '******',
'password': '******'
}))
text = '''\
[email protected]
devPassword=xflintpass
systemProp.gradle.wrapperUser=tuser
systemProp.gradle.wrapperPassword=tpassword
'''
cm.add_source(
credentials_source_gradle(temp_file.make_temp_file(content=text),
'dev'))
with env_override({
'MY_USERNAME': '******',
'MY_PASSWORD': '******'
}) as env:
self.assertEqual(True, cm.is_valid())
c = cm.credentials()
self.assertEqual('fred', c.username)
self.assertEqual('flintpass', c.password)
with env_override() as env:
self.assertEqual(True, cm.is_valid())
c = cm.credentials()
self.assertEqual('*****@*****.**', c.username)
self.assertEqual('xflintpass', c.password)
def test_env_vars(self):
content = '''\
ape
activity: ${_CONFIG_ACTIVITY}
snack: leaves
bonobo extends ape
activity: loving
snack: ${_CONFIG_SNACK}
chimp extends ape
activity: fighting
snack: eggs
'''
tmp_dir = self.make_temp_dir()
tmp_file = path.join(tmp_dir, 'apes.config')
file_util.save(tmp_file, content=content)
with env_override(env={
'_CONFIG_ACTIVITY': 'resting',
'_CONFIG_SNACK': 'kiwi'
}) as tmp_env:
s = SCL(tmp_dir, '*.config')
s.load()
self.assertEqual('fighting',
s.section('chimp').find_by_key('activity'))
self.assertEqual('loving',
s.section('bonobo').find_by_key('activity'))
self.assertEqual('eggs', s.section('chimp').find_by_key('snack'))
self.assertEqual('kiwi', s.section('bonobo').find_by_key('snack'))
def test_search_path_env_var(self):
content = '''\
ape
activity: resting
snack: leaves
bonobo extends ape
activity: loving
snack: kiwi
chimp extends ape
activity: fighting
snack: eggs
'''
tmp_file = self.make_named_temp_file('apes.config', content=content)
with env_override(
env={'_CONFIG_DIR': path.dirname(tmp_file)}) as tmp_env:
s = SCL('${_CONFIG_DIR}', '*.config')
s.load()
self.assertEqual('fighting',
s.section('chimp').find_by_key('activity'))
self.assertEqual('loving',
s.section('bonobo').find_by_key('activity'))
self.assertEqual('eggs', s.section('chimp').find_by_key('snack'))
self.assertEqual('kiwi', s.section('bonobo').find_by_key('snack'))
def test_env_vars(self):
c = credentials('<unittest>')
c.username = '******'
c.password = '******'
with env_override( { 'MY_USERNAME': '******', 'MY_PASSWORD': '******' }) as env:
self.assertEqual( 'fred', c.username )
self.assertEqual( 'flintpass', c.password )
def test_foo(self):
env = {
'SOMETHINGIMADEUP': 'GOOD',
'PATH': '/bin:/usr/bin:/my/path:/sbin'
}
with env_override(env = env) as tmp_env:
tmp_dir = self.make_temp_dir()
temp_content.write_items([
'file 1.sh "export PATH=/bin:/usr/bin:/sbin\n" 644',
'file 2.sh "export BAR=orange\n" 644',
'file 3.sh "export PATH=/a/bin:$PATH\nexport PATH=/b/bin:$PATH\n" 644',
'file 4.sh "export FOO=kiwi\n" 644',
'file 5.sh "export PATH=$PATH:/x/bin\nPATH=$PATH:/y/bin\n" 644',
'file 6.sh "unset SOMETHINGIMADEUP\n" 644',
], tmp_dir)
ed = env_dir(tmp_dir)
self.assertEqual( [ '1.sh', '2.sh', '3.sh', '4.sh', '5.sh', '6.sh' ], ed.files )
self.assertEqual( [
( 'BAR', 'orange', action.SET ),
( 'FOO', 'kiwi', action.SET ),
( 'PATH', '/a/bin', action.PATH_PREPEND ),
( 'PATH', '/b/bin', action.PATH_PREPEND ),
( 'PATH', '/my/path', action.PATH_REMOVE ),
( 'PATH', '/x/bin', action.PATH_APPEND ),
( 'PATH', '/y/bin', action.PATH_APPEND ),
( 'SOMETHINGIMADEUP', None, action.UNSET ),
], ed.instructions(tmp_env.to_dict()) )
def call_pyinstaller(clazz, args, build_dir = None, replace_env = None):
check.check_string_seq(args)
check.check_string(build_dir, allow_none = True)
check.check_dict(replace_env, check.STRING_TYPES, check.STRING_TYPES)
cmd = command_line.parse_args(args)
replace_env = replace_env or {}
env = os_env.clone_current_env(d = {})
env.update(replace_env)
clazz._log.log_d('using env: {}'.format(pprint.pformat(env)))
clazz._log.log_d('calling pyinstaller: {}'.format(' '.join(cmd)))
if build_dir:
file_util.mkdir(build_dir)
dist_dir = path.join(build_dir, 'dist')
work_dir = path.join(build_dir, 'work')
spec_dir = path.join(build_dir, 'spec')
args = args[:]
args.extend([ '--distpath', dist_dir ])
args.extend([ '--workpath', work_dir ])
args.extend([ '--specpath', spec_dir ])
try:
with env_override(env = env) as _:
PyInstaller_run(pyi_args = args, pyi_config = None)
except Exception as ex:
raise pyinstaller_error(str(ex))
def test_valid(self):
cs = CSE({'username': '******', 'password': '******'})
with env_override({
'MY_USERNAME': '******',
'MY_PASSWORD': '******'
}) as env:
self.assertEqual(True, cs.is_valid())
c = cs.credentials()
self.assertEqual('fred', c.username)
self.assertEqual('flintpass', c.password)
def test_from_config_file_from_env(self):
content = '''\
fruit
username: foo
password: sekret
port: 9999
'''
tmp_config = self.make_temp_file(content=content)
with env_override(
{'_BES_CLI_OPTIONS_UNIT_TEST_CONFIG_FILE': tmp_config}) as env:
o = _test_cli_options()
self.assertEqual('foo', o.username)
self.assertEqual('sekret', o.password)
self.assertEqual(9999, o.port)
def test_env_vars(self):
cm = credentials_manager()
cm.add_source(
credentials_source_env({
'username': '******',
'password': '******'
}))
with env_override({
'MY_USERNAME': '******',
'MY_PASSWORD': '******'
}) as env:
self.assertEqual(True, cm.is_valid())
c = cm.credentials()
self.assertEqual('fred', c.username)
self.assertEqual('flintpass', c.password)
def test_env_var(self):
text = '''\
# This is one
credential
provider: pcloud
type: download
email: [email protected] # one
password: ${SEKRET1}
# This is two
credential
provider: pcloud
type: upload
email: [email protected] # two
password: ${SEKRET2}
'''
with env_override(env = { 'SEKRET1': 'sekret1', 'SEKRET2': 'sekret2' }) as tmp_env:
s = simple_config.from_text(text)
sections = s.find_all_sections('credential')
self.assertEqual( 2, len(sections) )
self.assertEqual( 'download', sections[0].find_by_key('type') )
self.assertEqual( 'upload', sections[1].find_by_key('type') )
self.assertEqual( '${SEKRET1}', sections[0].find_by_key('password', resolve_env_vars = False) )
self.assertEqual( 'sekret1', sections[0].find_by_key('password', resolve_env_vars = True) )
self.assertEqual( 'sekret1', sections[0].get_value('password') )
self.assertEqual( True, sections[0].has_key('password') )
self.assertEqual( False, sections[0].has_key('missingkey') )
self.assertEqual( {
'provider': 'pcloud',
'type': 'download',
'email': '*****@*****.**',
'password': '******',
}, sections[0].to_dict(resolve_env_vars = False) )
self.assertEqual( {
'provider': 'pcloud',
'type': 'download',
'email': '*****@*****.**',
'password': '******',
}, sections[0].to_dict(resolve_env_vars = True) )
def test_env_override_push_pop(self):
original_env = os_env.clone_current_env()
with env_override() as env:
env.push()
env.set('FOO', '666')
self.assertEqual(self._dict_combine(original_env, {'FOO': '666'}),
os_env.clone_current_env())
env.push()
env.set('BAR', '667')
self.assertEqual(
self._dict_combine(original_env, {
'FOO': '666',
'BAR': '667'
}), os_env.clone_current_env())
env.pop()
self.assertEqual(self._dict_combine(original_env, {'FOO': '666'}),
os_env.clone_current_env())
env.pop()
self.assertEqual(original_env, os_env.clone_current_env())
self.assertEqual(original_env, os_env.clone_current_env())
def version_info(clazz, pip_exe, pythonpath=None):
'Return the version info of a pip executable'
check.check_string(pip_exe)
check.check_string_seq(pythonpath, allow_none=True)
pythonpath = pythonpath or []
cmd = [pip_exe, '--version']
env_PYTHONPATH = os.pathsep.join(pythonpath)
with env_override(env={'PYTHONPATH': env_PYTHONPATH}) as env:
clazz._log.log_d('version_info: pip_exe={} PYTHONPATH={}'.format(
pip_exe, env_PYTHONPATH))
try:
output_bytes = subprocess.check_output(
cmd, stderr=subprocess.STDOUT)
output = codecs.decode(output_bytes, 'utf-8').strip()
except subprocess.CalledProcessError as ex:
output_bytes = ex.output
output = codecs.decode(output_bytes, 'utf-8').strip()
msg = 'version_info: Failed to run: "{}" - {}'.format(
' '.join(cmd), output)
clazz._log.log_w(msg)
raise python_error(msg, status_code=ex.returncode)
clazz._log.log_d('version_info: output="{}"'.format(output))
f = re.findall(clazz._PIP_VERSION_PATTERN, output)
clazz._log.log_d('version_info: f="{}"'.format(f))
if not f:
raise python_error(
'version_info: not a valid pip version for {}: "{}"'.format(
pip_exe, output))
if len(f[0]) != 3:
raise python_error(
'version_info: not a valid pip version for {}: "{}"'.format(
pip_exe, output))
version = f[0][0]
where = f[0][1]
python_version = f[0][2]
return clazz._pip_version_info(version, where, python_version)
def test_extract_alpine_linux_with_docker(self):
tmp_tar_exe_dir = self.make_temp_dir()
fail_flag_file = self.make_temp_file(content = 'foo', suffix = '.flag')
fake_tar_content = '''\
#!/bin/bash
${_BES_TAR_EXE} ${1+"$@"}
if [[ -f ${_BES_TAR_FAIL_FLAG} ]]; then
rm -f ${_BES_TAR_FAIL_FLAG}
exit 2
fi
rv=$?
exit ${rv}
'''
tar_exe = file_util.save(path.join(tmp_tar_exe_dir, 'tar'), content = fake_tar_content, mode = 0o0755)
tmp_dir = self.make_temp_dir()
old_path = os_env_var
with env_override(env = { '_BES_TAR_EXE': tar_util.tar_exe(), '_BES_TAR_FAIL_FLAG': fail_flag_file }) as over:
os_env_var('PATH').prepend(tmp_tar_exe_dir)
tar_util.extract(self.data_path('test.tar'), tmp_dir)
expected_files = [
self.native_filename('1'),
self.native_filename('1/2'),
self.native_filename('1/2/3'),
self.native_filename('1/2/3/4'),
self.native_filename('1/2/3/4/5'),
self.native_filename('1/2/3/4/5/apple.txt'),
self.native_filename('1/2/3/4/5/kiwi.txt'),
self.native_filename('bar.txt'),
self.native_filename('empty'),
self.native_filename('foo.txt'),
self.native_filename('kiwi_link.txt'),
]
actual_files = file_find.find(tmp_dir, file_type = file_find.ANY)
self.assertEqual( expected_files, actual_files )
def test_env_override_set(self):
original_env = os_env.clone_current_env()
with env_override() as env:
env.set('FOO', '666')
env.set('BAR', 'hi')
self.assertEqual(original_env, os_env.clone_current_env())
def test_invalid(self):
cs = CSE({'username': '******', 'password': '******'})
with env_override({'MY_USERNAME': '******'}) as env:
self.assertEqual(False, cs.is_valid())
def test_env_override_init(self):
original_env = os_env.clone_current_env()
with env_override({'FOO': '666', 'BAR': 'hi'}) as env:
pass
self.assertEqual(original_env, os_env.clone_current_env())
def test_env_var_one_var(self):
f = self.fruit('${COLOR}', 'tart')
with env_override({'COLOR': 'yellow'}) as env:
self.assertEqual('yellow', f.color)
self.assertEqual('tart', f.flavor)
def test_env_var_two_vars(self):
f = self.fruit('${MODIFIER}${COLOR}', 'tart')
with env_override({'COLOR': 'yellow', 'MODIFIER': 'nice'}) as env:
self.assertEqual('niceyellow', f.color)
self.assertEqual('tart', f.flavor)
def test_env_var_tilde_and_var(self):
f = self.fruit('yellow', '~/${FLAVOR}')
with env_override({'HOME': '/tmp/foo', 'FLAVOR': 'tart'}) as env:
self.assertEqual('yellow', f.color)
self.assertEqual('/tmp/foo/tart', f.flavor)
def test_env_var_multiple_vars(self):
f = self.fruit('${COLOR}', '${FLAVOR}')
with env_override({'COLOR': 'yellow', 'FLAVOR': 'tart'}) as env:
self.assertEqual('yellow', f.color)
self.assertEqual('tart', f.flavor)