def test_union_multi_variables(self):
data1 = {
'conditions': [
['OS=="abc"', {
'variables': {
'command': ['bar'],
},
}],
],
}
data2 = {
'conditions': [
['CHROMEOS=="1"', {
'variables': {
'command': ['foo'],
},
}],
],
}
configs1 = isolate_format.load_isolate_as_config(FAKE_DIR, data1, None)
configs2 = isolate_format.load_isolate_as_config(FAKE_DIR, data2, None)
configs = configs1.union(configs2)
self.assertEqual(('CHROMEOS', 'OS'), configs.config_variables)
flatten = dict((k, v.flatten()) for k, v in configs._by_config.iteritems())
expected = {
((None, 'abc')): {'command': ['bar']},
('1', None): {'command': ['foo']},
}
self.assertEqual(expected, flatten)
def test_load_three_conditions(self):
linux = {
'conditions': [
['OS=="linux" and chromeos==1', {
'variables': {
'isolate_dependency_tracked': [
'file_linux',
'file_common',
],
},
}],
],
}
mac = {
'conditions': [
['OS=="mac" and chromeos==0', {
'variables': {
'isolate_dependency_tracked': [
'file_mac',
'file_common',
],
},
}],
],
}
win = {
'conditions': [
['OS=="win" and chromeos==0', {
'variables': {
'isolate_dependency_tracked': [
'file_win',
'file_common',
],
},
}],
],
}
expected = {
('linux', 1): {
'isolate_dependency_tracked': ['file_common', 'file_linux'],
},
('mac', 0): {
'isolate_dependency_tracked': ['file_common', 'file_mac'],
},
('win', 0): {
'isolate_dependency_tracked': ['file_common', 'file_win'],
},
}
# Pylint is confused about union() return type.
# pylint: disable=E1103
configs = isolate_format.union(
isolate_format.union(
isolate_format.union(
isolate_format.Configs(None, ()),
isolate_format.load_isolate_as_config(FAKE_DIR, linux, None)),
isolate_format.load_isolate_as_config(FAKE_DIR, mac, None)),
isolate_format.load_isolate_as_config(FAKE_DIR, win, None))
self.assertEqual(expected, configs.flatten())
def test_merge_two_empty(self):
# Flat stay flat. Pylint is confused about union() return type.
# pylint: disable=E1103
actual = isolate_format.union(
isolate_format.union(
isolate_format.Configs(None, ()),
isolate_format.load_isolate_as_config(FAKE_DIR, {}, None)),
isolate_format.load_isolate_as_config(FAKE_DIR, {}, None)).flatten()
self.assertEqual({}, actual)
def test_merge_two_empty(self):
actual = isolate_format.Configs(None, ()).union(
isolate_format.load_isolate_as_config(FAKE_DIR, {}, None)).union(
isolate_format.load_isolate_as_config(FAKE_DIR, {}, None))
expected = {
(): {
'isolate_dir': FAKE_DIR,
},
}
self.assertEqual(expected, actual.flatten())
def test_merge_two_empty(self):
# Flat stay flat. Pylint is confused about union() return type.
# pylint: disable=E1103
actual = isolate_format.Configs(None, ()).union(
isolate_format.load_isolate_as_config(FAKE_DIR, {}, None)).union(
isolate_format.load_isolate_as_config(FAKE_DIR, {}, None))
expected = {
(): {
'isolate_dir': FAKE_DIR,
},
}
self.assertEqual(expected, actual.flatten())
def test_merge_two_empty(self):
# Flat stay flat. Pylint is confused about union() return type.
# pylint: disable=E1103
actual = isolate_format.Configs(None, ()).union(
isolate_format.load_isolate_as_config(FAKE_DIR, {}, None)).union(
isolate_format.load_isolate_as_config(FAKE_DIR, {}, None))
expected = {
(): {
'isolate_dir': FAKE_DIR,
},
}
self.assertEqual(expected, actual.flatten())
def test_convert_old_to_new_else(self):
isolate_with_else_clauses = {
'conditions': [
['OS=="mac"', {
'variables': {'foo': 'bar'},
}, {
'variables': {'x': 'y'},
}],
],
}
with self.assertRaises(isolate_format.IsolateError):
isolate_format.load_isolate_as_config(
FAKE_DIR, isolate_with_else_clauses, None)
def test_convert_old_to_new_else(self):
isolate_with_else_clauses = {
'conditions': [
['OS=="mac"', {
'variables': {'foo': 'bar'},
}, {
'variables': {'x': 'y'},
}],
],
}
with self.assertRaises(isolate_format.isolateserver.ConfigError):
isolate_format.load_isolate_as_config(
FAKE_DIR, isolate_with_else_clauses, None)
def test_load_two_conditions(self):
linux = {
'conditions': [
[
'OS=="linux"', {
'variables': {
'files': [
'file_linux',
'file_common',
],
},
}
],
],
}
mac = {
'conditions': [
[
'OS=="mac"', {
'variables': {
'files': [
'file_mac',
'file_common',
],
},
}
],
],
}
expected = {
(None, ): {
'isolate_dir': FAKE_DIR,
},
('linux', ): {
'files': ['file_common', 'file_linux'],
'isolate_dir': FAKE_DIR,
},
('mac', ): {
'files': ['file_common', 'file_mac'],
'isolate_dir': FAKE_DIR,
},
}
# Pylint is confused about union() return type.
# pylint: disable=E1103
configs = isolate_format.Configs(None, ()).union(
isolate_format.load_isolate_as_config(
FAKE_DIR, linux, None)).union(
isolate_format.load_isolate_as_config(FAKE_DIR, mac,
None)).flatten()
self.assertEqual(expected, configs)
def load_isolate_as_config(args, stdin):
# Reads isolate content from stdin .
isolate_dir, = args
# file_comment is "" .
out = isolate_format.load_isolate_as_config(isolate_dir,
eval(stdin.read()), "")
# we pass output to Go as json
def convKey(valuesOfKeys):
return [{
'Value': '' if k is None else k[0],
'IsBound': not (k is None),
} for k in valuesOfKeys]
def convValue(v):
r = -1 if v.read_only is None else v.read_only
return {
'ReadOnly': r,
'Files': v.files,
'Command': v.command,
'IsolateDir': v.isolate_dir,
}
return {
'ConfigVariables':
out.config_variables,
'ByConfig':
list({
'key': convKey(k),
'value': convValue(v)
} for k, v in out._by_config.iteritems()),
}
def test_load_multi_variables(self):
# Load an .isolate with different condition on different variables.
data = {
'conditions': [
['OS=="abc"', {
'variables': {
'command': ['bar'],
},
}],
['CHROMEOS=="1"', {
'variables': {
'command': ['foo'],
},
}],
],
}
configs = isolate_format.load_isolate_as_config(FAKE_DIR, data, None)
self.assertEqual(('CHROMEOS', 'OS'), configs.config_variables)
flatten = dict((k, v.flatten()) for k, v in configs._by_config.iteritems())
expected = {
((None, 'abc')): {'command': ['bar']},
(('1', None)): {'command': ['foo']},
# TODO(maruel): It is a conflict.
(('1', 'abc')): {'command': ['bar']},
}
self.assertEqual(expected, flatten)
def load_isolates(items):
"""Parses each .isolate file and returns the merged results.
It only loads what load_isolate_as_config() can process.
Return values:
files: dict(filename, set(OS where this filename is a dependency))
dirs: dict(dirame, set(OS where this dirname is a dependency))
oses: set(all the OSes referenced)
"""
# pylint: disable=W0212
configs = isolate_format.Configs(None, ())
for item in items:
item = os.path.abspath(item)
logging.debug('loading %s' % item)
if item == '-':
content = sys.stdin.read()
else:
with open(item, 'r') as f:
content = f.read()
new_config = isolate_format.load_isolate_as_config(
os.path.dirname(item), isolate_format.eval_content(content),
isolate_format.extract_comment(content))
logging.debug('has configs: ' +
','.join(map(repr, new_config._by_config)))
configs = configs.union(new_config)
logging.debug('Total configs: ' + ','.join(map(repr, configs._by_config)))
return configs
def load_isolates(items):
"""Parses each .isolate file and returns the merged results.
It only loads what load_isolate_as_config() can process.
Return values:
files: dict(filename, set(OS where this filename is a dependency))
dirs: dict(dirame, set(OS where this dirname is a dependency))
oses: set(all the OSes referenced)
"""
# pylint: disable=W0212
configs = None
for item in items:
item = os.path.abspath(item)
logging.debug("loading %s" % item)
if item == "-":
content = sys.stdin.read()
else:
with open(item, "r") as f:
content = f.read()
new_config = load_isolate_as_config(os.path.dirname(item), eval_content(content), extract_comment(content))
logging.debug("has configs: " + ",".join(map(repr, new_config._by_config)))
configs = union(configs, new_config)
logging.debug("Total configs: " + ",".join(map(repr, configs._by_config)))
return configs
def load_isolates(items):
"""Parses each .isolate file and returns the merged results.
It only loads what load_isolate_as_config() can process.
Return values:
files: dict(filename, set(OS where this filename is a dependency))
dirs: dict(dirame, set(OS where this dirname is a dependency))
oses: set(all the OSes referenced)
"""
# pylint: disable=W0212
configs = isolate_format.Configs(None, ())
for item in items:
item = os.path.abspath(item)
logging.debug('loading %s' % item)
if item == '-':
content = sys.stdin.read()
else:
with open(item, 'r') as f:
content = f.read()
new_config = isolate_format.load_isolate_as_config(
os.path.dirname(item),
isolate_format.eval_content(content),
isolate_format.extract_comment(content))
logging.debug('has configs: ' + ','.join(map(repr, new_config._by_config)))
configs = configs.union(new_config)
logging.debug('Total configs: ' + ','.join(map(repr, configs._by_config)))
return configs
def test_load_two_conditions(self):
linux = {
'conditions': [
['OS=="linux"', {
'variables': {
'isolate_dependency_tracked': [
'file_linux',
'file_common',
],
},
}],
],
}
mac = {
'conditions': [
['OS=="mac"', {
'variables': {
'isolate_dependency_tracked': [
'file_mac',
'file_common',
],
},
}],
],
}
expected = {
(None,): {
'isolate_dir': FAKE_DIR,
},
('linux',): {
'isolate_dependency_tracked': ['file_common', 'file_linux'],
'isolate_dir': FAKE_DIR,
},
('mac',): {
'isolate_dependency_tracked': ['file_common', 'file_mac'],
'isolate_dir': FAKE_DIR,
},
}
# Pylint is confused about union() return type.
# pylint: disable=E1103
configs = isolate_format.Configs(None, ()).union(
isolate_format.load_isolate_as_config(FAKE_DIR, linux, None)).union(
isolate_format.load_isolate_as_config(FAKE_DIR, mac, None)
).flatten()
self.assertEqual(expected, configs)
def test_load_isolate_as_config_empty(self):
expected = {
(): {
'isolate_dir': FAKE_DIR,
},
}
self.assertEqual(
expected,
isolate_format.load_isolate_as_config(FAKE_DIR, {}, None).flatten())
def test_load_isolate_as_config_duplicate_command(self):
value = {
'variables': {
'command': ['rm', '-rf', '/'],
},
'conditions': [
['OS=="atari"', {
'variables': {
'command': ['echo', 'Hello World'],
},
}],
],
}
try:
isolate_format.load_isolate_as_config(FAKE_DIR, value, None)
self.fail()
except AssertionError:
pass
def test_load_with_globals(self):
values = {
'variables': {
'isolate_dependency_tracked': [
'file_common',
],
},
'conditions': [
['OS=="linux"', {
'variables': {
'isolate_dependency_tracked': [
'file_linux',
],
'read_only': 1,
},
}],
['OS=="mac" or OS=="win"', {
'variables': {
'isolate_dependency_tracked': [
'file_non_linux',
],
'read_only': 0,
},
}],
],
}
expected = {
(None,): {
'isolate_dependency_tracked': [
'file_common',
],
'isolate_dir': FAKE_DIR,
},
('linux',): {
'isolate_dependency_tracked': [
'file_linux',
],
'isolate_dir': FAKE_DIR,
'read_only': 1,
},
('mac',): {
'isolate_dependency_tracked': [
'file_non_linux',
],
'isolate_dir': FAKE_DIR,
'read_only': 0,
},
('win',): {
'isolate_dependency_tracked': [
'file_non_linux',
],
'isolate_dir': FAKE_DIR,
'read_only': 0,
},
}
actual = isolate_format.load_isolate_as_config(FAKE_DIR, values, None)
self.assertEqual(expected, actual.flatten())
def test_load_isolate_as_config_duplicate_command(self):
value = {
'variables': {
'command': ['rm', '-rf', '/'],
},
'conditions': [
['OS=="atari"', {
'variables': {
'command': ['echo', 'Hello World'],
},
}],
],
}
try:
isolate_format.load_isolate_as_config(FAKE_DIR, value, None)
self.fail()
except AssertionError:
pass
def test_load_with_globals(self):
values = {
'variables': {
'files': [
'file_common',
],
},
'conditions': [
['OS=="linux"', {
'variables': {
'files': [
'file_linux',
],
'read_only': 1,
},
}],
['OS=="mac" or OS=="win"', {
'variables': {
'files': [
'file_non_linux',
],
'read_only': 0,
},
}],
],
}
expected = {
(None,): {
'files': [
'file_common',
],
'isolate_dir': FAKE_DIR,
},
('linux',): {
'files': [
'file_linux',
],
'isolate_dir': FAKE_DIR,
'read_only': 1,
},
('mac',): {
'files': [
'file_non_linux',
],
'isolate_dir': FAKE_DIR,
'read_only': 0,
},
('win',): {
'files': [
'file_non_linux',
],
'isolate_dir': FAKE_DIR,
'read_only': 0,
},
}
actual = isolate_format.load_isolate_as_config(FAKE_DIR, values, None)
self.assertEqual(expected, actual.flatten())
def test_load_isolate_as_config_empty(self):
expected = {
(): {
'isolate_dir': FAKE_DIR,
},
}
self.assertEqual(
expected,
isolate_format.load_isolate_as_config(FAKE_DIR, {}, None).flatten())
def test_union_multi_variables(self):
data1 = {
'conditions': [
['OS=="abc"', {
'variables': {
'command': ['bar'],
},
}],
],
}
data2 = {
'conditions': [
['CHROMEOS=="1"', {
'variables': {
'command': ['foo'],
},
}],
],
}
configs1 = isolate_format.load_isolate_as_config(FAKE_DIR, data1, None)
configs2 = isolate_format.load_isolate_as_config(FAKE_DIR, data2, None)
configs = configs1.union(configs2)
self.assertEqual(('CHROMEOS', 'OS'), configs.config_variables)
flatten = dict(
(k, v.flatten()) for k, v in configs._by_config.iteritems())
expected = {
(None, None): {
'isolate_dir': FAKE_DIR,
},
(None, 'abc'): {
'command': ['bar'],
'isolate_dir': FAKE_DIR,
},
('1', None): {
'command': ['foo'],
'isolate_dir': FAKE_DIR,
},
}
self.assertEqual(expected, flatten)
def test_load_isolate_as_config_no_variable(self):
value = {
'variables': {
'command': ['echo', 'You should get an Atari'],
'files': ['a', 'b', 'touched'],
'read_only': 1,
},
}
# The key is the empty tuple, since there is no variable to bind to.
expected = {
(): {
'command': ['echo', 'You should get an Atari'],
'files': ['a', 'b', 'touched'],
'isolate_dir': FAKE_DIR,
'read_only': 1,
},
}
self.assertEqual(
expected, isolate_format.load_isolate_as_config(
FAKE_DIR, value, None).flatten())
def test_load_isolate_as_config_no_variable(self):
value = {
'variables': {
'command': ['echo', 'You should get an Atari'],
'files': ['a', 'b', 'touched'],
'read_only': 1,
},
}
# The key is the empty tuple, since there is no variable to bind to.
expected = {
(): {
'command': ['echo', 'You should get an Atari'],
'files': ['a', 'b', 'touched'],
'isolate_dir': FAKE_DIR,
'read_only': 1,
},
}
self.assertEqual(
expected, isolate_format.load_isolate_as_config(
FAKE_DIR, value, None).flatten())
def test_load_multi_variables(self):
# Load an .isolate with different condition on different variables.
data = {
'conditions': [
['OS=="abc"', {
'variables': {
'command': ['bar'],
},
}],
['CHROMEOS=="1"', {
'variables': {
'command': ['foo'],
},
}],
],
}
configs = isolate_format.load_isolate_as_config(FAKE_DIR, data, None)
self.assertEqual(('CHROMEOS', 'OS'), configs.config_variables)
flatten = dict(
(k, v.flatten()) for k, v in configs._by_config.iteritems())
expected = {
(None, None): {
'isolate_dir': FAKE_DIR,
},
(None, 'abc'): {
'command': ['bar'],
'isolate_dir': FAKE_DIR,
},
('1', None): {
'command': ['foo'],
'isolate_dir': FAKE_DIR,
},
# TODO(maruel): It is a conflict.
('1', 'abc'): {
'command': ['bar'],
'isolate_dir': FAKE_DIR,
},
}
self.assertEqual(expected, flatten)
def test_configs_comment(self):
configs = isolate_format.load_isolate_as_config(
FAKE_DIR, {}, '# Yo dawg!\n# Chill out.\n').union(
isolate_format.load_isolate_as_config(FAKE_DIR, {}, None))
self.assertEqual('# Yo dawg!\n# Chill out.\n', configs.file_comment)
configs = isolate_format.load_isolate_as_config(
FAKE_DIR, {}, None).union(
isolate_format.load_isolate_as_config(
FAKE_DIR, {}, '# Yo dawg!\n# Chill out.\n'))
self.assertEqual('# Yo dawg!\n# Chill out.\n', configs.file_comment)
# Only keep the first one.
configs = isolate_format.load_isolate_as_config(
FAKE_DIR, {}, '# Yo dawg!\n').union(
isolate_format.load_isolate_as_config(FAKE_DIR, {},
'# Chill out.\n'))
self.assertEqual('# Yo dawg!\n', configs.file_comment)
def test_configs_comment(self):
# Pylint is confused with isolate_format.union() return type.
# pylint: disable=E1103
configs = isolate_format.load_isolate_as_config(
FAKE_DIR, {}, '# Yo dawg!\n# Chill out.\n').union(
isolate_format.load_isolate_as_config(FAKE_DIR, {}, None))
self.assertEqual('# Yo dawg!\n# Chill out.\n', configs.file_comment)
configs = isolate_format.load_isolate_as_config(FAKE_DIR, {}, None).union(
isolate_format.load_isolate_as_config(
FAKE_DIR, {}, '# Yo dawg!\n# Chill out.\n'))
self.assertEqual('# Yo dawg!\n# Chill out.\n', configs.file_comment)
# Only keep the first one.
configs = isolate_format.load_isolate_as_config(
FAKE_DIR, {}, '# Yo dawg!\n').union(
isolate_format.load_isolate_as_config(
FAKE_DIR, {}, '# Chill out.\n'))
self.assertEqual('# Yo dawg!\n', configs.file_comment)
def test_configs_comment(self):
# Pylint is confused with isolate_format.union() return type.
# pylint: disable=E1103
configs = isolate_format.load_isolate_as_config(
FAKE_DIR, {}, '# Yo dawg!\n# Chill out.\n').union(
isolate_format.load_isolate_as_config(FAKE_DIR, {}, None))
self.assertEqual('# Yo dawg!\n# Chill out.\n', configs.file_comment)
configs = isolate_format.load_isolate_as_config(FAKE_DIR, {}, None).union(
isolate_format.load_isolate_as_config(
FAKE_DIR, {}, '# Yo dawg!\n# Chill out.\n'))
self.assertEqual('# Yo dawg!\n# Chill out.\n', configs.file_comment)
# Only keep the first one.
configs = isolate_format.load_isolate_as_config(
FAKE_DIR, {}, '# Yo dawg!\n').union(
isolate_format.load_isolate_as_config(
FAKE_DIR, {}, '# Chill out.\n'))
self.assertEqual('# Yo dawg!\n', configs.file_comment)
def test_load_with_includes_with_commands_and_variables(self):
# This one is the pinacle of fun. Check that isolate_dir is the expected
# value. To achieve this, put the .isolate files into subdirectories.
dir_1 = os.path.join(self.tempdir, '1')
dir_3 = os.path.join(self.tempdir, '3')
dir_3_2 = os.path.join(self.tempdir, '3', '2')
os.mkdir(dir_1)
os.mkdir(dir_3)
os.mkdir(dir_3_2)
isolate1 = {
'conditions': [
['OS=="amiga" or OS=="win"', {
'variables': {
'command': [
'foo', 'amiga_or_win', '<(PATH)',
],
},
}],
['OS=="linux"', {
'variables': {
'command': [
'foo', 'linux', '<(PATH)',
],
'isolate_dependency_tracked': [
'<(PATH)/file_linux',
],
},
}],
['OS=="mac" or OS=="win"', {
'variables': {
'isolate_dependency_tracked': [
'<(PATH)/file_non_linux',
],
},
}],
],
}
isolate2 = {
'conditions': [
['OS=="linux" or OS=="mac"', {
'variables': {
'command': [
'foo', 'linux_or_mac', '<(PATH)',
],
'isolate_dependency_tracked': [
'<(PATH)/other/file',
],
},
}],
],
}
isolate3 = {
'includes': [
'../1/isolate1.isolate',
'2/isolate2.isolate',
],
'conditions': [
['OS=="amiga"', {
'variables': {
'isolate_dependency_tracked': [
'<(PATH)/file_amiga',
],
},
}],
['OS=="mac"', {
'variables': {
'command': [
'foo', 'mac', '<(PATH)',
],
'isolate_dependency_tracked': [
'<(PATH)/file_mac',
],
},
}],
],
}
# No need to write isolate3.
with open(os.path.join(dir_1, 'isolate1.isolate'), 'wb') as f:
isolate_format.pretty_print(isolate1, f)
with open(os.path.join(dir_3_2, 'isolate2.isolate'), 'wb') as f:
isolate_format.pretty_print(isolate2, f)
# The 'isolate_dir' are important, they are what will be used when
# definining the final isolate_dir to use to run the command in the
# .isolated file.
actual = isolate_format.load_isolate_as_config(dir_3, isolate3, None)
expected = {
(None,): {
'isolate_dir': dir_1,
},
('amiga',): {
'command': ['foo', 'amiga_or_win', '<(PATH)'],
'isolate_dependency_tracked': [
'<(PATH)/file_amiga',
],
'isolate_dir': dir_1,
},
('linux',): {
# Last included takes precedence. *command comes from isolate2*, so
# it becomes the canonical root, so reference to file from isolate1 is
# via '../../1'.
'command': ['foo', 'linux_or_mac', '<(PATH)'],
'isolate_dependency_tracked': [
'<(PATH)/file_linux',
'<(PATH)/other/file',
],
'isolate_dir': dir_3_2,
},
('mac',): {
'command': ['foo', 'mac', '<(PATH)'],
'isolate_dependency_tracked': [
'<(PATH)/file_mac',
'<(PATH)/file_non_linux',
'<(PATH)/other/file',
],
'isolate_dir': dir_3,
},
('win',): {
# command comes from isolate1.
'command': ['foo', 'amiga_or_win', '<(PATH)'],
'isolate_dependency_tracked': [
'<(PATH)/file_non_linux',
],
'isolate_dir': dir_1,
},
}
self.assertEqual(expected, actual.flatten())
def test_load_three_conditions(self):
linux = {
'conditions': [
[
'OS=="linux" and chromeos==1', {
'variables': {
'files': [
'file_linux',
'file_common',
],
},
}
],
],
}
mac = {
'conditions': [
[
'OS=="mac" and chromeos==0', {
'variables': {
'files': [
'file_mac',
'file_common',
],
},
}
],
],
}
win = {
'conditions': [
[
'OS=="win" and chromeos==0', {
'variables': {
'files': [
'file_win',
'file_common',
],
},
}
],
],
}
expected = {
(None, None): {
'isolate_dir': FAKE_DIR,
},
('linux', 1): {
'files': ['file_common', 'file_linux'],
'isolate_dir': FAKE_DIR,
},
('mac', 0): {
'files': ['file_common', 'file_mac'],
'isolate_dir': FAKE_DIR,
},
('win', 0): {
'files': ['file_common', 'file_win'],
'isolate_dir': FAKE_DIR,
},
}
configs = isolate_format.Configs(None, ()).union(
isolate_format.load_isolate_as_config(
FAKE_DIR, linux, None)).union(
isolate_format.load_isolate_as_config(
FAKE_DIR, mac, None)).union(
isolate_format.load_isolate_as_config(
FAKE_DIR, win, None))
self.assertEqual(expected, configs.flatten())
def test_load_with_includes_with_commands(self):
# This one is messy.
isolate1 = {
'conditions': [
['OS=="linux"', {
'variables': {
'command': [
'foo', 'bar',
],
'isolate_dependency_tracked': [
'file_linux',
],
},
}, {
'variables': {
'isolate_dependency_tracked': [
'file_non_linux',
],
},
}],
['OS=="win"', {
'variables': {
'command': [
'foo', 'bar',
],
},
}],
],
}
tools.write_json(
os.path.join(self.tempdir, 'isolate1.isolate'), isolate1, True)
isolate2 = {
'conditions': [
['OS=="linux" or OS=="mac"', {
'variables': {
'command': [
'zoo',
],
'isolate_dependency_tracked': [
'other/file',
],
},
}],
],
}
tools.write_json(
os.path.join(self.tempdir, 'isolate2.isolate'), isolate2, True)
isolate3 = {
'includes': ['isolate1.isolate', 'isolate2.isolate'],
'conditions': [
['OS=="mac"', {
'variables': {
'command': [
'yo', 'dawg',
],
'isolate_dependency_tracked': [
'file_mac',
],
},
}],
],
}
actual = isolate_format.load_isolate_as_config(self.tempdir, isolate3, None)
expected = {
('linux',): {
# Last included takes precedence.
'command': ['zoo'],
'isolate_dependency_tracked': ['file_linux', 'other/file'],
},
('mac',): {
# Command in isolate3 takes precedence.
'command': ['yo', 'dawg'],
'isolate_dependency_tracked': [
'file_mac',
'file_non_linux',
'other/file',
],
},
('win',): {
'command': ['foo', 'bar'],
'isolate_dependency_tracked': ['file_non_linux'],
},
}
self.assertEqual(expected, actual.flatten())
def test_load_isolate_as_config_empty(self):
self.assertEqual({}, isolate_format.load_isolate_as_config(
FAKE_DIR, {}, None).flatten())
def test_load_isolate_as_config(self):
value = {
'conditions': [
['OS=="amiga" or OS=="atari" or OS=="coleco" or OS=="dendy"', {
'variables': {
KEY_TRACKED: ['a'],
KEY_UNTRACKED: ['b'],
KEY_TOUCHED: ['touched'],
},
}],
['OS=="atari"', {
'variables': {
KEY_TRACKED: ['c', 'x'],
KEY_UNTRACKED: ['d'],
KEY_TOUCHED: ['touched_a'],
'command': ['echo', 'Hello World'],
'read_only': 2,
},
}],
['OS=="amiga" or OS=="coleco" or OS=="dendy"', {
'variables': {
KEY_TRACKED: ['e', 'x'],
KEY_UNTRACKED: ['f'],
KEY_TOUCHED: ['touched_e'],
'command': ['echo', 'You should get an Atari'],
},
}],
['OS=="amiga"', {
'variables': {
KEY_TRACKED: ['g'],
'read_only': 1,
},
}],
['OS=="amiga" or OS=="atari" or OS=="dendy"', {
'variables': {
KEY_UNTRACKED: ['h'],
},
}],
],
}
expected = {
(None,): {
'isolate_dir': FAKE_DIR,
},
('amiga',): {
KEY_TOUCHED: ['touched', 'touched_e'],
KEY_TRACKED: ['a', 'e', 'g', 'x'],
KEY_UNTRACKED: ['b', 'f', 'h'],
'command': ['echo', 'You should get an Atari'],
'isolate_dir': FAKE_DIR,
'read_only': 1,
},
('atari',): {
KEY_TOUCHED: ['touched', 'touched_a'],
KEY_TRACKED: ['a', 'c', 'x'],
KEY_UNTRACKED: ['b', 'd', 'h'],
'command': ['echo', 'Hello World'],
'isolate_dir': FAKE_DIR,
'read_only': 2,
},
('coleco',): {
KEY_TOUCHED: ['touched', 'touched_e'],
KEY_TRACKED: ['a', 'e', 'x'],
KEY_UNTRACKED: ['b', 'f'],
'command': ['echo', 'You should get an Atari'],
'isolate_dir': FAKE_DIR,
},
('dendy',): {
KEY_TOUCHED: ['touched', 'touched_e'],
KEY_TRACKED: ['a', 'e', 'x'],
KEY_UNTRACKED: ['b', 'f', 'h'],
'command': ['echo', 'You should get an Atari'],
'isolate_dir': FAKE_DIR,
},
}
self.assertEqual(
expected, isolate_format.load_isolate_as_config(
FAKE_DIR, value, None).flatten())
def load_included_isolate(isolate_dir, _isolate_path): return isolate_format.load_isolate_as_config(isolate_dir, a, None)
def test_load_with_includes_with_commands(self):
# This one is messy. Check that isolate_dir is the expected value. To
# achieve this, put the .isolate files into subdirectories.
dir_1 = os.path.join(self.tempdir, '1')
dir_3 = os.path.join(self.tempdir, '3')
dir_3_2 = os.path.join(self.tempdir, '3', '2')
os.mkdir(dir_1)
os.mkdir(dir_3)
os.mkdir(dir_3_2)
isolate1 = {
'conditions': [
[
'OS=="amiga" or OS=="win"', {
'variables': {
'command': [
'foo',
'amiga_or_win',
],
},
}
],
[
'OS=="linux"', {
'variables': {
'command': [
'foo',
'linux',
],
'files': [
'file_linux',
],
},
}
],
[
'OS=="mac" or OS=="win"', {
'variables': {
'files': [
'file_non_linux',
],
},
}
],
],
}
isolate2 = {
'conditions': [
[
'OS=="linux" or OS=="mac"', {
'variables': {
'command': [
'foo',
'linux_or_mac',
],
'files': [
'other/file',
],
},
}
],
],
}
# Do not define command in isolate3, otherwise commands in the other
# included .isolated will be ignored.
isolate3 = {
'includes': [
'../1/isolate1.isolate',
'2/isolate2.isolate',
],
'conditions': [
[
'OS=="amiga"', {
'variables': {
'files': [
'file_amiga',
],
},
}
],
['OS=="mac"', {
'variables': {
'files': [
'file_mac',
],
},
}],
],
}
# No need to write isolate3.
with open(os.path.join(dir_1, 'isolate1.isolate'), 'wb') as f:
isolate_format.pretty_print(isolate1, f)
with open(os.path.join(dir_3_2, 'isolate2.isolate'), 'wb') as f:
isolate_format.pretty_print(isolate2, f)
# The 'isolate_dir' are important, they are what will be used when
# defining the final isolate_dir to use to run the command in the .isolated
# file.
actual = isolate_format.load_isolate_as_config(dir_3, isolate3, None)
expected = {
(None, ): {
# TODO(maruel): See TODO in ConfigSettings.flatten().
# TODO(maruel): If kept, in this case dir_3 should be selected.
'isolate_dir': dir_1,
},
('amiga', ): {
'command': ['foo', 'amiga_or_win'],
'files': [
# Note that the file was rebased from isolate1. This is important,
# isolate1 represent the canonical root path because it is the one
# that defined the command.
'../3/file_amiga',
],
'isolate_dir':
dir_1,
},
('linux', ): {
# Last included takes precedence. *command comes from isolate2*, so
# it becomes the canonical root, so reference to file from isolate1 is
# via '../../1'.
'command': ['foo', 'linux_or_mac'],
'files': [
'../../1/file_linux',
'other/file',
],
'isolate_dir': dir_3_2,
},
('mac', ): {
'command': ['foo', 'linux_or_mac'],
'files': [
'../../1/file_non_linux',
'../file_mac',
'other/file',
],
'isolate_dir': dir_3_2,
},
('win', ): {
# command comes from isolate1.
'command': ['foo', 'amiga_or_win'],
'files': [
# While this may be surprising, this is because the command was
# defined in isolate1, not isolate3.
'file_non_linux',
],
'isolate_dir':
dir_1,
},
}
self.assertEqual(expected, actual.flatten())
def load_included_isolate(isolate_dir, _isolate_path):
return isolate_format.load_isolate_as_config(isolate_dir, a, None)
def test_load_isolate_as_config(self):
value = {
'conditions': [
[
'OS=="amiga" or OS=="atari" or OS=="coleco" or OS=="dendy"',
{
'variables': {
'files': ['a', 'b', 'touched'],
},
}
],
[
'OS=="atari"', {
'variables': {
'files': ['c', 'd', 'touched_a', 'x'],
'command': ['echo', 'Hello World'],
'read_only': 2,
},
}
],
[
'OS=="amiga" or OS=="coleco" or OS=="dendy"', {
'variables': {
'files': ['e', 'f', 'touched_e', 'x'],
'command': ['echo', 'You should get an Atari'],
},
}
],
[
'OS=="amiga"', {
'variables': {
'files': ['g'],
'read_only': 1,
},
}
],
[
'OS=="amiga" or OS=="atari" or OS=="dendy"', {
'variables': {
'files': ['h'],
},
}
],
],
}
expected = {
(None, ): {
'isolate_dir': FAKE_DIR,
},
('amiga', ): {
'files':
['a', 'b', 'e', 'f', 'g', 'h', 'touched', 'touched_e', 'x'],
'command': ['echo', 'You should get an Atari'],
'isolate_dir':
FAKE_DIR,
'read_only':
1,
},
('atari', ): {
'files':
['a', 'b', 'c', 'd', 'h', 'touched', 'touched_a', 'x'],
'command': ['echo', 'Hello World'],
'isolate_dir': FAKE_DIR,
'read_only': 2,
},
('coleco', ): {
'files': ['a', 'b', 'e', 'f', 'touched', 'touched_e', 'x'],
'command': ['echo', 'You should get an Atari'],
'isolate_dir': FAKE_DIR,
},
('dendy', ): {
'files':
['a', 'b', 'e', 'f', 'h', 'touched', 'touched_e', 'x'],
'command': ['echo', 'You should get an Atari'],
'isolate_dir': FAKE_DIR,
},
}
self.assertEqual(
expected,
isolate_format.load_isolate_as_config(FAKE_DIR, value,
None).flatten())
def test_load_with_includes_with_commands(self):
# This one is messy. Check that isolate_dir is the expected value. To
# achieve this, put the .isolate files into subdirectories.
dir_1 = os.path.join(self.tempdir, '1')
dir_3 = os.path.join(self.tempdir, '3')
dir_3_2 = os.path.join(self.tempdir, '3', '2')
os.mkdir(dir_1)
os.mkdir(dir_3)
os.mkdir(dir_3_2)
isolate1 = {
'conditions': [
['OS=="amiga" or OS=="win"', {
'variables': {
'command': [
'foo', 'amiga_or_win',
],
},
}],
['OS=="linux"', {
'variables': {
'command': [
'foo', 'linux',
],
'isolate_dependency_tracked': [
'file_linux',
],
},
}],
['OS=="mac" or OS=="win"', {
'variables': {
'isolate_dependency_tracked': [
'file_non_linux',
],
},
}],
],
}
isolate2 = {
'conditions': [
['OS=="linux" or OS=="mac"', {
'variables': {
'command': [
'foo', 'linux_or_mac',
],
'isolate_dependency_tracked': [
'other/file',
],
},
}],
],
}
isolate3 = {
'includes': [
'../1/isolate1.isolate',
'2/isolate2.isolate',
],
'conditions': [
['OS=="amiga"', {
'variables': {
'isolate_dependency_tracked': [
'file_amiga',
],
},
}],
['OS=="mac"', {
'variables': {
'command': [
'foo', 'mac',
],
'isolate_dependency_tracked': [
'file_mac',
],
},
}],
],
}
# No need to write isolate3.
with open(os.path.join(dir_1, 'isolate1.isolate'), 'wb') as f:
isolate_format.pretty_print(isolate1, f)
with open(os.path.join(dir_3_2, 'isolate2.isolate'), 'wb') as f:
isolate_format.pretty_print(isolate2, f)
# The 'isolate_dir' are important, they are what will be used when
# definining the final isolate_dir to use to run the command in the
# .isolated file.
actual = isolate_format.load_isolate_as_config(dir_3, isolate3, None)
expected = {
(None,): {
# TODO(maruel): See TODO in ConfigSettings.flatten().
# TODO(maruel): If kept, in this case dir_3 should be selected.
'isolate_dir': dir_1,
},
('amiga',): {
'command': ['foo', 'amiga_or_win'],
'isolate_dependency_tracked': [
# Note that the file was rebased from isolate1. This is important,
# isolate1 represent the canonical root path because it is the one
# that defined the command.
'../3/file_amiga',
],
'isolate_dir': dir_1,
},
('linux',): {
# Last included takes precedence. *command comes from isolate2*, so
# it becomes the canonical root, so reference to file from isolate1 is
# via '../../1'.
'command': ['foo', 'linux_or_mac'],
'isolate_dependency_tracked': [
'../../1/file_linux',
'other/file',
],
'isolate_dir': dir_3_2,
},
('mac',): {
# command in isolate3 takes precedence over the ones included.
'command': ['foo', 'mac'],
'isolate_dependency_tracked': [
'../1/file_non_linux',
'2/other/file',
'file_mac',
],
'isolate_dir': dir_3,
},
('win',): {
# command comes from isolate1.
'command': ['foo', 'amiga_or_win'],
'isolate_dependency_tracked': [
# While this may be surprising, this is because the command was
# defined in isolate1, not isolate3.
'file_non_linux',
],
'isolate_dir': dir_1,
},
}
self.assertEqual(expected, actual.flatten())
def test_load_with_includes(self):
included_isolate = {
'variables': {
'files': [
'file_common',
],
},
'conditions': [
[
'OS=="linux"', {
'variables': {
'files': [
'file_linux',
],
'read_only': 1,
},
}
],
[
'OS=="mac" or OS=="win"', {
'variables': {
'files': [
'file_non_linux',
],
'read_only': 0,
},
}
],
],
}
with open(os.path.join(self.tempdir, 'included.isolate'), 'wb') as f:
isolate_format.pretty_print(included_isolate, f)
values = {
'includes': ['included.isolate'],
'variables': {
'files': [
'file_less_common',
],
},
'conditions': [
[
'OS=="mac"', {
'variables': {
'files': [
'file_mac',
],
'read_only': 2,
},
}
],
],
}
actual = isolate_format.load_isolate_as_config(self.tempdir, values,
None)
expected = {
(None, ): {
'files': [
'file_common',
'file_less_common',
],
'isolate_dir': self.tempdir,
},
('linux', ): {
'files': [
'file_linux',
],
'isolate_dir': self.tempdir,
'read_only': 1,
},
('mac', ): {
'files': [
'file_mac',
'file_non_linux',
],
'isolate_dir': self.tempdir,
'read_only': 2,
},
('win', ): {
'files': [
'file_non_linux',
],
'isolate_dir': self.tempdir,
'read_only': 0,
},
}
self.assertEqual(expected, actual.flatten())
def test_load_with_includes(self):
included_isolate = {
'variables': {
'isolate_dependency_tracked': [
'file_common',
],
},
'conditions': [
['OS=="linux"', {
'variables': {
'isolate_dependency_tracked': [
'file_linux',
],
'read_only': 1,
},
}],
['OS=="mac" or OS=="win"', {
'variables': {
'isolate_dependency_tracked': [
'file_non_linux',
],
'read_only': 0,
},
}],
],
}
with open(os.path.join(self.tempdir, 'included.isolate'), 'wb') as f:
isolate_format.pretty_print(included_isolate, f)
values = {
'includes': ['included.isolate'],
'variables': {
'isolate_dependency_tracked': [
'file_less_common',
],
},
'conditions': [
['OS=="mac"', {
'variables': {
'isolate_dependency_tracked': [
'file_mac',
],
'read_only': 2,
},
}],
],
}
actual = isolate_format.load_isolate_as_config(self.tempdir, values, None)
expected = {
(None,): {
'isolate_dependency_tracked': [
'file_common',
'file_less_common',
],
'isolate_dir': self.tempdir,
},
('linux',): {
'isolate_dependency_tracked': [
'file_linux',
],
'isolate_dir': self.tempdir,
'read_only': 1,
},
('mac',): {
'isolate_dependency_tracked': [
'file_mac',
'file_non_linux',
],
'isolate_dir': self.tempdir,
'read_only': 2,
},
('win',): {
'isolate_dependency_tracked': [
'file_non_linux',
],
'isolate_dir': self.tempdir,
'read_only': 0,
},
}
self.assertEqual(expected, actual.flatten())
def test_load_with_includes_with_commands_and_variables(self):
# This one is the pinacle of fun. Check that isolate_dir is the expected
# value. To achieve this, put the .isolate files into subdirectories.
dir_1 = os.path.join(self.tempdir, '1')
dir_3 = os.path.join(self.tempdir, '3')
dir_3_2 = os.path.join(self.tempdir, '3', '2')
os.mkdir(dir_1)
os.mkdir(dir_3)
os.mkdir(dir_3_2)
isolate1 = {
'conditions': [
[
'OS=="amiga" or OS=="win"', {
'variables': {
'command': [
'foo',
'amiga_or_win',
'<(PATH)',
],
},
}
],
[
'OS=="linux"', {
'variables': {
'command': [
'foo',
'linux',
'<(PATH)',
],
'files': [
'<(PATH)/file_linux',
],
},
}
],
[
'OS=="mac" or OS=="win"', {
'variables': {
'files': [
'<(PATH)/file_non_linux',
],
},
}
],
],
}
isolate2 = {
'conditions': [
[
'OS=="linux" or OS=="mac"', {
'variables': {
'command': [
'foo',
'linux_or_mac',
'<(PATH)',
],
'files': [
'<(PATH)/other/file',
],
},
}
],
],
}
# Do not define command in isolate3, otherwise commands in the other
# included .isolated will be ignored.
isolate3 = {
'includes': [
'../1/isolate1.isolate',
'2/isolate2.isolate',
],
'conditions': [
[
'OS=="amiga"', {
'variables': {
'files': [
'<(PATH)/file_amiga',
],
},
}
],
[
'OS=="mac"', {
'variables': {
'files': [
'<(PATH)/file_mac',
],
},
}
],
],
}
# No need to write isolate3.
with open(os.path.join(dir_1, 'isolate1.isolate'), 'wb') as f:
isolate_format.pretty_print(isolate1, f)
with open(os.path.join(dir_3_2, 'isolate2.isolate'), 'wb') as f:
isolate_format.pretty_print(isolate2, f)
# The 'isolate_dir' are important, they are what will be used when
# defining the final isolate_dir to use to run the command in the .isolated
# file.
actual = isolate_format.load_isolate_as_config(dir_3, isolate3, None)
expected = {
(None, ): {
'isolate_dir': dir_1,
},
('amiga', ): {
'command': ['foo', 'amiga_or_win', '<(PATH)'],
'files': [
'<(PATH)/file_amiga',
],
'isolate_dir': dir_1,
},
('linux', ): {
# Last included takes precedence. *command comes from isolate2*, so
# it becomes the canonical root, so reference to file from isolate1 is
# via '../../1'.
'command': ['foo', 'linux_or_mac', '<(PATH)'],
'files': [
'<(PATH)/file_linux',
'<(PATH)/other/file',
],
'isolate_dir': dir_3_2,
},
('mac', ): {
'command': ['foo', 'linux_or_mac', '<(PATH)'],
'files': [
'<(PATH)/file_mac',
'<(PATH)/file_non_linux',
'<(PATH)/other/file',
],
'isolate_dir':
dir_3_2,
},
('win', ): {
# command comes from isolate1.
'command': ['foo', 'amiga_or_win', '<(PATH)'],
'files': [
'<(PATH)/file_non_linux',
],
'isolate_dir': dir_1,
},
}
self.assertEqual(expected, actual.flatten())
def test_load_with_includes(self):
included_isolate = {
'variables': {
'isolate_dependency_tracked': [
'file_common',
],
},
'conditions': [
['OS=="linux"', {
'variables': {
'isolate_dependency_tracked': [
'file_linux',
],
'read_only': 1,
},
}, {
'variables': {
'isolate_dependency_tracked': [
'file_non_linux',
],
'read_only': 0,
},
}],
],
}
tools.write_json(
os.path.join(self.tempdir, 'included.isolate'), included_isolate, True)
values = {
'includes': ['included.isolate'],
'variables': {
'isolate_dependency_tracked': [
'file_less_common',
],
},
'conditions': [
['OS=="mac"', {
'variables': {
'isolate_dependency_tracked': [
'file_mac',
],
'read_only': 2,
},
}],
],
}
actual = isolate_format.load_isolate_as_config(self.tempdir, values, None)
expected = {
('linux',): {
'isolate_dependency_tracked': [
'file_common',
'file_less_common',
'file_linux',
],
'read_only': 1,
},
('mac',): {
'isolate_dependency_tracked': [
'file_common',
'file_less_common',
'file_mac',
'file_non_linux',
],
'read_only': 2,
},
('win',): {
'isolate_dependency_tracked': [
'file_common',
'file_less_common',
'file_non_linux',
],
'read_only': 0,
},
}
self.assertEqual(expected, actual.flatten())
