def setUpClass(cls):
'''Test class level common fixture.'''
cls.mediator = aws_informer.AWSMediator(
region_name=site_boogio.test_region_name,
profile_name=site_boogio.test_profile_name
)
def test_aws_mediator_use_filters(self):
'''Test aws_mediator_entity filtered entity retrieval.'''
mediator = aws_informer.AWSMediator(
region_name=site_boogio.test_region_name,
profile_name=site_boogio.test_profile_name
)
# Pull a set of elastic IPs and get a couple of values.
entities = mediator.entities('eip')
all_ips = [e['PublicIp'] for e in entities]
# If this isn't true we won't really be testing what this
# case is intended to test.
self.assertTrue(len(all_ips) > 3)
mediator.flush()
selected_ips = all_ips[:3]
mediator.add_filters(
'eip', {'public-ip': selected_ips})
some_entities = mediator.entities('eip')
self.assertEqual(len(some_entities), len(selected_ips))
# We have to flush so we force a re-fetch.
mediator.flush()
all_entities = mediator.entities('eip', use_filters=False)
self.assertEqual(len(all_entities), len(all_ips))
def setUp(self):
'''Test case common fixture setup.'''
self.mediator = aws_informer.AWSMediator()
self.iam_informer = aws_informer.IAMInformer(mediator=self.mediator,
record_types=['Users'])
mediator = self.mediator
informer = self.iam_informer
self.assertIn('Users', informer.supplementals)
# print informer.supplementals['Users'][0]
# - - - - - - - - - - - - - - - - - -
# user = informer.supplementals['Users'][0]
def request(user):
'''Helper for creating a request structure.'''
return {
'origin': user,
'session_kwargs': {
'profile_name': mediator.session.profile_name
},
'client_type': 'iam',
'client_method': 'list_access_keys',
'method_args': [],
'method_kwargs': {
'UserName': user['UserName']
},
'response_data_keys': {
'AccessKeyMetadata': 'AccessKeys'
}
}
# - - - - - - - - - - - - - - - - - -
# This establishes the baseline for request duration.
# - - - - - - - - - - - - - - - - - -
baseline_sample_size = 12
durations = []
for user_index in range(baseline_sample_size):
start = time.time()
mediator.get_aws_info_in_parallel(
[request(informer.supplementals['Users'][user_index])])
durations.append(time.time() - start)
# self.duration_baseline = duration / baseline_sample_size
self.max_duration_baseline = max(durations)
self.min_duration_baseline = min(durations)
# We'll allow requests "too slow" up to this limit without failing.
self.duration_leeway_factor = 2.2
def test_aws_mediator_init(self):
'''Test initialization of aws mediators.'''
# - - - - - - - - - - - - - - - - - -
mediator = aws_informer.AWSMediator(
region_name=site_boogio.test_region_name
)
self.assertIsNotNone(mediator)
self.assertIsNotNone(mediator.account_id)
# - - - - - - - - - - - - - - - - - -
mediator = aws_informer.AWSMediator(
profile_name=site_boogio.test_profile_name
)
self.assertIsNotNone(mediator)
self.assertIsNotNone(mediator.account_id)
# - - - - - - - - - - - - - - - - - -
mediator = aws_informer.AWSMediator(
region_name=site_boogio.test_region_name,
profile_name=site_boogio.test_profile_name
)
self.assertIsNotNone(mediator)
self.assertIsNotNone(mediator.account_id)
# - - - - - - - - - - - - - - - - - -
mediator = aws_informer.AWSMediator(
session=self.boto3_session
)
self.assertIsNotNone(mediator)
self.assertIsNotNone(mediator.account_id)
# - - - - - - - - - - - - - - - - - -
# Errors due to assigning region/profile/session incompatibly.
with self.assertRaises(ValueError):
mediator = aws_informer.AWSMediator(
region_name=site_boogio.test_region_name,
session=self.boto3_session
)
with self.assertRaises(ValueError):
mediator = aws_informer.AWSMediator(
profile_name=site_boogio.test_profile_name,
session=self.boto3_session
)
with self.assertRaises(ValueError):
mediator = aws_informer.AWSMediator(
region_name=site_boogio.test_region_name,
profile_name=site_boogio.test_profile_name,
session=self.boto3_session
)
def _get_initialized_mediators(self):
'''Return the list of ``AWSMediator`` instances to use.'''
all_profile_kwargs = [{}]
if self.profiles:
all_profile_kwargs = [{'profile_name': p} for p in self.profiles]
all_region_kwargs = [{}]
if self.regions:
all_region_kwargs = [{'region_name': r} for r in self.regions]
all_mediator_kwargs = [
dict(x[0], **x[1])
for x in itertools.product(all_profile_kwargs, all_region_kwargs)
]
return [
aws_informer.AWSMediator(**mediator_kwargs)
for mediator_kwargs in all_mediator_kwargs
]
def test_set_elb_informer_instances_keyname_environments(self):
'''Test ELB assigned EC2 environment supplementals.'''
mediator = aws_informer.AWSMediator(
region_name=site_boogio.test_region_name,
profile_name=site_boogio.test_profile_name)
mediator.flush()
self.assertEqual(mediator.informer_cache, {})
elb_resource = mediator.entities('elb')[0]
elb_informer = aws_informer.ELBInformer(elb_resource,
mediator=mediator)
# Without EC2 entities already fetched, this fails.
with self.assertRaises(RuntimeError):
site_boogio.set_elb_informer_instances_keyname_environments(
elb_informer)
# Now fetch EC2 entities.
self.assertTrue(len(mediator.entities('ec2')) > 0)
site_boogio.set_elb_informer_instances_keyname_environments(
elb_informer)
self.assertIn('instance_environments', elb_informer.supplementals)
def test_aws_mediator_remove_all_filters(self):
'''Test aws_mediator_remove_all_filters().'''
mediator = aws_informer.AWSMediator(
region_name=site_boogio.test_region_name,
profile_name=site_boogio.test_profile_name
)
self.assertEqual(mediator.filters, {})
# - - - - - - - - - - - -
# Remove all filters.
# - - - - - - - - - - - -
mediator.add_filters('eip', {'public-ip': ['123.45.67.89']})
self.assertEqual(
mediator.filters,
{'eip': {'public-ip': ['123.45.67.89']}}
)
mediator.remove_all_filters()
self.assertEqual(mediator.filters, {})
# - - - - - - - - - - - -
# Remove all entity type filters.
# - - - - - - - - - - - -
mediator.add_filters('ec2', {'instance-state-name': ['running']})
mediator.add_filters('eip', {'domain': ['vpc']})
mediator.add_filters('eip', {'public-ip': ['123.45.67.89']})
self.assertItemsEqual(mediator.filters.keys(), ['eip', 'ec2'])
mediator.remove_all_filters('ec2')
self.assertItemsEqual(mediator.filters.keys(), ['eip'])
# - - - - - - - - - - - -
mediator.add_filters('ec2', {'instance-state-name': ['running']})
self.assertItemsEqual(mediator.filters.keys(), ['eip', 'ec2'])
mediator.remove_all_filters('eip')
self.assertItemsEqual(mediator.filters.keys(), ['ec2'])
# - - - - - - - - - - - -
mediator.add_filters('eip', {'domain': ['vpc']})
mediator.add_filters('eip', {'public-ip': ['123.45.67.89']})
self.assertItemsEqual(mediator.filters.keys(), ['eip', 'ec2'])
mediator.remove_all_filters('eip', 'ec2')
self.assertEqual(mediator.filters, {})
# - - - - - - - - - - - -
# Remove non-existent entity type filters.
# - - - - - - - - - - - -
mediator.add_filters('ec2', {'instance-state-name': ['running']})
mediator.add_filters('eip', {'domain': ['vpc']})
mediator.add_filters('eip', {'public-ip': ['123.45.67.89']})
self.assertItemsEqual(mediator.filters.keys(), ['eip', 'ec2'])
mediator.remove_all_filters('s3')
self.assertItemsEqual(mediator.filters.keys(), ['eip', 'ec2'])
def test_aws_mediator_filters_kwarg(self):
'''Test aws_mediator._filters_kwarg().'''
mediator = aws_informer.AWSMediator(
region_name=site_boogio.test_region_name,
profile_name=site_boogio.test_profile_name
)
# - - - - - - - - - - - -
# No filters defined for entity type.
# - - - - - - - - - - - -
self.assertEqual(
mediator._filters_kwarg('eip'),
{'Filters': []}
)
# - - - - - - - - - - - -
# Single filter key for entity type.
# - - - - - - - - - - - -
mediator.add_filters('eip', {'public-ip': ['123.45.67.89']})
mediator.add_filters('eip', {'public-ip': ['56.78.91.234']})
eip_expected_values = ['123.45.67.89', '56.78.91.234']
self.assertEqual(
mediator._filters_kwarg('eip', use_filters=False),
{'Filters': []}
)
self.assertEqual(len(mediator._filters_kwarg('eip')['Filters']), 1)
self.assertEqual(
mediator._filters_kwarg('eip')['Filters'][0]['Name'],
'public-ip'
)
self.assertItemsEqual(
mediator._filters_kwarg('eip')['Filters'][0]['Values'],
eip_expected_values
)
# - - - - - - - - - - - -
# Multiple filter keys for entity type.
# - - - - - - - - - - - -
mediator.add_filters('eip', {'domain': ['vpc']})
domain_expected_values = ['vpc']
self.assertEqual(
mediator._filters_kwarg('eip', use_filters=False),
{'Filters': []}
)
eip_filters_kwarg = mediator._filters_kwarg('eip')['Filters']
self.assertEqual(len(eip_filters_kwarg), 2)
self.assertItemsEqual(
[f['Name'] for f in eip_filters_kwarg],
['public-ip', 'domain']
)
eip_public_ip_filter = [
f for f in eip_filters_kwarg if f['Name'] == 'public-ip'
][0]
self.assertItemsEqual(
eip_public_ip_filter['Values'],
eip_expected_values
)
eip_domain_filter = [
f for f in eip_filters_kwarg if f['Name'] == 'domain'
][0]
self.assertItemsEqual(
eip_domain_filter['Values'],
domain_expected_values
)
def test_aws_mediator_add_filters(self):
'''Test aws_mediator.add_filters().'''
mediator = aws_informer.AWSMediator(
region_name=site_boogio.test_region_name,
profile_name=site_boogio.test_profile_name
)
self.assertEqual(mediator.filters, {})
# - - - - - - - - - - - -
# Adding a single filter value to one entity type.
# - - - - - - - - - - - -
mediator.add_filters(
'eip',
{'public-ip': ['123.45.67.89']}
)
expected_values = ['123.45.67.89']
self.assertItemsEqual(mediator.filters.keys(), ['eip'])
self.assertItemsEqual(
mediator.filters['eip'].keys(),
['public-ip']
)
self.assertItemsEqual(
mediator.filters['eip']['public-ip'],
expected_values
)
self.assertEqual(
mediator._filters_kwarg('eip')['Filters'],
[{'Name': 'public-ip', 'Values': expected_values}]
)
# - - - - - - - - - - - -
# Adding a second filter value.
# - - - - - - - - - - - -
mediator.add_filters(
'eip',
{'public-ip': ['56.78.91.234']}
)
expected_values = ['123.45.67.89', '56.78.91.234']
self.assertItemsEqual(mediator.filters.keys(), ['eip'])
self.assertItemsEqual(
mediator.filters['eip'].keys(),
['public-ip']
)
self.assertItemsEqual(
mediator.filters['eip']['public-ip'],
expected_values
)
# - - - - - - - - - - - -
# Adding a duplicate filter value.
# - - - - - - - - - - - -
mediator.add_filters(
'eip',
{'public-ip': ['56.78.91.234']}
)
self.assertItemsEqual(mediator.filters.keys(), ['eip'])
self.assertItemsEqual(
mediator.filters['eip'].keys(),
['public-ip']
)
self.assertItemsEqual(
mediator.filters['eip']['public-ip'],
['123.45.67.89', '56.78.91.234']
)
self.assertEqual(
len(mediator.filters['eip']['public-ip']),
len(['123.45.67.89', '56.78.91.234'])
)
# - - - - - - - - - - - -
# Adding a second entity type.
# - - - - - - - - - - - -
mediator.add_filters(
'ec2',
{'instance-state-name': ['running']}
)
self.assertItemsEqual(mediator.filters.keys(), ['eip', 'ec2'])
# eip filters
self.assertItemsEqual(
mediator.filters['eip'].keys(),
['public-ip']
)
self.assertItemsEqual(
mediator.filters['eip']['public-ip'],
['123.45.67.89', '56.78.91.234']
)
# ec2 filters
self.assertItemsEqual(
mediator.filters['ec2'].keys(),
['instance-state-name']
)
self.assertItemsEqual(
mediator.filters['ec2']['instance-state-name'],
['running']
)
# - - - - - - - - - - - -
# Adding a second filter field name.
# - - - - - - - - - - - -
mediator.add_filters(
'eip',
{'domain': ['vpc']}
)
self.assertItemsEqual(mediator.filters.keys(), ['eip', 'ec2'])
# eip filters
self.assertItemsEqual(
mediator.filters['eip'].keys(),
['public-ip', 'domain']
)
self.assertItemsEqual(
mediator.filters['eip']['public-ip'],
['123.45.67.89', '56.78.91.234']
)
self.assertItemsEqual(
mediator.filters['eip']['domain'],
['vpc']
)
# ec2 filters
self.assertItemsEqual(
mediator.filters['ec2']['instance-state-name'],
['running']
)
# Check _filters_kwarg()
eip_filters_kwarg = mediator._filters_kwarg('eip')['Filters']
self.assertEqual(
len(eip_filters_kwarg),
2
)
self.assertItemsEqual(
[f['Name'] for f in eip_filters_kwarg],
['public-ip', 'domain']
)
eip_public_ip_filter = [
f for f in eip_filters_kwarg if f['Name'] == 'public-ip'
][0]
self.assertItemsEqual(
eip_public_ip_filter['Values'],
['123.45.67.89', '56.78.91.234']
)
eip_domain_filter = [
f for f in eip_filters_kwarg if f['Name'] == 'domain'
][0]
self.assertItemsEqual(
eip_domain_filter['Values'],
['vpc']
)
def setUp(self):
'''Test class level common fixture.'''
self.mediator = aws_informer.AWSMediator(
profile_name=site_boogio.test_profile_name,
region_name=site_boogio.test_region_name)
# ----------------------------------------------------------------------------
'''Test cases for the aws_informer individual entity type informers.
These test cases are very slow, so are isolated in their own file.
'''
import os
import unittest
from boogio import aws_informer
from boogio import site_boogio
# Sharing this will mean reducing fetch time when the same resources are needed
# in multiple test cases.
GLOBAL_MEDIATOR = aws_informer.AWSMediator(
region_name=site_boogio.test_region_name,
profile_name=site_boogio.test_profile_name)
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@unittest.skipIf(not os.environ.get('RUN_SLOW_IAM_TESTS'),
('Enable IAM tests by setting environment variable'
' RUN_SLOW_IAM_TESTS to a truthy value.'))
class TestIAMInformer(unittest.TestCase):
'''Basic test cases for IAMInformer.
IAMInformers have no resource, and store all their data in their
supplementals. Typically only one IAMInformer need be instantiated
for a given environment.
'''
