def test_generate_aws_events_with_some_times(self):
"""Assert generation of InstanceEvents with some times."""
account = helper.generate_aws_account()
instance = helper.generate_aws_instance(account)
powered_times = (
(None, util_helper.utc_dt(2017, 1, 1)),
(util_helper.utc_dt(2017, 1, 2), util_helper.utc_dt(2017, 1, 3)),
(util_helper.utc_dt(2017, 1, 4), None),
)
events = helper.generate_aws_instance_events(instance, powered_times)
self.assertEqual(len(events), 4)
self.assertEqual(events[0].occurred_at, powered_times[0][1])
self.assertEqual(events[1].occurred_at, powered_times[1][0])
self.assertEqual(events[2].occurred_at, powered_times[1][1])
self.assertEqual(events[3].occurred_at, powered_times[2][0])
self.assertEqual(events[0].event_type, InstanceEvent.TYPE.power_off)
self.assertEqual(events[1].event_type, InstanceEvent.TYPE.power_on)
self.assertEqual(events[2].event_type, InstanceEvent.TYPE.power_off)
self.assertEqual(events[3].event_type, InstanceEvent.TYPE.power_on)
self.assertIsNotNone(events[0].machineimage)
self.assertIsNotNone(events[0].instance_type)
self.assertIsNotNone(events[0].subnet)
# Assert they all have the same AMI, subnet, and instance type.
for event in events[1:]:
self.assertEqual(event.machineimage, events[0].machineimage)
self.assertEqual(event.instance_type, events[0].instance_type)
self.assertEqual(event.subnet, events[0].subnet)
def test_generate_aws_events_with_args_and_some_times(self):
"""Assert generation of InstanceEvents with all specified args."""
account = helper.generate_aws_account()
instance = helper.generate_aws_instance(account)
powered_times = (
(None, util_helper.utc_dt(2017, 1, 1)),
(util_helper.utc_dt(2017, 1, 2), util_helper.utc_dt(2017, 1, 3)),
(util_helper.utc_dt(2017, 1, 4), None),
)
ec2_ami_id = util_helper.generate_dummy_image_id()
instance_type = random.choice(util_helper.SOME_EC2_INSTANCE_TYPES)
subnet = str(uuid.uuid4())
events = helper.generate_aws_instance_events(
instance,
powered_times,
ec2_ami_id=ec2_ami_id,
instance_type=instance_type,
subnet=subnet,
)
self.assertEqual(len(events), 4)
# We don't care to check *everything* in the events since that should
# already be covered by ``test_generate_events_with_some_times``.
# Here we only care that argument values were set correctly.
for event in events:
self.assertEqual(event.machineimage.ec2_ami_id, ec2_ami_id)
self.assertEqual(event.instance_type, instance_type)
self.assertEqual(event.subnet, subnet)
def setUp(self):
"""Set up commonly used data for each test."""
# set up start & end dates and images
self.start = util_helper.utc_dt(2018, 1, 1, 0, 0, 0)
self.end = util_helper.utc_dt(2018, 2, 1, 0, 0, 0)
self.account = account_helper.generate_aws_account()
self.account.created_at = util_helper.utc_dt(2017, 1, 1, 0, 0, 0)
self.account.save()
# set up an account created after the end date for testing
self.account_after_end = account_helper.generate_aws_account()
self.account_after_end.created_at = \
util_helper.utc_dt(2018, 3, 1, 0, 0, 0)
self.account_after_end.save()
# set up an account created on the end date for testing
self.account_on_end = account_helper.generate_aws_account()
self.account_on_end.created_at = self.end
self.account_on_end.save()
self.windows_image = account_helper.generate_aws_image(
self.account,
is_encrypted=False,
is_windows=True,
)
self.rhel_image = account_helper.generate_aws_image(
self.account,
is_encrypted=False,
is_windows=False,
ec2_ami_id=None,
is_rhel=True,
is_openshift=False)
self.openshift_image = account_helper.generate_aws_image(
self.account,
is_encrypted=False,
is_windows=False,
ec2_ami_id=None,
is_rhel=False,
is_openshift=True)
self.openshift_and_rhel_image = account_helper.generate_aws_image(
self.account,
is_encrypted=False,
is_windows=False,
ec2_ami_id=None,
is_rhel=True,
is_openshift=True)
self.instance_1 = account_helper.generate_aws_instance(self.account)
self.instance_2 = account_helper.generate_aws_instance(self.account)
def test_generate_aws_instance_default(self):
"""Assert generation of an AwsInstance with minimal args."""
account = helper.generate_aws_account()
instance = helper.generate_aws_instance(account)
self.assertIsInstance(instance, AwsInstance)
self.assertEqual(instance.account, account)
self.assertIsNotNone(instance.ec2_instance_id)
self.assertGreater(len(instance.ec2_instance_id), 0)
self.assertIsNotNone(instance.region)
self.assertGreater(len(instance.region), 0)
def test_generate_aws_instance_with_args(self):
"""Assert generation of an AwsInstance with all specified args."""
account = helper.generate_aws_account()
ec2_instance_id = util_helper.generate_dummy_instance_id()
region = random.choice(util_helper.SOME_AWS_REGIONS)
instance = helper.generate_aws_instance(
account,
ec2_instance_id=ec2_instance_id,
region=region,
)
self.assertIsInstance(instance, AwsInstance)
self.assertEqual(instance.account, account)
self.assertEqual(instance.ec2_instance_id, ec2_instance_id)
self.assertEqual(instance.region, region)
def test_generate_aws_instance_with_args(self):
"""Assert generation of an AwsInstance with all specified args."""
account = helper.generate_aws_account()
ec2_instance_id = str(uuid.uuid4())
region = str(uuid.uuid4())
instance = helper.generate_aws_instance(
account,
ec2_instance_id=ec2_instance_id,
region=region,
)
self.assertIsInstance(instance, AwsInstance)
self.assertEqual(instance.account, account)
self.assertEqual(instance.ec2_instance_id, ec2_instance_id)
self.assertEqual(instance.region, region)
def test_generate_aws_events_default_and_no_times(self):
"""Assert generation of InstanceEvents with minimal args."""
account = helper.generate_aws_account()
instance = helper.generate_aws_instance(account)
events = helper.generate_aws_instance_events(instance, tuple())
self.assertEqual(len(events), 0)
'rhel_other':
account_helper.generate_aws_image(accounts['super_spaghetti'],
is_rhel=True,
ec2_ami_id='ami-rhel_other'),
}
}
for account, account_images in images.items():
for image in account_images.values():
print(f'image:'
f'id={image.id};'
f'account_id={image.account_id};'
f'ec2_ami_id={image.ec2_ami_id};')
instances = {
'normie_greatest': [
account_helper.generate_aws_instance(accounts['normie_greatest']),
account_helper.generate_aws_instance(accounts['normie_greatest']),
account_helper.generate_aws_instance(accounts['normie_greatest']),
account_helper.generate_aws_instance(accounts['normie_greatest']),
],
'normie_another': [
account_helper.generate_aws_instance(accounts['normie_another']),
account_helper.generate_aws_instance(accounts['normie_another']),
],
'super_spaghetti': [
account_helper.generate_aws_instance(accounts['super_spaghetti']),
],
}
for account, account_instances in instances.items():
for instance in account_instances:
print(f'instance:'
openshift_detected=True,
ec2_ami_id='ami-ocp',
),
}
}
for account, account_images in images.items():
for image in account_images.values():
print(f'image:'
f'id={image.id};'
f'owner_aws_account_id={image.owner_aws_account_id};'
f'ec2_ami_id={image.ec2_ami_id};'
f'name={image.name};')
instances = {
'normie_account': [
account_helper.generate_aws_instance(accounts['normie_account']),
account_helper.generate_aws_instance(accounts['normie_account']),
account_helper.generate_aws_instance(accounts['normie_account']),
account_helper.generate_aws_instance(accounts['normie_account']),
],
}
for account, account_instances in instances.items():
for instance in account_instances:
print(f'instance:'
f'id={instance.id};'
f'account_id={instance.account_id};')
times = [
(util_helper.utc_dt(2018, 1, 12, 5, 0,
0), util_helper.utc_dt(2018, 1, 12, 6, 0, 0)),
(
_faker = faker.Faker()
user_1 = util_helper.generate_test_user()
print(f'user_1.id={user_1.id};'
f'user_1.username={user_1.username};')
account_1 = account_helper.generate_aws_account(
user=user_1, name=_faker.bs())
print(f'account_1.id={account_1.id};'
f'account_1.user_id={account_1.user_id};'
f'account_1.name={account_1.name};')
instance_1 = account_helper.generate_aws_instance(account_1)
print(f'instance_1.id={instance_1.id};'
f'instance_1.account_id={instance_1.account_id};')
image_rhel = account_helper.generate_aws_image(
account_1, is_rhel=True,
ec2_ami_id='ami-rhel')
print(f'image_rhel.id={image_rhel.id};'
f'image_rhel.ec2_ami_id={image_rhel.ec2_ami_id};'
)
events = account_helper.generate_aws_instance_events(
instance_1,
[(
print(f'user_1.id={user_1.id};' f'user_1.username={user_1.username};')
print(f'user_2.id={user_2.id};' f'user_2.username={user_2.username};')
print(f'user_super.id={user_super.id};'
f'user_super.username={user_super.username};')
account_1 = account_helper.generate_aws_account(user=user_1, name=_faker.bs())
account_2 = account_helper.generate_aws_account(user=user_1, name=_faker.bs())
print(f'account_1.id={account_1.id};'
f'account_1.user_id={account_1.user_id};'
f'account_1.name={account_1.name};')
print(f'account_2.id={account_2.id};'
f'account_2.user_id={account_2.user_id};'
f'account_2.name={account_2.name};')
instance_1 = account_helper.generate_aws_instance(account_1)
instance_2 = account_helper.generate_aws_instance(account_1)
instance_3 = account_helper.generate_aws_instance(account_1)
instance_4 = account_helper.generate_aws_instance(account_2)
print(f'instance_1.id={instance_1.id};'
f'instance_1.account_id={instance_1.account_id};')
print(f'instance_2.id={instance_2.id};'
f'instance_2.account_id={instance_2.account_id};')
print(f'instance_3.id={instance_3.id};'
f'instance_3.account_id={instance_3.account_id};')
print(f'instance_4.id={instance_4.id};'
f'instance_4.account_id={instance_4.account_id};')
image_plain = account_helper.generate_aws_image(account_1,
ec2_ami_id='ami-plain')
def setUp(self):
"""
Set up commonly used data for each test.
From this rich combination of data, we should have enough data for some
interesting tests! If you think your test needs more, consider adding
to this based class setup.
The rough hierarchy of initial objects looks something like this:
user_1:
image_plain
image_rhel
image_ocp
image_rhel_ocp
image_windows
account_1:
instance_1
instance_2
instance_3
instance_4
instance_5
account_2:
None
user_2:
account_3:
None
account_4:
None
user_super:
None
"""
self.user_1 = util_helper.generate_test_user()
self.user_2 = util_helper.generate_test_user()
self.user_super = util_helper.generate_test_user(is_superuser=True)
self.account_1 = account_helper.generate_aws_account(
user=self.user_1, name=_faker.bs())
self.account_2 = account_helper.generate_aws_account(
user=self.user_1, name=_faker.bs())
self.account_3 = account_helper.generate_aws_account(
user=self.user_2, name=_faker.bs())
self.account_4 = account_helper.generate_aws_account(
user=self.user_2, name=_faker.bs())
self.instance_1 = account_helper.generate_aws_instance(self.account_1)
self.instance_2 = account_helper.generate_aws_instance(self.account_1)
self.instance_3 = account_helper.generate_aws_instance(self.account_1)
self.instance_4 = account_helper.generate_aws_instance(self.account_1)
self.instance_5 = account_helper.generate_aws_instance(self.account_1)
self.image_plain = account_helper.generate_aws_image(self.account_1)
self.image_windows = account_helper.generate_aws_image(
self.account_1, is_windows=True)
self.image_rhel = account_helper.generate_aws_image(
self.account_1, is_rhel=True)
self.image_ocp = account_helper.generate_aws_image(
self.account_1, is_openshift=True)
self.image_rhel_ocp = account_helper.generate_aws_image(
self.account_1, is_rhel=True, is_openshift=True)
# Report on "month of January in 2018"
self.start = util_helper.utc_dt(2018, 1, 1, 0, 0, 0)
self.end = util_helper.utc_dt(2018, 2, 1, 0, 0, 0)