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_overlapping_rhel_runs_within_day_with_user_filter(self):
"""
Test with two overlapping RHEL instances run within the day.
Because a user filter is applied, only one instance's data is seen.
"""
rhel_instance1 = api_helper.generate_instance(
self.user1account1, image=self.image_rhel3
)
rhel_instance2 = api_helper.generate_instance(
self.user2account1, image=self.image_rhel4
)
api_helper.generate_single_run(
rhel_instance1,
(
util_helper.utc_dt(2019, 5, 1, 1, 0, 0),
util_helper.utc_dt(2019, 5, 1, 2, 0, 0),
),
image=rhel_instance1.machine_image,
)
# This second instance run should be filtered away.
api_helper.generate_single_run(
rhel_instance2,
(
util_helper.utc_dt(2019, 5, 1, 1, 30, 0),
util_helper.utc_dt(2019, 5, 1, 2, 30, 0),
),
image=rhel_instance2.machine_image,
)
request_date = datetime.date(2019, 5, 1)
expected_date = request_date
expected_instances = 1
usage = calculate_max_concurrent_usage(request_date, user_id=self.user1.id)
self.assertMaxConcurrentUsage(usage, expected_date, expected_instances)
def test_non_overlapping_rhel_runs_within_day(self):
"""
Test with two non-overlapping RHEL instances run within the day.
Two instances of different size run at different times, and this test
should see the *larger* of the two matching the max values.
"""
rhel_instance1 = api_helper.generate_instance(
self.user1account1, image=self.image_rhel4
)
rhel_instance2 = api_helper.generate_instance(
self.user1account2, image=self.image_rhel5
)
api_helper.generate_single_run(
rhel_instance1,
(
util_helper.utc_dt(2019, 5, 1, 1, 0, 0),
util_helper.utc_dt(2019, 5, 1, 2, 0, 0),
),
image=rhel_instance1.machine_image,
)
api_helper.generate_single_run(
rhel_instance2,
(
util_helper.utc_dt(2019, 5, 1, 3, 0, 0),
util_helper.utc_dt(2019, 5, 1, 4, 0, 0),
),
image=rhel_instance2.machine_image,
)
request_date = datetime.date(2019, 5, 1)
expected_date = request_date
expected_instances = 1
usage = calculate_max_concurrent_usage(request_date, user_id=self.user1.id)
self.assertMaxConcurrentUsage(usage, expected_date, expected_instances)
def test_overlapping_rhel_runs_within_day(self):
"""
Test with two overlapping RHEL instances run within the day.
Because no account filter is applied, both instances are seen.
"""
rhel_instance1 = api_helper.generate_instance(
self.user1account1, image=self.image_rhel1
)
rhel_instance2 = api_helper.generate_instance(
self.user1account1, image=self.image_rhel2
)
api_helper.generate_single_run(
rhel_instance1,
(
util_helper.utc_dt(2019, 5, 1, 1, 0, 0),
util_helper.utc_dt(2019, 5, 1, 2, 0, 0),
),
image=rhel_instance1.machine_image,
)
api_helper.generate_single_run(
rhel_instance2,
(
util_helper.utc_dt(2019, 5, 1, 1, 30, 0),
util_helper.utc_dt(2019, 5, 1, 2, 30, 0),
),
image=rhel_instance2.machine_image,
)
expected_date = request_date = datetime.date(2019, 5, 1)
usage = calculate_max_concurrent_usage(request_date, user_id=self.user1.id)
self.assertEqual(usage.date, expected_date)
self.assertEqual(len(usage.maximum_counts), 32)
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 test_delete_multiple_instance_from_queryset_cleans_up_image(self):
"""Deleting instances that share an image cleans up the image."""
helper.generate_instance(cloud_account=self.account, image=self.image)
aws_models.AwsInstance.objects.all().delete()
self.assertEqual(0, aws_models.AwsMachineImage.objects.count())
self.assertEqual(0, models.MachineImage.objects.count())
self.assertEqual(0, aws_models.AwsInstance.objects.count())
self.assertEqual(0, models.Instance.objects.count())
def test_delete_instance_does_not_clean_up_shared_machineimage(self):
"""Test that deleting an instance does not clean up an shared image."""
helper.generate_instance(cloud_account=self.account, image=self.image)
self.instance.delete()
self.instance_without_image.delete()
self.assertEqual(1, aws_models.AwsMachineImage.objects.count())
self.assertEqual(1, models.MachineImage.objects.count())
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_disable_returns_early_if_account_is_enabled(self):
"""Test that AwsCloudAccount.disable returns early if is_enabled."""
self.assertTrue(self.account.is_enabled)
helper.generate_instance(cloud_account=self.account)
with patch("api.clouds.aws.util.delete_cloudtrail"
) as mock_delete_cloudtrail:
mock_delete_cloudtrail.return_value = True
self.account.content_object.disable()
mock_delete_cloudtrail.assert_not_called()
def setUp(self):
"""Set up basic aws account."""
self.account = helper.generate_cloud_account()
self.image = helper.generate_image()
self.instance = helper.generate_instance(cloud_account=self.account,
image=self.image)
self.instance_without_image = helper.generate_instance(
cloud_account=self.account,
no_image=True,
)
def test_disable_succeeds_if_no_instance_events(self, mock_notify_sources):
"""Test that disabling an account works despite having no instance events."""
self.assertTrue(self.account.is_enabled)
helper.generate_instance(cloud_account=self.account)
with patch("api.clouds.aws.util.delete_cloudtrail"
) as mock_delete_cloudtrail:
mock_delete_cloudtrail.return_value = True
self.account.disable()
mock_delete_cloudtrail.assert_called()
self.account.refresh_from_db()
self.assertFalse(self.account.is_enabled)
self.assertEqual(0, aws_models.AwsInstanceEvent.objects.count())
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_single_rhel_run_no_result(self):
"""
Test with a single RHEL instance requesting results in futures.
Also assert that no ConcurrentUsage is saved to the database because the
requested date is in the future, and we cannot know that data yet.
"""
rhel_instance = api_helper.generate_instance(self.user1account1,
image=self.image_rhel)
api_helper.generate_single_run(
rhel_instance,
(
util_helper.utc_dt(2019, 5, 1, 1, 0, 0),
util_helper.utc_dt(2019, 5, 1, 2, 0, 0),
),
image=rhel_instance.machine_image,
calculate_concurrent_usage=False,
)
request_date = datetime.date(2019, 5, 4)
expected_date = request_date
self.assertEqual(
models.ConcurrentUsage.objects.filter(
date=request_date, user_id=self.user1.id).count(),
0,
)
concurrent_usage = get_max_concurrent_usage(request_date,
user_id=self.user1.id)
self.assertEqual(
models.ConcurrentUsage.objects.filter(
date=request_date, user_id=self.user1.id).count(),
0,
)
self.assertEqual(concurrent_usage.date, expected_date)
self.assertEqual(len(concurrent_usage.maximum_counts), 0)
def test_multiple_requests_use_precalculated_data(self):
"""Test multiple requests use the same saved pre-calculated data."""
rhel_instance = api_helper.generate_instance(self.user1account1,
image=self.image_rhel)
api_helper.generate_single_run(
rhel_instance,
(
util_helper.utc_dt(2019, 5, 1, 1, 0, 0),
util_helper.utc_dt(2019, 5, 1, 2, 0, 0),
),
image=rhel_instance.machine_image,
)
request_date = datetime.date(2019, 5, 1)
expected_date = request_date
expected_instances = 1
concurrent_usage = get_max_concurrent_usage(request_date,
user_id=self.user1.id)
concurrent_usage_2 = get_max_concurrent_usage(request_date,
user_id=self.user1.id)
concurrent_usage_3 = get_max_concurrent_usage(request_date,
user_id=self.user1.id)
self.assertEqual(concurrent_usage, concurrent_usage_2)
self.assertEqual(concurrent_usage, concurrent_usage_3)
self.assertEqual(concurrent_usage.date, expected_date)
self.assertEqual(len(concurrent_usage.maximum_counts), 24)
for single_day_counts in concurrent_usage.maximum_counts:
self.assertEqual(single_day_counts["instances_count"],
expected_instances)
def test_action_noun_verb_detail(self):
"""Assert "detail" requests work."""
client = helper.SandboxedRestClient()
client._force_authenticate(self.user)
account = helper.generate_cloud_account(user=self.user)
image = helper.generate_image(status=MachineImage.INSPECTED)
helper.generate_instance(account, image=image)
response = client.post_machineimages(
noun_id=image.id,
detail="reinspect",
api_root="/internal/api/cloudigrade/v1",
)
self.assertEqual(response.status_code, http.HTTPStatus.OK)
self.assertEqual(MachineImage.PENDING, response.data["status"])
def test_generate_aws_events_with_args_and_some_times(self):
"""Assert generation of InstanceEvents with all specified args."""
account = helper.generate_cloud_account()
ec2_ami_id = util_helper.generate_dummy_image_id()
image = helper.generate_image(ec2_ami_id=ec2_ami_id)
instance = helper.generate_instance(account, image=image)
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),
)
instance_type = util_helper.get_random_instance_type()
subnet = str(uuid.uuid4())
events = helper.generate_instance_events(
instance,
powered_times,
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:
if event.event_type != event.TYPE.power_off:
self.assertEqual(
event.instance.machine_image.content_object.ec2_ami_id, ec2_ami_id
)
self.assertEqual(event.content_object.instance_type, instance_type)
self.assertEqual(event.content_object.subnet, subnet)
def test_inspect_pending_images(self):
"""
Test that only old "pending" images are found and reinspected.
Note that we effectively time-travel here to points in the past to
create the account, images, and instances. This is necessary because
updated_at is automatically set by Django and cannot be manually set,
but we need things with specific older updated_at times.
"""
real_now = get_now()
yesterday = real_now - datetime.timedelta(days=1)
with clouditardis(yesterday):
account = account_helper.generate_cloud_account()
image_old_inspected = account_helper.generate_image()
image_old_pending = account_helper.generate_image(
status=MachineImage.PENDING)
# an instance exists using old inspected image.
account_helper.generate_instance(cloud_account=account,
image=image_old_inspected)
# an instance exists using old pending image.
instance_old_pending = account_helper.generate_instance(
cloud_account=account, image=image_old_pending)
# another instance exists using the same old pending image, but the
# image should still only be reinspected once regardless of how
# many instances used it.
account_helper.generate_instance(cloud_account=account,
image=image_old_pending)
one_hour_ago = real_now - datetime.timedelta(seconds=60 * 60)
with clouditardis(one_hour_ago):
image_new_inspected = account_helper.generate_image()
image_new_pending = account_helper.generate_image(
status=MachineImage.PENDING)
# an instance exists using new inspected image.
account_helper.generate_instance(cloud_account=account,
image=image_new_inspected)
# an instance exists using new pending image, but it should not
# trigger inspection because the image is not old enough.
account_helper.generate_instance(cloud_account=account,
image=image_new_pending)
expected_calls = [
call(
account.content_object.account_arn,
image_old_pending.content_object.ec2_ami_id,
instance_old_pending.content_object.region,
)
]
with patch.object(tasks, "start_image_inspection") as mock_start:
tasks.inspect_pending_images()
mock_start.assert_has_calls(expected_calls, any_order=True)
def test_generate_azure_events_default_and_no_times(self):
"""Assert generation of an azure InstanceEvent."""
account = helper.generate_cloud_account(cloud_type="azure")
instance = helper.generate_instance(account, cloud_type="azure")
events = helper.generate_instance_events(instance,
tuple(),
cloud_type="azure")
self.assertEqual(len(events), 0)
def test_update_aws_clount_different_aws_account_id_success(
self,
mock_enable,
mock_disable,
mock_notify_sources,
):
"""Test update_aws_cloud_account works."""
aws_account_id2 = util_helper.generate_dummy_aws_account_id()
arn2 = util_helper.generate_dummy_arn(account_id=aws_account_id2)
api_helper.generate_instance(self.clount)
util.update_aws_cloud_account(self.clount, arn2, self.account_number,
self.auth_id, self.source_id)
self.assertTrue(
AwsCloudAccount.objects.filter(account_arn=arn2).exists())
self.assertEqual(0, Instance.objects.all().count())
def test_generate_azure_instance_default(self):
"""Assert generation of an Instance with minimal args."""
account = helper.generate_cloud_account(cloud_type="azure")
instance = helper.generate_instance(account, cloud_type="azure")
self.assertIsInstance(instance, Instance)
self.assertEqual(instance.cloud_account, account)
self.assertIsNotNone(instance.content_object.resource_id)
self.assertIsNotNone(instance.content_object.region)
self.assertGreater(len(instance.content_object.region), 0)
def setUp(self):
"""Set up a bunch of test data."""
self.user1 = util_helper.generate_test_user()
self.user1.date_joined = util_helper.utc_dt(2019, 1, 1, 0, 0, 0)
self.user1.save()
self.account1 = api_helper.generate_cloud_account(user=self.user1)
self.account2 = api_helper.generate_cloud_account(user=self.user1)
self.image1_rhel = api_helper.generate_image(
rhel_detected=True,
rhel_version="7.7",
syspurpose={"role": "potato"},
)
self.image2_rhel = api_helper.generate_image(rhel_detected=True)
self.instance1 = api_helper.generate_instance(self.account1,
image=self.image1_rhel)
self.instance2 = api_helper.generate_instance(self.account1,
image=self.image2_rhel)
self.instance_type1 = "c5.xlarge" # 4 vcpu and 8.0 memory
self.factory = APIRequestFactory()
self.faker = faker.Faker()
def setUp(self):
"""Set up data for an account with a running instance."""
self.account = account_helper.generate_cloud_account()
self.instance = account_helper.generate_instance(self.account)
self.aws_instance = self.instance.content_object
self.region = self.aws_instance.region
self.power_on_time = util_helper.utc_dt(2018, 1, 1, 0, 0, 0)
self.power_off_time = util_helper.utc_dt(2019, 1, 1, 0, 0, 0)
event = account_helper.generate_single_instance_event(
self.instance,
self.power_on_time,
event_type=InstanceEvent.TYPE.power_on)
self.process_event(event)
def test_generate_aws_instance_with_args(self):
"""Assert generation of an AwsInstance with all specified args."""
account = helper.generate_cloud_account()
ec2_instance_id = util_helper.generate_dummy_instance_id()
region = util_helper.get_random_region()
instance = helper.generate_instance(
account,
ec2_instance_id=ec2_instance_id,
region=region,
)
self.assertIsInstance(instance, Instance)
self.assertEqual(instance.cloud_account, account)
self.assertEqual(instance.content_object.ec2_instance_id, ec2_instance_id)
self.assertEqual(instance.content_object.region, region)
def test_delete_run_removes_concurrent_usage(self):
"""Test when a run is deleted, related concurrent usage are deleted."""
account = helper.generate_cloud_account()
image = helper.generate_image()
instance = helper.generate_instance(cloud_account=account, image=image)
runtime = (
util_helper.utc_dt(2019, 1, 1, 0, 0, 0),
util_helper.utc_dt(2019, 1, 2, 0, 0, 0),
)
helper.generate_single_run(instance=instance, runtime=runtime)
self.assertGreater(models.ConcurrentUsage.objects.count(), 0)
models.Run.objects.all().delete()
self.assertEqual(models.ConcurrentUsage.objects.count(), 0)
def test_build_events_info_for_saving_too_old_events(self):
"""Test _build_events_info_for_saving with events that are too old."""
instance = api_helper.generate_instance(self.account)
# Note: this time is *before* self.account.created_at.
occurred_at = "2016-01-02T12:34:56+00:00"
instance_event = api_helper.generate_cloudtrail_instance_event(
instance=instance,
occurred_at=occurred_at,
event_type=InstanceEvent.TYPE.power_on,
instance_type=None,
)
events_info = tasks._build_events_info_for_saving(
self.account, instance, [instance_event])
self.assertEqual(len(events_info), 0)
def test_calculation_in_progress(self, mock_schedule_concurrent_task):
"""Test exception is raised if calculation is currently running."""
rhel_instance = api_helper.generate_instance(self.user1account1,
image=self.image_rhel)
api_helper.generate_single_run(
rhel_instance,
(
util_helper.utc_dt(2019, 5, 1, 1, 0, 0),
util_helper.utc_dt(2019, 5, 1, 2, 0, 0),
),
image=rhel_instance.machine_image,
calculate_concurrent_usage=False,
)
request_date = datetime.date(2019, 5, 1)
expected_date = request_date
expected_instances = 1
self.assertEqual(
models.ConcurrentUsage.objects.filter(
date=request_date, user_id=self.user1.id).count(),
0,
)
concurrent_task = models.ConcurrentUsageCalculationTask(
date=request_date, user_id=self.user1.id, task_id="test123")
concurrent_task.status = models.ConcurrentUsageCalculationTask.RUNNING
concurrent_task.save()
with self.assertRaises(ResultsUnavailable):
get_max_concurrent_usage(request_date, user_id=self.user1.id)
# now actually calculate concurrent usage
calculate_max_concurrent_usage(request_date, self.user1.id)
concurrent_usage = get_max_concurrent_usage(request_date,
user_id=self.user1.id)
self.assertEqual(
models.ConcurrentUsage.objects.filter(
date=request_date, user_id=self.user1.id).count(),
1,
)
self.assertEqual(concurrent_usage.date, expected_date)
self.assertEqual(len(concurrent_usage.maximum_counts), 24)
for single_day_counts in concurrent_usage.maximum_counts:
self.assertEqual(single_day_counts["instances_count"],
expected_instances)
def test_single_rhel_run_entirely_after_day(self):
"""Test with a RHEL instance run entirely after the day."""
rhel_instance = api_helper.generate_instance(
self.user1account1, image=self.image_rhel1
)
api_helper.generate_single_run(
rhel_instance,
(
util_helper.utc_dt(2019, 5, 2, 1, 0, 0),
util_helper.utc_dt(2019, 5, 2, 2, 0, 0),
),
image=rhel_instance.machine_image,
)
request_date = datetime.date(2019, 5, 1)
expected_date = request_date
usage = calculate_max_concurrent_usage(request_date, user_id=self.user1.id)
self.assertMaxConcurrentUsage(usage, expected_date, 0)
def test_disable_succeeds(self, mock_notify_sources):
"""
Test that disabling an account does all the relevant cleanup.
Disabling a CloudAccount having an AwsCloudAccount should:
- set the CloudAccount.is_enabled to False
- create a power_off InstanceEvent for any powered-on instances
- disable the CloudTrail (via AwsCloudAccount.disable)
"""
self.assertTrue(self.account.is_enabled)
self.assertEqual(self.account.enabled_at, self.account.created_at)
instance = helper.generate_instance(cloud_account=self.account)
runtimes = [
(
util_helper.utc_dt(2019, 1, 1, 0, 0, 0),
util_helper.utc_dt(2019, 1, 2, 0, 0, 0),
),
(util_helper.utc_dt(2019, 1, 3, 0, 0, 0), None),
]
disable_date = util_helper.utc_dt(2019, 1, 4, 0, 0, 0)
with util_helper.clouditardis(disable_date):
# We need to generate the runs while inside the clouditardis because we
# don't need an ever-growing number of daily ConcurrentUsage objects being
# created as the real-world clock ticks forward.
for runtime in runtimes:
helper.generate_single_run(instance=instance, runtime=runtime)
self.assertEqual(3, aws_models.AwsInstanceEvent.objects.count())
with patch("api.clouds.aws.util.delete_cloudtrail"
) as mock_delete_cloudtrail:
mock_delete_cloudtrail.return_value = True
self.account.disable()
mock_delete_cloudtrail.assert_called()
self.account.refresh_from_db()
self.assertFalse(self.account.is_enabled)
self.assertEqual(self.account.enabled_at, self.created_at)
self.assertEqual(4, aws_models.AwsInstanceEvent.objects.count())
last_event = (models.InstanceEvent.objects.filter(
instance=instance).order_by("-occurred_at").first())
self.assertEqual(last_event.event_type,
models.InstanceEvent.TYPE.power_off)
def test_single_run_overlapping_day_start(self):
"""Test with a RHEL instance run overlapping the start of the day."""
rhel_instance = api_helper.generate_instance(
self.user1account1, image=self.image_rhel1
)
api_helper.generate_single_run(
rhel_instance,
(
util_helper.utc_dt(2019, 4, 30, 1, 0, 0),
util_helper.utc_dt(2019, 5, 1, 2, 0, 0),
),
image=rhel_instance.machine_image,
)
request_date = datetime.date(2019, 5, 1)
expected_date = request_date
expected_instances = 1
usage = calculate_max_concurrent_usage(request_date, user_id=self.user1.id)
self.assertMaxConcurrentUsage(usage, expected_date, expected_instances)
def test_single_rhel_run_within_day(self):
"""Test with a single RHEL instance run within the day."""
rhel_instance = api_helper.generate_instance(
self.user1account1, image=self.image_rhel1
)
api_helper.generate_single_run(
rhel_instance,
(
util_helper.utc_dt(2019, 5, 1, 1, 0, 0),
util_helper.utc_dt(2019, 5, 1, 2, 0, 0),
),
image=rhel_instance.machine_image,
)
request_date = datetime.date(2019, 5, 1)
expected_date = request_date
expected_instances = 1
usage = calculate_max_concurrent_usage(request_date, user_id=self.user1.id)
self.assertEqual(len(usage.maximum_counts), 24)
self.assertMaxConcurrentUsage(usage, expected_date, expected_instances)
