def test_generate_test_user(self): """Assert generation of test user with appropriate defaults.""" user = helper.generate_test_user() self.assertFalse(user.is_superuser) other_user = helper.generate_test_user() self.assertNotEqual(user, other_user) self.assertNotEqual(user.username, other_user.username)
def setUp(self): """Set up commonly used data for each test.""" # various images not belonging to any particular cloud account self.image_plain = api_helper.generate_image() self.image_rhel = api_helper.generate_image(rhel_detected=True) self.image_ocp = api_helper.generate_image(openshift_detected=True) # define users 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) # define users' cloud accounts self.account_1 = api_helper.generate_cloud_account(user=self.user_1, name=_faker.bs()) # define instances that belong to user_1 account_1 self.instance_plain = api_helper.generate_instance( cloud_account=self.account_1, image=self.image_plain) self.instance_rhel = api_helper.generate_instance( cloud_account=self.account_1, image=self.image_rhel) self.instance_ocp = api_helper.generate_instance( cloud_account=self.account_1, image=self.image_ocp) self.instance_noimage = api_helper.generate_instance( cloud_account=self.account_1, no_image=True) api_helper.generate_instance_type_definitions()
def setUp(self): """Set up a bunch of test data.""" self.user1 = util_helper.generate_test_user() self.user2 = util_helper.generate_test_user() self.account1 = api_helper.generate_cloud_account(user=self.user1) self.account2 = api_helper.generate_cloud_account(user=self.user2) self.image_plain = api_helper.generate_image() self.image_windows = api_helper.generate_image(is_windows=True) self.image_rhel = api_helper.generate_image(rhel_detected=True) self.image_ocp = api_helper.generate_image(openshift_detected=True) self.instance1 = api_helper.generate_instance( cloud_account=self.account1, image=self.image_plain ) self.instance2 = api_helper.generate_instance( cloud_account=self.account1, image=self.image_windows ) self.instance3 = api_helper.generate_instance( cloud_account=self.account1, image=self.image_rhel ) self.instance4 = api_helper.generate_instance( cloud_account=self.account1, image=self.image_ocp )
def test_generate_test_user(self): """Assert generation of test user with appropriate defaults.""" user = helper.generate_test_user() self.assertEqual(user.email, user.username) self.assertTrue(user.email.endswith('@mail.127.0.0.1.nip.io')) self.assertFalse(user.is_superuser) other_user = helper.generate_test_user() self.assertNotEqual(user, other_user) self.assertNotEqual(user.username, other_user.username)
def setUp(self): """ Set up a bunch of test data. This gets very noisy very quickly because we need users who have accounts that have instances that have events that used various image types. """ # Users self.user1 = util_helper.generate_test_user() self.user2 = util_helper.generate_test_user() # Accounts for the users self.account_u1_1 = api_helper.generate_cloud_account(user=self.user1) self.account_u1_2 = api_helper.generate_cloud_account(user=self.user1) self.account_u2_1 = api_helper.generate_cloud_account(user=self.user2) self.account_u2_2 = api_helper.generate_cloud_account(user=self.user2) # Images with various contents self.image_plain = api_helper.generate_image() self.image_windows = api_helper.generate_image(is_windows=True) self.image_rhel = api_helper.generate_image(rhel_detected=True) self.image_ocp = api_helper.generate_image(openshift_detected=True, architecture="arm64") self.image_rhel_ocp = api_helper.generate_image( rhel_detected=True, openshift_detected=True, status=MachineImage.UNAVAILABLE) self.inspected_image = api_helper.generate_image( status=MachineImage.INSPECTED) # Instances for the accounts self.instance_u1_1 = api_helper.generate_instance( cloud_account=self.account_u1_1, image=self.image_plain) self.instance_u1_2 = api_helper.generate_instance( cloud_account=self.account_u1_2, image=self.image_rhel) self.instance_u2_1 = api_helper.generate_instance( cloud_account=self.account_u2_1, image=self.image_ocp) self.instance_u2_2 = api_helper.generate_instance( cloud_account=self.account_u2_2, image=self.image_rhel_ocp) # Some initial event activity spread across the accounts powered_times = (( util_helper.utc_dt(2018, 1, 9, 0, 0, 0), util_helper.utc_dt(2018, 1, 10, 0, 0, 0), ), ) instance_images = ( (self.instance_u1_1, self.image_plain), (self.instance_u1_2, self.image_rhel), (self.instance_u2_1, self.image_ocp), (self.instance_u2_2, self.image_rhel_ocp), ) for instance, image in instance_images: self.generate_events(powered_times, instance, image) self.factory = APIRequestFactory()
def test_lock_task_for_user_ids_create_usertasklock(self): """Assert UserTaskLock is created by context manager.""" user1 = util_helper.generate_test_user() user2 = util_helper.generate_test_user() with lock_task_for_user_ids([user1.id, user2.id]): locks = UserTaskLock.objects.all() for lock in locks: self.assertEqual(lock.locked, True) locks = UserTaskLock.objects.all() for lock in locks: self.assertEqual(lock.locked, False)
def generate_aws_account(arn=None, aws_account_id=None, user=None, name=None): """ Generate an AwsAccount for testing. Any optional arguments not provided will be randomly generated. Args: arn (str): Optional ARN. aws_account_id (12-digit string): Optional AWS account ID. user (User): Optional Django auth User to be this account's owner. name (str): Optional name for this account. Returns: AwsAccount: The created AwsAccount. """ if arn is None: arn = helper.generate_dummy_arn(account_id=aws_account_id) if user is None: user = helper.generate_test_user() return AwsAccount.objects.create( account_arn=arn, aws_account_id=aws.AwsArn(arn).account_id, user=user, name=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 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_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 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_create_fails_cloudtrail_configuration_error( self, mock_notify_sources): """Test that an exception occurs if cloudtrail configuration fails.""" mock_request = Mock() mock_request.user = util_helper.generate_test_user() context = {"request": mock_request} serializer = CloudAccountSerializer(context=context) client_error = ClientError( error_response={"Error": { "Code": "AccessDeniedException" }}, operation_name=Mock(), ) 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 = self.role mock_verify.return_value = True, [] mock_cloudtrail.side_effect = client_error expected_error = "Could not enable" with self.assertLogs( "api.models", level="INFO") as cm, self.assertRaises(ValidationError): serializer.create(self.validated_data) log_record = cm.records[1] self.assertIn(expected_error, log_record.msg.detail["account_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 = 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_openshift_tag_added(self, mock_aws, mock_check_image_state): """Test openshift tag added to MachineImage.""" mock_session = mock_aws.boto3.Session.return_value ami_id = util_helper.generate_dummy_image_id() ami_region = random.choice(util_helper.SOME_AWS_REGIONS) mock_ami = util_helper.generate_mock_image(ami_id) mock_ami.tags = [{ 'Key': 'cloudigrade-ocp-present', 'Value': 'cloudigrade-ocp-present' }] mock_resource = mock_session.resource.return_value mock_resource.Image.return_value = mock_ami test_user = util_helper.generate_test_user() test_account = AwsAccount.objects.create( user=test_user, aws_account_id=util_helper.generate_dummy_aws_account_id, account_arn=util_helper.generate_dummy_arn) test_image = AwsMachineImage.objects.create(account=test_account, ec2_ami_id=ami_id) serializer = AwsAccountSerializer() openshift_tag = test_image.tags.filter(description='openshift').first() self.assertEqual(openshift_tag, None) serializer.add_openshift_tag(mock_session, ami_id, ami_region, test_image) openshift_tag = test_image.tags.filter(description='openshift').first() self.assertNotEqual(openshift_tag, None)
def test_generate_test_user_with_args(self): """Assert generation of test user with specified arguments.""" email = f'{uuid.uuid4()}@example.com' user = helper.generate_test_user(email=email, is_superuser=True) self.assertEqual(user.email, email) self.assertEqual(user.username, email) self.assertTrue(user.is_superuser)
def test_create_fails_access_denied(self, mock_notify_sources): """Test that an exception is raised if access is denied to the arn.""" client_error = ClientError( error_response={"Error": { "Code": "AccessDenied" }}, operation_name=Mock(), ) mock_request = Mock() mock_request.user = util_helper.generate_test_user() context = {"request": mock_request} serializer = CloudAccountSerializer(context=context) 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.side_effect = client_error mock_verify.return_value = True, [] expected_error = { "account_arn": ['Permission denied for ARN "{0}"'.format(self.arn)] } with self.assertLogs( "api.models", level="INFO") as cm, self.assertRaises(ValidationError): serializer.create(self.validated_data) log_record = cm.records[1] self.assertIn( expected_error["account_arn"][0], log_record.msg.detail["account_arn"][0], )
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_succeeds_when_account_verified(self, mock_enable): """Test saving of a test ARN.""" mock_request = Mock() mock_request.user = util_helper.generate_test_user() context = {"request": mock_request} serializer = CloudAccountSerializer(context=context) result = serializer.create(self.validated_data) self.assertIsInstance(result, CloudAccount) mock_enable.assert_called() # Verify that we created the account. account = AwsCloudAccount.objects.get( aws_account_id=self.aws_account_id) self.assertEqual(self.aws_account_id, account.aws_account_id) self.assertEqual(self.arn, account.account_arn) # Verify that we created no instances yet. instances = Instance.objects.filter( cloud_account=account.cloud_account.get()).all() self.assertEqual(len(instances), 0) # Verify that we created no images yet. amis = AwsMachineImage.objects.all() self.assertEqual(len(amis), 0)
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_create_aws_clount_fails_with_different_user_same_account_id( self, mock_enable, mock_notify_sources): """Test create_aws_cloud_account failure message for different user.""" # The first call just creates the existing objects. util.create_aws_cloud_account(self.user, self.arn, self.name, self.auth_id, self.app_id, self.source_id) other_arn = util_helper.generate_dummy_arn( account_id=self.aws_account_id, resource=_faker.word()) other_auth_id = _faker.pyint() other_app_id = _faker.pyint() other_source_id = _faker.pyint() other_user = util_helper.generate_test_user() with self.assertRaises(ValidationError) as raise_context: util.create_aws_cloud_account( other_user, other_arn, self.name, other_auth_id, other_app_id, other_source_id, ) exception_detail = raise_context.exception.detail self.assertIn("Could not set up cloud metering.", exception_detail["account_arn"]) self.assertNotIn("CG1002", exception_detail["account_arn"])
def test_generate_test_user_with_args(self): """Assert generation of test user with specified arguments.""" account_number = _faker.random_int(min=100000, max=999999) user = helper.generate_test_user(account_number=account_number, is_superuser=True) self.assertEqual(user.username, account_number) self.assertTrue(user.is_superuser)
def test_openshift_no_tags(self, mock_aws, mock_check_image_state): """Test case where AMI has no tags.""" mock_session = mock_aws.boto3.Session.return_value ami_id = util_helper.generate_dummy_image_id() ami_region = random.choice(util_helper.SOME_AWS_REGIONS) mock_ami = util_helper.generate_mock_image(ami_id) mock_ami.tags = None mock_resource = mock_session.resource.return_value mock_resource.Image.return_value = mock_ami test_user = util_helper.generate_test_user() test_account = AwsAccount.objects.create( user=test_user, aws_account_id=util_helper.generate_dummy_aws_account_id, account_arn=util_helper.generate_dummy_arn) test_image = AwsMachineImage.objects.create(account=test_account, ec2_ami_id=ami_id) serializer = AwsAccountSerializer() openshift_tag = test_image.tags.filter(description='openshift').first() self.assertEqual(openshift_tag, None) serializer.add_openshift_tag(mock_session, ami_id, ami_region, test_image) openshift_tag = test_image.tags.filter(description='openshift').first() self.assertEqual(openshift_tag, None)
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_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 test_lock_task_for_user_ids_updates_usertasklock(self): """Assert UserTaskLock is updated by context manager.""" user = util_helper.generate_test_user() UserTaskLock.objects.create(user=user) with lock_task_for_user_ids([user.id]) as locks: for lock in locks: self.assertEqual(lock.locked, True) lock = UserTaskLock.objects.get(user=user) self.assertEqual(lock.locked, False)
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 setUp(self): """Set up data for tests.""" self.account_number = str(_faker.pyint()) self.account_number_not_found = str(_faker.pyint()) self.user = util_helper.generate_test_user(self.account_number) self.internal_rh_header = util_helper.get_internal_identity_auth_header( ) self.auth_class = IdentityHeaderAuthenticationInternalAllowFakeIdentityHeader( )
def setUp(self): """Set up an AwsCloudAccount for relevant events.""" 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, created_at=util_helper.utc_dt(2017, 12, 1, 0, 0, 0), )
def test_create_succeeds_when_account_verified(self): """Test saving and processing of a test ARN.""" 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, } 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, \ patch.object(account_serializers, 'copy_ami_snapshot') as mock_copy_snapshot: 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 mock_copy_snapshot.return_value = None serializer = AwsAccountSerializer(context=context) result = serializer.create(validated_data) self.assertIsInstance(result, AwsAccount) account = AwsAccount.objects.get(aws_account_id=aws_account_id) self.assertEqual(aws_account_id, account.aws_account_id) self.assertEqual(arn, account.account_arn) instances = AwsInstance.objects.filter(account=account).all() self.assertEqual(len(running_instances[region]), len(instances)) for region, mock_instances_list in running_instances.items(): for mock_instance in mock_instances_list: instance_id = mock_instance['InstanceId'] instance = AwsInstance.objects.get(ec2_instance_id=instance_id) self.assertIsInstance(instance, AwsInstance) self.assertEqual(region, instance.region) event = InstanceEvent.objects.get(instance=instance) self.assertIsInstance(event, InstanceEvent) self.assertEqual(InstanceEvent.TYPE.power_on, event.event_type) amis = AwsMachineImage.objects.filter(account=account).all() self.assertEqual(len(running_instances[region]), len(amis))