def test_copy_ami_snapshot_private_shared(self, mock_aws): """Assert that the task copies the image when it is private/shared.""" mock_account_id = util_helper.generate_dummy_aws_account_id() mock_session = mock_aws.boto3.Session.return_value mock_aws.get_session_account_id.return_value = mock_account_id # the account id to use as the private shared image owner other_account_id = util_helper.generate_dummy_aws_account_id() mock_region = util_helper.get_random_region() mock_arn = util_helper.generate_dummy_arn(mock_account_id, mock_region) mock_image_id = util_helper.generate_dummy_image_id() mock_image = util_helper.generate_mock_image(mock_image_id) mock_snapshot_id = util_helper.generate_dummy_snapshot_id() mock_snapshot = util_helper.generate_mock_snapshot( mock_snapshot_id, encrypted=False, owner_id=other_account_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 account_helper.generate_image(ec2_ami_id=mock_image_id) with patch.object(tasks.imageprep, "create_volume") as mock_create_volume, patch.object( tasks.imageprep, "copy_ami_to_customer_account" ) as mock_copy_ami_to_customer_account: tasks.copy_ami_snapshot(mock_arn, mock_image_id, mock_region) mock_create_volume.delay.assert_not_called() mock_copy_ami_to_customer_account.delay.assert_called_with( mock_arn, mock_image_id, mock_region)
def test_success(self, mock_primary_id, mock_tasks_aws, mock_create): """Assert the task happy path upon normal operation.""" # User that would ultimately own the created objects. user = User.objects.create() # Dummy values for the various interactions. session_account_id = util_helper.generate_dummy_aws_account_id() auth_id = _faker.pyint() application_id = _faker.pyint() source_id = _faker.pyint() customer_secret_access_key = util_helper.generate_dummy_arn( account_id=session_account_id) primary_account_id = util_helper.generate_dummy_aws_account_id() mock_primary_id.return_value = primary_account_id mock_tasks_aws.get_session_account_id.return_value = session_account_id mock_tasks_aws.AwsArn.return_value.account_id = session_account_id # Fake out the policy verification. policy_name = _faker.slug() policy_arn = util_helper.generate_dummy_arn( account_id=session_account_id) mock_ensure_policy = mock_tasks_aws.ensure_cloudigrade_policy mock_ensure_policy.return_value = (policy_name, policy_arn) # Fake out the role verification. role_name = _faker.slug() role_arn = util_helper.generate_dummy_arn( account_id=session_account_id) mock_ensure_role = mock_tasks_aws.ensure_cloudigrade_role mock_ensure_role.return_value = (role_name, role_arn) tasks.configure_customer_aws_and_create_cloud_account( user.username, customer_secret_access_key, auth_id, application_id, source_id, ) cloud_account_name = api_util.get_standard_cloud_account_name( "aws", session_account_id) mock_create.assert_called_with( user, role_arn, cloud_account_name, auth_id, application_id, source_id, )
def test_create_fails_when_assume_role_fails_unexpectedly(self): """Test that account is not saved if assume_role fails unexpectedly.""" aws_account_id = util_helper.generate_dummy_aws_account_id() arn = util_helper.generate_dummy_arn(aws_account_id) validated_data = { 'account_arn': arn, } mock_request = Mock() mock_request.user = util_helper.generate_test_user() context = {'request': mock_request} client_error = ClientError( error_response=MagicMock(), operation_name=Mock(), ) with patch.object(aws.sts, 'boto3') as mock_boto3: mock_assume_role = mock_boto3.client.return_value.assume_role mock_assume_role.side_effect = client_error serializer = AwsAccountSerializer(context=context) with self.assertRaises(ClientError) as cm: serializer.create(validated_data) raised_exception = cm.exception self.assertEqual(raised_exception, client_error)
def test_create_fails_when_arn_access_denied(self): """Test that an account is not saved if ARN access is denied.""" aws_account_id = util_helper.generate_dummy_aws_account_id() arn = util_helper.generate_dummy_arn(aws_account_id) validated_data = { 'account_arn': arn, } mock_request = Mock() mock_request.user = util_helper.generate_test_user() context = {'request': mock_request} client_error = ClientError( error_response={'Error': { 'Code': 'AccessDenied' }}, operation_name=Mock(), ) with patch.object(aws.sts, 'boto3') as mock_boto3: mock_assume_role = mock_boto3.client.return_value.assume_role mock_assume_role.side_effect = client_error 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(arn, raised_exception.detail['account_arn'][0])
def setUp(self): """Set up test models.""" aws_account_id = util_helper.generate_dummy_aws_account_id() arn = util_helper.generate_dummy_arn(account_id=aws_account_id) self.role = util_helper.generate_dummy_role() self.account = helper.generate_cloud_account( arn=arn, aws_account_id=aws_account_id, name="test")
def test_copy_ami_snapshot_not_marketplace(self, mock_aws): """Assert that an exception is raised when there is an error.""" mock_account_id = util_helper.generate_dummy_aws_account_id() mock_session = mock_aws.boto3.Session.return_value mock_aws.get_session_account_id.return_value = mock_account_id mock_region = random.choice(util_helper.SOME_AWS_REGIONS) mock_arn = util_helper.generate_dummy_arn(mock_account_id, mock_region) mock_image_id = util_helper.generate_dummy_image_id() mock_image = util_helper.generate_mock_image(mock_image_id) mock_snapshot_id = util_helper.generate_dummy_snapshot_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.side_effect = ClientError( error_response={ 'Error': { 'Code': 'ItIsAMystery', 'Message': 'Mystery Error', } }, operation_name=Mock(), ) with self.assertRaises(RuntimeError) as e: copy_ami_snapshot(mock_arn, mock_image_id, mock_region) self.assertIn('ClientError', e.exception.args[0]) self.assertIn('ItIsAMystery', e.exception.args[0]) self.assertIn('Mystery Error', e.exception.args[0])
def test_update_cloudtrail_exception(self): """ Test the update_cloudtrail function. Assert that an error is returned when the CloudTrail does not exist. """ aws_account_id = helper.generate_dummy_aws_account_id() name = '{0}{1}'.format(settings.CLOUDTRAIL_NAME_PREFIX, aws_account_id) mock_session = Mock() mock_copy_error = { 'Error': { 'Code': 'TrailNotFoundException', 'Message': 'Unknown trail: {0} for the user ' '{1}'.format(name, aws_account_id) } } mock_client = mock_session.client.return_value mock_client.update_trail.side_effect = ClientError( mock_copy_error, 'UpdateTrail') with self.assertRaises(ClientError): cloudtrail.update_cloudtrail(mock_client, name)
def test_save_with_concurrent_usages(self): """Test that save deletes the related concurrent_usages.""" user = util_helper.generate_test_user() aws_account_id = util_helper.generate_dummy_aws_account_id() account = api_helper.generate_cloud_account( aws_account_id=aws_account_id, user=user, ) image = api_helper.generate_image( owner_aws_account_id=aws_account_id, rhel_detected=True, ) instance = api_helper.generate_instance(account, image=image) api_helper.generate_single_run( instance, ( util_helper.utc_dt(2019, 5, 1, 1, 0, 0), util_helper.utc_dt(2019, 5, 1, 2, 0, 0), ), image=instance.machine_image, ) request_date = datetime.date(2019, 5, 1) calculate_max_concurrent_usage(request_date, user_id=user.id) self.assertEquals(1, ConcurrentUsage.objects.count()) image.rhel_detected_by_tag = True image.save() self.assertEquals(0, ConcurrentUsage.objects.count())
def setUp(self): """Set up shared variables.""" self.authentication_id = _faker.pyint() self.account_id = util_helper.generate_dummy_aws_account_id() self.arn = util_helper.generate_dummy_arn(account_id=self.account_id) self.clount = api_helper.generate_cloud_account( arn=self.arn, platform_authentication_id=self.authentication_id) self.username = _faker.user_name() self.application_id = _faker.pyint() self.source_id = _faker.pyint() self.account_number = str(_faker.pyint()) self.auth_return_value = { "username": self.arn, "resource_type": settings.SOURCES_RESOURCE_TYPE, "resource_id": self.application_id, "id": self.authentication_id, "authtype": settings.SOURCES_CLOUDMETER_ARN_AUTHTYPE, } self.app_return_value = { "source_id": self.source_id, "id": self.application_id, }
def test_delete_cloudtrail_exception(self): """ Test the delete_cloudtrail function. Assert that an error is returned when the CloudTrail does not exist. """ aws_account_id = helper.generate_dummy_aws_account_id() name = "{0}{1}".format(settings.CLOUDTRAIL_NAME_PREFIX, aws_account_id) mock_session = Mock() mock_error = { "Error": { "Code": "TrailNotFoundException", "Message": "Unknown trail: {0} for the user: {1}".format( name, aws_account_id), } } mock_client = mock_session.client.return_value mock_client.delete_trail.side_effect = ClientError( mock_error, "DeleteTrail") with self.assertRaises(ClientError): cloudtrail.delete_cloudtrail(mock_client, name)
def test_delete_cloudtrail(self): """Test the delete_cloudtrail function. Assert that delete_cloudtrail function returns the response returned from calling the cloudtrail delete_trail function. """ aws_account_id = helper.generate_dummy_aws_account_id() name = "{0}{1}".format(settings.CLOUDTRAIL_NAME_PREFIX, aws_account_id) mock_session = Mock() # This was the real response from a delete_trail call made on 2020-07-15. mock_response = { "ResponseMetadata": { "RequestId": "cd3513ab-6c5f-490a-b94f-7dea5faa9e40", "HTTPStatusCode": 200, "HTTPHeaders": { "x-amzn-requestid": "cd3513ab-6c5f-490a-b94f-7dea5faa9e40", "content-type": "application/x-amz-json-1.1", "content-length": "2", "date": "Wed, 15 Jul 2020 15:31:25 GMT", }, "RetryAttempts": 0, } } mock_client = mock_session.client.return_value mock_client.delete_trail.return_value = mock_response expected_value = mock_response actual_value = cloudtrail.delete_cloudtrail(mock_client, name) self.assertEqual(expected_value, actual_value)
def test_create_cloudtrail_limit_exception(self): """Test the create_cloudtrail function. Assert that an error is returned when trail limit is reached """ aws_account_id = helper.generate_dummy_aws_account_id() name = "{0}{1}".format(settings.CLOUDTRAIL_NAME_PREFIX, aws_account_id) mock_session = Mock() mock_error = { "Error": { "Code": "MaximumNumberOfTrailsExceededException", "Message": "User: 123456789012 already has 1337 trails in us-east-1.", } } mock_client = mock_session.client.return_value mock_client.create_trail.side_effect = ClientError( mock_error, "CreateTrail") with self.assertRaises(MaximumNumberOfTrailsExceededException): cloudtrail.create_cloudtrail(mock_client, name)
def test_create_fails_when_cloudtrail_fails(self): """Test that an account is not saved if cloudtrails errors.""" 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() validated_data = { 'account_arn': arn, } client_error = ClientError( error_response={'Error': { 'Code': 'AccessDeniedException' }}, operation_name=Mock(), ) 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, 'configure_cloudtrail') as mock_cloudtrail: mock_assume_role = mock_boto3.client.return_value.assume_role mock_assume_role.return_value = role mock_verify.return_value = True, [] mock_cloudtrail.side_effect = client_error 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(arn, raised_exception.detail['account_arn'][0])
def test_copy_ami_snapshot_not_marketplace(self, mock_aws): """Assert that an exception is raised when there is an error.""" mock_account_id = util_helper.generate_dummy_aws_account_id() mock_session = mock_aws.boto3.Session.return_value mock_aws.get_session_account_id.return_value = mock_account_id mock_region = util_helper.get_random_region() mock_arn = util_helper.generate_dummy_arn(mock_account_id, mock_region) mock_image_id = util_helper.generate_dummy_image_id() account_helper.generate_image(ec2_ami_id=mock_image_id) mock_image = util_helper.generate_mock_image(mock_image_id) mock_snapshot_id = util_helper.generate_dummy_snapshot_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.side_effect = ClientError( error_response={ "Error": { "Code": "ItIsAMystery", "Message": "Mystery Error" } }, operation_name=Mock(), ) with self.assertRaises(RuntimeError) as e: tasks.copy_ami_snapshot(mock_arn, mock_image_id, mock_region) self.assertIn("ClientError", e.exception.args[0]) self.assertIn("ItIsAMystery", e.exception.args[0]) self.assertIn("Mystery Error", e.exception.args[0])
def test_copy_ami_snapshot_marketplace(self, mock_aws): """Assert that a suspected marketplace image is checked.""" mock_account_id = util_helper.generate_dummy_aws_account_id() mock_session = mock_aws.boto3.Session.return_value mock_aws.get_session_account_id.return_value = mock_account_id mock_region = util_helper.get_random_region() mock_arn = util_helper.generate_dummy_arn(mock_account_id, mock_region) mock_image_id = util_helper.generate_dummy_image_id() mock_image = util_helper.generate_mock_image(mock_image_id) mock_snapshot_id = util_helper.generate_dummy_snapshot_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.side_effect = ClientError( error_response={"Error": { "Code": "InvalidSnapshot.NotFound" }}, operation_name=Mock(), ) account_helper.generate_image(ec2_ami_id=mock_image_id) with patch.object(tasks.imageprep, "create_volume") as mock_create_volume, patch.object( tasks.imageprep, "copy_ami_to_customer_account" ) as mock_copy_ami_to_customer_account: tasks.copy_ami_snapshot(mock_arn, mock_image_id, mock_region) mock_create_volume.delay.assert_not_called() mock_copy_ami_to_customer_account.delay.assert_called_with( mock_arn, mock_image_id, mock_region)
def test_update_from_sources_kafka_message_new_aws_account_id( self, mock_enable, mock_get_auth, mock_notify_sources, mock_get_app): """ Assert the new cloud account created for new aws_account_id. A new CloudAccount will get created with the new arn. And the old CloudAccount will be removed. """ message, headers = util_helper.generate_authentication_create_message_value( self.account_number, self.username, self.authentication_id) new_account_id = util_helper.generate_dummy_aws_account_id() new_arn = util_helper.generate_dummy_arn(account_id=new_account_id) self.auth_return_value["username"] = new_arn mock_get_auth.return_value = self.auth_return_value mock_get_app.return_value = self.app_return_value with patch.object(sts, "boto3") as mock_boto3, patch.object( aws_models, "_delete_cloudtrail"), patch( "api.clouds.aws.util.verify_permissions"): mock_assume_role = mock_boto3.client.return_value.assume_role mock_assume_role.return_value = util_helper.generate_dummy_role() tasks.update_from_source_kafka_message(message, headers) mock_enable.assert_called()
def test_put_event_selectors(self): """Test the put_event_selectors function. Assert that put_event_selectors returns the response returned from calling the cloudtrail put_event_selectors function. """ aws_account_id = helper.generate_dummy_aws_account_id() name = '{0}{1}'.format(settings.CLOUDTRAIL_NAME_PREFIX, aws_account_id) mock_session = Mock() mock_response = { 'TrailARN': 'arn:aws:cloudtrail:us-east-1:' '{0}:trail/{1}'.format(aws_account_id, name), 'EventSelectors': [{ 'ReadWriteType': 'WriteOnly', 'IncludeManagementEvents': True, 'DataResources': [] }], } mock_client = mock_session.client.return_value # set the aws put_event_selectors function response as mock_response mock_client.put_event_selectors.return_value = mock_response # set the expected response as the mock_response as well expected_return_value = mock_response actual_return_value = cloudtrail.put_event_selectors(mock_client, name) self.assertEqual(expected_return_value, actual_return_value)
def test_create_cloudtrail_exception(self): """Test the create_cloudtrail function. Assert that an error is returned when the trail already exists """ aws_account_id = helper.generate_dummy_aws_account_id() name = '{0}{1}'.format(settings.CLOUDTRAIL_NAME_PREFIX, aws_account_id) mock_session = Mock() mock_error = { 'Error': { 'Code': 'TrailAlreadyExistsException', 'Message': 'Trail {0} already exists' 'for customer: {1}'.format(name, aws_account_id) } } mock_client = mock_session.client.return_value mock_client.create_trail.side_effect = ClientError( mock_error, 'CreateTrail') with self.assertRaises(ClientError): cloudtrail.create_cloudtrail(mock_client, name)
def test_create_fails_when_account_not_verified(self): """Test that an account is not saved if verification fails.""" 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() validated_data = { 'account_arn': arn, } mock_request = Mock() mock_request.user = util_helper.generate_test_user() context = {'request': mock_request} failed_actions = ['foo', 'bar'] with patch.object(aws, 'verify_account_access') as mock_verify, \ patch.object(aws.sts, 'boto3') as mock_boto3: mock_assume_role = mock_boto3.client.return_value.assume_role mock_assume_role.return_value = role mock_verify.return_value = False, failed_actions serializer = AwsAccountSerializer(context=context) with self.assertRaises(serializers.ValidationError) as cm: serializer.create(validated_data) exception = cm.exception self.assertIn('account_arn', exception.detail) for index in range(len(failed_actions)): self.assertIn(failed_actions[index], exception.detail['account_arn'][index + 1])
def test_parse_arn_with_region_and_account(self): """Assert successful account ID parsing from a well-formed ARN.""" mock_account_id = helper.generate_dummy_aws_account_id() mock_arn = helper.generate_dummy_arn(account_id=mock_account_id, region="test-region-1") arn_object = AwsArn(mock_arn) partition = arn_object.partition self.assertIsNotNone(partition) service = arn_object.service self.assertIsNotNone(service) region = arn_object.region self.assertIsNotNone(region) account_id = arn_object.account_id self.assertIsNotNone(account_id) resource_type = arn_object.resource_type self.assertIsNotNone(resource_type) resource_separator = arn_object.resource_separator self.assertIsNotNone(resource_separator) resource = arn_object.resource self.assertIsNotNone(resource) reconstructed_arn = ("arn:" + partition + ":" + service + ":" + region + ":" + str(account_id) + ":" + resource_type + resource_separator + resource) self.assertEqual(mock_account_id, account_id) self.assertEqual(mock_arn, reconstructed_arn)
def test_copy_ami_snapshot_encrypted(self, mock_aws): """Assert that the task marks the image as encrypted in the DB.""" mock_account_id = util_helper.generate_dummy_aws_account_id() mock_region = util_helper.get_random_region() mock_arn = util_helper.generate_dummy_arn(mock_account_id, mock_region) mock_image_id = util_helper.generate_dummy_image_id() mock_image = util_helper.generate_mock_image(mock_image_id) mock_snapshot_id = util_helper.generate_dummy_snapshot_id() mock_snapshot = util_helper.generate_mock_snapshot(mock_snapshot_id, encrypted=True) mock_session = mock_aws.boto3.Session.return_value 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 ami = account_helper.generate_image(ec2_ami_id=mock_image_id) with patch.object(tasks, "create_volume") as mock_create_volume: tasks.copy_ami_snapshot(mock_arn, mock_image_id, mock_region) ami.refresh_from_db() self.assertTrue(ami.is_encrypted) self.assertEqual(ami.status, ami.ERROR) mock_create_volume.delay.assert_not_called()
def test_create_new_machine_images(self): """Test that new machine images are saved to the DB.""" aws_account_id = util_helper.generate_dummy_aws_account_id() arn = util_helper.generate_dummy_arn(aws_account_id) account = AwsAccount( account_arn=arn, aws_account_id=aws_account_id, user=util_helper.generate_test_user(), ) account.save() region = random.choice(util_helper.SOME_AWS_REGIONS) running_instances = { region: [ util_helper.generate_dummy_describe_instance( state=aws.InstanceState.running ) ] } ami_id = running_instances[region][0]['ImageId'] result = util.create_new_machine_images(account, running_instances) amis = AwsMachineImage.objects.filter(account=account).all() self.assertEqual(result, [ami_id]) for ami in amis: self.assertEqual(ami.ec2_ami_id, ami_id)
def test_create_new_machine_images_with_windows_image(self): """Test that new windows machine images are marked appropriately.""" aws_account_id = util_helper.generate_dummy_aws_account_id() arn = util_helper.generate_dummy_arn(aws_account_id) account = AwsAccount( account_arn=arn, aws_account_id=aws_account_id, user=util_helper.generate_test_user(), ) account.save() region = random.choice(util_helper.SOME_AWS_REGIONS) running_instances = { region: [ util_helper.generate_dummy_describe_instance( state=aws.InstanceState.running ) ] } running_instances[region][0]['Platform'] = 'Windows' ami_id = running_instances[region][0]['ImageId'] result = util.create_new_machine_images(account, running_instances) amis = AwsMachineImage.objects.filter(account=account).all() self.assertEqual(result, [ami_id]) for ami in amis: self.assertEqual(ami.ec2_ami_id, ami_id) self.assertEqual(ImageTag.objects.filter( description='windows').first(), ami.tags.filter(description='windows').first())
def test_copy_ami_snapshot_encrypted(self, mock_aws): """Assert that the task marks the image as encrypted in the DB.""" mock_account_id = util_helper.generate_dummy_aws_account_id() mock_region = random.choice(util_helper.SOME_AWS_REGIONS) mock_arn = util_helper.generate_dummy_arn(mock_account_id, mock_region) mock_image_id = util_helper.generate_dummy_image_id() mock_image = util_helper.generate_mock_image(mock_image_id) mock_snapshot_id = util_helper.generate_dummy_snapshot_id() mock_snapshot = util_helper.generate_mock_snapshot(mock_snapshot_id, encrypted=True) mock_session = mock_aws.boto3.Session.return_value 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 account = AwsAccount( aws_account_id=mock_account_id, account_arn=mock_arn, user=util_helper.generate_test_user(), ) account.save() ami = AwsMachineImage.objects.create(account=account, is_windows=False, ec2_ami_id=mock_image_id) ami.save() with patch.object(tasks, 'create_volume') as mock_create_volume,\ self.assertRaises(AwsSnapshotEncryptedError): copy_ami_snapshot(mock_arn, mock_image_id, mock_region) self.assertTrue(ami.is_encrypted) mock_create_volume.delay.assert_not_called()
def test_report_with_timezones_specified(self): """Test that start/end dates with timezones shift correctly to UTC.""" cloud_provider = AWS_PROVIDER_STRING cloud_account_id = util_helper.generate_dummy_aws_account_id() start_no_tz = '2018-01-01T00:00:00-05' end_no_tz = '2018-02-01T00:00:00+04' request_data = { 'cloud_provider': cloud_provider, 'cloud_account_id': str(cloud_account_id), 'start': start_no_tz, 'end': end_no_tz, } expected_start = util_helper.utc_dt(2018, 1, 1, 5, 0) expected_end = util_helper.utc_dt(2018, 1, 31, 20, 0) with patch.object(reports, 'get_time_usage') as mock_get_hourly: serializer = ReportSerializer(data=request_data) serializer.is_valid(raise_exception=True) results = serializer.generate() mock_get_hourly.assert_called_with( cloud_provider=cloud_provider, cloud_account_id=cloud_account_id, start=expected_start, end=expected_end) self.assertEqual(results, mock_get_hourly.return_value)
def test_save_instance_with_available_image(self): """Test that save instance events also writes image on instance.""" aws_account_id = util_helper.generate_dummy_aws_account_id() arn = util_helper.generate_dummy_arn(aws_account_id) account = api_helper.generate_cloud_account( arn=arn, aws_account_id=aws_account_id) region = util_helper.get_random_region() instances_data = { region: [ util_helper.generate_dummy_describe_instance( state=aws.InstanceState.running) ] } ami_id = instances_data[region][0]["ImageId"] mock_session = Mock() described_amis = util_helper.generate_dummy_describe_image( image_id=ami_id, owner_id=aws_account_id) with patch.object(util.aws, "describe_images") as mock_describe_images: mock_describe_images.return_value = [described_amis] util.create_new_machine_images(mock_session, instances_data) mock_describe_images.assert_called_with(mock_session, {ami_id}, region) awsinstance = util.save_instance(account, instances_data[region][0], region) instance = awsinstance.instance.get() self.assertEqual(instance.machine_image.content_object.ec2_ami_id, ami_id) self.assertEqual(instance.machine_image.status, MachineImage.PENDING)
def test_create_new_machine_images_with_windows_image(self): """Test that new windows machine images are marked appropriately.""" aws_account_id = util_helper.generate_dummy_aws_account_id() arn = util_helper.generate_dummy_arn(aws_account_id) api_helper.generate_cloud_account(arn=arn, aws_account_id=aws_account_id) region = util_helper.get_random_region() instances_data = { region: [ util_helper.generate_dummy_describe_instance( state=aws.InstanceState.running) ] } instances_data[region][0]["Platform"] = "Windows" ami_id = instances_data[region][0]["ImageId"] mock_session = Mock() described_amis = util_helper.generate_dummy_describe_image( image_id=ami_id, owner_id=aws_account_id) with patch.object(util.aws, "describe_images") as mock_describe_images: mock_describe_images.return_value = [described_amis] result = util.create_new_machine_images(mock_session, instances_data) mock_describe_images.assert_called_with(mock_session, {ami_id}, region) self.assertEqual(result, [ami_id]) images = list(AwsMachineImage.objects.all()) self.assertEqual(len(images), 1) self.assertEqual(images[0].ec2_ami_id, ami_id) self.assertEqual(images[0].platform, AwsMachineImage.WINDOWS)
def test_delete_clount_doesnt_delete_user_for_two_clounts( self, mock_notify_source): """Test User is not deleted if it has more clounts left.""" user = util_helper.generate_test_user() username = user.username aws_account_id = util_helper.generate_dummy_aws_account_id() account = api_helper.generate_cloud_account( aws_account_id=aws_account_id, user=user, ) aws_account_id2 = util_helper.generate_dummy_aws_account_id() api_helper.generate_cloud_account( aws_account_id=aws_account_id2, user=user, ) account.delete() self.assertTrue(User.objects.filter(username=username).exists())
def setUp(self): """Set up common variables for tests.""" self.user = util_helper.generate_test_user() self.aws_account_id = util_helper.generate_dummy_aws_account_id() self.account = api_helper.generate_cloud_account( aws_account_id=self.aws_account_id, user=self.user) self.arn = util_helper.generate_dummy_arn( account_id=self.aws_account_id)
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)