Python YamlBindings.import_dict方法代码示例

# 需要导入模块: from spinnaker.yaml_util import YamlBindings [as 别名]
# 或者: from spinnaker.yaml_util.YamlBindings import import_dict [as 别名]
  def test_load_key_not_found(self):
    bindings = YamlBindings()
    bindings.import_dict({'field': '${injected.value}', 'injected': {}})

    with self.assertRaises(KeyError):
      bindings['unknown']
    self.assertEqual(None, bindings.get('unknown', None))

# 需要导入模块: from spinnaker.yaml_util import YamlBindings [as 别名]
# 或者: from spinnaker.yaml_util.YamlBindings import import_dict [as 别名]
  def test_transform_ok(self):
     bindings = YamlBindings()
     bindings.import_dict({'a': {'b': { 'space': 'WithSpace',
                                        'nospace': 'WithoutSpace',
                                        'empty': 'Empty'}},
                           'x' : {'unique': True}})
     template = """
a:
  b:
    space: {space}
    nospace:{nospace}
    empty:{empty}
unique:
  b:
     space: A
     nospace:B
     empty:
"""
     source = template.format(space='SPACE', nospace='NOSPACE', empty='')
     expect = template.format(space='WithSpace',
                              nospace=' WithoutSpace',
                              empty=' Empty')
     got = source
     for key in [ 'a.b.space', 'a.b.nospace', 'a.b.empty' ]:
       got = bindings.transform_yaml_source(got, key)

     self.assertEqual(expect, bindings.transform_yaml_source(expect, 'bogus'))
     self.assertEqual(expect, got)

# 需要导入模块: from spinnaker.yaml_util import YamlBindings [as 别名]
# 或者: from spinnaker.yaml_util.YamlBindings import import_dict [as 别名]
 def test_update_field_union_child(self):
   bindings = YamlBindings()
   bindings.import_dict({'parent1': {'a': 'A'}, 'parent2': {'x': 'X'}})
   bindings.import_dict({'parent1': {'b': 'B'}})
   self.assertEqual({'parent1': {'a': 'A', 'b': 'B'},
                     'parent2': {'x': 'X'}},
                    bindings.map)

# 需要导入模块: from spinnaker.yaml_util import YamlBindings [as 别名]
# 或者: from spinnaker.yaml_util.YamlBindings import import_dict [as 别名]
 def test_true_false_not_resolved(self):
     bindings = YamlBindings()
     bindings.import_dict({'indirect': '${t}'})
     validator = ValidateConfig(
           configurator=Configurator(bindings=bindings))
     self.assertFalse(validator.verify_true_false('indirect'))
     self.assertEqual('Missing "indirect".', validator.errors[0])

# 需要导入模块: from spinnaker.yaml_util import YamlBindings [as 别名]
# 或者: from spinnaker.yaml_util.YamlBindings import import_dict [as 别名]
 def test_load_transitive_indirect(self):
   bindings = YamlBindings()
   bindings.import_dict({'field': '${injected.value}', 'found': 'FOUND'})
   bindings.import_dict({'injected': {'value': '${found}'}})
   self.assertEqual('FOUND', bindings.get('field'))
   self.assertEqual('FOUND', bindings['field'])
   self.assertEqual('FOUND', bindings.get('field', None))

# 需要导入模块: from spinnaker.yaml_util import YamlBindings [as 别名]
# 或者: from spinnaker.yaml_util.YamlBindings import import_dict [as 别名]
def populate_google_yml(content):
  credentials = {'project': '', 'jsonPath': ''}
  google_dict = {'enabled': False,
                 'defaultRegion': 'us-central1',
                 'defaultZone': 'us-central1-f',}

  google_dict['primaryCredentials'] = credentials

  if is_google_instance():
      zone = os.path.basename(
           check_fetch(GOOGLE_INSTANCE_METADATA_URL + '/zone',
                       google=True).content)
      google_dict['enabled'] = 'true'
      google_dict['defaultRegion'] = zone[:-2]
      google_dict['defaultZone'] = zone
      credentials['project'] = check_fetch(
            GOOGLE_METADATA_URL + '/project/project-id', google=True).content

  bindings = YamlBindings()
  bindings.import_dict({'providers': {'google': google_dict}})
  content = bindings.transform_yaml_source(content, 'providers.google.enabled')
  content = bindings.transform_yaml_source(
      content, 'providers.google.defaultRegion')
  content = bindings.transform_yaml_source(
      content, 'providers.google.defaultZone')
  content = bindings.transform_yaml_source(
      content, 'providers.google.primaryCredentials.project')
  content = bindings.transform_yaml_source(
      content, 'providers.google.primaryCredentials.jsonPath')

  return content

# 需要导入模块: from spinnaker.yaml_util import YamlBindings [as 别名]
# 或者: from spinnaker.yaml_util.YamlBindings import import_dict [as 别名]
  def test_load_dict(self):
    expect = {'a': 'A',
              'b': 0,
              'c': ['A','B'],
              'd': {'child': {'grandchild': 'x'}},
              'e': None}

    bindings = YamlBindings()
    bindings.import_dict(expect)
    self.assertEqual(expect, bindings.map)

# 需要导入模块: from spinnaker.yaml_util import YamlBindings [as 别名]
# 或者: from spinnaker.yaml_util.YamlBindings import import_dict [as 别名]
 def test_true_false_good(self):
     bindings = YamlBindings()
     bindings.import_dict(
         {'t': True, 'f':False, 'indirect':'${t}', 'default': '${x:true}'})
     validator = ValidateConfig(
           configurator=Configurator(bindings=bindings))
     self.assertTrue(validator.verify_true_false('t'))
     self.assertTrue(validator.verify_true_false('f'))
     self.assertTrue(validator.verify_true_false('indirect'))
     self.assertTrue(validator.verify_true_false('default'))

# 需要导入模块: from spinnaker.yaml_util import YamlBindings [as 别名]
# 或者: from spinnaker.yaml_util.YamlBindings import import_dict [as 别名]
 def host_test_helper(self, tests, valid, required=False):
     bindings = YamlBindings()
     bindings.import_dict(tests)
     validator = ValidateConfig(
           configurator=Configurator(bindings=bindings))
     for key, value in tests.items():
         msg = '"{key}" was {valid}'.format(
             key=key, valid='invalid' if valid else 'valid')
                                            
         self.assertEqual(valid, validator.verify_host(key, required), msg)
     return validator

# 需要导入模块: from spinnaker.yaml_util import YamlBindings [as 别名]
# 或者: from spinnaker.yaml_util.YamlBindings import import_dict [as 别名]
  def test_transform_fail(self):
     bindings = YamlBindings()
     bindings.import_dict({'a': {'b': { 'child': 'Hello, World!'}},
                           'x' : {'unique': True}})
     yaml = """
a:
  b:
     child: Hello
"""
     with self.assertRaises(ValueError):
       bindings.transform_yaml_source(yaml, 'x.unique')

# 需要导入模块: from spinnaker.yaml_util import YamlBindings [as 别名]
# 或者: from spinnaker.yaml_util.YamlBindings import import_dict [as 别名]
 def test_verify_at_least_one_provider_enabled_good(self):
     bindings = YamlBindings()
     bindings.import_dict({
         'providers': {
             'aws': { 'enabled': False },
             'google': {'enabled': False },
             'another': {'enabled': True }
         },
     })
     validator = ValidateConfig(
           configurator=Configurator(bindings=bindings))
     self.assertTrue(validator.verify_at_least_one_provider_enabled())

# 需要导入模块: from spinnaker.yaml_util import YamlBindings [as 别名]
# 或者: from spinnaker.yaml_util.YamlBindings import import_dict [as 别名]
 def baseUrl_test_helper(self, tests, valid, scheme_optional):
     bindings = YamlBindings()
     bindings.import_dict(tests)
     validator = ValidateConfig(
           configurator=Configurator(bindings=bindings))
     for key, value in tests.items():
         msg = '"{key}" was {valid}'.format(
             key=key, valid='invalid' if valid else 'valid')
                                            
         self.assertEqual(
             valid,
             validator.verify_baseUrl(key, True,
                                      scheme_optional=scheme_optional),
             msg)

# 需要导入模块: from spinnaker.yaml_util import YamlBindings [as 别名]
# 或者: from spinnaker.yaml_util.YamlBindings import import_dict [as 别名]
 def test_verify_at_least_one_provider_enabled_bad(self):
     bindings = YamlBindings()
     bindings.import_dict({
         'providers': {
             'aws': { 'enabled': False },
             'google': {'enabled': False }
         },
         'services': {'test': { 'enabled': True }}
     })
     validator = ValidateConfig(
           configurator=Configurator(bindings=bindings))
     self.assertFalse(validator.verify_at_least_one_provider_enabled())
     self.assertEqual('None of the providers are enabled.',
                      validator.errors[0])

# 需要导入模块: from spinnaker.yaml_util import YamlBindings [as 别名]
# 或者: from spinnaker.yaml_util.YamlBindings import import_dict [as 别名]
    def test_update_deck_settings(self):
        temp_sourcedir = tempfile.mkdtemp()
        temp_targetdir = tempfile.mkdtemp()
        template = """
preamble
// BEGIN reconfigure_spinnaker
// var gateUrl = ${{services.gate.baseUrl}};
{gate_url_value}
// var bakeryBaseUrl = ${{services.bakery.baseUrl}};
{bakery_url_value}
// END reconfigure_spinnaker
// var gateUrl = ${{services.gate.baseUrl}};
stuff here is left along.
"""
        # This was originally just a comment, which was preserved.
        bakery_url_assignment = ("var bakeryBaseUrl = 'BAKERY_BASE_URL';"
                                 "\n# comment")

        # This was originally a different let statement that was removed.
        gate_url_assignment = "var gateUrl = 'GATE_BASE_URL';"
        bindings = YamlBindings()
        bindings.import_dict({
            'services': {
                'gate': { 'baseUrl': 'GATE_BASE_URL' },
                'bakery': { 'baseUrl': 'BAKERY_BASE_URL' },
             }
        })

        installation = InstallationParameters
        installation.INSTALLED_CONFIG_DIR = temp_sourcedir
        installation.DECK_INSTALL_DIR = temp_targetdir
        configurator = Configurator(installation_parameters=installation,
                                    bindings=bindings)
        try:
            source_settings_path = os.path.join(temp_sourcedir, 'settings.js')
            target_settings_path = os.path.join(temp_targetdir, 'settings.js')
            with open(source_settings_path, 'w') as f:
                f.write(template.format(gate_url_value="var gateUrl='old';",
                                        bakery_url_value='# comment'))

            configurator.update_deck_settings()
            with open(target_settings_path, 'r') as f:
                got = f.read()
            expect = template.format(gate_url_value=gate_url_assignment,
                                     bakery_url_value=bakery_url_assignment)
            self.assertEqual(expect, got)
        finally:
            shutil.rmtree(temp_sourcedir)
            shutil.rmtree(temp_targetdir)

# 需要导入模块: from spinnaker.yaml_util import YamlBindings [as 别名]
# 或者: from spinnaker.yaml_util.YamlBindings import import_dict [as 别名]
 def test_load_default_bool(self):
   bindings = YamlBindings()
   bindings.import_dict({'field': '${undefined:True}'})
   self.assertEqual(True, bindings.get('field'))
   bindings.import_dict({'field': '${undefined:true}'})
   self.assertEqual(True, bindings.get('field'))
   bindings.import_dict({'field': '${undefined:false}'})
   self.assertEqual(False, bindings.get('field'))
   bindings.import_dict({'field': '${undefined:False}'})
   self.assertEqual(False, bindings.get('field'))