def test_get_noun(self): """Assert "get" requests work.""" client = helper.SandboxedRestClient() client._force_authenticate(self.user) account = helper.generate_cloud_account(user=self.user) response = client.get_accounts(account.id) self.assertEqual(response.status_code, http.HTTPStatus.OK) response_json = response.json() self.assertEqual(response_json["account_id"], account.id)
def test_create_noun(self, mock_notify_sources): """Assert "create" requests work.""" client = helper.SandboxedRestClient(api_root="/internal/api/cloudigrade/v1") client._force_authenticate(self.user) arn = util_helper.generate_dummy_arn() name = _faker.sentence() data = util_helper.generate_dummy_aws_cloud_account_post_data() data.update({"account_arn": arn, "name": name}) response = client.create_accounts(data=data) self.assertEqual(response.status_code, http.HTTPStatus.CREATED) response_json = response.json() self.assertEqual(response_json["content_object"]["account_arn"], arn) self.assertEqual(response_json["name"], name) self.assertEqual(response_json["user_id"], self.user.id)
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_list_noun(self): """Assert "list" requests work.""" client = helper.SandboxedRestClient() client._force_authenticate(self.user) response = client.list_accounts() self.assertEqual(response.status_code, http.HTTPStatus.OK) response_json = response.json() self.assertIn("data", response_json) self.assertIsInstance(response_json["data"], list) self.assertIn("meta", response_json) self.assertIn("count", response_json["meta"]) self.assertIn("links", response_json) self.assertIn("next", response_json["links"]) self.assertIn("previous", response_json["links"]) self.assertIn("first", response_json["links"]) self.assertIn("last", response_json["links"])
def test_invalid_request(self): """Assert invalid requests raise AttributeError.""" client = helper.SandboxedRestClient() with self.assertRaises(AttributeError): client.foo_bar()
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() self.user3 = 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=models.MachineImage.UNAVAILABLE, ) self.inspected_image = api_helper.generate_image( status=models.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), ) self.events = [] for instance, image in instance_images: self.events.extend( self.generate_events(powered_times, instance, image)) self.client = api_helper.SandboxedRestClient( api_root="/internal/api/cloudigrade/v1") self.client._force_authenticate(self.user3)
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