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()