def test_gen_uuid_matches_regex(self):
pg = ParamGen(**self.class_kwargs)
generated_uuid = pg._gen_uuid()
self.assertRegex(
generated_uuid,
re.compile(
'[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}')
)
def test_get_available_azs(self):
pg = ParamGen(**self.class_kwargs)
acceptable_azs = ['us-east-1a','us-east-1b','us-east-1c','us-east-1d','us-east-1e','us-east-1f']
pg._boto_client = MockClientFactory()
returned_azs = pg.get_available_azs(2)
returned_az_list = returned_azs.split(',')
test_criteria = [
# tuple (first_param, second_param, test_description)
(len(returned_az_list), 2, "Verifying we return 2 AZs"),
(len(set(returned_az_list)), 2, "Verifying we return 2 *unique* AZs")
]
for first_param, second_param, test_desc in test_criteria:
with self.subTest(test_desc):
self.assertEqual(first_param, second_param)
def test_genpassword_type(self):
pg = ParamGen(**self.class_kwargs)
genpassword_criteria = [
# A tuple of (func_call, length, flags, re.Pattern, description)
(pg.genpassword, 15, None, re.compile('[0-9A-Za-z]'), 'Testing a 15 character password. Default PW type'),
(pg.genpassword, 15, 'S', re.compile("[!#\$&{\*:\[=,\]-_%\+a-zA-Z0-9]+"), 'Testing a 15 character password, Special Characters Type'),
(pg.genpassword, 15, 'A', re.compile('[0-9A-Za-z]'), 'Testing a 15 character password, Alphanumeric Character Type')
]
for func_call, pwlen, pwflags, re_pattern, test_desc in genpassword_criteria:
with self.subTest(test_desc):
self.assertRegex(func_call(pwlen, pwflags), re_pattern)
def test_regex_replace_param_value(self):
pg = ParamGen(**self.class_kwargs)
pg.param_name = 'test_param'
pg.param_value = 'example-foo-value'
re_pattern = re.compile('foo')
pg._regex_replace_param_value(re_pattern, 'bar')
self.assertEqual(pg.param_value, 'example-bar-value')
def test_param_transform(self):
input_params = [
{
"ParameterKey": "AvailabilityZones",
"ParameterValue": "$[taskcat_genaz_3]"
},
{
"ParameterKey":"SingleAZ",
"ParameterValue": "$[taskcat_getsingleaz_2]"
},
{
"ParameterKey": "StackName",
"ParameterValue": "TestStack"
},
{
"ParameterKey": "ByteValue",
"ParameterValue": '1'
},
{
"ParameterKey": "UUID",
"ParameterValue": "$[taskcat_genuuid]"
},
{
"ParameterKey": "RandomNumber",
"ParameterValue": "$[taskcat_random-numbers]"
},
{
"ParameterKey": "RandomString",
"ParameterValue": "$[taskcat_random-string]"
},
{
"ParameterKey": "UUID",
"ParameterValue": "$[taskcat_genuuid]"
},
{
"ParameterKey": "PasswordA",
"ParameterValue": "$[taskcat_genpass_8A]"
},
{
"ParameterKey": "PasswordAConfirm",
"ParameterValue": "$[taskcat_getval_PasswordA]"
},
{
"ParameterKey": "PasswordB",
"ParameterValue": "$[taskcat_genpass_32S]"
},
{
"ParameterKey":"LocalOverrideTest",
"ParameterValue":"override"
},
{
"ParameterKey":"GlobalOverrideTest",
"ParameterValue":"override"
}
]
bclient = MockClientFactory()
bclient.logger = logger
class_kwargs = self.class_kwargs
class_kwargs['param_list'] = input_params
class_kwargs['boto_client'] = bclient
pg = ParamGen(**class_kwargs)
pg.transform_parameter()
transformed_params = [x['ParameterValue'] for x in pg.results]
original_params = [x['ParameterValue'] for x in input_params]
ignore_patterns = ['RE_COUNT']
missed_regex_patterns = []
regex_pattern_text = set()
_found = False
for rp in self.regex_patterns:
regex_pattern_text.add(rp.test_pattern_attribute)
for tp in transformed_params:
if rp.test_pattern_attribute in ignore_patterns:
continue
with self.subTest("Transformed Value: {} must not match Regex: {}".format(tp, rp.test_pattern_attribute)):
self.assertNotRegex(tp, getattr(pg,rp.test_pattern_attribute))
regex_pattern_text = list(regex_pattern_text)
for rp in self.regex_patterns:
regex_test = re.compile(getattr(pg, rp.test_pattern_attribute))
for tp in original_params:
if regex_test.search(tp):
_found = True
if not _found:
missed_regex_patterns.append(rp.test_pattern_attribute)
self.assertEqual(missed_regex_patterns, [])
with self.subTest("SingleAZ transformed value must be us-east-1b"):
for r in pg.results:
if r['ParameterKey'] == 'SingleAZ':
self.assertEqual(r['ParameterValue'], 'us-east-1b')
def test_convert_to_str(self):
pg = ParamGen(**self.class_kwargs)
pg.param_name = 'test_param'
pg.param_value = 1234
pg.convert_to_str()
self.assertEqual(pg.param_value, '1234')
def test_gen_uuid_is_string(self):
pg = ParamGen(**self.class_kwargs)
generated_uuid = pg._gen_uuid()
self.assertEqual(type(generated_uuid), type(str()))
def test_gen_rand_num_len(self):
genstr = ParamGen._gen_rand_num(78)
self.assertEqual(len(genstr), 78)
def test_gen_rand_num(self):
genstr = ParamGen._gen_rand_num(24)
self.assertRegex(genstr, re.compile('[0-9]'))
def test_gen_rand_str_len(self):
genstr = ParamGen._gen_rand_str(33)
self.assertEqual(len(genstr), 33)
def test_gen_rand_str_regex(self):
genstr = ParamGen._gen_rand_str(24)
self.assertRegex(genstr, re.compile('[a-z]'))
def test_genpassword_length(self):
pg = ParamGen(**self.class_kwargs)
self.assertEqual(len(pg.genpassword(15)), 15)
def test_get_content(self):
pg = ParamGen(**self.class_kwargs)
pg._boto_client = MockClientFactory()
self.assertEqual(pg.get_content(bucket='unit-test-bucket', object_key='unit-test-key'), 'unicorns')
def test_genaz_raises_taskcat_exception(self):
pg = ParamGen(**self.class_kwargs)
pg._boto_client = MockClientFactory(ec2_single_az=True)
with self.assertRaises(TaskCatException):
pg.get_available_azs(2)
def test_special_regular_expression(self):
pg = ParamGen(**self.class_kwargs)
self.assertEqual(pg.regxfind(ParamGen.RE_COUNT, '$[taskcat_getaz_2]'), '2')
self.assertEqual(pg.regxfind(ParamGen.RE_COUNT, '$[taskcat_genpass_8]'), '8')
def test_regxfind(self):
pg = ParamGen(**self.class_kwargs)
re_object = re.compile('foo')
self.assertEqual(pg.regxfind(re_object, 'aslkjfafoo'), 'foo')
