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 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 test_configs_comment(self):
    # Pylint is confused with isolate_format.union() return type.
    # pylint: disable=E1103
    configs = isolate_format.union(
        isolate_format.load_isolate_as_config(
            FAKE_DIR, {}, '# Yo dawg!\n# Chill out.\n'),
        isolate_format.load_isolate_as_config(FAKE_DIR, {}, None))
    self.assertEqual('# Yo dawg!\n# Chill out.\n', configs.file_comment)

    configs = isolate_format.union(
        isolate_format.load_isolate_as_config(FAKE_DIR, {}, None),
        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.union(
        isolate_format.load_isolate_as_config(FAKE_DIR, {}, '# Yo dawg!\n'),
        isolate_format.load_isolate_as_config(FAKE_DIR, {}, '# Chill out.\n'))
    self.assertEqual('# Yo dawg!\n', configs.file_comment)
 def test_union(self):
   value1 = {
     'a': set(['A']),
     'b': ['B', 'C'],
     'c': 'C',
   }
   value2 = {
     'a': set(['B', 'C']),
     'b': [],
     'd': set(),
   }
   expected = {
     'a': set(['A', 'B', 'C']),
     'b': ['B', 'C'],
     'c': 'C',
     'd': set(),
   }
   self.assertEqual(expected, isolate_format.union(value1, value2))