def test_CMDcheck_new_variables(self):
# Test bug #61.
isolate_file = os.path.join(self.cwd, 'x.isolate')
isolated_file = os.path.join(self.cwd, 'x.isolated')
cmd = [
'-i', isolate_file,
'-s', isolated_file,
'--config-variable', 'OS=dendy',
]
with open(isolate_file, 'wb') as f:
f.write(
'# Foo\n'
'{'
' \'conditions\':['
' [\'OS=="dendy"\', {'
' \'variables\': {'
' \'command\': [\'foo\'],'
' \'isolate_dependency_tracked\': [\'foo\'],'
' },'
' }],'
' ],'
'}')
with open(os.path.join(self.cwd, 'foo'), 'wb') as f:
f.write('yeah')
self.mock(sys, 'stdout', cStringIO.StringIO())
self.assertEqual(0, isolate.CMDcheck(isolate.OptionParserIsolate(), cmd))
# Now add a new config variable.
with open(isolate_file, 'wb') as f:
f.write(
'# Foo\n'
'{'
' \'conditions\':['
' [\'OS=="dendy"\', {'
' \'variables\': {'
' \'command\': [\'foo\'],'
' \'isolate_dependency_tracked\': [\'foo\'],'
' },'
' }],'
' [\'foo=="baz"\', {'
' \'variables\': {'
' \'isolate_dependency_tracked\': [\'bar\'],'
' },'
' }],'
' ],'
'}')
with open(os.path.join(self.cwd, 'bar'), 'wb') as f:
f.write('yeah right!')
# The configuration is OS=dendy and foo=bar. So it should load both
# configurations.
self.assertEqual(
0,
isolate.CMDcheck(
isolate.OptionParserIsolate(),
cmd + ['--config-variable', 'foo=bar']))
def test_CMDrun_extra_args(self):
cmd = [
'run',
'--isolate', 'blah.isolate',
'--', 'extra_args',
]
self.mock(isolate, 'load_complete_state', self.load_complete_state)
self.mock(isolate.subprocess, 'call', lambda *_, **_kwargs: 0)
self.assertEqual(0, isolate.CMDrun(isolate.OptionParserIsolate(), cmd))
def test_CMDcheck_empty(self):
isolate_file = os.path.join(self.cwd, 'x.isolate')
isolated_file = os.path.join(self.cwd, 'x.isolated')
with open(isolate_file, 'wb') as f:
f.write('# Foo\n{\n}')
self.mock(sys, 'stdout', cStringIO.StringIO())
cmd = ['-i', isolate_file, '-s', isolated_file]
isolate.CMDcheck(isolate.OptionParserIsolate(), cmd)
def test_CMDcheck_isolate_copied(self):
# Note that moving the .isolate file is a different code path, this is about
# copying the .isolate file to a new place and specifying the new location
# on a subsequent execution.
x_isolate_file = os.path.join(self.cwd, 'x.isolate')
isolated_file = os.path.join(self.cwd, 'x.isolated')
cmd = ['-i', x_isolate_file, '-s', isolated_file]
with open(x_isolate_file, 'wb') as f:
f.write('{}')
self.assertEqual(0, isolate.CMDcheck(isolate.OptionParserIsolate(), cmd))
self.assertTrue(os.path.isfile(isolated_file + '.state'))
with open(isolated_file + '.state', 'rb') as f:
self.assertEqual(json.load(f)['isolate_file'], 'x.isolate')
# Move the .isolate file.
y_isolate_file = os.path.join(self.cwd, 'Y.isolate')
shutil.copyfile(x_isolate_file, y_isolate_file)
cmd = ['-i', y_isolate_file, '-s', isolated_file]
self.assertEqual(0, isolate.CMDcheck(isolate.OptionParserIsolate(), cmd))
with open(isolated_file + '.state', 'rb') as f:
self.assertEqual(json.load(f)['isolate_file'], 'Y.isolate')
def test_CMDarchive(self):
actual = []
self.mock(
isolate.isolateserver, 'upload_tree',
lambda **kwargs: actual.append(kwargs))
isolate_file = os.path.join(self.cwd, 'x.isolate')
isolated_file = os.path.join(self.cwd, 'x.isolated')
with open(isolate_file, 'wb') as f:
f.write(
'# Foo\n'
'{'
' \'conditions\':['
' [\'OS=="dendy"\', {'
' \'variables\': {'
' \'isolate_dependency_tracked\': [\'foo\'],'
' },'
' }],'
' ],'
'}')
with open(os.path.join(self.cwd, 'foo'), 'wb') as f:
f.write('fooo')
self.mock(sys, 'stdout', cStringIO.StringIO())
cmd = [
'-i', isolate_file,
'-s', isolated_file,
'--isolate-server', 'http://localhost:1',
'--config-variable', 'OS', 'dendy',
]
self.assertEqual(0, isolate.CMDarchive(isolate.OptionParserIsolate(), cmd))
expected = [
{
'base_url': 'http://localhost:1',
'indir': self.cwd,
'infiles': {
isolated_file: {
'priority': '0',
},
u'foo': {
'h': '520d41b29f891bbaccf31d9fcfa72e82ea20fcf0',
's': 4,
},
},
'namespace': 'default-gzip',
},
]
# These always change.
actual[0]['infiles'][isolated_file].pop('h')
actual[0]['infiles'][isolated_file].pop('s')
actual[0]['infiles']['foo'].pop('m')
actual[0]['infiles']['foo'].pop('t')
self.assertEqual(expected, actual)
def test_CMDrun_no_isolated(self):
isolate_file = os.path.join(self.cwd, 'x.isolate')
with open(isolate_file, 'wb') as f:
f.write('{"variables": {"command": ["python", "-c", "print(\'hi\')"]} }')
def expect_call(cmd, cwd):
self.assertEqual([sys.executable, '-c', "print('hi')", 'run'], cmd)
self.assertTrue(os.path.isdir(cwd))
return 0
self.mock(isolate.subprocess, 'call', expect_call)
cmd = ['run', '--isolate', isolate_file]
self.assertEqual(0, isolate.CMDrun(isolate.OptionParserIsolate(), cmd))
def test_CMDrewrite(self):
isolate_file = os.path.join(self.cwd, 'x.isolate')
data = (
'# Foo',
'{',
'}',
)
with open(isolate_file, 'wb') as f:
f.write('\n'.join(data))
self.mock(sys, 'stdout', cStringIO.StringIO())
cmd = ['-i', isolate_file]
self.assertEqual(0, isolate.CMDrewrite(isolate.OptionParserIsolate(), cmd))
with open(isolate_file, 'rb') as f:
actual = f.read()
expected = "# Foo\n{\n 'conditions': [\n ],\n}\n"
self.assertEqual(expected, actual)
def test_variable_arg(self):
parser = isolate.OptionParserIsolate()
parser.require_isolated = False
expected_path = {
'Baz': 'sub=string',
}
expected_config = {
'Foo': 'bar',
}
expected_extra = {
'biz': 'b uz=a',
'EXECUTABLE_SUFFIX': '.exe' if sys.platform == 'win32' else '',
}
options, args = parser.parse_args(
['--config-variable', 'Foo', 'bar',
'--path-variable', 'Baz=sub=string',
'--extra-variable', 'biz', 'b uz=a'])
self.assertEqual(expected_path, options.path_variables)
self.assertEqual(expected_config, options.config_variables)
self.assertEqual(expected_extra, options.extra_variables)
self.assertEqual([], args)
def test_variable_arg_fail(self):
parser = isolate.OptionParserIsolate()
self.mock(sys, 'stderr', cStringIO.StringIO())
with self.assertRaises(SystemExit):
parser.parse_args(['--config-variable', 'Foo'])
def test_CMDcheck_stale_version(self):
isolate_file = os.path.join(self.cwd, 'x.isolate')
isolated_file = os.path.join(self.cwd, 'x.isolated')
with open(isolate_file, 'wb') as f:
f.write(
'# Foo\n'
'{'
' \'conditions\':['
' [\'OS=="dendy"\', {'
' \'variables\': {'
' \'command\': [\'foo\'],'
' },'
' }],'
' ],'
'}')
self.mock(sys, 'stdout', cStringIO.StringIO())
cmd = [
'-i', isolate_file,
'-s', isolated_file,
'--config-variable', 'OS=dendy',
]
self.assertEqual(0, isolate.CMDcheck(isolate.OptionParserIsolate(), cmd))
with open(isolate_file, 'rb') as f:
actual = f.read()
expected = (
'# Foo\n{ \'conditions\':[ [\'OS=="dendy"\', { '
'\'variables\': { \'command\': [\'foo\'], }, }], ],}')
self.assertEqual(expected, actual)
with open(isolated_file, 'rb') as f:
actual_isolated = f.read()
expected_isolated = (
'{"algo":"sha-1","command":["foo"],"files":{},'
'"relative_cwd":".","version":"%s"}'
) % isolate.isolateserver.ISOLATED_FILE_VERSION
self.assertEqual(expected_isolated, actual_isolated)
isolated_data = json.loads(actual_isolated)
with open(isolated_file + '.state', 'rb') as f:
actual_isolated_state = f.read()
expected_isolated_state = (
'{"OS":"%s","algo":"sha-1","child_isolated_files":[],"command":["foo"],'
'"config_variables":{"OS":"dendy"},'
'"extra_variables":{"EXECUTABLE_SUFFIX":""},"files":{},'
'"isolate_file":"x.isolate","path_variables":{},'
'"relative_cwd":".","root_dir":"%s","version":"%s"}'
) % (sys.platform, self.cwd, isolate.SavedState.EXPECTED_VERSION)
self.assertEqual(expected_isolated_state, actual_isolated_state)
isolated_state_data = json.loads(actual_isolated_state)
# Now edit the .isolated.state file to break the version number and make
# sure it doesn't crash.
with open(isolated_file + '.state', 'wb') as f:
isolated_state_data['version'] = '100.42'
json.dump(isolated_state_data, f)
self.assertEqual(0, isolate.CMDcheck(isolate.OptionParserIsolate(), cmd))
# Now edit the .isolated file to break the version number and make
# sure it doesn't crash.
with open(isolated_file, 'wb') as f:
isolated_data['version'] = '100.42'
json.dump(isolated_data, f)
self.assertEqual(0, isolate.CMDcheck(isolate.OptionParserIsolate(), cmd))
# Make sure the files were regenerated.
with open(isolated_file, 'rb') as f:
actual_isolated = f.read()
self.assertEqual(expected_isolated, actual_isolated)
with open(isolated_file + '.state', 'rb') as f:
actual_isolated_state = f.read()
self.assertEqual(expected_isolated_state, actual_isolated_state)
