def test_load_three_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',
],
},
}],
],
}
win = {
'conditions': [
['OS=="win"', {
'variables': {
'isolate_dependency_tracked': [
'file_win',
'file_common',
],
},
}],
],
}
expected = {
'linux': {
'isolate_dependency_tracked': ['file_common', 'file_linux'],
},
'mac': {
'isolate_dependency_tracked': ['file_common', 'file_mac'],
},
'win': {
'isolate_dependency_tracked': ['file_common', 'file_win'],
},
}
# Pylint is confused about union() return type.
# pylint: disable=E1103
configs = isolate.union(
isolate.union(
isolate.union(
isolate.Configs([], None),
isolate.load_isolate_as_config(linux, None, [])),
isolate.load_isolate_as_config(mac, None, [])),
isolate.load_isolate_as_config(win, None, [])).flatten()
self.assertEquals(expected, configs)
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.union(
isolate.union(
isolate.union(
isolate.Configs(None),
isolate.load_isolate_as_config(self.cwd, linux, None)),
isolate.load_isolate_as_config(self.cwd, mac, None)),
isolate.load_isolate_as_config(self.cwd, win, None)).flatten()
self.assertEqual(expected, configs)
def test_merge_two_empty(self):
# Flat stay flat. Pylint is confused about union() return type.
# pylint: disable=E1103
actual = isolate.union(
isolate.union(
isolate.Configs(None),
isolate.load_isolate_as_config(self.cwd, {}, None)),
isolate.load_isolate_as_config(self.cwd, {}, None)).flatten()
self.assertEqual({}, actual)
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)
"""
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)
"""
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 test_load_isolate_as_config_duplicate_command(self):
value = {
'variables': {
'command': ['rm', '-rf', '/'],
},
'conditions': [
['OS=="atari"', {
'variables': {
'command': ['echo', 'Hello World'],
},
}],
],
}
try:
isolate.load_isolate_as_config(self.cwd, value, None)
self.fail()
except AssertionError:
pass
def test_load_isolate_as_config_no_condition(self):
value = {
'variables': {
KEY_TRACKED: ['a'],
KEY_UNTRACKED: ['b'],
},
}
expected = {
KEY_TRACKED: ['a'],
KEY_UNTRACKED: ['b'],
}
actual = isolate.load_isolate_as_config(value, None, [])
# Flattening the whole config will discard 'None'.
self.assertEquals({}, actual.flatten())
self.assertEquals([None], actual.per_os.keys())
# But the 'None' value is still available as a backup.
self.assertEquals(expected, actual.per_os[None].flatten())
def load_isolates(items, default_oses):
"""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)
"""
configs = Configs(default_oses, None)
for item in items:
logging.debug('loading %s' % item)
with open(item, 'r') as f:
content = f.read()
new_config = load_isolate_as_config(
eval_content(content), extract_comment(content), default_oses)
logging.debug('has OSes: %s' % ','.join(k for k in new_config.per_os if k))
configs = union(configs, new_config)
logging.debug('Total OSes: %s' % ','.join(k for k in configs.per_os if k))
return configs
def test_configs_comment(self):
# Pylint is confused with isolate.union() return type.
# pylint: disable=E1103
configs = isolate.union(
isolate.load_isolate_as_config({}, '# Yo dawg!\n# Chill out.\n', []),
isolate.load_isolate_as_config({}, None, []))
self.assertEquals('# Yo dawg!\n# Chill out.\n', configs.file_comment)
configs = isolate.union(
isolate.load_isolate_as_config({}, None, []),
isolate.load_isolate_as_config({}, '# Yo dawg!\n# Chill out.\n', []))
self.assertEquals('# Yo dawg!\n# Chill out.\n', configs.file_comment)
# Only keep the first one.
configs = isolate.union(
isolate.load_isolate_as_config({}, '# Yo dawg!\n', []),
isolate.load_isolate_as_config({}, '# Chill out.\n', []))
self.assertEquals('# Yo dawg!\n', configs.file_comment)
def test_load_with_includes(self):
included_isolate = {
'variables': {
'isolate_dependency_tracked': [
'file_common',
],
},
'conditions': [
['OS=="linux"', {
'variables': {
'isolate_dependency_tracked': [
'file_linux',
],
},
}, {
'variables': {
'isolate_dependency_tracked': [
'file_non_linux',
],
},
}],
],
}
isolate.trace_inputs.write_json(
os.path.join(self.cwd, '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',
],
},
}],
],
}
actual = isolate.load_isolate_as_config(self.cwd, values, None)
expected = {
('linux',): {
'isolate_dependency_tracked': [
'file_common',
'file_less_common',
'file_linux',
],
},
('mac',): {
'isolate_dependency_tracked': [
'file_common',
'file_less_common',
'file_mac',
'file_non_linux',
],
},
('win',): {
'isolate_dependency_tracked': [
'file_common',
'file_less_common',
'file_non_linux',
],
},
}
self.assertEqual(expected, actual.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': True,
},
}],
['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': False,
},
}],
['OS=="amiga" or OS=="atari" or OS=="dendy"', {
'variables': {
KEY_UNTRACKED: ['h'],
},
}],
],
}
expected = {
('amiga',): {
'command': ['echo', 'You should get an Atari'],
KEY_TOUCHED: ['touched', 'touched_e'],
KEY_TRACKED: ['a', 'e', 'g', 'x'],
KEY_UNTRACKED: ['b', 'f', 'h'],
'read_only': False,
},
('atari',): {
'command': ['echo', 'Hello World'],
KEY_TOUCHED: ['touched', 'touched_a'],
KEY_TRACKED: ['a', 'c', 'x'],
KEY_UNTRACKED: ['b', 'd', 'h'],
'read_only': True,
},
('coleco',): {
'command': ['echo', 'You should get an Atari'],
KEY_TOUCHED: ['touched', 'touched_e'],
KEY_TRACKED: ['a', 'e', 'x'],
KEY_UNTRACKED: ['b', 'f'],
},
('dendy',): {
'command': ['echo', 'You should get an Atari'],
KEY_TOUCHED: ['touched', 'touched_e'],
KEY_TRACKED: ['a', 'e', 'x'],
KEY_UNTRACKED: ['b', 'f', 'h'],
},
}
self.assertEqual(
expected, isolate.load_isolate_as_config(
self.cwd, value, None).flatten())
def test_load_isolate_as_config_empty(self):
self.assertEqual({}, isolate.load_isolate_as_config(
self.cwd, {}, None).flatten())
def test_load_isolate_as_config_empty(self):
self.assertEquals({}, isolate.load_isolate_as_config(
{}, None, []).flatten())
