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};'