def test_get_billing_source_for_provider_error(self):
"""Test to build Koku Provider billing_source json obj with errors."""
test_matrix = [
{
"provider_type": Provider.PROVIDER_AWS,
"billing_source": {
"data_source": "test-bucket"
},
"expected_response": ProviderBuilderError,
},
{
"provider_type": Provider.PROVIDER_AZURE,
"billing_source": {
"bucket": {
"foo": "bar"
}
},
"expected_response": ProviderBuilderError,
},
]
client = ProviderBuilder(auth_header=Config.SOURCES_FAKE_HEADER)
for test in test_matrix:
with self.assertRaises(test.get("expected_response")):
client.get_billing_source_for_provider(
test.get("provider_type"), test.get("billing_source"))
def test__build_credentials_auth_errors(self):
"""Test to build Koku Provider authentication json obj with errors."""
test_matrix = [
{
"provider_type": Provider.PROVIDER_AWS,
"authentication": {
"credentialz": {
"role_arn": "arn:fake"
}
},
"expected_response": ProviderBuilderError,
},
{
"provider_type": Provider.PROVIDER_OCP,
"authentication": {
"credentialz": "test-cluster-id"
},
"expected_response": ProviderBuilderError,
},
{
"provider_type": Provider.PROVIDER_AZURE,
"authentication": {
"credentialz": {
"foo": "bar"
}
},
"expected_response": ProviderBuilderError,
},
]
client = ProviderBuilder(auth_header=Config.SOURCES_FAKE_HEADER)
for test in test_matrix:
with self.assertRaises(test.get("expected_response")):
client._build_credentials_auth(test.get("authentication"))
def test_create_provider_exceptions(self):
"""Test to create a provider with a non-recoverable error."""
client = ProviderBuilder(auth_header=Config.SOURCES_FAKE_HEADER)
with self.assertRaises(ValidationError):
source_uuid = faker.uuid4()
client.create_provider(self.name, self.provider_type,
self.authentication, self.billing_source,
source_uuid)
def test_create_provider_with_source_uuid(self):
"""Test to create a provider with source uuid ."""
client = ProviderBuilder(auth_header=Config.SOURCES_FAKE_HEADER)
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
provider = client.create_provider_from_source(self.mock_source)
self.assertEqual(provider.name, self.name)
self.assertEqual(str(provider.uuid), self.source_uuid)
def test_update_provider_exception(self):
"""Test to update a provider with a connection error."""
client = ProviderBuilder(auth_header=Config.SOURCES_FAKE_HEADER)
expected_uuid = faker.uuid4()
with self.assertRaises(Provider.DoesNotExist):
client.update_provider(expected_uuid, "Aws Test",
Provider.PROVIDER_AWS,
{"resource_name": "arn:test"},
{"bucket": "bucket"})
def test_create_provider(self):
"""Test to create a provider."""
client = ProviderBuilder(auth_header=Config.SOURCES_FAKE_HEADER)
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
provider = client.create_provider(self.name, self.provider_type,
self.authentication,
self.billing_source)
self.assertEqual(provider.name, self.name)
def test_create_provider_no_tenant(self):
"""Test to create a provider after tenant was removed."""
client = ProviderBuilder(auth_header=Config.SOURCES_FAKE_HEADER)
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
mock_source = MockSourceObject(self.name, self.provider_type,
self.authentication,
self.billing_source)
provider = client.create_provider_from_source(mock_source)
self.assertEqual(provider.name, self.name)
def create(self, validated_data):
"""Create a source from validated data."""
auth_header = get_auth_header(self.context.get("request"))
manager = ProviderBuilder(auth_header)
validated_data["auth_header"] = auth_header
source = Sources.objects.create(**validated_data)
provider = manager.create_provider_from_source(source)
source.koku_uuid = provider.uuid
source.save()
LOG.info("Admin created Source and Provider.")
return source
def test_destroy_provider(self):
"""Test to destroy a provider."""
client = ProviderBuilder(auth_header=Config.SOURCES_FAKE_HEADER)
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
provider = client.create_provider_from_source(self.mock_source)
self.assertEqual(provider.name, self.name)
self.assertEqual(str(provider.uuid), self.source_uuid)
client.destroy_provider(self.source_uuid)
with self.assertRaises(Provider.DoesNotExist):
Provider.objects.get(uuid=self.source_uuid)
def test_destroy_provider_exception(self):
"""Test to destroy a provider with a connection error."""
client = ProviderBuilder(auth_header=Config.SOURCES_FAKE_HEADER)
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
provider = client.create_provider_from_source(self.mock_source)
self.assertEqual(provider.name, self.name)
self.assertEqual(str(provider.uuid), self.source_uuid)
logging.disable(logging.NOTSET)
with self.assertLogs(logger="api.provider.provider_builder",
level=logging.INFO):
client.destroy_provider(faker.uuid4())
def test_update_provider(self):
"""Test to update a provider."""
client = ProviderBuilder(auth_header=Config.SOURCES_FAKE_HEADER)
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
provider = client.create_provider_from_source(self.mock_source)
new_name = "Aws Test"
self.mock_source.name = new_name
updated_provider = client.update_provider_from_source(
self.mock_source)
self.assertEqual(updated_provider.uuid, provider.uuid)
self.assertEqual(updated_provider.name, new_name)
def test_update_provider_pause(self):
"""Test to update a provider for pause/unpause."""
client = ProviderBuilder(auth_header=Config.SOURCES_FAKE_HEADER)
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
provider = client.create_provider_from_source(self.mock_source)
self.assertFalse(provider.paused)
for test in [True, False]:
with self.subTest(paused=test):
self.mock_source.paused = test
updated_provider = client.update_provider_from_source(
self.mock_source)
self.assertEqual(updated_provider.paused, test)
def create(self, validated_data):
"""Create a source from validated data."""
auth_header = get_auth_header(self.context.get("request"))
manager = ProviderBuilder(auth_header)
validated_data["auth_header"] = auth_header
source = Sources.objects.create(**validated_data)
try:
provider = manager.create_provider_from_source(source)
except SkipStatusPush:
raise serializers.ValidationError("GCP billing table not ready")
source.koku_uuid = provider.uuid
source.save()
LOG.info("Admin created Source and Provider.")
return source
def test_create_provider(self):
"""Test to create a provider."""
# Delete tenants
Tenant.objects.filter(schema_name="acct12345").delete(
) # filtering avoids migrating the template0 again
client = ProviderBuilder(auth_header=Config.SOURCES_FAKE_HEADER)
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
mock_source = MockSourceObject(self.name, self.provider_type,
self.authentication,
self.billing_source)
provider = client.create_provider_from_source(mock_source)
self.assertEqual(provider.name, self.name)
def test_update_provider(self):
"""Test to update a provider."""
client = ProviderBuilder(auth_header=Config.SOURCES_FAKE_HEADER)
source_uuid = faker.uuid4()
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
provider = client.create_provider(self.name, self.provider_type,
self.authentication,
self.billing_source, source_uuid)
new_name = "Aws Test"
updated_provider = client.update_provider(
source_uuid, new_name, Provider.PROVIDER_AWS,
{"resource_name": "arn:test"}, {"bucket": "bucket"})
self.assertEqual(updated_provider.uuid, provider.uuid)
self.assertEqual(updated_provider.name, new_name)
def destroy(self, request, *args, **kwargs):
"""Delete a source."""
source = self.get_object()
manager = ProviderBuilder(request.user.identity_header.get("encoded"))
for _ in range(5):
try:
manager.destroy_provider(source.koku_uuid)
except IntegrityError as error:
LOG.warning(f"Retrying Source delete due to error: {error}")
except Exception as error: # catch everything else. return immediately
msg = f"Source removal resulted in UNKNOWN error: {type(error).__name__}: {error}"
LOG.error(msg)
return Response(msg, status=500)
else:
return super().destroy(request, *args, **kwargs)
LOG.error("Failed to remove Source")
return Response("Failed to remove Source", status=500)
def test_create_provider_ocp_cluster_register(self):
"""Test to create an OCP provider with a System identity."""
# Delete tenants
Tenant.objects.all().delete()
client = ProviderBuilder(
auth_header=Config.SOURCES_FAKE_CLUSTER_HEADER)
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
mock_source_auth = {
"credentials": {
"cluster_id": "0bb29135-d6d1-478b-b5b6-6bd129cb6d5d1001"
}
}
mock_source = MockSourceObject(self.name, Provider.PROVIDER_OCP,
mock_source_auth, None)
provider = client.create_provider_from_source(mock_source)
self.assertEqual(provider.name, self.name)
class SourcesProviderCoordinator:
"""Coordinator to control source and provider operations."""
def __init__(self, source_id, auth_header):
"""Initialize the client."""
header = {"x-rh-identity": auth_header, "sources-client": "True"}
self._source_id = source_id
self._identity_header = header
self._provider_builder = ProviderBuilder(self._identity_header)
def create_account(self,
name,
provider_type,
authentication,
billing_source,
source_uuid=None):
"""Call to create provider."""
try:
provider = self._provider_builder.create_provider(
name, provider_type, authentication, billing_source,
source_uuid)
add_provider_koku_uuid(self._source_id, provider.uuid)
except ProviderBuilderError as provider_err:
raise SourcesProviderCoordinatorError(str(provider_err))
return provider
def update_account(self, provider_uuid, name, provider_type,
authentication, billing_source):
"""Call to update provider."""
try:
provider = self._provider_builder.update_provider(
provider_uuid, name, provider_type, authentication,
billing_source)
clear_update_flag(self._source_id)
except ProviderBuilderError as provider_err:
raise SourcesProviderCoordinatorError(str(provider_err))
return provider
def destroy_account(self, provider_uuid):
"""Call to destroy provider."""
try:
self._provider_builder.destroy_provider(provider_uuid)
destroy_source_event(self._source_id)
except ProviderBuilderError as provider_err:
LOG.error(f"Failed to remove provider. Error: {str(provider_err)}")
def test_get_billing_source_for_provider(self):
"""Test to build Koku Provider billing_source json obj."""
test_matrix = [
{
"provider_type": Provider.PROVIDER_AWS,
"billing_source": {
"data_source": {
"bucket": "test-bucket"
}
},
"expected_response": {
"data_source": {
"bucket": "test-bucket"
}
},
},
{
"provider_type": Provider.PROVIDER_OCP,
"billing_source": {},
"expected_response": {}
},
{
"provider_type": Provider.PROVIDER_AZURE,
"billing_source": {
"data_source": {
"foo": "bar"
}
},
"expected_response": {
"data_source": {
"foo": "bar"
}
},
},
]
client = ProviderBuilder(auth_header=Config.SOURCES_FAKE_HEADER)
for test in test_matrix:
with self.subTest(test=test):
response = client.get_billing_source_for_provider(
test.get("provider_type"), test.get("billing_source"))
self.assertEqual(response, test.get("expected_response"))
def test_get_authentication_for_provider(self):
"""Test to build Koku Provider authentication json obj."""
test_matrix = [
{
"provider_type": Provider.PROVIDER_AWS,
"authentication": {
"resource_name": "arn:fake"
},
"expected_response": {
"provider_resource_name": "arn:fake"
},
},
{
"provider_type": Provider.PROVIDER_OCP,
"authentication": {
"resource_name": "test-cluster-id"
},
"expected_response": {
"provider_resource_name": "test-cluster-id"
},
},
{
"provider_type": Provider.PROVIDER_AZURE,
"authentication": {
"credentials": {
"foo": "bar"
}
},
"expected_response": {
"credentials": {
"foo": "bar"
}
},
},
]
client = ProviderBuilder(auth_header=Config.SOURCES_FAKE_HEADER)
for test in test_matrix:
response = client.get_authentication_for_provider(
test.get("provider_type"), test.get("authentication"))
self.assertEqual(response, test.get("expected_response"))
class SourcesProviderCoordinator:
"""Coordinator to control source and provider operations."""
def __init__(self, source_id, auth_header):
"""Initialize the client."""
header = {"x-rh-identity": auth_header, "sources-client": "True"}
self._source_id = source_id
self._identity_header = header
self._provider_builder = ProviderBuilder(self._identity_header)
def create_account(self, source):
"""Call to create provider."""
try:
LOG.info(
f"Creating Provider for Source ID: {str(self._source_id)}")
provider = self._provider_builder.create_provider_from_source(
source)
add_provider_koku_uuid(self._source_id, provider.uuid)
except ProviderBuilderError as provider_err:
raise SourcesProviderCoordinatorError(str(provider_err))
return provider
def update_account(self, source):
"""Call to update provider."""
try:
LOG.info(
f"Updating Provider for Source ID: {str(self._source_id)}")
provider = self._provider_builder.update_provider_from_source(
source)
except ProviderBuilderError as provider_err:
raise SourcesProviderCoordinatorError(str(provider_err))
return provider
def destroy_account(self, koku_uuid):
"""Call to destroy provider."""
try:
self._provider_builder.destroy_provider(koku_uuid)
destroy_source_event(self._source_id)
except ProviderBuilderError as provider_err:
LOG.error(f"Failed to remove provider. Error: {str(provider_err)}")
def test_update_provider_error(self):
"""Test to update a provider with a koku server error."""
client = ProviderBuilder(auth_header=Config.SOURCES_FAKE_HEADER)
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
client.create_provider_from_source(self.mock_source)
with self.assertRaises(ValidationError):
new_name = "Aws Test"
self.mock_source.name = new_name
client.update_provider_from_source(self.mock_source)
def test_update_provider_error(self):
"""Test to update a provider with a koku server error."""
client = ProviderBuilder(auth_header=Config.SOURCES_FAKE_HEADER)
source_uuid = faker.uuid4()
with patch.object(ProviderAccessor,
"cost_usage_source_ready",
returns=True):
client.create_provider(self.name, self.provider_type,
self.authentication, self.billing_source,
source_uuid)
with self.assertRaises(ValidationError):
client.update_provider(source_uuid, "Aws Test",
Provider.PROVIDER_AWS,
{"resource_name": "arn:test"},
{"bucket": "bucket"})
def destroy(self, request, *args, **kwargs):
"""Delete a source."""
source = self.get_object()
manager = ProviderBuilder(request.user.identity_header.get("encoded"))
manager.destroy_provider(source.koku_uuid)
return super().destroy(request, *args, **kwargs)
def __init__(self, source_id, auth_header):
"""Initialize the client."""
header = {"x-rh-identity": auth_header, "sources-client": "True"}
self._source_id = source_id
self._identity_header = header
self._provider_builder = ProviderBuilder(self._identity_header)
def test_create_provider_exceptions(self):
"""Test to create a provider with a non-recoverable error."""
client = ProviderBuilder(auth_header=Config.SOURCES_FAKE_HEADER)
with self.assertRaises(ValidationError):
client.create_provider_from_source(self.mock_source)
def test_update_provider_exception(self):
"""Test to update a provider with a connection error."""
client = ProviderBuilder(auth_header=Config.SOURCES_FAKE_HEADER)
with self.assertRaises(Provider.DoesNotExist):
client.update_provider_from_source(self.mock_source)
