def test_create_with_provider(self):
"""Test creating a rate with provider."""
provider_name = 'sample_provider'
provider = Provider.objects.create(name=provider_name,
created_by=self.user,
customer=self.customer)
# Get Provider UUID
provider_uuid = provider.uuid
metric = CostModelMetricsMap.OCP_METRIC_CPU_CORE_USAGE_HOUR
rates = {'tiered_rate': [{'unit': 'USD', 'value': 0.22}]}
with tenant_context(self.tenant):
manager = RateManager()
rate_obj = manager.create(metric=metric,
rates=rates,
provider_uuids=[provider_uuid])
self.assertEqual(rate_obj.metric, metric)
self.assertEqual(rate_obj.rates, rates)
self.assertIsNotNone(rate_obj.uuid)
rate_map = RateMap.objects.filter(rate=rate_obj.id)
self.assertIsNotNone(rate_map)
self.assertEqual(rate_map.first().provider_uuid, provider_uuid)
self.assertEqual(
RateManager(rate_obj.uuid).get_provider_uuids(),
[provider_uuid])
def test_create_with_provider_duplicates(self):
"""Test creating with duplicate rates for a provider."""
provider_name = 'sample_provider'
provider = Provider.objects.create(name=provider_name,
created_by=self.user,
customer=self.customer)
# Get Provider UUID
provider_uuid = provider.uuid
metric = CostModelMetricsMap.OCP_METRIC_CPU_CORE_USAGE_HOUR
rates = {'tiered_rate': [{'unit': 'USD', 'value': 0.22}]}
with tenant_context(self.tenant):
manager = RateManager()
rate_obj = manager.create(metric=metric,
rates=rates,
provider_uuids=[provider_uuid])
self.assertEqual(rate_obj.metric, metric)
self.assertEqual(rate_obj.rates, rates)
self.assertIsNotNone(rate_obj.uuid)
with self.assertRaises(RateManagerError):
manager.create(metric=metric,
rates=rates,
provider_uuids=[provider_uuid])
def to_representation(self, rate):
"""Create external representation of a rate."""
rates = rate.rates
provider_uuids = RateManager(rate_uuid=rate.uuid).get_provider_uuids()
display_data = self._get_metric_display_data(rate.metric)
out = {
'uuid': rate.uuid,
'provider_uuids': provider_uuids,
'metric': {
'name': rate.metric,
'unit': display_data.get('unit'),
'display_name': display_data.get('display_name')
}
}
for rate_type in rates.values():
if isinstance(rate_type, list):
for rate_item in rate_type:
RateSerializer._convert_to_decimal(rate_item)
if not rate_item.get('usage'):
rate_item['usage'] = {
'usage_start': rate_item.pop('usage_start'),
'usage_end': rate_item.pop('usage_end'),
'unit': display_data.get('unit')
}
else:
RateSerializer._convert_to_decimal(rate_type)
out.update(rates)
return out
def test_create(self):
"""Test creating a rate."""
metric = CostModelMetricsMap.OCP_METRIC_CPU_CORE_USAGE_HOUR
rates = {'tiered_rate': [{'unit': 'USD', 'value': 0.22}]}
with tenant_context(self.tenant):
manager = RateManager()
rate_obj = manager.create(metric=metric, rates=rates)
self.assertEqual(rate_obj.metric, metric)
self.assertEqual(rate_obj.rates, rates)
self.assertIsNotNone(rate_obj.uuid)
rate_map = RateMap.objects.filter(rate=rate_obj.id)
self.assertEqual(len(rate_map), 0)
self.assertEqual(
RateManager(rate_obj.uuid).get_provider_uuids(), [])
def test_create_with_two_providers(self):
"""Test creating with rate with multiple providers."""
provider_name = 'sample_provider'
provider = Provider.objects.create(name=provider_name,
created_by=self.user,
customer=self.customer)
# Get Provider UUID
provider_uuid = provider.uuid
provider_name_2 = 'sample_provider2'
provider_2 = Provider.objects.create(name=provider_name_2,
created_by=self.user,
customer=self.customer)
provider_uuid_2 = provider_2.uuid
metric = CostModelMetricsMap.OCP_METRIC_CPU_CORE_USAGE_HOUR
rates = {'tiered_rate': [{'unit': 'USD', 'value': 0.22}]}
with tenant_context(self.tenant):
manager = RateManager()
rate_obj = manager.create(
metric=metric,
rates=rates,
provider_uuids=[provider_uuid, provider_uuid_2])
self.assertEqual(rate_obj.metric, metric)
self.assertEqual(rate_obj.rates, rates)
self.assertIsNotNone(rate_obj.uuid)
rate_map = RateMap.objects.filter(rate=rate_obj.id)
self.assertEqual(len(rate_map), 2)
self.assertEqual(
RateMap.objects.get(provider_uuid=provider_uuid).rate_id,
rate_obj.id)
self.assertEqual(
RateMap.objects.get(provider_uuid=provider_uuid_2).rate_id,
rate_obj.id)
# Remove Rate object and verify that the RateMap is updated to no longer contain the providers.
with tenant_context(self.tenant):
Rate.objects.get(id=rate_obj.id).delete()
rate_map = RateMap.objects.filter(rate=rate_obj.id)
self.assertEqual(len(rate_map), 0)
def create(self, validated_data):
"""Create the rate object in the database."""
provider_uuids = validated_data.pop('provider_uuids', [])
metric = validated_data.pop('metric')
try:
rate_obj = RateManager().create(
metric=metric.get('name'),
rates=self._transform_rate_for_db(validated_data),
provider_uuids=provider_uuids)
except RateManagerError as create_error:
raise serializers.ValidationError(create_error.message)
return rate_obj
def update(self, instance, validated_data, *args, **kwargs):
"""Update the rate object in the database."""
provider_uuids = validated_data.pop('provider_uuids', [])
metric = validated_data.pop('metric')
new_providers_for_instance = []
for uuid in provider_uuids:
new_providers_for_instance.append(
str(Provider.objects.filter(uuid=uuid).first().uuid))
manager = RateManager(rate_uuid=instance.uuid)
try:
manager.update_provider_uuids(new_providers_for_instance)
manager.update_metric(metric.get('name'))
except RateManagerError as create_error:
raise serializers.ValidationError(create_error.message)
manager.update_rates(self._transform_rate_for_db(validated_data))
return manager.instance
def test_remove_ocp(self, mock_delete_report):
"""Remove ocp provider."""
# Create Provider
provider_authentication = ProviderAuthentication.objects.create(
provider_resource_name='cluster_id_1001')
provider = Provider.objects.create(
name='ocpprovidername',
created_by=self.user,
customer=self.customer,
authentication=provider_authentication,
)
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):
rates = {
'tiered_rate': [{
'unit': 'USD',
'value': 1.0,
'usage_start': None,
'usage_end': None
}]
}
manager = RateManager()
manager.create(
metric=CostModelMetricsMap.OCP_METRIC_CPU_CORE_USAGE_HOUR,
rates=rates,
provider_uuids=[provider.uuid])
manager = ProviderManager(provider_uuid)
manager.remove(other_user)
rates_query = RateMap.objects.all().filter(
provider_uuid=provider_uuid)
self.assertFalse(rates_query)
provider_query = Provider.objects.all().filter(uuid=provider_uuid)
self.assertFalse(provider_query)
def test_update_provider_uuids_duplicate_metric(self):
"""Test updating a rate with a metric colision for a provider."""
provider_name = 'sample_provider'
provider = Provider.objects.create(name=provider_name,
created_by=self.user,
customer=self.customer)
# Get Provider UUID
provider_uuid = provider.uuid
metric = CostModelMetricsMap.OCP_METRIC_CPU_CORE_USAGE_HOUR
rates = {'tiered_rate': [{'unit': 'USD', 'value': 0.22}]}
with tenant_context(self.tenant):
manager = RateManager()
rate_obj = manager.create(metric=metric,
rates=rates,
provider_uuids=[provider_uuid])
self.assertEqual(rate_obj.metric, metric)
self.assertEqual(rate_obj.rates, rates)
self.assertIsNotNone(rate_obj.uuid)
rate_map = RateMap.objects.filter(rate=rate_obj.id)
self.assertIsNotNone(rate_map)
self.assertEqual(rate_map.first().provider_uuid, provider_uuid)
self.assertEqual(
RateManager(rate_obj.uuid).get_provider_uuids(),
[provider_uuid])
# Create another rate with same metric
rates_2 = {'tiered_rate': [{'unit': 'USD', 'value': 0.52}]}
with tenant_context(self.tenant):
manager_2 = RateManager()
rate_obj_2 = manager_2.create(metric=metric, rates=rates_2)
rate_map = RateMap.objects.filter(rate=rate_obj_2.id)
self.assertIsNotNone(rate_map)
self.assertEqual(len(rate_map), 0)
# Update rate_2 with provider uuid that is already associated with another rate of same type
with tenant_context(self.tenant):
manager_3 = RateManager(rate_uuid=rate_obj_2.uuid)
with self.assertRaises(RateManagerError):
manager_3.update_provider_uuids(provider_uuids=[provider_uuid])
def test_update_provider_uuids(self):
"""Test creating a rate then update with a provider uuid."""
metric = CostModelMetricsMap.OCP_METRIC_CPU_CORE_USAGE_HOUR
rates = {'tiered_rate': [{'unit': 'USD', 'value': 0.22}]}
rate_obj = None
with tenant_context(self.tenant):
manager = RateManager()
rate_obj = manager.create(metric=metric, rates=rates)
self.assertEqual(rate_obj.metric, metric)
self.assertEqual(rate_obj.rates, rates)
self.assertIsNotNone(rate_obj.uuid)
rate_map = RateMap.objects.filter(rate=rate_obj.id)
self.assertEqual(len(rate_map), 0)
provider_name = 'sample_provider'
provider = Provider.objects.create(name=provider_name,
created_by=self.user,
customer=self.customer)
# Get Provider UUID
provider_uuid = provider.uuid
# Add provider to existing rate
with tenant_context(self.tenant):
manager = RateManager(rate_uuid=rate_obj.uuid)
manager.update_provider_uuids(provider_uuids=[provider_uuid])
rate_map = RateMap.objects.filter(rate=rate_obj.id)
self.assertIsNotNone(rate_map)
self.assertEqual(rate_map.first().provider_uuid, provider_uuid)
self.assertEqual(len(rate_map), 1)
# Add provider provider again to existing rate. Verify there is still only 1 item in map
with tenant_context(self.tenant):
manager = RateManager(rate_uuid=rate_obj.uuid)
manager.update_provider_uuids(provider_uuids=[provider_uuid])
rate_map = RateMap.objects.filter(rate=rate_obj.id)
self.assertIsNotNone(rate_map)
self.assertEqual(rate_map.first().provider_uuid, provider_uuid)
self.assertEqual(len(rate_map), 1)
# Remove provider from existing rate
with tenant_context(self.tenant):
manager = RateManager(rate_uuid=rate_obj.uuid)
manager.update_provider_uuids(provider_uuids=[])
rate_map = RateMap.objects.filter(rate=rate_obj.id)
self.assertEqual(len(rate_map), 0)