def test_get_account_alias_invalid_env(self): """ Tests if get_account_alias raises exceptions when given invalid environments Returns: None Raises: AssertionError if any of the assert checks fail """ # Create junk environment values by attaching numbers to non-ephemeral environments and not attaching numbers # to ephemeral environments for env, account_alias in EFConfig.ENV_ACCOUNT_MAP.items(): if env not in EFConfig.EPHEMERAL_ENVS: env += '0' with self.assertRaises(ValueError) as exception: ef_utils.get_account_alias(env) self.assertTrue("unknown env" in exception.exception.message) # Hard coded junk values with self.assertRaises(ValueError) as exception: ef_utils.get_account_alias("non-existent-env") self.assertTrue("unknown env" in exception.exception.message) with patch('ef_utils.env_valid') as mock_env_valid: with self.assertRaises(ValueError) as exception: mock_env_valid.return_value = True ef_utils.get_account_alias("non-existent-env") self.assertTrue( "has no entry in ENV_ACCOUNT_MAP" in exception.exception.message) with self.assertRaises(ValueError) as exception: ef_utils.get_account_alias("") self.assertTrue("unknown env" in exception.exception.message) with self.assertRaises(ValueError) as exception: ef_utils.get_account_alias(None) self.assertTrue("unknown env" in exception.exception.message)
def test_fully_qualified_env(self): """Does {{ENV_FULL}} resolve correctly""" # proto0 test_string = "{{ENV_FULL}}" resolver = EFTemplateResolver(profile=get_account_alias("proto0"), env="proto0", region=TEST_REGION, service=TEST_SERVICE) resolver.load(test_string, PARAMS) self.assertEqual(resolver.render(), "proto0") # prod resolver = EFTemplateResolver(profile=get_account_alias("prod"), env="prod", region=TEST_REGION, service=TEST_SERVICE) resolver.load(test_string, PARAMS) self.assertEqual(resolver.render(), "prod") # mgmt.ellationeng resolver = EFTemplateResolver( profile=get_account_alias("mgmt.ellationeng"), env="mgmt.ellationeng", region=TEST_REGION, service=TEST_SERVICE) resolver.load(test_string, PARAMS) self.assertEqual(resolver.render(), "mgmt.ellationeng")
def test_fully_qualified_env(self, mock_create_aws): """Does {{ENV_FULL}} resolve correctly""" mock_create_aws.return_value = self._clients # alpha0 test_string = "{{ENV_FULL}}" resolver = EFTemplateResolver(profile=get_account_alias("alpha0"), env="alpha0", region=TEST_REGION, service=TEST_SERVICE) resolver.load(test_string, PARAMS) self.assertEqual(resolver.render(), "alpha0") # prod resolver = EFTemplateResolver(profile=get_account_alias("test"), env="test", region=TEST_REGION, service=TEST_SERVICE) resolver.load(test_string, PARAMS) self.assertEqual(resolver.render(), "test") # mgmt.testaccount resolver = EFTemplateResolver( profile=get_account_alias("mgmt.testaccount"), env="mgmt.testaccount", region=TEST_REGION, service=TEST_SERVICE) resolver.load(test_string, PARAMS) self.assertEqual(resolver.render(), "mgmt.testaccount")
def test_get_account_alias(self): """ Checks if get_account_alias returns the correct account based on valid environments Returns: None Raises: AssertionError if any of the assert checks fail """ for env, account_alias in EFConfig.ENV_ACCOUNT_MAP.items(): # Attach a numeric value to environments that are ephemeral if env in EFConfig.EPHEMERAL_ENVS: env += '0' self.assertEquals(ef_utils.get_account_alias(env), account_alias) # Do tests for global and mgmt envs, which have a special mapping, Example: global.account_alias if "global" in EFConfig.ENV_ACCOUNT_MAP: for account_alias in EFConfig.ENV_ACCOUNT_MAP.values(): self.assertEquals( ef_utils.get_account_alias("global." + account_alias), account_alias) if "mgmt" in EFConfig.ENV_ACCOUNT_MAP: for account_alias in EFConfig.ENV_ACCOUNT_MAP.values(): self.assertEquals( ef_utils.get_account_alias("mgmt." + account_alias), account_alias)
def handle_args_and_set_context(args): """ Args: args: the command line args, probably passed from main() as sys.argv[1:] Returns: a populated Context object based on CLI args """ parser = argparse.ArgumentParser() parser.add_argument("env", help="environment") parser.add_argument("path_to_template", help="path to the config template to process") parser.add_argument("--no_params", help="disable loading values from params file", action="store_true", default=False) parser.add_argument("--verbose", help="Output extra info", action="store_true", default=False) parsed = vars(parser.parse_args(args)) path_to_template = abspath(parsed["path_to_template"]) service = path_to_template.split('/')[-3] return Context(get_account_alias(parsed["env"]), EFConfig.DEFAULT_REGION, parsed["env"], service, path_to_template, parsed["no_params"], parsed["verbose"])
def test_render_multiline_string_from_list(self, mock_create_aws): """Does {{multi}} resolve correctly as a multiline string from yaml parameters file""" mock_create_aws.return_value = self._clients test_string = "{{multi2}}" resolver = EFTemplateResolver(profile=get_account_alias("test"), env="test", region=TEST_REGION, service=TEST_SERVICE) with open(self.test_params_json) as json_file: resolver.load(test_string, json_file) self.assertEqual(resolver.render(), "one\ntwo\nthree")
def test_load_yaml_file(self, mock_create_aws): """Does {{one}} resolve correctly from yaml parameters file""" mock_create_aws.return_value = self._clients test_string = "{{one}}" resolver = EFTemplateResolver(profile=get_account_alias("alpha0"), env="alpha0", region=TEST_REGION, service=TEST_SERVICE) with open(self.test_params_yaml) as yaml_file: resolver.load(test_string, yaml_file) self.assertEqual(resolver.render(), "alpha one")
def test_render_multiline_string(self, mock_create_aws): """Does {{multi}} resolve correctly as a multiline string from yaml parameters file""" mock_create_aws.return_value = self._clients test_string = "{{multi}}" resolver = EFTemplateResolver(profile=get_account_alias("test"), env="test", region=TEST_REGION, service=TEST_SERVICE) with open(self.test_params_yaml) as yaml_file: resolver.load(test_string, yaml_file) self.assertEqual( resolver.render(), "thisisareallylongstringthatcoversmultiple\nlinesfortestingmultilinestrings" )
def env(self, value): """ Sets context.env, context.env_short, and context.account_alias if env is valid For envs of the form "global.<account>" and "mgmt.<account_alias>", env is captured as "global" or "mgmt" and account_alias is parsed out of the full env rather than looked up Args: value: the fully-qualified env value Raises: ValueError if env is not valid """ env_valid(value) self._env_full = value if value.find(".") == -1: # plain environment, e.g. prod, staging, proto<n> self._env = value self._account_alias = get_account_alias(value) else: # "<env>.<account_alias>" form, e.g. global.ellationeng or mgmt.ellationeng self._env, self._account_alias = value.split(".") # since we extracted an env, must reconfirm that it's legit global_env_valid(self._env) self._env_short = get_env_short(value)
class TestEFVersionResolver(unittest.TestCase): """Tests for 'ef_version_resolver.py'""" # initialize based on where running where = whereami() if where == "local": session = boto3.Session(profile_name=get_account_alias("proto0"), region_name=EFConfig.DEFAULT_REGION) elif where == "ec2": region = http_get_metadata("placement/availability-zone/") region = region[:-1] session = boto3.Session(region_name=region) else: fail("Can't test in environment: " + where) clients = { "ec2": session.client("ec2") } def test_ami_id(self): """Does ami-id,data-api resolve to an AMI id""" test_string = "ami-id,data-api" resolver = EFVersionResolver(TestEFVersionResolver.clients) self.assertRegexpMatches(resolver.lookup(test_string), "^ami-[a-f0-9]{8}$")
http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. """ import unittest from ef_config import EFConfig from ef_template_resolver import EFTemplateResolver from ef_utils import get_account_alias TEST_PROFILE = get_account_alias("proto0") TEST_REGION = EFConfig.DEFAULT_REGION TEST_ENV = "proto0" TEST_SERVICE = "none" PARAMS = """{ "params":{ "default":{ "one": "default one", "two": "default two", "o": "o", "ne": "ne", "/_-.": "slashunderscoredashdot", ".": "dot", "my-thing": "my-hyphen-thing" },
VPC CIDR block: {{aws:ec2:vpc/cidrblock,vpc-staging}}\n\ WAF Web ACL ID: {{aws:waf:web-acl-id,staging-StaticAcl}}\n\ SSL Certificate ARN us-west-2/cx-proto3.com: {{aws:acm:certificate-arn,us-west-2/cx-proto3.com}}\n\ Elastic network interface (ENI) eni-proto3-dnsproxy-1a: {{aws:ec2:eni/eni-id,eni-proto3-dnsproxy-1a}}\n\ Elastic IP Allocation ID: {{aws:ec2:elasticip/elasticip-id,ElasticIpMgmtCingest1}}\n\ Elastic IP IP Address: {{aws:ec2:elasticip/elasticip-ipaddress,ElasticIpMgmtCingest1}}\n\ EFConfig resolver, accountaliasofenv,prod: {{efconfig:accountaliasofenv,staging}}\n\ AMI lookup: {{version:ami-id,proto0/test-instance}}\n\ Latest AMI for test-instance: {{version:ami-id,proto0/test-instance}}\ " GLOBAL_ENV_TEST_STRING = "fully-qualified environment:{{ENV_FULL}}\n" # Test with proto0 if LOCAL: resolver = EFTemplateResolver(profile=get_account_alias("proto0"), env="proto0", region="us-west-2", service="mine", verbose=True) else: resolver = EFTemplateResolver(verbose=True) resolver.load(TEST_STRING, PARAMS) resolver.render() print(resolver.template) print("unresolved symbol count: " + str(len(resolver.unresolved_symbols()))) print("unresolved symbols: " + repr(resolver.unresolved_symbols())) print("all template symbols: " + repr(resolver.symbols)) print("all EFTemplateResolver symbols: " + repr(resolver.resolved))
limitations under the License. """ import os import unittest from mock import call, Mock, patch # For local application imports, context_paths must be first despite lexicon ordering import context_paths from ef_config import EFConfig from ef_template_resolver import EFTemplateResolver from ef_utils import get_account_alias TEST_PROFILE = get_account_alias("test") TEST_REGION = EFConfig.DEFAULT_REGION TEST_ENV = "test" TEST_SERVICE = "none" PARAMS = """{ "params":{ "default":{ "one": "default one", "two": "default two", "o": "o", "ne": "ne", "/_-.": "slashunderscoredashdot", ".": "dot", "my-thing": "my-hyphen-thing" },
def test_get_account_alias(self): """Does get_account_alias resolve correctly""" self.assertEquals(get_account_alias("prod"), "ellation") self.assertEquals(get_account_alias("staging"), "ellationeng") self.assertEquals(get_account_alias("proto0"), "ellationeng") self.assertEquals(get_account_alias("global.ellation"), "ellation")