def test_create(self):
"""Test creating a cost model."""
metric = metric_constants.OCP_METRIC_CPU_CORE_USAGE_HOUR
source_type = Provider.PROVIDER_OCP
tiered_rates = [{"unit": "USD", "value": 0.22}]
data = {
"name":
"Test Cost Model",
"description":
"Test",
"rates": [{
"metric": {
"name": metric
},
"source_type": source_type,
"tiered_rates": tiered_rates
}],
}
with tenant_context(self.tenant):
manager = CostModelManager()
with patch("cost_models.cost_model_manager.chain"):
cost_model_obj = manager.create(**data)
self.assertIsNotNone(cost_model_obj.uuid)
for rate in cost_model_obj.rates:
self.assertEqual(rate.get("metric", {}).get("name"), metric)
self.assertEqual(rate.get("tiered_rates"), tiered_rates)
self.assertEqual(rate.get("source_type"), source_type)
cost_model_map = CostModelMap.objects.filter(
cost_model=cost_model_obj)
self.assertEqual(len(cost_model_map), 0)
self.assertEqual(
CostModelManager(
cost_model_obj.uuid).get_provider_names_uuids(), [])
def test_delete_single_provider_with_cost_model(self,
mock_delete_archived_data,
mock_commit):
"""Assert the cost models are deleted upon provider instance delete."""
mock_commit.side_effect = mock_delete_archived_data.delay(
self.schema, Provider.PROVIDER_AWS, self.aws_provider_uuid)
provider_uuid = self.aws_provider.uuid
data = {
"name": "Test Cost Model",
"description": "Test",
"rates": [],
"markup": {
"value": FAKE.pyint() % 100,
"unit": "percent"
},
"provider_uuids": [provider_uuid],
}
with tenant_context(self.tenant):
manager = CostModelManager()
with patch("cost_models.cost_model_manager.chain"):
manager.create(**data)
cost_model_map = CostModelMap.objects.filter(
provider_uuid=provider_uuid)
self.assertIsNotNone(cost_model_map)
self.aws_provider.delete()
self.assertEquals(
0,
CostModelMap.objects.filter(
provider_uuid=provider_uuid).count())
mock_delete_archived_data.delay.assert_called_with(
self.schema, Provider.PROVIDER_AWS, self.aws_provider_uuid)
def test_create(self):
"""Test creating a cost model."""
metric = CostModelMetricsMap.OCP_METRIC_CPU_CORE_USAGE_HOUR
source_type = 'OCP'
tiered_rates = [{'unit': 'USD', 'value': 0.22}]
data = {
'name':
'Test Cost Model',
'description':
'Test',
'rates': [{
'metric': {
'name': metric
},
'source_type': source_type,
'tiered_rates': tiered_rates
}]
}
with tenant_context(self.tenant):
manager = CostModelManager()
cost_model_obj = manager.create(**data)
self.assertIsNotNone(cost_model_obj.uuid)
for rate in cost_model_obj.rates:
self.assertEqual(rate.get('metric', {}).get('name'), metric)
self.assertEqual(rate.get('tiered_rates'), tiered_rates)
self.assertEqual(rate.get('source_type'), source_type)
cost_model_map = CostModelMap.objects.filter(
cost_model=cost_model_obj)
self.assertEqual(len(cost_model_map), 0)
self.assertEqual(
CostModelManager(
cost_model_obj.uuid).get_provider_names_uuids(), [])
def test_create_with_two_providers(self):
"""Test creating a cost model 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
source_type = 'OCP'
tiered_rates = [{'unit': 'USD', 'value': 0.22}]
data = {
'name':
'Test Cost Model',
'description':
'Test',
'provider_uuids': [provider_uuid, provider_uuid_2],
'rates': [{
'metric': {
'name': metric
},
'source_type': source_type,
'tiered_rates': tiered_rates
}]
}
with tenant_context(self.tenant):
manager = CostModelManager()
cost_model_obj = manager.create(**data)
self.assertIsNotNone(cost_model_obj.uuid)
for rate in cost_model_obj.rates:
self.assertEqual(rate.get('metric', {}).get('name'), metric)
self.assertEqual(rate.get('tiered_rates'), tiered_rates)
self.assertEqual(rate.get('source_type'), source_type)
cost_model_map = CostModelMap.objects.filter(
cost_model=cost_model_obj)
self.assertEqual(len(cost_model_map), 2)
self.assertEqual(
CostModelMap.objects.get(
provider_uuid=provider_uuid).cost_model, cost_model_obj)
self.assertEqual(
CostModelMap.objects.get(
provider_uuid=provider_uuid_2).cost_model, cost_model_obj)
# Remove Rate object and verify that the CostModelMap is updated to no longer contain the providers.
with tenant_context(self.tenant):
CostModel.objects.get(uuid=cost_model_obj.uuid).delete()
cost_model_map = CostModelMap.objects.filter(
cost_model=cost_model_obj)
self.assertEqual(len(cost_model_map), 0)
def test_create_with_two_providers(self):
"""Test creating a cost model 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
source_type = Provider.PROVIDER_OCP
tiered_rates = [{"unit": "USD", "value": 0.22}]
data = {
"name":
"Test Cost Model",
"description":
"Test",
"provider_uuids": [provider_uuid, provider_uuid_2],
"rates": [{
"metric": {
"name": metric
},
"source_type": source_type,
"tiered_rates": tiered_rates
}],
}
with tenant_context(self.tenant):
manager = CostModelManager()
cost_model_obj = manager.create(**data)
self.assertIsNotNone(cost_model_obj.uuid)
for rate in cost_model_obj.rates:
self.assertEqual(rate.get("metric", {}).get("name"), metric)
self.assertEqual(rate.get("tiered_rates"), tiered_rates)
self.assertEqual(rate.get("source_type"), source_type)
cost_model_map = CostModelMap.objects.filter(
cost_model=cost_model_obj)
self.assertEqual(len(cost_model_map), 2)
self.assertEqual(
CostModelMap.objects.get(
provider_uuid=provider_uuid).cost_model, cost_model_obj)
self.assertEqual(
CostModelMap.objects.get(
provider_uuid=provider_uuid_2).cost_model, cost_model_obj)
# Remove Rate object and verify that the CostModelMap is updated to no longer contain the providers.
with tenant_context(self.tenant):
CostModel.objects.get(uuid=cost_model_obj.uuid).delete()
cost_model_map = CostModelMap.objects.filter(
cost_model=cost_model_obj)
self.assertEqual(len(cost_model_map), 0)
def test_create_second_cost_model_same_provider(self):
"""Test that the cost model map is updated for the second model."""
provider_name = "sample_provider"
with patch("masu.celery.tasks.check_report_updates"):
provider = Provider.objects.create(name=provider_name,
created_by=self.user,
customer=self.customer)
# Get Provider UUID
provider_uuid = provider.uuid
provider_names_uuids = [{
"uuid": str(provider.uuid),
"name": provider.name
}]
metric = metric_constants.OCP_METRIC_CPU_CORE_USAGE_HOUR
source_type = Provider.PROVIDER_OCP
tiered_rates = [{"unit": "USD", "value": 0.22}]
data = {
"name":
"Test Cost Model",
"description":
"Test",
"provider_uuids": [provider_uuid],
"rates": [{
"metric": {
"name": metric
},
"source_type": source_type,
"tiered_rates": tiered_rates
}],
}
with tenant_context(self.tenant):
manager = CostModelManager()
with patch("cost_models.cost_model_manager.chain") as mock_chain:
cost_model_obj = manager.create(**data)
mock_chain.return_value.apply_async.assert_called()
cost_model_map = CostModelMap.objects.filter(
provider_uuid=provider_uuid)
self.assertIsNotNone(cost_model_map)
self.assertEqual(cost_model_map.first().cost_model, cost_model_obj)
self.assertEqual(
CostModelManager(
cost_model_obj.uuid).get_provider_names_uuids(),
provider_names_uuids)
second_cost_model_obj = None
with patch("cost_models.cost_model_manager.chain"):
with self.assertRaises(CostModelException):
second_cost_model_obj = manager.create(**data)
cost_model_map = CostModelMap.objects.filter(
provider_uuid=provider_uuid)
self.assertIsNotNone(cost_model_map)
# Make sure we still associate this provider with the previous cost model.
self.assertEqual(cost_model_map.first().cost_model, cost_model_obj)
# Make sure second cost model was never created.
self.assertIsNone(second_cost_model_obj)
def destroy(self, request, *args, **kwargs):
"""Delete a rate."""
uuid = kwargs.get("uuid")
try:
manager = CostModelManager(cost_model_uuid=uuid)
except CostModel.DoesNotExist:
LOG.info("CostModel does not exist.")
else:
manager.update_provider_uuids([])
return super().destroy(request=request, args=args, kwargs=kwargs)
def destroy(self, request, *args, **kwargs):
"""Delete a rate."""
uuidParam = kwargs.get("uuid")
try:
manager = CostModelManager(cost_model_uuid=uuidParam)
except CostModel.DoesNotExist:
LOG.info("CostModel does not exist.")
except ValidationError as err:
raise CostModelQueryException(err)
else:
manager.update_provider_uuids([])
return super().destroy(request=request, args=args, kwargs=kwargs)
def destroy(self, request, *args, **kwargs):
"""Delete a rate."""
uuid = kwargs.get("uuid")
invalidate_view_cache_for_tenant_and_cache_key(
request.tenant.schema_name, cache_key_prefix=SOURCES_PREFIX)
try:
manager = CostModelManager(cost_model_uuid=uuid)
except CostModel.DoesNotExist:
LOG.info("CostModel does not exist.")
else:
manager.update_provider_uuids([])
return super().destroy(request=request, args=args, kwargs=kwargs)
def test_create_with_provider(self):
"""Test creating a cost model with provider uuids."""
provider_name = "sample_provider"
with patch("masu.celery.tasks.check_report_updates"):
provider = Provider.objects.create(name=provider_name,
created_by=self.user,
customer=self.customer)
# Get Provider UUID
provider_uuid = provider.uuid
metric = metric_constants.OCP_METRIC_CPU_CORE_USAGE_HOUR
source_type = Provider.PROVIDER_OCP
tiered_rates = [{"unit": "USD", "value": 0.22}]
data = {
"name":
"Test Cost Model",
"description":
"Test",
"provider_uuids": [provider_uuid],
"rates": [{
"metric": {
"name": metric
},
"source_type": source_type,
"tiered_rates": tiered_rates
}],
}
with tenant_context(self.tenant):
manager = CostModelManager()
with patch("cost_models.cost_model_manager.chain") as mock_chain:
cost_model_obj = manager.create(**data)
mock_chain.return_value.apply_async.assert_called()
self.assertIsNotNone(cost_model_obj.uuid)
for rate in cost_model_obj.rates:
self.assertEqual(rate.get("metric", {}).get("name"), metric)
self.assertEqual(rate.get("tiered_rates"), tiered_rates)
self.assertEqual(rate.get("source_type"), source_type)
cost_model_map = CostModelMap.objects.filter(
cost_model=cost_model_obj)
self.assertIsNotNone(cost_model_map)
self.assertEqual(cost_model_map.first().provider_uuid,
provider_uuid)
self.assertEqual(
CostModelManager(
cost_model_obj.uuid).get_provider_names_uuids(),
[{
"uuid": str(provider_uuid),
"name": "sample_provider"
}],
)
def test_create_with_provider(self):
"""Test creating a cost model with provider uuids."""
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
source_type = 'OCP'
tiered_rates = [{'unit': 'USD', 'value': 0.22}]
data = {
'name':
'Test Cost Model',
'description':
'Test',
'provider_uuids': [provider_uuid],
'rates': [{
'metric': {
'name': metric
},
'source_type': source_type,
'tiered_rates': tiered_rates
}]
}
with tenant_context(self.tenant):
manager = CostModelManager()
cost_model_obj = manager.create(**data)
self.assertIsNotNone(cost_model_obj.uuid)
for rate in cost_model_obj.rates:
self.assertEqual(rate.get('metric', {}).get('name'), metric)
self.assertEqual(rate.get('tiered_rates'), tiered_rates)
self.assertEqual(rate.get('source_type'), source_type)
cost_model_map = CostModelMap.objects.filter(
cost_model=cost_model_obj)
self.assertIsNotNone(cost_model_map)
self.assertEqual(cost_model_map.first().provider_uuid,
provider_uuid)
self.assertEqual(
CostModelManager(
cost_model_obj.uuid).get_provider_names_uuids(),
[{
'uuid': str(provider_uuid),
'name': 'sample_provider'
}])
def to_representation(self, cost_model_obj):
"""Add provider UUIDs to the returned model."""
rep = super().to_representation(cost_model_obj)
rates = rep['rates']
for rate in rates:
metric = rate.get('metric', {})
display_data = self._get_metric_display_data(
cost_model_obj.source_type,
metric.get('name')
)
metric.update(
{
'label_metric': display_data.label_metric,
'label_measurement': display_data.label_measurement,
'label_measurement_unit': display_data.label_measurement_unit,
}
)
rep['rates'] = rates
source_type = rep.get('source_type')
if source_type in SOURCE_TYPE_MAP:
source_type = SOURCE_TYPE_MAP[source_type]
rep['source_type'] = source_type
cm_uuid = cost_model_obj.uuid
provider_uuids = CostModelManager(cm_uuid).get_provider_uuids()
rep.update({'provider_uuids': provider_uuids})
return rep
def to_representation(self, cost_model_obj):
"""Add provider UUIDs to the returned model."""
rep = super().to_representation(cost_model_obj)
rates = rep["rates"]
for rate in rates:
metric = rate.get("metric", {})
display_data = self._get_metric_display_data(
cost_model_obj.source_type, metric.get("name"))
metric.update({
"label_metric":
display_data.label_metric,
"label_measurement":
display_data.label_measurement,
"label_measurement_unit":
display_data.label_measurement_unit,
})
rep["rates"] = rates
source_type = rep.get("source_type")
if source_type in SOURCE_TYPE_MAP:
source_type = SOURCE_TYPE_MAP[source_type]
rep["source_type"] = source_type
cm_uuid = cost_model_obj.uuid
provider_uuids = CostModelManager(cm_uuid).get_provider_names_uuids()
rep.update({"providers": provider_uuids})
return rep
def to_representation(self, cost_model_obj):
"""Add provider UUIDs to the returned model."""
rep = super().to_representation(cost_model_obj)
rates = rep["rates"]
for rate in rates:
metric = rate.get("metric", {})
display_data = self._get_metric_display_data(
cost_model_obj.source_type, metric.get("name"))
try:
metric.update({
"label_metric":
display_data["label_metric"],
"label_measurement":
display_data["label_measurement"],
"label_measurement_unit":
display_data["label_measurement_unit"],
})
except (KeyError, TypeError):
LOG.error("Invalid Cost Model Metric Map", exc_info=True)
raise CostModelMetricMapJSONException("Internal Error.")
rep["rates"] = rates
source_type = rep.get("source_type")
if source_type in SOURCE_TYPE_MAP:
source_type = SOURCE_TYPE_MAP[source_type]
rep["source_type"] = source_type
rep["source_uuids"] = rep.get("provider_uuids", [])
if rep.get("provider_uuids"):
del rep["provider_uuids"]
cm_uuid = cost_model_obj.uuid
source_uuids = CostModelManager(cm_uuid).get_provider_names_uuids()
rep.update({"sources": source_uuids})
return rep
def create(self, validated_data):
"""Create the cost model object in the database."""
source_uuids = validated_data.pop("source_uuids", [])
validated_data.update({"provider_uuids": source_uuids})
try:
return CostModelManager().create(**validated_data)
except CostModelException as error:
raise serializers.ValidationError(error_obj("cost-models", str(error)))
def test_deleting_cost_model_refreshes_materialized_views(
self, mock_chain, mock_update, mock_refresh):
"""Test deleting a cost model refreshes the materialized views."""
provider_name = "sample_provider"
with patch("masu.celery.tasks.check_report_updates"):
provider = Provider.objects.create(name=provider_name,
created_by=self.user,
customer=self.customer)
# Get Provider UUID
provider_uuid = provider.uuid
data = {
"name": "Test Cost Model",
"description": "Test",
"provider_uuids": [provider_uuid],
"markup": {
"value": 10,
"unit": "percent"
},
}
with tenant_context(self.tenant):
manager = CostModelManager()
with patch("cost_models.cost_model_manager.chain"):
cost_model_obj = manager.create(**data)
self.assertIsNotNone(cost_model_obj.uuid)
cost_model_map = CostModelMap.objects.filter(
cost_model=cost_model_obj)
self.assertIsNotNone(cost_model_map)
start_date = DateHelper().this_month_start.strftime("%Y-%m-%d")
end_date = DateHelper().today.strftime("%Y-%m-%d")
# simulates deleting a cost_model
manager.update_provider_uuids(provider_uuids=[])
mock_chain.assert_called_once_with(
mock_update.s(self.schema_name, provider_uuid, start_date,
end_date).set(),
mock_refresh.si(self.schema_name,
provider.type,
provider_uuid=provider_uuid).set(),
)
def test_remove_ocp(self):
"""Remove ocp provider."""
# Create Provider
credentials = {"cluster_id": "cluster_id_1001"}
provider_authentication = ProviderAuthentication.objects.create(
credentials=credentials)
with patch("masu.celery.tasks.check_report_updates"):
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,
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):
ocp_metric = metric_constants.OCP_METRIC_CPU_CORE_USAGE_HOUR
ocp_source_type = Provider.PROVIDER_OCP
tiered_rates = [{"unit": "USD", "value": 0.22}]
ocp_data = {
"name":
"Test Cost Model",
"description":
"Test",
"provider_uuids": [],
"rates": [{
"metric": {
"name": ocp_metric
},
"source_type": ocp_source_type,
"tiered_rates": tiered_rates
}],
}
manager = CostModelManager()
manager.create(**ocp_data)
manager = ProviderManager(provider_uuid)
manager.remove(self._create_delete_request(other_user))
cost_model_query = CostModelMap.objects.all().filter(
provider_uuid=provider_uuid)
self.assertFalse(cost_model_query)
provider_query = Provider.objects.all().filter(uuid=provider_uuid)
self.assertFalse(provider_query)
def test_create_second_cost_model_same_provider(self):
"""Test that the cost model map is updated for the second model."""
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_names_uuids = [{
"uuid": str(provider.uuid),
"name": provider.name
}]
metric = CostModelMetricsMap.OCP_METRIC_CPU_CORE_USAGE_HOUR
source_type = Provider.PROVIDER_OCP
tiered_rates = [{"unit": "USD", "value": 0.22}]
data = {
"name":
"Test Cost Model",
"description":
"Test",
"provider_uuids": [provider_uuid],
"rates": [{
"metric": {
"name": metric
},
"source_type": source_type,
"tiered_rates": tiered_rates
}],
}
with tenant_context(self.tenant):
manager = CostModelManager()
cost_model_obj = manager.create(**data)
cost_model_map = CostModelMap.objects.filter(
provider_uuid=provider_uuid)
self.assertIsNotNone(cost_model_map)
self.assertEqual(cost_model_map.first().cost_model, cost_model_obj)
self.assertEqual(
CostModelManager(
cost_model_obj.uuid).get_provider_names_uuids(),
provider_names_uuids)
second_cost_model_obj = manager.create(**data)
cost_model_map = CostModelMap.objects.filter(
provider_uuid=provider_uuid)
self.assertIsNotNone(cost_model_map)
# Make sure we no longer associate this provider with
# the previous cost model
self.assertNotEqual(cost_model_map.first().cost_model,
cost_model_obj)
self.assertEqual(cost_model_map.first().cost_model,
second_cost_model_obj)
self.assertEqual(
CostModelManager(
second_cost_model_obj.uuid).get_provider_names_uuids(),
provider_names_uuids)
def test_update_distribution_choice(self):
"""Test creating a cost model."""
metric = metric_constants.OCP_METRIC_CPU_CORE_USAGE_HOUR
source_type = Provider.PROVIDER_OCP
tiered_rates = [{"unit": "USD", "value": 0.22}]
distribution = "memory"
update_distribution = "cpu"
data = {
"name":
"Test Cost Model",
"description":
"Test",
"rates": [{
"metric": {
"name": metric
},
"source_type": source_type,
"tiered_rates": tiered_rates
}],
"distribution":
distribution,
}
with tenant_context(self.tenant):
manager = CostModelManager()
with patch("cost_models.cost_model_manager.chain"):
cost_model_obj = manager.create(**data)
self.assertIsNotNone(cost_model_obj.uuid)
self.assertEqual(cost_model_obj.distribution, distribution)
for rate in cost_model_obj.rates:
self.assertEqual(rate.get("metric", {}).get("name"), metric)
self.assertEqual(rate.get("tiered_rates"), tiered_rates)
self.assertEqual(rate.get("source_type"), source_type)
data["distribution"] = update_distribution
with patch("cost_models.cost_model_manager.chain"):
cost_model_obj = manager.update(**data)
self.assertEqual(manager.instance.distribution,
update_distribution)
def test_create_second_cost_model_same_provider(self):
"""Test that the cost model map is updated for the second model."""
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_names_uuids = [{
'uuid': str(provider.uuid),
'name': provider.name
}]
metric = CostModelMetricsMap.OCP_METRIC_CPU_CORE_USAGE_HOUR
source_type = 'OCP'
tiered_rates = [{'unit': 'USD', 'value': 0.22}]
data = {
'name':
'Test Cost Model',
'description':
'Test',
'provider_uuids': [provider_uuid],
'rates': [{
'metric': {
'name': metric
},
'source_type': source_type,
'tiered_rates': tiered_rates
}]
}
with tenant_context(self.tenant):
manager = CostModelManager()
cost_model_obj = manager.create(**data)
cost_model_map = CostModelMap.objects.filter(
provider_uuid=provider_uuid)
self.assertIsNotNone(cost_model_map)
self.assertEqual(cost_model_map.first().cost_model, cost_model_obj)
self.assertEqual(
CostModelManager(
cost_model_obj.uuid).get_provider_names_uuids(),
provider_names_uuids)
second_cost_model_obj = manager.create(**data)
cost_model_map = CostModelMap.objects.filter(
provider_uuid=provider_uuid)
self.assertIsNotNone(cost_model_map)
# Make sure we no longer associate this provider with
# the previous cost model
self.assertNotEqual(cost_model_map.first().cost_model,
cost_model_obj)
self.assertEqual(cost_model_map.first().cost_model,
second_cost_model_obj)
self.assertEqual(
CostModelManager(
second_cost_model_obj.uuid).get_provider_names_uuids(),
provider_names_uuids)
def test_deleting_cost_model_not_triggers_tasks(self, mock_chain,
mock_update, mock_refresh):
"""Test deleting a cost model with an inactive provider does not trigger tasks."""
provider_name = "sample_provider"
with patch("masu.celery.tasks.check_report_updates"):
provider = Provider.objects.create(name=provider_name,
created_by=self.user,
customer=self.customer)
# Get Provider UUID
provider_uuid = provider.uuid
provider.active = False
provider.save()
data = {
"name": "Test Cost Model",
"description": "Test",
"provider_uuids": [provider_uuid],
"markup": {
"value": 10,
"unit": "percent"
},
}
with tenant_context(self.tenant):
manager = CostModelManager()
with patch("cost_models.cost_model_manager.chain"):
cost_model_obj = manager.create(**data)
self.assertIsNotNone(cost_model_obj.uuid)
cost_model_map = CostModelMap.objects.filter(
cost_model=cost_model_obj)
self.assertIsNotNone(cost_model_map)
# simulates deleting a cost_model
manager.update_provider_uuids(provider_uuids=[])
mock_chain.assert_not_called()
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):
ocp_metric = CostModelMetricsMap.OCP_METRIC_CPU_CORE_USAGE_HOUR
ocp_source_type = 'OCP'
tiered_rates = [{'unit': 'USD', 'value': 0.22}]
ocp_data = {
'name':
'Test Cost Model',
'description':
'Test',
'provider_uuids': [],
'rates': [{
'metric': {
'name': ocp_metric
},
'source_type': ocp_source_type,
'tiered_rates': tiered_rates
}]
}
manager = CostModelManager()
manager.create(**ocp_data)
manager = ProviderManager(provider_uuid)
manager.remove(other_user)
cost_model_query = CostModelMap.objects.all().filter(
provider_uuid=provider_uuid)
self.assertFalse(cost_model_query)
provider_query = Provider.objects.all().filter(uuid=provider_uuid)
self.assertFalse(provider_query)
def update(self, instance, validated_data, *args, **kwargs):
"""Update the rate object in the database."""
provider_uuids = validated_data.pop('provider_uuids', [])
new_providers_for_instance = []
for uuid in provider_uuids:
new_providers_for_instance.append(str(Provider.objects.filter(uuid=uuid).first().uuid))
manager = CostModelManager(cost_model_uuid=instance.uuid)
manager.update_provider_uuids(new_providers_for_instance)
manager.update(**validated_data)
return manager.instance
def update(self, instance, validated_data, *args, **kwargs):
"""Update the rate object in the database."""
source_uuids = validated_data.pop("source_uuids", [])
new_providers_for_instance = []
for uuid in source_uuids:
new_providers_for_instance.append(str(Provider.objects.filter(uuid=uuid).first().uuid))
try:
manager = CostModelManager(cost_model_uuid=instance.uuid)
manager.update_provider_uuids(new_providers_for_instance)
manager.update(**validated_data)
except CostModelException as error:
raise serializers.ValidationError(error_obj("cost-models", str(error)))
return manager.instance
def create(self, validated_data):
"""Create the cost model object in the database."""
return CostModelManager().create(**validated_data)
def test_update_provider_uuids(self):
"""Test creating a cost model then update with a provider uuid."""
metric = CostModelMetricsMap.OCP_METRIC_CPU_CORE_USAGE_HOUR
source_type = 'OCP'
tiered_rates = [{'unit': 'USD', 'value': 0.22}]
data = {
'name':
'Test Cost Model',
'description':
'Test',
'rates': [{
'metric': {
'name': metric
},
'source_type': source_type,
'tiered_rates': tiered_rates
}]
}
cost_model_obj = None
with tenant_context(self.tenant):
manager = CostModelManager()
cost_model_obj = manager.create(**data)
cost_model_map = CostModelMap.objects.filter(
cost_model=cost_model_obj)
self.assertEqual(len(cost_model_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 cost model
with tenant_context(self.tenant):
manager = CostModelManager(cost_model_uuid=cost_model_obj.uuid)
manager.update_provider_uuids(provider_uuids=[provider_uuid])
cost_model_map = CostModelMap.objects.filter(
cost_model=cost_model_obj)
self.assertIsNotNone(cost_model_map)
self.assertEqual(cost_model_map.first().provider_uuid,
provider_uuid)
self.assertEqual(len(cost_model_map), 1)
# Add provider again to existing cost model. Verify there is still only 1 item in map
with tenant_context(self.tenant):
manager = CostModelManager(cost_model_uuid=cost_model_obj.uuid)
manager.update_provider_uuids(provider_uuids=[provider_uuid])
cost_model_map = CostModelMap.objects.filter(
cost_model=cost_model_obj)
self.assertIsNotNone(cost_model_map)
self.assertEqual(cost_model_map.first().provider_uuid,
provider_uuid)
self.assertEqual(len(cost_model_map), 1)
# Remove provider from existing rate
with tenant_context(self.tenant):
manager = CostModelManager(cost_model_uuid=cost_model_obj.uuid)
manager.update_provider_uuids(provider_uuids=[])
cost_model_map = CostModelMap.objects.filter(
cost_model=cost_model_obj)
self.assertEqual(len(cost_model_map), 0)
def create(self, validated_data):
"""Create the cost model object in the database."""
source_uuids = validated_data.pop("source_uuids", [])
validated_data.update({"provider_uuids": source_uuids})
return CostModelManager().create(**validated_data)
def test_update_provider_uuids(self):
"""Test creating a cost model then update with a provider uuid."""
metric = metric_constants.OCP_METRIC_CPU_CORE_USAGE_HOUR
source_type = Provider.PROVIDER_OCP
tiered_rates = [{"unit": "USD", "value": 0.22}]
data = {
"name":
"Test Cost Model",
"description":
"Test",
"rates": [{
"metric": {
"name": metric
},
"source_type": source_type,
"tiered_rates": tiered_rates
}],
}
cost_model_obj = None
with tenant_context(self.tenant):
manager = CostModelManager()
with patch("cost_models.cost_model_manager.chain") as mock_chain:
cost_model_obj = manager.create(**data)
mock_chain.return_value.apply_async.assert_not_called()
cost_model_map = CostModelMap.objects.filter(
cost_model=cost_model_obj)
self.assertEqual(len(cost_model_map), 0)
provider_name = "sample_provider"
with patch("masu.celery.tasks.check_report_updates"):
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 cost model
with tenant_context(self.tenant):
manager = CostModelManager(cost_model_uuid=cost_model_obj.uuid)
with patch("cost_models.cost_model_manager.chain") as mock_chain:
manager.update_provider_uuids(provider_uuids=[provider_uuid])
mock_chain.return_value.apply_async.assert_called()
cost_model_map = CostModelMap.objects.filter(
cost_model=cost_model_obj)
self.assertIsNotNone(cost_model_map)
self.assertEqual(cost_model_map.first().provider_uuid,
provider_uuid)
self.assertEqual(len(cost_model_map), 1)
# Add provider again to existing cost model. Verify there is still only 1 item in map
with tenant_context(self.tenant):
manager = CostModelManager(cost_model_uuid=cost_model_obj.uuid)
with patch("cost_models.cost_model_manager.chain") as mock_chain:
manager.update_provider_uuids(provider_uuids=[provider_uuid])
mock_chain.return_value.apply_async.assert_called()
cost_model_map = CostModelMap.objects.filter(
cost_model=cost_model_obj)
self.assertIsNotNone(cost_model_map)
self.assertEqual(cost_model_map.first().provider_uuid,
provider_uuid)
self.assertEqual(len(cost_model_map), 1)
# Remove provider from existing rate
with tenant_context(self.tenant):
manager = CostModelManager(cost_model_uuid=cost_model_obj.uuid)
with patch("cost_models.cost_model_manager.chain") as mock_chain:
manager.update_provider_uuids(provider_uuids=[])
mock_chain.return_value.apply_async.assert_called()
cost_model_map = CostModelMap.objects.filter(
cost_model=cost_model_obj)
self.assertEqual(len(cost_model_map), 0)
