def test_create_gcp_provider_validate_report_prefix_too_long(self):
"""Test the data_source.report_prefix validation for GCP provider."""
provider = {
"name": "test_provider_val_data_source",
"type": Provider.PROVIDER_GCP.lower(),
"authentication": {
"credentials": {
"project_id": "gcp_project"
}
},
"billing_source": {
"data_source": {
"dataset":
"test_dataset",
"table_id":
"test_table_id",
"report_prefix":
"an-unnecessarily-long-prefix-that-is-here-simply-for-the-purpose-of"
"testing-the-custom-validator-the-checks-for-too-long-of-a-report_prefix",
}
},
}
with self.assertRaises(ValidationError) as e:
serializer = ProviderSerializer(data=provider,
context=self.request_context)
serializer.is_valid(raise_exception=True)
self.assertEqual(e.exception.status_code, 400)
self.assertEqual(
str(e.exception.detail["billing_source"]["data_source"]
["data_source.report_prefix"][0]),
f"Ensure this field has no more than {REPORT_PREFIX_MAX_LENGTH} characters.",
)
def test_create_gcp_provider_validate_no_data_source_bucket(self):
"""Test the data_source.bucket validation for GCP provider."""
provider = {
"name": "test_provider_val_data_source",
"type": Provider.PROVIDER_GCP.lower(),
"authentication": {
"credentials": {
"project_id": "gcp_project"
}
},
"billing_source": {
"data_source": {
"potato": ""
}
},
}
with self.assertRaises(ValidationError) as e:
serializer = ProviderSerializer(data=provider,
context=self.request_context)
serializer.is_valid(raise_exception=True)
self.assertEqual(e.exception.status_code, 400)
self.assertEqual(
str(e.exception.detail["billing_source"]["data_source"]
["provider.data_source"][0]),
"One or more required fields is invalid/missing. Required fields are ['dataset']",
)
def test_update_with_duplication_error(self):
provider = self.generic_providers[Provider.PROVIDER_AWS]
provider2 = copy.deepcopy(provider)
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
serializer = ProviderSerializer(data=provider,
context=self.request_context)
if serializer.is_valid(raise_exception=True):
serializer.save() # add first provider
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
provider2["billing_source"] = {
"data_source": {
"bucket": "my_new_bucket"
}
}
serializer = ProviderSerializer(data=provider2,
context=self.request_context)
if serializer.is_valid(raise_exception=True):
serializer.save() # add second provider
serializer.validated_data["billing_source"] = provider.get(
"billing_source")
if serializer.is_valid(raise_exception=True):
with self.assertRaises(ValidationError) as excCtx:
serializer.update(serializer.instance,
serializer.validated_data
) # try to make second match first
validationErr = excCtx.exception.detail[
ProviderErrors.DUPLICATE_AUTH][0]
self.assertTrue("Cost management does not allow duplicate accounts"
in str(validationErr))
def test_missing_source_parameters_exception(self):
"""Test that ValidationError is raised when there are missing parameters."""
fields = ["resource_group", "storage_account"]
credentials = {
"subscription_id": FAKE.uuid4(),
"tenant_id": FAKE.uuid4(),
"client_id": FAKE.uuid4(),
"client_secret": FAKE.word(),
}
source_name = {
"resource_group": FAKE.word(),
"storage_account": FAKE.word()
}
del source_name[random.choice(fields)]
provider = {
"name": FAKE.word(),
"type": Provider.PROVIDER_AZURE.lower(),
"authentication": credentials,
"billing_source": {
"data_source": source_name
},
}
with self.assertRaises(ValidationError):
serializer = ProviderSerializer(data=provider,
context=self.request_context)
serializer.is_valid(raise_exception=True)
def test_create_gcp_provider_duplicate_bucket(self):
"""Test that the same blank billing entry is used for all OCP providers."""
provider = {
'name': 'test_provider_one',
'type': Provider.PROVIDER_GCP,
'authentication': {
'credentials': {
'project_id': 'gcp_project'
}
},
'billing_source': {
'data_source': {
'bucket': 'test_bucket',
}
}
}
with patch.object(ProviderAccessor,
'cost_usage_source_ready',
returns=True):
serializer = ProviderSerializer(data=provider,
context=self.request_context)
if serializer.is_valid(raise_exception=True):
serializer.save()
with self.assertRaises(ValidationError):
serializer = ProviderSerializer(data=provider,
context=self.request_context)
if serializer.is_valid(raise_exception=True):
serializer.save()
def test_missing_source_parameters_exception(self):
"""Test that ValidationError is raised when there are missing parameters."""
fields = ['resource_group', 'storage_account']
credentials = {
'subscription_id': FAKE.uuid4(),
'tenant_id': FAKE.uuid4(),
'client_id': FAKE.uuid4(),
'client_secret': FAKE.word()
}
source_name = {
'resource_group': FAKE.word(),
'storage_account': FAKE.word()
}
del source_name[random.choice(fields)]
provider = {
'name': FAKE.word(),
'type': Provider.PROVIDER_AZURE,
'authentication': credentials,
'billing_source': {
'data_source': source_name
}
}
with self.assertRaises(ValidationError):
serializer = ProviderSerializer(data=provider,
context=self.request_context)
serializer.is_valid(raise_exception=True)
def initialize_request(self, context=None):
"""Initialize model data."""
if context:
request_context = context.get("request_context")
else:
request_context = self.request_context
provider_data = {
"name": "test_provider",
"type": Provider.PROVIDER_OCP.lower(),
"authentication": {
"credentials": {
"cluster_id": self.fake.word()
}
},
"billing_source": {},
}
serializer = ProviderSerializer(data=provider_data,
context=request_context)
if serializer.is_valid(raise_exception=True):
self.provider = serializer.save()
self.ocp_metric = metric_constants.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,
"source_uuids": [self.provider.uuid],
"rates": [{
"metric": {
"name": self.ocp_metric
},
"cost_type": "Infrastructure",
"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):
with patch("cost_models.cost_model_manager.chain"):
instance = serializer.save()
self.fake_data_cost_model_uuid = instance.uuid
def test_error_update_provider_with_used_auth_or_billing_source(self):
p1 = {
"name": "test_provider_1",
"type": Provider.PROVIDER_OCP.lower(),
"authentication": {
"credentials": {
"cluster_id": "my-ocp-cluster-1"
}
},
"billing_source": {},
}
p2 = {
"name": "test_provider_2",
"type": Provider.PROVIDER_OCP.lower(),
"authentication": {
"credentials": {
"cluster_id": "my-ocp-cluster-2"
}
},
"billing_source": {},
}
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
serializer = ProviderSerializer(data=p1,
context=self.request_context)
if serializer.is_valid(raise_exception=True):
serializer.save()
serializer = ProviderSerializer(data=p2,
context=self.request_context)
if serializer.is_valid(raise_exception=True):
instance = serializer.save()
d = {
"name": "test_provider_2",
"type": Provider.PROVIDER_OCP.lower(),
"authentication": {
"credentials": {
"cluster_id": "my-ocp-cluster-1"
}
},
"billing_source": {},
}
with self.assertRaises(ValidationError) as excCtx:
serializer = ProviderSerializer(
instance, data=d, context=self.request_context)
if serializer.is_valid(raise_exception=True):
serializer.save()
validationErr = excCtx.exception.detail[
ProviderErrors.DUPLICATE_AUTH][0]
self.assertTrue(
"Cost management does not allow duplicate accounts" in str(
validationErr))
def test_error_providers_with_same_auth_or_billing_source(self):
"""Test that the errors are wrapped correctly."""
provider = self.generic_providers[Provider.PROVIDER_OCP]
with patch.object(ProviderAccessor, "cost_usage_source_ready", returns=True):
serializer = ProviderSerializer(data=provider, context=self.request_context)
if serializer.is_valid(raise_exception=True):
serializer.save()
with self.assertRaises(ValidationError) as excCtx:
serializer = ProviderSerializer(data=provider, context=self.request_context)
if serializer.is_valid(raise_exception=True):
serializer.save()
validationErr = excCtx.exception.detail[ProviderErrors.DUPLICATE_AUTH][0]
self.assertTrue("Cost management does not allow duplicate accounts" in str(validationErr))
def test_create_all_providers(self):
"""Tests that adding all unique providers together is successful."""
list_of_uuids = []
initial_date_updated = self.customer.date_updated
self.assertIsNotNone(initial_date_updated)
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):
instance = serializer.save()
schema_name = serializer.data["customer"].get("schema_name")
self.assertIsInstance(instance.uuid, uuid.UUID)
self.assertIsNone(schema_name)
self.assertFalse("schema_name" in serializer.data["customer"])
list_of_uuids.append(instance.uuid)
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
serializer = ProviderSerializer(
data=self.generic_providers[Provider.PROVIDER_AWS],
context=self.request_context)
if serializer.is_valid(raise_exception=True):
instance = serializer.save()
schema_name = serializer.data["customer"].get("schema_name")
self.assertIsInstance(instance.uuid, uuid.UUID)
self.assertIsNone(schema_name)
self.assertFalse("schema_name" in serializer.data["customer"])
list_of_uuids.append(instance.uuid)
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
serializer = ProviderSerializer(
data=self.generic_providers[Provider.PROVIDER_OCP],
context=self.request_context)
if serializer.is_valid(raise_exception=True):
instance = serializer.save()
schema_name = serializer.data["customer"].get("schema_name")
self.assertIsInstance(instance.uuid, uuid.UUID)
self.assertIsNone(schema_name)
self.assertFalse("schema_name" in serializer.data["customer"])
list_of_uuids.append(instance.uuid)
for a, b in permutations(list_of_uuids, 2):
self.assertNotEqual(a, b)
self.assertGreater(self.customer.date_updated, initial_date_updated)
def test_create_provider_with_bucket_and_data_source(self):
"""Test creating a provider with data_source and bucket fields should fail."""
bucket_name = "my_s3_bucket"
provider = {
"name": "test_provider",
"type": Provider.PROVIDER_AWS.lower(),
"authentication": {
"credentials": {
"role_arn": "four"
}
},
"billing_source": {
"data_source": {
"bucket": "bar"
},
"bucket": bucket_name
},
}
user_data = self._create_user_data()
alt_request_context = self._create_request_context(
self.create_mock_customer_data(), user_data, create_tenant=True)
request = alt_request_context["request"]
request.user.customer = None
serializer = ProviderSerializer(data=provider,
context=alt_request_context)
if serializer.is_valid(raise_exception=True):
with self.assertRaises(serializers.ValidationError):
serializer.save()
def test_create_provider_with_credentials_and_data_source(self):
"""Test creating a provider with data_source field instead of bucket."""
provider = {
"name": "test_provider",
"type": Provider.PROVIDER_AWS.lower(),
"authentication": {
"credentials": {
"role_arn": "four"
}
},
"billing_source": {
"data_source": {
"bucket": "bar"
}
},
}
instance = None
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
serializer = ProviderSerializer(data=provider,
context=self.request_context)
if serializer.is_valid(raise_exception=True):
instance = serializer.save()
schema_name = serializer.data["customer"].get("schema_name")
self.assertIsInstance(instance.uuid, uuid.UUID)
self.assertTrue(instance.active)
self.assertIsNone(schema_name)
self.assertFalse("schema_name" in serializer.data["customer"])
def test_create_provider_with_credentials_and_provider_resource_name(self):
"""Test creating a provider with credentials and provider_resource_name fields should fail."""
iam_arn = 'arn:aws:s3:::my_s3_bucket'
provider = {
'name': 'test_provider',
'type': Provider.PROVIDER_AWS.lower(),
'authentication': {
'credentials': {
'one': 'two',
'three': 'four'
},
'provider_resource_name': iam_arn
},
'billing_source': {
'data_source': {
'foo': 'bar'
}
}
}
request = self.request_context['request']
request.user.customer = None
serializer = ProviderSerializer(data=provider,
context=self.request_context)
if serializer.is_valid(raise_exception=True):
with self.assertRaises(serializers.ValidationError):
serializer.save()
def test_create_provider_fails_customer(self):
"""Test creating a provider where customer is not found for user."""
provider = {
"name": "test_provider",
"type": Provider.PROVIDER_AWS.lower(),
"authentication": {
"credentials": {
"role_arn": "arn:aws:s3:::my_s3_bucket"
}
},
"billing_source": {
"data_source": {
"bucket": "my_s3_bucket"
}
},
}
user_data = self._create_user_data()
alt_request_context = self._create_request_context(
self.create_mock_customer_data(), user_data, create_tenant=True)
request = alt_request_context["request"]
request.user.customer = None
serializer = ProviderSerializer(data=provider,
context=alt_request_context)
if serializer.is_valid(raise_exception=True):
with self.assertRaises(serializers.ValidationError):
serializer.save()
def test_create_provider_for_demo_account(self):
"""Test creating a provider for a demo account."""
provider = {
"name": "test_provider",
"type": Provider.PROVIDER_AWS.lower(),
"authentication": {
"credentials": {
"one": "two",
"three": "four"
}
},
"billing_source": {
"data_source": {
"foo": "bar"
}
},
}
instance = None
account_id = self.customer_data.get("account_id")
with self.settings(DEMO_ACCOUNTS={account_id: {}}):
with patch.object(ProviderAccessor,
"cost_usage_source_ready") as mock_method:
serializer = ProviderSerializer(data=provider,
context=self.request_context)
if serializer.is_valid(raise_exception=True):
instance = serializer.save()
mock_method.assert_not_called()
schema_name = serializer.data["customer"].get("schema_name")
self.assertIsInstance(instance.uuid, uuid.UUID)
self.assertTrue(instance.active)
self.assertIsNone(schema_name)
self.assertFalse("schema_name" in serializer.data["customer"])
def test_create_provider_with_credentials_and_provider_resource_name(self):
"""Test creating a provider with credentials and provider_resource_name fields should fail."""
iam_arn = "arn:aws:s3:::my_s3_bucket"
provider = {
"name": "test_provider",
"type": Provider.PROVIDER_AWS.lower(),
"authentication": {
"credentials": {
"one": "two",
"three": "four"
},
"provider_resource_name": iam_arn
},
"billing_source": {
"data_source": {
"foo": "bar"
}
},
}
user_data = self._create_user_data()
alt_request_context = self._create_request_context(
self.create_mock_customer_data(), user_data, create_tenant=True)
request = alt_request_context["request"]
request.user.customer = None
serializer = ProviderSerializer(data=provider,
context=alt_request_context)
if serializer.is_valid(raise_exception=True):
with self.assertRaises(serializers.ValidationError):
serializer.save()
def test_create_aws_provider(self):
"""Test creating a provider."""
iam_arn = "arn:aws:s3:::my_s3_bucket"
bucket_name = "my_s3_bucket"
provider = {
"name": "test_provider",
"type": Provider.PROVIDER_AWS.lower(),
"authentication": {
"provider_resource_name": iam_arn
},
"billing_source": {
"bucket": bucket_name
},
}
instance = None
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
serializer = ProviderSerializer(data=provider,
context=self.request_context)
if serializer.is_valid(raise_exception=True):
instance = serializer.save()
schema_name = serializer.data["customer"].get("schema_name")
self.assertIsInstance(instance.uuid, uuid.UUID)
self.assertTrue(instance.active)
self.assertIsNone(schema_name)
self.assertFalse("schema_name" in serializer.data["customer"])
def test_create_gcp_provider(self):
"""Test that the same blank billing entry is used for all OCP providers."""
provider = {
"name": "test_provider_one",
"type": Provider.PROVIDER_GCP.lower(),
"authentication": {
"credentials": {
"project_id": "gcp_project"
}
},
"billing_source": {
"data_source": {
"dataset": "test_dataset",
"table_id": "test_table_id",
"report_prefix": "precious"
}
},
}
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
serializer = ProviderSerializer(data=provider,
context=self.request_context)
if serializer.is_valid(raise_exception=True):
instance = serializer.save()
schema_name = serializer.data["customer"].get("schema_name")
self.assertIsInstance(instance.uuid, uuid.UUID)
self.assertTrue(instance.active)
self.assertIsNone(schema_name)
self.assertFalse("schema_name" in serializer.data["customer"])
def create_provider(self,
name,
provider_type,
authentication,
billing_source,
source_uuid=None):
"""Call to create provider."""
connection.set_schema_to_public()
context, customer, user = self._create_context()
tenant = Tenant.objects.get(schema_name=customer.schema_name)
json_data = {
"name":
name,
"type":
provider_type.lower(),
"authentication":
self.get_authentication_for_provider(provider_type,
authentication),
"billing_source":
self.get_billing_source_for_provider(provider_type,
billing_source),
}
if source_uuid:
json_data["uuid"] = str(source_uuid)
connection.set_tenant(tenant)
serializer = ProviderSerializer(data=json_data, context=context)
if serializer.is_valid(raise_exception=True):
instance = serializer.save()
connection.set_schema_to_public()
return instance
def create_provider_from_source(self, source):
"""Call to create provider."""
connection.set_schema_to_public()
context, customer, _ = self._create_context()
tenant = Tenant.objects.get(schema_name=customer.schema_name)
provider_type = source.source_type
json_data = {
"name":
source.name,
"type":
provider_type.lower(),
"authentication":
self._build_credentials_auth(source.authentication),
"billing_source":
self.get_billing_source_for_provider(provider_type,
source.billing_source),
}
if source.source_uuid:
json_data["uuid"] = str(source.source_uuid)
connection.set_tenant(tenant)
serializer = ProviderSerializer(data=json_data, context=context)
try:
if serializer.is_valid(raise_exception=True):
instance = serializer.save()
except ValidationError as error:
connection.set_schema_to_public()
raise error
connection.set_schema_to_public()
return instance
def test_create_ocp_provider(self):
"""Test creating an OCP provider."""
cluster_id = "my-ocp-cluster-1"
provider = {
"name": "test_provider",
"type": Provider.PROVIDER_OCP.lower(),
"authentication": {
"credentials": {
"cluster_id": cluster_id
}
},
"billing_source": {},
}
instance = None
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
serializer = ProviderSerializer(data=provider,
context=self.request_context)
if serializer.is_valid(raise_exception=True):
instance = serializer.save()
schema_name = serializer.data["customer"].get("schema_name")
self.assertIsInstance(instance.uuid, uuid.UUID)
self.assertTrue(instance.active)
self.assertIsNone(schema_name)
self.assertFalse("schema_name" in serializer.data["customer"])
def test_create_provider_with_bucket_and_data_source(self):
"""Test creating a provider with data_source and bucket fields should fail."""
bucket_name = 'my_s3_bucket'
provider = {
'name': 'test_provider',
'type': Provider.PROVIDER_AWS,
'authentication': {
'credentials': {
'one': 'two',
'three': 'four'
}
},
'billing_source': {
'data_source': {
'foo': 'bar'
},
'bucket': bucket_name
}
}
request = self.request_context['request']
request.user.customer = None
serializer = ProviderSerializer(data=provider,
context=self.request_context)
if serializer.is_valid(raise_exception=True):
with self.assertRaises(serializers.ValidationError):
serializer.save()
def test_create_gcp_provider(self):
"""Test that the same blank billing entry is used for all OCP providers."""
provider = {
'name': 'test_provider_one',
'type': Provider.PROVIDER_GCP,
'authentication': {
'credentials': {
'project_id': 'gcp_project'
}
},
'billing_source': {
'data_source': {
'bucket': 'test_bucket',
'report_prefix': 'precious'
}
}
}
with patch.object(ProviderAccessor,
'cost_usage_source_ready',
returns=True):
serializer = ProviderSerializer(data=provider,
context=self.request_context)
if serializer.is_valid(raise_exception=True):
instance = serializer.save()
schema_name = serializer.data['customer'].get('schema_name')
self.assertIsInstance(instance.uuid, uuid.UUID)
self.assertTrue(instance.active)
self.assertIsNone(schema_name)
self.assertFalse('schema_name' in serializer.data['customer'])
def test_create_ocp_provider(self):
"""Test creating an OCP provider."""
cluster_id = 'my-ocp-cluster-1'
provider = {
'name': 'test_provider',
'type': Provider.PROVIDER_OCP,
'authentication': {
'provider_resource_name': cluster_id
}
}
instance = None
with patch.object(ProviderAccessor,
'cost_usage_source_ready',
returns=True):
serializer = ProviderSerializer(data=provider,
context=self.request_context)
if serializer.is_valid(raise_exception=True):
instance = serializer.save()
schema_name = serializer.data['customer'].get('schema_name')
self.assertIsInstance(instance.uuid, uuid.UUID)
self.assertTrue(instance.active)
self.assertIsNone(schema_name)
self.assertFalse('schema_name' in serializer.data['customer'])
def test_create_provider_with_credentials_and_data_source(self):
"""Test creating a provider with data_source field instead of bucket."""
provider = {
'name': 'test_provider',
'type': Provider.PROVIDER_AWS,
'authentication': {
'credentials': {
'one': 'two',
'three': 'four'
}
},
'billing_source': {
'data_source': {
'foo': 'bar'
}
}
}
instance = None
with patch.object(ProviderAccessor,
'cost_usage_source_ready',
returns=True):
serializer = ProviderSerializer(data=provider,
context=self.request_context)
if serializer.is_valid(raise_exception=True):
instance = serializer.save()
schema_name = serializer.data['customer'].get('schema_name')
self.assertIsInstance(instance.uuid, uuid.UUID)
self.assertTrue(instance.active)
self.assertIsNone(schema_name)
self.assertFalse('schema_name' in serializer.data['customer'])
def test_create_aws_provider(self):
"""Test creating a provider."""
iam_arn = 'arn:aws:s3:::my_s3_bucket'
bucket_name = 'my_s3_bucket'
provider = {
'name': 'test_provider',
'type': Provider.PROVIDER_AWS,
'authentication': {
'provider_resource_name': iam_arn
},
'billing_source': {
'bucket': bucket_name
}
}
instance = None
with patch.object(ProviderAccessor,
'cost_usage_source_ready',
returns=True):
serializer = ProviderSerializer(data=provider,
context=self.request_context)
if serializer.is_valid(raise_exception=True):
instance = serializer.save()
schema_name = serializer.data['customer'].get('schema_name')
self.assertIsInstance(instance.uuid, uuid.UUID)
self.assertTrue(instance.active)
self.assertIsNone(schema_name)
self.assertFalse('schema_name' in serializer.data['customer'])
def test_create_provider_invalid_type(self):
"""Test that an invalid provider type is not validated."""
iam_arn = "arn:aws:s3:::my_s3_bucket"
bucket_name = "my_s3_bucket"
provider = {
"name": "test_provider",
"type": "Bad",
"authentication": {
"credentials": {
"role_arn": iam_arn
}
},
"billing_source": {
"data_source": {
"bucket": bucket_name
}
},
}
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
with self.assertRaises(ValidationError):
serializer = ProviderSerializer(data=provider,
context=self.request_context)
if serializer.is_valid(raise_exception=True):
serializer.save()
def test_create_ibm_provider(self):
"""Test that the same blank billing entry is used for all OCP providers."""
provider = {
"name": "test_provider_ibm",
"type": Provider.PROVIDER_IBM.lower(),
"authentication": {
"credentials": {
"iam_token": "1111-1111-1111-1111"
}
},
"billing_source": {
"data_source": {
"enterprise_id": "2222-2222-2222-2222"
}
},
}
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
serializer = ProviderSerializer(data=provider,
context=self.request_context)
if serializer.is_valid(raise_exception=True):
instance = serializer.save()
schema_name = serializer.data["customer"].get("schema_name")
self.assertIsInstance(instance.uuid, uuid.UUID)
self.assertTrue(instance.active)
self.assertIsNone(schema_name)
self.assertFalse("schema_name" in serializer.data["customer"])
def test_create_gcp_provider_duplicate_bucket(self):
"""Test that the same blank billing entry is used for all OCP providers."""
provider = {
"name": "test_provider_one",
"type": Provider.PROVIDER_GCP.lower(),
"authentication": {"credentials": {"project_id": "gcp_project"}},
"billing_source": {"data_source": {"bucket": "test_bucket"}},
}
with patch.object(ProviderAccessor, "cost_usage_source_ready", returns=True):
serializer = ProviderSerializer(data=provider, context=self.request_context)
if serializer.is_valid(raise_exception=True):
serializer.save()
with self.assertRaises(ValidationError):
serializer = ProviderSerializer(data=provider, context=self.request_context)
if serializer.is_valid(raise_exception=True):
serializer.save()
def test_create_ocp_source_with_existing_provider(self):
"""Test creating an OCP Source when the provider already exists."""
cluster_id = "my-ocp-cluster-1"
provider = {
"name": "test_provider",
"type": Provider.PROVIDER_OCP.lower(),
"authentication": {
"credentials": {
"cluster_id": cluster_id
}
},
"billing_source": {},
}
instance = None
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
serializer = ProviderSerializer(data=provider,
context=self.request_context)
if serializer.is_valid(raise_exception=True):
instance = serializer.save()
schema_name = serializer.data["customer"].get("schema_name")
self.assertIsInstance(instance.uuid, uuid.UUID)
self.assertTrue(instance.active)
self.assertIsNone(schema_name)
self.assertFalse("schema_name" in serializer.data["customer"])
# Add Source without provider uuid
sources = Sources.objects.create(
source_id=1,
auth_header="testheader",
offset=1,
authentication={"cluster_id": cluster_id})
sources.save()
# Verify ValidationError is raised when another source is added with an existing
# provider.
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
serializer = ProviderSerializer(data=provider,
context=self.request_context)
if serializer.is_valid(raise_exception=True):
with self.assertRaises(serializers.ValidationError):
serializer.save()
