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_generate_aws_ec2_definitions_when_empty(self):
"""Assert generation of AWS EC2 instance definitions."""
self.assertEqual(InstanceDefinition.objects.count(), 0)
helper.generate_instance_type_definitions()
self.assertEqual(
InstanceDefinition.objects.count(),
len(util_helper.SOME_EC2_INSTANCE_TYPES),
)
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,
created_at=util_helper.utc_dt(2017, 12, 1, 0, 0, 0),
)
api_helper.generate_instance_type_definitions()
def test_generate_aws_ec2_definitions_warns_when_not_empty(self, mock_logger):
"""Assert warning when generating definition that already exists."""
helper.generate_instance_type_definitions()
helper.generate_instance_type_definitions()
self.assertEqual(
InstanceDefinition.objects.count(),
len(util_helper.SOME_EC2_INSTANCE_TYPES),
)
# warning counts should match because each type was attempted twice.
self.assertEqual(
len(mock_logger.warning.mock_calls),
len(util_helper.SOME_EC2_INSTANCE_TYPES),
)
def __init__(self):
"""Initialize all the data for the examples."""
api_helper.generate_instance_type_definitions(cloud_type="aws")
api_helper.generate_instance_type_definitions(cloud_type="azure")
self.customer_account_number = "100001"
self.customer_user = util_helper.get_test_user(
self.customer_account_number, is_superuser=False)
self.customer_user.date_joined = util_helper.utc_dt(
2019, 1, 1, 0, 0, 0)
self.customer_user.save()
self.customer_client = api_helper.SandboxedRestClient()
self.customer_client._force_authenticate(self.customer_user)
self.internal_client = api_helper.SandboxedRestClient(
api_root="/internal/api/cloudigrade/v1")
self.internal_client._force_authenticate(self.customer_user)
self.customer_arn = util_helper.generate_dummy_arn()
# Times to use for various account and event activity.
self.now = get_now()
self.this_morning = self.now.replace(hour=0,
minute=0,
second=0,
microsecond=0)
self.yesterday = self.this_morning - timedelta(days=1)
self.last_month = self.this_morning - timedelta(days=31)
self.last_week = self.this_morning - timedelta(days=7)
self.three_days_ago = self.this_morning - timedelta(days=3)
self.two_days_ago = self.this_morning - timedelta(days=2)
self.two_weeks_ago = self.this_morning - timedelta(weeks=2)
self.tomorrow = self.this_morning + timedelta(days=1)
self.next_week = self.this_morning + timedelta(weeks=1)
######################################
# Generate AWS data for the customer user.
self.aws_customer_account = api_helper.generate_cloud_account(
arn=util_helper.generate_dummy_arn(),
user=self.customer_user,
name="greatest account ever",
created_at=self.two_weeks_ago,
)
self.azure_customer_account = api_helper.generate_cloud_account(
user=self.customer_user,
name="meh account",
created_at=self.two_weeks_ago,
cloud_type="azure",
azure_subscription_id=str(seeded_uuid4()),
azure_tenant_id=str(seeded_uuid4()),
)
self.customer_instances = [
api_helper.generate_instance(self.aws_customer_account),
api_helper.generate_instance(self.aws_customer_account),
api_helper.generate_instance(self.aws_customer_account),
api_helper.generate_instance(self.azure_customer_account,
cloud_type="azure"),
api_helper.generate_instance(self.azure_customer_account,
cloud_type="azure"),
api_helper.generate_instance(self.azure_customer_account,
cloud_type="azure"),
]
# Generate events so we can see customer activity in the responses.
# These events represent all customer instances starting one week ago,
# stopping two days ago, and starting again yesterday.
self.events = []
for instance in self.customer_instances[:2]:
self.events.extend(
api_helper.generate_instance_events(
instance,
[
(self.last_week, self.three_days_ago),
(self.yesterday, None),
],
))
for instance in self.customer_instances[3:6]:
self.events.extend(
api_helper.generate_instance_events(
instance,
[
(self.last_week, self.three_days_ago),
(self.yesterday, None),
],
cloud_type="azure",
))
# Build the runs for the created events.
# Note: this crude and *direct* implementation of Run-saving should be
# replaced as we continue porting pilot functionality and (eventually)
# better general-purpose Run-handling functions materialize.
normalized_runs = normalize_runs(models.InstanceEvent.objects.all())
for normalized_run in normalized_runs:
run = models.Run(
start_time=normalized_run.start_time,
end_time=normalized_run.end_time,
machineimage_id=normalized_run.image_id,
instance_id=normalized_run.instance_id,
instance_type=normalized_run.instance_type,
memory=normalized_run.instance_memory,
vcpu=normalized_run.instance_vcpu,
)
run.save()
# Force all images to have RHEL detected ("7.7")
self.images = list(
set(instance.machine_image for instance in self.customer_instances
if instance.machine_image is not None))
for image in self.images:
image.inspection_json = json.dumps({
"rhel_enabled_repos_found": True,
"rhel_version": "7.7",
"syspurpose": {
"role": "Red Hat Enterprise Linux Server",
"service_level_agreement": "Premium",
"usage": "Development/Test",
},
})
image.status = image.INSPECTED
image.region = "us-east-1"
image.save()
# Pre-calculate concurrent usage data for upcoming requests.
# Calculate each day since "last week" (oldest date we use in example requests).
the_date = self.last_week.date()
one_day_delta = timedelta(days=1)
# while the_date <= self.this_morning.date():
while the_date <= self.next_week.date():
task_id = f"calculate-concurrent-usage-{seeded_uuid4()}"
models.ConcurrentUsageCalculationTask.objects.create(
user_id=self.customer_user.id,
date=the_date.isoformat(),
task_id=task_id,
status=models.ConcurrentUsageCalculationTask.COMPLETE,
)
calculate_max_concurrent_usage(the_date, self.customer_user.id)
the_date = the_date + one_day_delta
def setUp(self):
"""Set up common variables for tests."""
self.user = util_helper.generate_test_user()
api_helper.generate_instance_type_definitions()
