def initialize_request(self, context=None): """Initialize model data.""" if context: request_context = context.get('request_context') request = request_context['request'] serializer = UserSerializer(data=context.get('user_data'), context=request_context) else: request_context = self.request_context request = request_context['request'] serializer = UserSerializer(data=self.user_data, context=request_context) if serializer.is_valid(raise_exception=True): user = serializer.save() request.user = user provider_data = {'name': 'test_provider', 'type': Provider.PROVIDER_OCP, 'authentication': { 'provider_resource_name': self.fake.word() }} serializer = ProviderSerializer(data=provider_data, context=request_context) if serializer.is_valid(raise_exception=True): self.provider = serializer.save() self.fake_data = {'provider_uuids': [self.provider.uuid], 'metric': {'name': CostModelMetricsMap.OCP_METRIC_MEM_GB_USAGE_HOUR}, 'tiered_rate': [{ 'value': round(Decimal(random.random()), 6), 'unit': 'USD', 'usage': {'usage_start': None, 'usage_end': None} }] } with tenant_context(self.tenant): serializer = RateSerializer(data=self.fake_data, context=request_context) if serializer.is_valid(raise_exception=True): serializer.save()
def setUp(self): """Set up the tests.""" super().setUp() request = self.request_context['request'] serializer = UserSerializer(data=self.user_data, context=self.request_context) if serializer.is_valid(raise_exception=True): user = serializer.save() request.user = user provider_data = {'name': 'test_provider', 'type': Provider.PROVIDER_OCP, 'authentication': { 'provider_resource_name': self.fake.word() }} serializer = ProviderSerializer(data=provider_data, context=self.request_context) if serializer.is_valid(raise_exception=True): self.provider = serializer.save() ocp_metric = CostModelMetricsMap.OCP_METRIC_CPU_CORE_USAGE_HOUR ocp_source_type = 'OCP' tiered_rates = [{'unit': 'USD', 'value': 0.22}] self.ocp_data = { 'name': 'Test Cost Model', 'description': 'Test', 'source_type': ocp_source_type, 'provider_uuids': [self.provider.uuid], 'rates': [ { 'metric': {'name': ocp_metric}, 'tiered_rates': tiered_rates } ] }
def setUp(self): """Set up the tests.""" super().setUp() request = self.request_context["request"] serializer = UserSerializer(data=self.user_data, context=self.request_context) if serializer.is_valid(raise_exception=True): user = serializer.save() request.user = user provider_data = { "name": "test_provider", "type": Provider.PROVIDER_OCP.lower(), "authentication": {"provider_resource_name": self.fake.word()}, } serializer = ProviderSerializer(data=provider_data, context=self.request_context) if serializer.is_valid(raise_exception=True): self.provider = serializer.save() ocp_metric = CostModelMetricsMap.OCP_METRIC_CPU_CORE_USAGE_HOUR ocp_source_type = Provider.PROVIDER_OCP tiered_rates = [{"unit": "USD", "value": 0.22}] self.ocp_data = { "name": "Test Cost Model", "description": "Test", "source_type": ocp_source_type, "providers": [{"uuid": self.provider.uuid, "name": self.provider.name}], "markup": {"value": 10, "unit": "percent"}, "rates": [{"metric": {"name": ocp_metric}, "tiered_rates": tiered_rates}], }
def test_user_preference_timezone(self): """Test that valid timezones are saved.""" user = None serializer = UserSerializer(data=self.user_data, context=self.request_context) if serializer.is_valid(raise_exception=True): user = serializer.save() kwargs = {"context": {"user": user}} data = { "name": "timezone", "description": self.fake.text(), "preference": { "timezone": "Antarctica/Troll" } } pref = list(UserPreference.objects.filter(user=user, name="timezone")).pop() self.assertIsNotNone(pref) self.assertIsInstance(pref, UserPreference) serializer = UserPreferenceSerializer(pref, data=data, **kwargs) if serializer.is_valid(raise_exception=True): pref = serializer.save() self.assertEqual(pref.name, data.get("name")) self.assertEqual(pref.description, data.get("description")) self.assertEqual(pref.preference, data.get("preference"))
def test_user_preference_currency(self): """Test that valid currency codes are saved.""" user = None serializer = UserSerializer(data=self.user_data, context=self.request_context) if serializer.is_valid(raise_exception=True): user = serializer.save() kwargs = {"context": {"user": user}} data = { "name": "currency", "description": self.fake.text(), "preference": { "currency": random.choice(_currency_symbols()) }, } pref = list(UserPreference.objects.filter(user=user, name="currency")).pop() self.assertIsNotNone(pref) self.assertIsInstance(pref, UserPreference) serializer = UserPreferenceSerializer(pref, data=data, **kwargs) if serializer.is_valid(raise_exception=True): pref = serializer.save() self.assertEqual(pref.name, data.get("name")) self.assertEqual(pref.description, data.get("description")) self.assertEqual(pref.preference, data.get("preference"))
def test_user_preference_currency(self): """Test that valid currency codes are saved.""" user = None serializer = UserSerializer(data=self.user_data, context=self.request_context) if serializer.is_valid(raise_exception=True): user = serializer.save() kwargs = {'context': {'user': user}} data = { 'name': 'currency', 'description': self.fake.text(), 'preference': { 'currency': random.choice(_currency_symbols()) } } pref = list(UserPreference.objects.filter(user=user, name='currency')).pop() self.assertIsNotNone(pref) self.assertIsInstance(pref, UserPreference) serializer = UserPreferenceSerializer(pref, data=data, **kwargs) if serializer.is_valid(raise_exception=True): pref = serializer.save() self.assertEqual(pref.name, data.get('name')) self.assertEqual(pref.description, data.get('description')) self.assertEqual(pref.preference, data.get('preference'))
def test_user_preference_timezone(self): """Test that valid timezones are saved.""" user = None serializer = UserSerializer(data=self.user_data, context=self.request_context) if serializer.is_valid(raise_exception=True): user = serializer.save() kwargs = {'context': {'user': user}} data = { 'name': 'timezone', 'description': self.fake.text(), 'preference': { 'timezone': 'Antarctica/Troll' } } pref = list(UserPreference.objects.filter(user=user, name='timezone')).pop() self.assertIsNotNone(pref) self.assertIsInstance(pref, UserPreference) serializer = UserPreferenceSerializer(pref, data=data, **kwargs) if serializer.is_valid(raise_exception=True): pref = serializer.save() self.assertEqual(pref.name, data.get('name')) self.assertEqual(pref.description, data.get('description')) self.assertEqual(pref.preference, data.get('preference'))
def test_create_same_provider_different_customers(self): """Test that the same provider can be created for 2 different customers.""" user_data = self._create_user_data() alt_request_context = self._create_request_context( self.create_mock_customer_data(), user_data, create_tenant=True ) alt_request = alt_request_context["request"] serializer = UserSerializer(data=user_data, context=alt_request_context) if serializer.is_valid(raise_exception=True): user = serializer.save() alt_request.user = user alt_request_context["request"] = alt_request with patch.object(ProviderAccessor, "cost_usage_source_ready", returns=True): serializer = ProviderSerializer( data=self.generic_providers[Provider.PROVIDER_AZURE], context=self.request_context ) if serializer.is_valid(raise_exception=True): instance1 = serializer.save() with patch.object(ProviderAccessor, "cost_usage_source_ready", returns=True): serializer = ProviderSerializer( data=self.generic_providers[Provider.PROVIDER_AZURE], context=alt_request_context ) if serializer.is_valid(raise_exception=True): instance2 = serializer.save() self.assertNotEqual(instance1.uuid, instance2.uuid) self.assertEqual(instance1.billing_source_id, instance2.billing_source_id) self.assertEqual(instance1.authentication_id, instance2.authentication_id)
def initialize_request(self, context=None): """Initialize model data.""" if context: request_context = context.get("request_context") request = request_context["request"] serializer = UserSerializer(data=context.get("user_data"), context=request_context) else: request_context = self.request_context request = request_context["request"] serializer = UserSerializer(data=self.user_data, context=request_context) if serializer.is_valid(raise_exception=True): user = serializer.save() request.user = user provider_data = { "name": "test_provider", "type": Provider.PROVIDER_OCP.lower(), "authentication": { "provider_resource_name": self.fake.word() }, } serializer = ProviderSerializer(data=provider_data, context=request_context) if serializer.is_valid(raise_exception=True): self.provider = serializer.save() self.ocp_metric = CostModelMetricsMap.OCP_METRIC_CPU_CORE_USAGE_HOUR self.ocp_source_type = Provider.PROVIDER_OCP tiered_rates = [{ "value": round(Decimal(random.random()), 6), "unit": "USD", "usage": { "usage_start": None, "usage_end": None }, }] self.fake_data = { "name": "Test Cost Model", "description": "Test", "source_type": self.ocp_source_type, "provider_uuids": [self.provider.uuid], "rates": [{ "metric": { "name": self.ocp_metric }, "tiered_rates": tiered_rates }], } with tenant_context(self.tenant): serializer = CostModelSerializer(data=self.fake_data, context=request_context) if serializer.is_valid(raise_exception=True): serializer.save()
def test_unique_user(self): """Test that a user must be unique.""" # create the user serializer_1 = UserSerializer(data=self.user_data[0]) if serializer_1.is_valid(raise_exception=True): serializer_1.save() serializer_2 = UserSerializer(data=self.user_data[0]) with self.assertRaises(ValidationError): if serializer_2.is_valid(raise_exception=True): serializer_2.save()
def test_unique_user(self): """Test that a user must be unique.""" # create the user serializer_1 = UserSerializer(data=self.user_data[0]) if serializer_1.is_valid(raise_exception=True): serializer_1.save() duplicate_email = self.user_data[0] duplicate_email['username'] = '******' serializer_2 = UserSerializer(data=duplicate_email) with self.assertRaises(ValidationError): if serializer_2.is_valid(raise_exception=True): serializer_2.save()
def test_remove_not_removeable(self, _): """Test error raised if user without capability tries to remove a provider.""" # Create Provider credentials = {"role_arn": "arn:aws:iam::2:role/mg"} provider_authentication = ProviderAuthentication.objects.create(credentials=credentials) data_source = {"bucket": "my_s3_bucket"} provider_billing = ProviderBillingSource.objects.create(data_source=data_source) with patch("masu.celery.tasks.check_report_updates"): provider = Provider.objects.create( name="awsprovidername", created_by=self.user, customer=self.customer, authentication=provider_authentication, billing_source=provider_billing, ) provider_uuid = provider.uuid new_user_dict = self._create_user_data() request_context = self._create_request_context(self.customer_data, new_user_dict, False, create_user=False) user_serializer = UserSerializer(data=new_user_dict, context=request_context) other_user = None if user_serializer.is_valid(raise_exception=True): other_user = user_serializer.save() with tenant_context(self.tenant): manager = ProviderManager(provider_uuid) with self.assertRaises(ProviderManagerError): manager.remove(self._create_delete_request(other_user))
def setUp(self): """Set up the customer view tests.""" super().setUp() serializer = UserSerializer(data=self.user_data, context=self.request_context) if serializer.is_valid(raise_exception=True): serializer.save() self.test_cases = [{ 'value': '-1', 'unit': 'month', 'resolution': 'monthly' }, { 'value': '-2', 'unit': 'month', 'resolution': 'monthly' }, { 'value': '-10', 'unit': 'day', 'resolution': 'daily' }, { 'value': '-30', 'unit': 'day', 'resolution': 'daily' }]
def test_remove_users(self): """Remove users associated with a customer.""" # Create Customer customer = None serializer = CustomerSerializer(data=self.customer_data[0]) if serializer.is_valid(raise_exception=True): customer = serializer.save() customer_uuid = customer.uuid # Add another user group = Group.objects.get(name=customer.name) new_user_dict = self.gen_user_data() user_serializer = UserSerializer(data=new_user_dict) new_user = None if user_serializer.is_valid(raise_exception=True): new_user = user_serializer.save() group.user_set.add(new_user) manager = CustomerManager(customer_uuid) # Attempt to remove as customer owner with self.assertRaises(CustomerManagerPermissionError): manager.remove_users(customer.owner) # Attempt to remove as regular user with self.assertRaises(CustomerManagerPermissionError): manager.remove_users(new_user) # Attempt to remove as super user superuser = User.objects.filter(is_superuser=True).first() manager.remove_users(superuser) self.assertFalse(manager.get_users_for_customer())
def test_is_removable_by_user(self): """Can current user remove provider.""" # Create Customer customer = None serializer = CustomerSerializer(data=self.customer_data[0]) if serializer.is_valid(raise_exception=True): customer = serializer.save() # Create Provider provider = Provider.objects.create(name='providername', created_by=customer.owner, customer=customer) provider_uuid = provider.uuid # Create another user for negative tests # Add another user group = Group.objects.get(name=customer.name) new_user_dict = self.gen_user_data() user_serializer = UserSerializer(data=new_user_dict) new_user = None if user_serializer.is_valid(raise_exception=True): new_user = user_serializer.save() group.user_set.add(new_user) manager = ProviderManager(provider_uuid) self.assertTrue(manager.is_removable_by_user(customer.owner)) self.assertFalse(manager.is_removable_by_user(new_user)) superuser = User.objects.filter(is_superuser=True).first() self.assertFalse(manager.is_removable_by_user(superuser))
def test_remove(self): """Remove provider.""" # Create Customer customer = None serializer = CustomerSerializer(data=self.customer_data[0]) if serializer.is_valid(raise_exception=True): customer = serializer.save() # Create Provider provider = Provider.objects.create(name='providername', created_by=customer.owner, customer=customer) provider_uuid = provider.uuid # Create another user for negative tests # Add another user group = Group.objects.get(name=customer.name) new_user_dict = self.gen_user_data() user_serializer = UserSerializer(data=new_user_dict) other_user = None if user_serializer.is_valid(raise_exception=True): other_user = user_serializer.save() group.user_set.add(other_user) manager = ProviderManager(provider_uuid) with self.assertRaises(ProviderManagerError): self.assertFalse(manager.remove(other_user)) manager.remove(customer.owner) provider_query = Provider.objects.all().filter(uuid=provider_uuid) self.assertFalse(provider_query)
def test_user_preference_currency_invalid(self): """Test that we fail to create invalid preference.""" user = None serializer = UserSerializer(data=self.user_data) if serializer.is_valid(raise_exception=True): user = serializer.save() kwargs = {'context': {'user': user}} data = {'name': 'currency', 'description': self.fake.text(), 'preference': {'currency': 'LOL'}} with self.assertRaises(ValidationError): serializer = UserPreferenceSerializer(data=data, **kwargs) if serializer.is_valid(raise_exception=True): serializer.save()
def setUp(self): """Create test case objects.""" super().setUp() request = self.request_context["request"] serializer = UserSerializer(data=self.user_data, context=self.request_context) if serializer.is_valid(raise_exception=True): user = serializer.save() request.user = user self.generic_providers = { Provider.PROVIDER_OCP: { "name": "test_provider", "type": Provider.PROVIDER_OCP.lower(), "authentication": {"credentials": {"provider_resource_name": "my-ocp-cluster-1"}}, }, Provider.PROVIDER_AWS: { "name": "test_provider", "type": Provider.PROVIDER_AWS.lower(), "authentication": {"credentials": {"provider_resource_name": "arn:aws:s3:::my_s3_bucket"}}, "billing_source": {"data_source": {"bucket": "my_s3_bucket"}}, }, Provider.PROVIDER_AZURE: { "name": "test_provider", "type": Provider.PROVIDER_AZURE.lower(), "authentication": { "credentials": { "subscription_id": "12345678-1234-5678-1234-567812345678", "tenant_id": "12345678-1234-5678-1234-567812345678", "client_id": "12345678-1234-5678-1234-567812345678", "client_secret": "12345", } }, "billing_source": {"data_source": {"resource_group": {}, "storage_account": {}}}, }, }
def setUp(self): """Set up the customer view tests.""" super().setUp() serializer = UserSerializer(data=self.user_data, context=self.request_context) if serializer.is_valid(raise_exception=True): serializer.save()
def test_get_users_for_customer(self): """Can current user remove provider.""" # Create Customer customer = None serializer = CustomerSerializer(data=self.customer_data[0]) if serializer.is_valid(raise_exception=True): customer = serializer.save() customer_uuid = customer.uuid # Add another user group = Group.objects.get(name=customer.name) new_user_dict = self.gen_user_data() user_serializer = UserSerializer(data=new_user_dict) new_user = None if user_serializer.is_valid(raise_exception=True): new_user = user_serializer.save() group.user_set.add(new_user) manager = CustomerManager(customer_uuid) users = manager.get_users_for_customer() self.assertEqual(len(users), 2) new_user_found = False owner_found = False for found_user in users: if found_user.username == new_user_dict['username']: new_user_found = True elif found_user.username == customer.owner.username: owner_found = True self.assertTrue(new_user_found) self.assertTrue(owner_found)
def test_remove_aws(self): """Remove aws provider.""" # Create Provider provider_authentication = ProviderAuthentication.objects.create(provider_resource_name='arn:aws:iam::2:role/mg') provider_billing = ProviderBillingSource.objects.create(bucket='my_s3_bucket') provider = Provider.objects.create(name='awsprovidername', created_by=self.user, customer=self.customer, authentication=provider_authentication, billing_source=provider_billing) provider_uuid = provider.uuid new_user_dict = self._create_user_data() request_context = self._create_request_context(self.customer_data, new_user_dict, False) user_serializer = UserSerializer(data=new_user_dict, context=request_context) other_user = None if user_serializer.is_valid(raise_exception=True): other_user = user_serializer.save() with tenant_context(self.tenant): manager = ProviderManager(provider_uuid) manager.remove(self._create_delete_request(other_user)) provider_query = Provider.objects.all().filter(uuid=provider_uuid) auth_count = ProviderAuthentication.objects.count() billing_count = ProviderBillingSource.objects.count() self.assertFalse(provider_query) self.assertEqual(auth_count, 0) self.assertEqual(billing_count, 0)
def create_user(username, email, customer, request): """Create a user for a customer. Args: username (str): The username email (str): The email for the user customer (Customer): The customer the user is associated with request (object): The incoming request Returns: (User) The created user """ new_user = None try: with transaction.atomic(): user_data = {"username": username, "email": email} context = {"request": request, "customer": customer} serializer = UserSerializer(data=user_data, context=context) if serializer.is_valid(raise_exception=True): new_user = serializer.save() UNIQUE_USER_COUNTER.labels(account=customer.account_id, user=username).inc() LOG.info("Created new user %s for customer(account_id %s).", username, customer.account_id) except (IntegrityError, ValidationError): new_user = User.objects.get(username=username) return new_user
def setUp(self): """Set up the provider manager tests.""" super().setUp() self.customer = Customer.objects.get(account_id=self.customer_data["account_id"]) serializer = UserSerializer(data=self.user_data, context=self.request_context) if serializer.is_valid(raise_exception=True): self.user = serializer.save()
def _create_user(username, email, customer, request): """Create a user for a customer. Args: username (str): The username email (str): The email for the user customer (Customer): The customer the user is associated with request (object): The incoming request Returns: (User) The created user """ new_user = None try: with transaction.atomic(): user_data = {'username': username, 'email': email} context = {'request': request} serializer = UserSerializer(data=user_data, context=context) if serializer.is_valid(raise_exception=True): new_user = serializer.save() unique_user_counter.labels(account=customer.account_id, user=username).inc() logger.info('Created new user %s for customer(account_id %s).', username, customer.account_id) except (IntegrityError, ValidationError): new_user = User.objects.get(username=username) return new_user
def test_user_preference_timezone_invalid(self): """Test that we fail to create invalid preference.""" user = None serializer = UserSerializer(data=self.user_data, context=self.request_context) if serializer.is_valid(raise_exception=True): user = serializer.save() kwargs = {'context': {'user': user}} data = {'name': 'timezone', 'description': self.fake.text(), 'preference': {'timezone': 'Glapflap/Parblesnops'}} with self.assertRaises(ValidationError): serializer = UserPreferenceSerializer(data=data, **kwargs) if serializer.is_valid(raise_exception=True): serializer.save()
def setUp(self): """Create test case objects.""" super().setUp() request = self.request_context["request"] serializer = UserSerializer(data=self.user_data, context=self.request_context) if serializer.is_valid(raise_exception=True): user = serializer.save() request.user = user
def setUp(self): """Set up the customer view tests.""" super().setUp() self.data_generator = OCPReportDataGenerator(self.tenant) self.data_generator.add_data_to_tenant() serializer = UserSerializer(data=self.user_data, context=self.request_context) if serializer.is_valid(raise_exception=True): serializer.save()
def test_uuid_field(self): """Test that we generate a uuid.""" # create the user instance = None serializer = UserSerializer(data=self.user_data[0]) if serializer.is_valid(raise_exception=True): instance = serializer.save() self.assertIsInstance(instance.uuid, uuid.UUID)
def test_user_preference_arbitrary(self): """Test that we can set and retrieve an arbitrary preference.""" user = None serializer = UserSerializer(data=self.user_data) if serializer.is_valid(raise_exception=True): user = serializer.save() test_pref = {'foo': ['a', [1, 2, 3], {'b': 'c'}]} data = {'user': model_to_dict(user), 'preference': test_pref} serializer = UserPreferenceSerializer(data=data) if serializer.is_valid(raise_exception=True): serializer.save() query = UserPreference.objects.filter(user__exact=user) self.assertEqual(len(query), len(self.preference_defaults) + 1) prefs = [q.preference for q in query] self.assertIn(test_pref, prefs)
def setUp(self): """Set up middleware tests.""" super().setUp() request = self.request_context["request"] request.path = "/api/v1/providers/" serializer = UserSerializer(data=self.user_data, context=self.request_context) if serializer.is_valid(raise_exception=True): user = serializer.save() request.user = user