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 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 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 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_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_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,
'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.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 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 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_invalid_email(self):
"""Test that we only accept valid e-mail addresses."""
bad_email_user = {'username': '******',
'password': '******',
'email': 'this.is.not.an.email.address'}
serializer = UserSerializer(data=bad_email_user)
with self.assertRaises(ValidationError):
if serializer.is_valid(raise_exception=True):
serializer.save()
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.client = APIClient()
self.factory = RequestFactory()
self.dh = DateHelper()
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 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_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 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.generic_providers = {
'OCP': {
'name': 'test_provider',
'type': Provider.PROVIDER_OCP,
'authentication': {
'credentials': {
'provider_resource_name': 'my-ocp-cluster-1'
}
}
},
'AWS': {
'name': 'test_provider',
'type': Provider.PROVIDER_AWS,
'authentication': {
'credentials': {
'provider_resource_name': 'arn:aws:s3:::my_s3_bucket'
}
},
'billing_source': {
'data_source': {
'bucket': 'my_s3_bucket'
}
}
},
'AZURE': {
'name': 'test_provider',
'type': Provider.PROVIDER_AZURE,
'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 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 _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 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 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 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 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_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_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_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_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 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 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