def test_setup(self): test_descriptor = { "tests": [{ "name": "my-custom", "description": ["custom test driver will be ignored"], "setup": "yac/tests/test/lib/setup_cleanup.py", "target": "https://www.google.com/", "driver": "yac/tests/lib/custom_test_pass.py" }] } params = Params({}) tests = IntegrationTests(test_descriptor) err = tests.run(params, context="", test_names=["my-custom"], setup_only=True) # test that the setup was called and set a param my_setup_param = params.get('setup-param') self.assertTrue(my_setup_param == 'setup-value') self.assertTrue(not err)
def test_kvp_params(self): kvps = "joe:blue,jan:green" params = Params({}) params.load_kvps(kvps) self.assertTrue(params.get("jan") == 'green') self.assertTrue(params.get("joe") == 'blue')
def test_no_yac_fxn(self): # test when a dictionary references a non-existant yac-fxn params = { "service-alias": { "type": "string", "value": "myservice" }, "env": { "type": "string", "value": "dev" } } test_dict1 = { "myparam": { "comment": "testing", "value": { "yac-calc": ["yac/tests/intrinsics/vectors/nonexistant.py"] } } } test_dict2 = { "myparam": { "comment": "testing", "value": { "yac-calc": ["no-existant-stock"] } } } # run test error_received1 = False try: updated_dict1 = apply_intrinsics(test_dict1, Params(params)) except IntrinsicsError as e: error_received1 = True error_received2 = False try: updated_dict2 = apply_intrinsics(test_dict2, Params(params)) except IntrinsicsError as e: error_received2 = True self.assertTrue(error_received1) self.assertTrue(error_received2)
def test_dir_non_existent(self): cwd = os.getcwd() temp_test_dir = "yac/tests/stacks/aws/vectors/deploy" svc_file_path = os.path.join(cwd, temp_test_dir) service_parmeters = { "render-me": { "value": "baby!" }, "service-alias": { "value": "testing" } } serialize_boot_files = { "directories": [{ "src": "i_do_not_exist", "dest": "/tmp/stacks/aws/vectors/deploy/rendered/sample_dir" }] } boot_files = BootFiles(serialize_boot_files) error_thrown = False try: boot_files.deploy(Params(service_parmeters), context="", dry_run_bool=False) except TemplateError as e: # this is the expected condition error_thrown = True self.assertTrue(error_thrown)
def test_map(self): params = { "user-name": { "value": "henry-grantham" }, "neighborhood-map": { "lookup": "user-name", "value": { "tom-jackson": "phinney", "henry-grantham": "capital-hill" } } } test_dict = { "InstancePort": { "Ref": "WebServerPort" }, "LoadBalancerName": { "yac-ref": "neighborhood-map" } } # run test updated_dict = apply_intrinsics(test_dict, Params(params)) updated_dict_str = json.dumps(updated_dict) print(updated_dict_str) ref_check = "capital-hill" in updated_dict_str self.assertTrue(ref_check)
def test_map_name_error(self): params = { "user-name": { "value": "henry-grantham" }, "neighborhood-map": { "lookup": "user-name", "value": { "tom-jackson": "phinney", "henry-grantham": "capital-hill" } } } test_dict = { "InstancePort": { "Ref": "WebServerPort" }, "LoadBalancerName": { "yac-ref": "neighborhood-maps" } } # verify we get an error error_received = False try: updated_dict = apply_intrinsics(test_dict, Params(params)) except IntrinsicsError as e: error_received = True self.assertTrue(error_received)
def test_conditional_miss2(self): serialized_input = { "key": "alias", "title": "Alias", "type": "string", "help": "Name of alias to assign this custom dev stack", "required": True, "conditions": { "kvps": "env:dev,date:today" } } inputs = Input(serialized_input) params = Params({"env": {"value": "dev"}}) # inject an invalid response followed by a valid response sys.stdin = io.StringIO("my-stack") value, user_prompted = inputs.process(params) # test that the user was not prompted and that no value was returned self.assertTrue(not user_prompted) self.assertTrue(not value)
def test_dir_template(self): # test rendering templates in a directory test_dir = 'yac/tests/template/vectors/sample_dir' test_file1 = '/tmp/sample_file1.txt' test_file2 = '/tmp/sample_file2.tmp' test_file3 = '/tmp/sub_dir/sample_file3.txt' test_file4 = '/tmp/sample_binary.xls' test_variables = { "user-fname": { "value": "Tom" }, "user-lname": { "value": "Jaxon" } } # run test apply_templates_in_dir(test_dir, Params(test_variables), "/tmp") self.assertTrue('Tom Jaxon' in open(test_file1).read()) self.assertTrue('Tom Jaxon' in open(test_file2).read()) self.assertTrue('Tom Jaxon' in open(test_file3).read()) # test to see if binary file copies to destination properly self.assertTrue(os.path.exists(test_file4))
def test_reference_error(self): params = { "suffix" : { "type" : "string", "value": "" }, "s3_path": { "type" : "boolean", "value": "/sets/jira/dev" } } test_dict = { "volumesFrom": { "comment": "testing", "value": {"yac-ref": "suffi"} } } error_received=False try: updated_dict = apply_intrinsics(test_dict, Params(params)) except IntrinsicsError as e: error_received = True print(json.dumps(test_dict,indent=2)) self.assertTrue(error_received)
def test_stemplate(self): test_file = 'yac/tests/template/vectors/sample_map_file.txt' test_variables = { "user-name": { "value": "henry-grantham" }, "neighborhood-map": { "lookup": "user-name", "value": { "tom-jackson": "phinney", "henry-grantham": "capital-hill" } } } # read file into string file_contents = get_file_contents(test_file) # run test updated_file_contents = apply_stemplate(file_contents, Params(test_variables)) # test that the correct neighborhood got rendered into the file contents render_check = "capital-hill" in updated_file_contents self.assertTrue(render_check)
def test_custom_select(self): test_descriptor = { "tests": [{ "name": "my-custom-1", "description": ["a custom test driver"], "target": "https://www.google.com/", "driver": "yac/tests/test/lib/custom_test_fail.py" }, { "name": "my-custom-2", "description": ["a custom test driver"], "target": "https://www.google.com/", "driver": "yac/tests/test/lib/custom_test_pass.py" }] } tests = IntegrationTests(test_descriptor) tests.run(Params({}), "", test_names=["my-custom-1", "my-custom-2"]) test_results = tests.get_results() # test that the pass count is 1 and passing tests includes # the requested test self.assertTrue(len(test_results.get_passing_tests()) == 1) self.assertTrue('my-custom-2' in test_results.get_passing_tests())
def test_files(self): temp_test_dir = "yac/tests/stacks/aws/vectors/deploy" service_parmeters = {"render-me": {"value": "baby!"}, "servicefile-path": {"value": temp_test_dir}, "service-alias": {"value": "testing"}} serialize_boot_files = { "files": [ { "src": "deploy_for_boot.txt", "dest": "/tmp/stacks/aws/vectors/deploy/rendered/deploy_for_boot.txt" } ] } boot_files = BootFiles(serialize_boot_files) try: boot_files.deploy(Params(service_parmeters),context="") except FileError as e: print(e.msg) # read file contents from destination file file_contents = get_file_contents(serialize_boot_files['files'][0]['dest']) # clean up shutil.rmtree("/tmp/stacks/aws/vectors/deploy/rendered") self.assertTrue(file_contents == "render my params, then deploy me %s"%(service_parmeters["render-me"]["value"]))
def test_group(self): test_descriptor = { "test-groups": [{ "name": "group-1", "target": "https://www.google.com/", "tests": [{ "name": "my-custom-1", "description": ["a custom test driver"], "target": "https://www.google.com/", "driver": "yac/tests/test/lib/custom_test_pass.py" }, { "name": "my-custom-2", "description": ["a custom test driver"], "target": "https://www.google.com/", "driver": "yac/tests/test/lib/custom_test_pass.py" }] }] } tests = IntegrationTests(test_descriptor) tests.run(Params({}), context="", group_names=["group-1"]) test_results = tests.get_results() # test that all pass self.assertTrue(len(test_results.get_passing_tests()) == 2)
def test_yac_fxn(self): params = { "service-alias": { "type": "string", "value": "myservice" }, "env": { "type": "string", "value": "dev" } } test_dict = { "myparam": { "comment": "testing", "value": { "yac-fxn": "yac/tests/intrinsics/vectors/fxn.py" } } } # run test updated_dict = apply_intrinsics(test_dict, Params(params)) # test that the value is populated per the value returned by fxn.py fxn_check = updated_dict['myparam']['value'] == "myservice" self.assertTrue(fxn_check)
def test_null_join(self): params = { "suffix" : { "type" : "string", "value": "" }, "s3_path": { "type" : "boolean", "value": "/sets/jira/dev" } } test_dict = { "volumesFrom": { "comment": "testing", "value": {"yac-join" : [ "/", [ {"yac-ref": "s3_path"}, {"yac-ref": "suffix"}, "backups.json" ]]} } } # run test updated_dict = apply_intrinsics(test_dict, Params(params)) join_check = updated_dict['volumesFrom']['value'] == "/sets/jira/dev/backups.json" self.assertTrue(join_check)
def test_group_test_misselect(self): test_descriptor = { "test-groups": [{ "name": "group-1", "target": "https://www.google.com/", "tests": [{ "name": "my-custom-1", "description": ["a custom test driver"], "target": "https://www.google.com/", "driver": "yac/tests/test/lib/custom_test_pass.py" }, { "name": "my-custom-2", "description": ["a custom test driver"], "target": "https://www.google.com/", "driver": "yac/tests/test/lib/custom_test_pass.py" }] }] } tests = IntegrationTests(test_descriptor) err = tests.run(Params({}), context="", group_names=["group-1:my-custom-na"]) test_results = tests.get_results() # test that the pass count is 0 and that an error was returned self.assertTrue(len(test_results.get_passing_tests()) == 0) print(err) self.assertTrue(err)
def test_stack(self): serialized_stack = { "type": "kubernetes", "deployments": [{ "apiVersion": "apps/v1", "kind": "Deployment", "spec": { "replicas": 2, "template": { "spec": { "resources": { "requests": { "memory": "129M", "cpu": 3 }, "limits": { "memory": "250M", "cpu": 4 } } } } } }] } stack = K8sStack(serialized_stack) stack.cost(Params({})) self.assertTrue(stack)
def get_params_from_file(cache_full_path): # sneak a peak at file before deleting with open(cache_full_path) as file_arg_fp: file_contents = file_arg_fp.read() return Params(json.loads(file_contents))
def test_via_custom_convention_temp(self): params = { "service-alias": { "comment": "my service alias", "value": "jira" }, "env": { "comment": "environment", "value": "dev" }, "naming-convention": { "comment": "my custom naming convention", "value": { "param-keys": ['service-alias','env'], "delimitter_fake": "-" } } } validation_errors = False try: resource_name = get_resource_name(Params(params), "elb") except ValidationError as e: validation_errors = True self.assertTrue(validation_errors)
def test_naming_convention(self): params = { "service-alias": { "value": "jira" }, "env": { "value": "prod" }, "naming-convention": { "comment": "name resources using the alias followed by the environment", "value": { "param-keys": ['service-alias', 'env'], "delimiter": "." } } } test_dict = { "Type": "AWS::AutoScaling::AutoScalingGroup", "Name": { "yac-name": "asg" } } updated_dict = apply_intrinsics(test_dict, Params(params)) name_check = updated_dict['Name'] == 'jira.prod.asg' self.assertTrue(name_check)
def test_params(self): test_parameters = { "ssl-cert" : { "value": "godzilla", "comment": "" }, "s3_path": { "value": "/sets/jira/dev", "comment": "" } } # run test params = Params(test_parameters) self.assertTrue(params.get("ssl-cert") == "godzilla")
def test_boot(self): # run test boot_list,err = do_calc(["yac/tests/stacks/aws/vectors/boot_simple.sh"],Params({})) len_check = len(boot_list)==20 self.assertTrue(len_check)
def test_map(self): test_parameters = { "user-name": { "value": "tom-johnson" }, "neighborhood-map": { "lookup": "user-name", "value": { "tom-johnson": "phinney", "henry-grantham": "queen-ann-hill" } } } params = Params(test_parameters) self.assertTrue(params.get("neighborhood-map") == "phinney")
def test_secrets(self): my_secrets = { "param-key-1": { "comment": "branch 1, child 1, entry 1", "source": "keepass", "lookup": { "path": "Branch 1/B1-C1/B1-C1-E1", "field": "password" } }, "param-key-2": { "comment": "branch 2, child 2, entry 1", "source": "keepass", "lookup": { "path": "Branch 2/B2-C2/B2-C2-E1", "field": "password" } } } secrets_vaults = [{ "type": "keepass", "name": "keepass", "configs": { "vault-path": "yac/tests/vault/vectors/test_vault.kdbx", "vault-pwd-path": TestCase.pwd_path } }] params = Params({}) vaults = SecretVaults(secrets_vaults) secrets = Secrets(my_secrets) secrets.load(params, vaults) print(secrets.get_errors()) both_loaded = (params.get("param-key-1") == 'b1-c1-e1-secret' and params.get("param-key-2") == 'b2-c2-e1-secret') self.assertTrue(both_loaded)
def test_stranger(self): string_w_variables = 'Simons says {{yac-calc:["yac/tests/template/vectors/say_hello.py"]}}' # run test string_w_variables = apply_stemplate(string_w_variables, Params({})) # test that "Hello stranger" got rendered into the string contents render_check = "hello stranger" in string_w_variables self.assertTrue(render_check)
def test_bad_calculator(self): string_w_variables = 'Simons says {{yac-calc: ["nonexistent.py"]}}' err = "" try: string_w_variables = apply_stemplate(string_w_variables, Params({})) except TemplateError as e: err = e self.assertTrue(err)
def test_yac_version(self): test_parameters = { "yac-version" : { "value": "2.0" } } ami_id = do_calc([],Params(test_parameters)) self.assertTrue(ami_id)
def test_schema_good(self): serialized_obj = { "type": "gcp-cloudmanager", "Resources": {} } # test that no schema validation errors are raised stack = GCPStack(serialized_obj) err = stack.build(Params({})) self.assertTrue(not err)
def test_map_miss(self): # user-name doesn't match any of the map keys test_parameters = { "user-name": { "value": "tom-johnsons" }, "neighborhood-map": { "lookup": "user-name", "value": { "tom-johnson": "phinney", "henry-grantham": "queen-ann-hill" } } } params = Params(test_parameters) value = params.get("neighborhood-map", "m.i.a") self.assertTrue(value == "m.i.a")
def test_run_task(self): tasks = Tasks(TestCase.serialized_tasks) restore_task = tasks.get('restore') # inject an response to input prompt sys.stdin = io.StringIO("dev") params = Params({}) err = restore_task.run(params) self.assertTrue(err == "")