def test_generate_aws_account_default(self):
"""Assert generation of an AwsAccount with default/no args."""
account = helper.generate_aws_account()
self.assertIsInstance(account, AwsAccount)
self.assertLess(account.aws_account_id, util_helper.MAX_AWS_ACCOUNT_ID)
self.assertGreater(account.aws_account_id, 0)
self.assertIn(str(account.aws_account_id), account.account_arn)
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 test_copy_ami_snapshot_success_with_reference(self, mock_aws):
"""Assert the snapshot copy task succeeds using a reference AMI ID."""
mock_session = mock_aws.boto3.Session.return_value
mock_account_id = mock_aws.get_session_account_id.return_value
account = account_helper.generate_aws_account()
arn = account.account_arn
region = random.choice(util_helper.SOME_AWS_REGIONS)
new_image_id = util_helper.generate_dummy_image_id()
mock_image = util_helper.generate_mock_image(new_image_id)
block_mapping = mock_image.block_device_mappings
mock_snapshot_id = block_mapping[0]['Ebs']['SnapshotId']
mock_snapshot = util_helper.generate_mock_snapshot(
mock_snapshot_id, owner_id=mock_account_id)
mock_new_snapshot_id = util_helper.generate_dummy_snapshot_id()
# This is the original ID of a private/shared image.
# It would have been saved to our DB upon initial discovery.
reference_image = account_helper.generate_aws_image(account=account)
reference_image_id = reference_image.ec2_ami_id
mock_aws.get_session.return_value = mock_session
mock_aws.get_ami.return_value = mock_image
mock_aws.get_ami_snapshot_id.return_value = mock_snapshot_id
mock_aws.get_snapshot.return_value = mock_snapshot
mock_aws.copy_snapshot.return_value = mock_new_snapshot_id
with patch.object(tasks, 'create_volume') as mock_create_volume, \
patch.object(tasks, 'remove_snapshot_ownership') as \
mock_remove_snapshot_ownership:
tasks.copy_ami_snapshot(
arn,
new_image_id,
region,
reference_image_id,
)
# arn, customer_snapshot_id, snapshot_region, snapshot_copy_id
mock_remove_snapshot_ownership.delay.assert_called_with(
arn,
mock_snapshot_id,
region,
mock_new_snapshot_id,
)
mock_create_volume.delay.assert_called_with(
reference_image_id,
mock_new_snapshot_id,
)
mock_aws.get_session.assert_called_with(arn)
mock_aws.get_ami.assert_called_with(mock_session, new_image_id, region)
mock_aws.get_ami_snapshot_id.assert_called_with(mock_image)
mock_aws.add_snapshot_ownership.assert_called_with(mock_snapshot)
mock_aws.copy_snapshot.assert_called_with(mock_snapshot_id, region)
# Verify that the copy object was stored correctly to reference later.
copied_image = AwsMachineImageCopy.objects.get(ec2_ami_id=new_image_id)
self.assertIsNotNone(copied_image)
self.assertEqual(copied_image.reference_awsmachineimage.ec2_ami_id,
reference_image_id)
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_account_with_args(self):
"""Assert generation of an AwsAccount with all specified args."""
aws_account_id = util_helper.generate_dummy_aws_account_id()
arn = util_helper.generate_dummy_arn(aws_account_id)
account = helper.generate_aws_account(arn, aws_account_id)
self.assertIsInstance(account, AwsAccount)
self.assertEqual(account.account_arn, arn)
self.assertEqual(account.aws_account_id, aws_account_id)
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_create_fails_when_another_arn_has_same_aws_account_id(self):
"""Test that an account is not saved if ARN reuses an AWS account."""
user = util_helper.generate_test_user()
aws_account_id = util_helper.generate_dummy_aws_account_id()
arn = util_helper.generate_dummy_arn(aws_account_id)
role = util_helper.generate_dummy_role()
region = random.choice(util_helper.SOME_AWS_REGIONS)
running_instances = {
region: [
util_helper.generate_dummy_describe_instance(
state=aws.InstanceState.running),
util_helper.generate_dummy_describe_instance(
state=aws.InstanceState.stopping)
]
}
validated_data = {
'account_arn': arn,
}
# Create one with the same AWS account ID but a different ARN.
account_helper.generate_aws_account(
aws_account_id=aws_account_id,
user=user,
)
mock_request = Mock()
mock_request.user = util_helper.generate_test_user()
context = {'request': mock_request}
with patch.object(aws, 'verify_account_access') as mock_verify, \
patch.object(aws.sts, 'boto3') as mock_boto3, \
patch.object(aws, 'get_running_instances') as mock_get_run:
mock_assume_role = mock_boto3.client.return_value.assume_role
mock_assume_role.return_value = role
mock_verify.return_value = True, []
mock_get_run.return_value = running_instances
serializer = AwsAccountSerializer(context=context)
with self.assertRaises(ValidationError) as cm:
serializer.create(validated_data)
raised_exception = cm.exception
self.assertIn('account_arn', raised_exception.detail)
self.assertIn(aws_account_id,
raised_exception.detail['account_arn'][0])
def setUp(self):
"""Set up common variables for tests."""
self.user = util_helper.generate_test_user()
self.mock_account_id = str(util_helper.generate_dummy_aws_account_id())
self.mock_arn = util_helper.generate_dummy_arn(self.mock_account_id)
self.mock_account = account_helper.generate_aws_account(
arn=self.mock_arn,
aws_account_id=self.mock_account_id,
user=self.user)
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)
import faker
from account.tests import helper as account_helper
from util.tests import helper as util_helper
_faker = faker.Faker()
users = {
'normie': util_helper.generate_test_user(),
}
for user in users.values():
print(f'user:'******'id={user.id};' f'username={user.username};')
accounts = {
'normie_account':
account_helper.generate_aws_account(user=users['normie'],
name='my favorite account'),
}
for account in accounts.values():
account.created_at = util_helper.utc_dt(2018, 1, 1, 0, 0, 0)
account.save()
print(f'account:'
f'id={account.id};'
f'user_id={account.user_id};'
f'name={account.name};')
images = {
'normie_account': {
'plain':
account_helper.generate_aws_image(
# accounts['normie_account'],
is_encrypted=False,
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)
def test_generate_aws_account_default(self):
"""Assert generation of an AwsAccount with default/no args."""
account = helper.generate_aws_account()
self.assertIsInstance(account, AwsAccount)
self.assertIsNotNone(re.match(r'\d{12}', account.aws_account_id))
from account.tests import helper as account_helper
from util.tests import helper as util_helper
users = {
'normie': util_helper.generate_test_user(),
}
for user in users.values():
print(f'user:'******'id={user.id};' f'username={user.username};')
accounts = {
'normie_account':
account_helper.generate_aws_account(
user=users['normie'],
name='greatest account ever 🎉',
aws_account_id=273470430754,
arn='arn:aws:iam::273470430754:role/role-for-cloudigrade'),
}
for account in accounts.values():
account.created_at = util_helper.utc_dt(2018, 1, 1, 0, 0, 0)
account.save()
print(f'account:'
f'id={account.id};'
f'user_id={account.user_id};'
f'name={account.name};')
from account.tests import helper as account_helper
from util.tests import helper as util_helper
_faker = faker.Faker()
users = {
'normie': util_helper.generate_test_user(),
'super': util_helper.generate_test_user(is_superuser=True)
}
for user in users.values():
print(f'user:'******'id={user.id};' f'username={user.username};')
accounts = {
'normie_greatest':
account_helper.generate_aws_account(user=users['normie'],
name='greatest account ever'),
'normie_another':
account_helper.generate_aws_account(user=users['normie'],
name='just another account'),
'super_spaghetti':
account_helper.generate_aws_account(user=users['super'],
name='knees weak arms spaghetti'),
}
for account in accounts.values():
account.created_at = util_helper.utc_dt(2018, 1, 1, 0, 0, 0)
account.save()
print(f'account:'
f'id={account.id};'
f'user_id={account.user_id};'
f'name={account.name};')
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)
import faker
from account.tests import helper as account_helper
from util.tests import helper as util_helper
_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};'
