def setUp(self):
"""Set up a test with database objects."""
super().setUp()
self.provider_uuid = '3c6e687e-1a09-4a05-970c-2ccf44b0952e'
self.schema = 'acct10001'
self.column_map = ReportingCommonDBAccessor().column_map
self.creator = ReportObjectCreator(self.schema, self.column_map)
reporting_period = self.creator.create_ocp_report_period(provider_uuid=self.provider_uuid)
report = self.creator.create_ocp_report(reporting_period)
self.creator.create_ocp_usage_line_item(reporting_period, report)
self.rates = [
{'metric': {'name': 'cpu_core_usage_per_hour'},
'tiered_rates': [{'value': 1.5, 'unit': 'USD'}]},
{'metric': {'name': 'memory_gb_usage_per_hour'},
'tiered_rates': [{'value': 2.5, 'unit': 'USD'}]},
{'metric': {'name': 'cpu_core_request_per_hour'},
'tiered_rates': [{'value': 3.5, 'unit': 'USD'}]},
{'metric': {'name': 'memory_gb_request_per_hour'},
'tiered_rates': [{'value': 4.5, 'unit': 'USD'}]},
{'metric': {'name': 'storage_gb_usage_per_month'},
'tiered_rates': [{'value': 5.5, 'unit': 'USD'}]},
{'metric': {'name': 'storage_gb_request_per_month'},
'tiered_rates': [{'value': 6.5, 'unit': 'USD'}]},
{'metric': {'name': 'node_cost_per_month'},
'tiered_rates': [{'value': 7.5, 'unit': 'USD'}]}
]
self.markup = {'value': 10, 'unit': 'percent'}
self.cost_model = self.creator.create_cost_model(
self.provider_uuid, Provider.PROVIDER_OCP, self.rates, self.markup
)
def setUp(self):
"""Set up initial data for tests."""
super(TestUploadUtilsWithData, self).setUp()
with ReportingCommonDBAccessor(self.schema) as common_accessor:
self.column_map = common_accessor.column_map
self.creator = ReportObjectCreator(self.schema, self.column_map)
timezone = pytz.timezone('UTC')
# Arbitrary date as "today" so we don't drift around with `now`.
self.today = datetime(2019, 11, 5, 0, 0, 0, tzinfo=timezone)
self.today_date = date(year=self.today.year,
month=self.today.month,
day=self.today.day)
self.create_some_data_for_date(self.today)
self.yesterday = self.today - timedelta(days=1)
self.yesterday_date = date(year=self.yesterday.year,
month=self.yesterday.month,
day=self.yesterday.day)
self.create_some_data_for_date(self.yesterday)
self.future = self.today + timedelta(days=900)
self.future_date = date(year=self.future.year,
month=self.future.month,
day=self.future.day)
def setUpClass(cls):
"""Set up the test class with required objects."""
super().setUpClass()
cls.common_accessor = ReportingCommonDBAccessor()
cls.column_map = cls.common_accessor.column_map
cls.accessor = AWSReportDBAccessor(schema=cls.schema,
column_map=cls.column_map)
cls.report_schema = cls.accessor.report_schema
cls.creator = ReportObjectCreator(cls.accessor, cls.column_map,
cls.report_schema.column_types)
cls.all_tables = list(AWS_CUR_TABLE_MAP.values())
cls.foreign_key_tables = [
AWS_CUR_TABLE_MAP['bill'],
AWS_CUR_TABLE_MAP['product'],
AWS_CUR_TABLE_MAP['pricing'],
AWS_CUR_TABLE_MAP['reservation'],
]
billing_start = datetime.datetime.utcnow().replace(day=1)
cls.manifest_dict = {
'assembly_id': '1234',
'billing_period_start_datetime': billing_start,
'num_total_files': 2,
'provider_id': cls.aws_provider.id,
}
cls.manifest_accessor = ReportManifestDBAccessor()
def test_get_bill_ids_from_provider_with_end_date(self):
"""Test that bill IDs are returned for an AWS provider with end date."""
date_accessor = DateAccessor()
with ProviderDBAccessor(
provider_uuid=self.aws_provider_uuid) as provider_accessor:
provider = provider_accessor.get_provider()
with AWSReportDBAccessor(schema=self.schema,
column_map=self.column_map) as accessor:
report_schema = accessor.report_schema
creator = ReportObjectCreator(self.schema, self.column_map)
end_date = date_accessor.today_with_timezone('utc').replace(day=1)
start_date = end_date
for i in range(2):
start_date = start_date - relativedelta(months=i)
bill = creator.create_cost_entry_bill(self.aws_provider_uuid,
bill_date=start_date)
bill_table_name = AWS_CUR_TABLE_MAP['bill']
bill_obj = getattr(accessor.report_schema, bill_table_name)
bills = accessor.get_cost_entry_bills_query_by_provider(
provider.uuid)
with schema_context(self.schema):
bills = bills.filter(
billing_period_start__lte=start_date.date()).all()
expected_bill_ids = [str(bill.id) for bill in bills]
bills = utils.get_bills_from_provider(self.aws_provider_uuid,
self.schema,
end_date=start_date)
with schema_context(self.schema):
bill_ids = [str(bill.id) for bill in bills]
self.assertEqual(bill_ids, expected_bill_ids)
def setUpClass(cls):
"""Set up the test class with required objects."""
super().setUpClass()
cls.accessor = OCPReportDBAccessor(schema=cls.schema)
cls.report_schema = cls.accessor.report_schema
cls.creator = ReportObjectCreator(cls.schema)
cls.all_tables = list(OCP_REPORT_TABLE_MAP.values())
def setUpClass(cls):
"""Set up for the class."""
super().setUpClass()
cls.aws_tables = list(AWS_CUR_TABLE_MAP.values())
cls.ocp_tables = list(OCP_REPORT_TABLE_MAP.values())
cls.all_tables = list(AWS_CUR_TABLE_MAP.values()) + list(OCP_REPORT_TABLE_MAP.values())
cls.creator = ReportObjectCreator(cls.schema)
def setUpClass(cls):
"""Set up the test class with required objects."""
super().setUpClass()
cls.common_accessor = ReportingCommonDBAccessor()
cls.column_map = cls.common_accessor.column_map
cls.accessor = OCPReportDBAccessor(schema='acct10001', column_map=cls.column_map)
cls.report_schema = cls.accessor.report_schema
cls.creator = ReportObjectCreator(cls.schema, cls.column_map)
cls.all_tables = list(OCP_REPORT_TABLE_MAP.values())
def setUpClass(cls):
"""Set up for the class."""
super().setUpClass()
cls.aws_tables = list(AWS_CUR_TABLE_MAP.values())
cls.ocp_tables = list(OCP_REPORT_TABLE_MAP.values())
cls.all_tables = list(AWS_CUR_TABLE_MAP.values()) + list(OCP_REPORT_TABLE_MAP.values())
with ReportingCommonDBAccessor() as report_common_db:
cls.column_map = report_common_db.column_map
cls.creator = ReportObjectCreator(cls.schema, cls.column_map)
def setUpClass(cls):
"""Set up the test class with required objects."""
super().setUpClass()
cls.accessor = AWSReportDBAccessor(cls.schema)
cls.report_schema = cls.accessor.report_schema
cls.all_tables = list(AWS_CUR_TABLE_MAP.values())
cls.creator = ReportObjectCreator(cls.schema)
cls.date_accessor = DateAccessor()
cls.manifest_accessor = ReportManifestDBAccessor()
def setUpClass(cls):
"""Set up the test class with required objects."""
super().setUpClass()
cls.accessor = GCPReportDBAccessor(schema=cls.schema)
cls.report_schema = cls.accessor.report_schema
cls.creator = ReportObjectCreator(cls.schema)
cls.all_tables = list(GCP_REPORT_TABLE_MAP.values())
cls.foreign_key_tables = [
GCP_REPORT_TABLE_MAP["bill"], GCP_REPORT_TABLE_MAP["product"]
]
def setUpClass(cls):
"""Set up the test class with required objects."""
super().setUpClass()
cls.common_accessor = ReportingCommonDBAccessor()
cls.column_map = cls.common_accessor.column_map
cls.ocp_provider_uuid = '3c6e687e-1a09-4a05-970c-2ccf44b0952e'
cls.accessor = OCPReportDBAccessor(schema='acct10001', column_map=cls.column_map)
cls.report_schema = cls.accessor.report_schema
cls.creator = ReportObjectCreator(cls.schema, cls.column_map)
cls.all_tables = list(OCP_REPORT_TABLE_MAP.values())
def setUpClass(cls):
"""Set up the test class with required objects."""
super().setUpClass()
cls.accessor = AzureReportDBAccessor("acct10001")
cls.report_schema = cls.accessor.report_schema
cls.all_tables = list(AZURE_REPORT_TABLE_MAP.values())
cls.creator = ReportObjectCreator(cls.schema)
cls.date_accessor = DateHelper()
cls.manifest_accessor = ReportManifestDBAccessor()
def setUpClass(cls):
"""Set up the test class with required objects."""
super().setUpClass()
with ReportingCommonDBAccessor() as report_common_db:
cls.column_map = report_common_db.column_map
cls.accessor = AzureReportDBAccessor("acct10001", cls.column_map)
cls.report_schema = cls.accessor.report_schema
cls.all_tables = list(AZURE_REPORT_TABLE_MAP.values())
cls.creator = ReportObjectCreator(cls.schema, cls.column_map)
cls.date_accessor = DateAccessor()
cls.manifest_accessor = ReportManifestDBAccessor()
def setUpClass(cls):
"""Set up the test class with required objects."""
super().setUpClass()
cls.accessor = AWSReportDBAccessor(schema=cls.schema)
cls.report_schema = cls.accessor.report_schema
cls.creator = ReportObjectCreator(cls.schema)
cls.all_tables = list(AWS_CUR_TABLE_MAP.values())
cls.foreign_key_tables = [
AWS_CUR_TABLE_MAP["bill"],
AWS_CUR_TABLE_MAP["product"],
AWS_CUR_TABLE_MAP["pricing"],
AWS_CUR_TABLE_MAP["reservation"],
]
def setUp(self):
"""Set up a test with database objects."""
super().setUp()
self.provider_uuid = '3c6e687e-1a09-4a05-970c-2ccf44b0952e'
self.schema = 'acct10001'
self.column_map = ReportingCommonDBAccessor().column_map
self.creator = ReportObjectCreator(self.schema, self.column_map)
reporting_period = self.creator.create_ocp_report_period()
report = self.creator.create_ocp_report(reporting_period)
self.creator.create_ocp_usage_line_item(reporting_period, report)
self.cost_model = self.creator.create_cost_model(
self.provider_uuid, 'OCP')
def setUp(self):
"""Set up a test with database objects."""
super().setUp()
self.provider_uuid = self.ocp_provider_uuid
self.creator = ReportObjectCreator(self.schema)
reporting_period = self.creator.create_ocp_report_period(
self.ocp_provider_uuid)
report = self.creator.create_ocp_report(reporting_period)
self.creator.create_ocp_usage_line_item(reporting_period, report)
self.creator.create_ocp_node_label_line_item(reporting_period, report)
self.cost_model = self.creator.create_cost_model(
self.provider_uuid, Provider.PROVIDER_OCP)
def setUpClass(cls):
"""Set up the test class with required objects."""
super().setUpClass()
cls.common_accessor = ReportingCommonDBAccessor()
cls.column_map = cls.common_accessor.column_map
cls.accessor = AzureReportDBAccessor(schema=cls.schema, column_map=cls.column_map)
cls.report_schema = cls.accessor.report_schema
cls.creator = ReportObjectCreator(cls.schema, cls.column_map)
cls.all_tables = list(AZURE_REPORT_TABLE_MAP.values())
cls.foreign_key_tables = [
AZURE_REPORT_TABLE_MAP['bill'],
AZURE_REPORT_TABLE_MAP['product'],
AZURE_REPORT_TABLE_MAP['meter'],
]
def setUp(self):
"""Set up a test with database objects."""
super().setUp()
# Use an OCP provider that does not have a cost model. Any OCP-on-X OCP provider will do
self.provider_uuid = self.ocpaws_provider_uuid
self.creator = ReportObjectCreator(self.schema)
reporting_period = self.creator.create_ocp_report_period(
provider_uuid=self.provider_uuid)
report = self.creator.create_ocp_report(reporting_period)
self.creator.create_ocp_usage_line_item(reporting_period, report)
self.creator.create_ocp_node_label_line_item(reporting_period, report)
self.rates, self.mapping = self.build_tag_rates()
self.cost_model = self.creator.create_cost_model(
self.provider_uuid, Provider.PROVIDER_OCP, self.rates)
def setUpClass(cls):
"""Set up the test class with required objects."""
super().setUpClass()
cls.common_accessor = ReportingCommonDBAccessor()
cls.column_map = cls.common_accessor.column_map
cls.accessor = AWSReportDBAccessor(schema=cls.schema,
column_map=cls.column_map)
cls.report_schema = cls.accessor.report_schema
cls.creator = ReportObjectCreator(cls.schema, cls.column_map)
cls.all_tables = list(AWS_CUR_TABLE_MAP.values())
cls.foreign_key_tables = [
AWS_CUR_TABLE_MAP['bill'],
AWS_CUR_TABLE_MAP['product'],
AWS_CUR_TABLE_MAP['pricing'],
AWS_CUR_TABLE_MAP['reservation'],
]
def setUpClass(cls):
"""Set up the test class with required objects."""
super().setUpClass()
cls.accessor = AzureReportDBAccessor(schema=cls.schema)
cls.report_schema = cls.accessor.report_schema
cls.creator = ReportObjectCreator(cls.schema)
cls.dh = DateHelper()
cls.all_tables = list(AZURE_REPORT_TABLE_MAP.values())
cls.foreign_key_tables = [
AZURE_REPORT_TABLE_MAP["bill"],
AZURE_REPORT_TABLE_MAP["product"],
AZURE_REPORT_TABLE_MAP["meter"],
]
cls.manifest_accessor = ReportManifestDBAccessor()
def setUp(self):
"""Set up a test with database objects."""
super().setUp()
self.provider_uuid = self.ocp_provider_uuid
self.schema = "acct10001"
self.creator = ReportObjectCreator(self.schema)
reporting_period = self.creator.create_ocp_report_period(
provider_uuid=self.provider_uuid)
report = self.creator.create_ocp_report(reporting_period)
self.creator.create_ocp_usage_line_item(reporting_period, report)
self.creator.create_ocp_node_label_line_item(reporting_period, report)
self.rates, self.expected_value_rate_mapping = build_rates()
self.markup = {"value": 10, "unit": "percent"}
self.cost_model = self.creator.create_cost_model(
self.provider_uuid, Provider.PROVIDER_OCP, self.rates, self.markup)
def _generate_ocp_on_aws_data(self, cluster_id=None):
"""Generate OCP and AWS data."""
if not cluster_id:
cluster_id = self.ocp_provider_resource_name
creator = ReportObjectCreator(self.schema, self.column_map)
bill_ids = []
today = DateAccessor().today_with_timezone("UTC")
last_month = today - relativedelta(months=1)
resource_id = "i-12345"
for cost_entry_date in (today, last_month):
bill = creator.create_cost_entry_bill(
provider_uuid=self.aws_provider_uuid,
bill_date=cost_entry_date)
bill_ids.append(str(bill.id))
cost_entry = creator.create_cost_entry(bill, cost_entry_date)
product = creator.create_cost_entry_product("Compute Instance")
pricing = creator.create_cost_entry_pricing()
reservation = creator.create_cost_entry_reservation()
creator.create_cost_entry_line_item(bill,
cost_entry,
product,
pricing,
reservation,
resource_id=resource_id)
with AWSReportDBAccessor(self.schema, self.column_map) as aws_accessor:
aws_accessor.populate_line_item_daily_table(
last_month.date(), today.date(), bill_ids)
provider_uuid = self.ocp_provider_uuid
for cost_entry_date in (today, last_month):
period = creator.create_ocp_report_period(
provider_uuid=provider_uuid,
period_date=cost_entry_date,
cluster_id=cluster_id)
report = creator.create_ocp_report(period, cost_entry_date)
creator.create_ocp_usage_line_item(period,
report,
resource_id=resource_id)
cluster_id = get_cluster_id_from_provider(self.ocp_test_provider_uuid)
with OCPReportDBAccessor(self.schema, self.column_map) as ocp_accessor:
ocp_accessor.populate_line_item_daily_table(
last_month.date(), today.date(), cluster_id)
def setUp(self):
"""Shared variables used by ocp common tests."""
super().setUp()
self.accessor = OCPReportDBAccessor(schema=self.schema)
self.provider_accessor = ProviderDBAccessor(
provider_uuid=self.ocp_test_provider_uuid)
self.report_schema = self.accessor.report_schema
self.creator = ReportObjectCreator(self.schema)
self.all_tables = list(OCP_REPORT_TABLE_MAP.values())
self.provider_uuid = self.provider_accessor.get_provider().uuid
reporting_period = self.creator.create_ocp_report_period(
provider_uuid=self.provider_uuid)
report = self.creator.create_ocp_report(
reporting_period, reporting_period.report_period_start)
self.creator.create_ocp_usage_line_item(reporting_period, report)
self.creator.create_ocp_storage_line_item(reporting_period, report)
self.creator.create_ocp_node_label_line_item(reporting_period, report)
def _generate_ocp_on_aws_data(self):
"""Test that the OCP on AWS cost summary table is populated."""
creator = ReportObjectCreator(self.schema, self.column_map)
bill_ids = []
today = DateAccessor().today_with_timezone('UTC')
last_month = today - relativedelta.relativedelta(months=1)
resource_id = 'i-12345'
for cost_entry_date in (today, last_month):
bill = creator.create_cost_entry_bill(
provider_id=self.aws_provider.id, bill_date=cost_entry_date)
bill_ids.append(str(bill.id))
cost_entry = creator.create_cost_entry(bill, cost_entry_date)
product = creator.create_cost_entry_product('Compute Instance')
pricing = creator.create_cost_entry_pricing()
reservation = creator.create_cost_entry_reservation()
creator.create_cost_entry_line_item(bill,
cost_entry,
product,
pricing,
reservation,
resource_id=resource_id)
with AWSReportDBAccessor(self.schema, self.column_map) as aws_accessor:
aws_accessor.populate_line_item_daily_table(
last_month.date(), today.date(), bill_ids)
cluster_id = self.ocp_provider_resource_name
provider_id = self.ocp_provider.id
for cost_entry_date in (today, last_month):
period = creator.create_ocp_report_period(cost_entry_date,
provider_id=provider_id,
cluster_id=cluster_id)
report = creator.create_ocp_report(period, cost_entry_date)
creator.create_ocp_usage_line_item(period,
report,
resource_id=resource_id)
cluster_id = get_cluster_id_from_provider(self.ocp_test_provider_uuid)
with OCPReportDBAccessor(self.schema, self.column_map) as ocp_accessor:
ocp_accessor.populate_line_item_daily_table(
last_month.date(), today.date(), cluster_id)
def setUp(self):
"""Set up initial data for tests."""
super().setUp()
self.creator = ReportObjectCreator(self.schema)
timezone = pytz.timezone("UTC")
# Arbitrary date as "today" so we don't drift around with `now`.
self.today = datetime(2019, 11, 5, 0, 0, 0, tzinfo=timezone)
self.today_date = date(year=self.today.year, month=self.today.month, day=self.today.day)
self.create_some_data_for_date(self.today)
self.yesterday = self.today - timedelta(days=1)
self.yesterday_date = date(year=self.yesterday.year, month=self.yesterday.month, day=self.yesterday.day)
self.create_some_data_for_date(self.yesterday)
self.future = self.today + timedelta(days=900)
self.future_date = date(year=self.future.year, month=self.future.month, day=self.future.day)
def setUp(self):
super().setUp()
self.common_accessor = ReportingCommonDBAccessor()
self.column_map = self.common_accessor.column_map
self.accessor = OCPReportDBAccessor(schema=self.schema,
column_map=self.column_map)
self.provider_accessor = ProviderDBAccessor(
provider_uuid=self.ocp_test_provider_uuid)
self.report_schema = self.accessor.report_schema
self.creator = ReportObjectCreator(self.schema, self.column_map)
self.all_tables = list(OCP_REPORT_TABLE_MAP.values())
self.provider_uuid = self.provider_accessor.get_provider().uuid
reporting_period = self.creator.create_ocp_report_period(
provider_uuid=self.provider_uuid)
report = self.creator.create_ocp_report(
reporting_period, reporting_period.report_period_start)
self.creator.create_ocp_usage_line_item(reporting_period, report)
self.creator.create_ocp_storage_line_item(reporting_period, report)
def setUp(self):
"""Set up initial data for tests."""
super(TestUploadUtilsWithData, self).setUp()
with ReportingCommonDBAccessor(self.schema) as common_accessor:
self.column_map = common_accessor.column_map
self.creator = ReportObjectCreator(self.schema, self.column_map)
self.today = DateAccessor().today_with_timezone('UTC')
self.today_date = date(
year=self.today.year, month=self.today.month, day=self.today.day
)
self.create_some_data_for_date(self.today)
self.yesterday = self.today - timedelta(days=1)
self.yesterday_date = date(
year=self.yesterday.year, month=self.yesterday.month, day=self.yesterday.day
)
self.create_some_data_for_date(self.yesterday)
self.future = self.today + timedelta(days=900)
self.future_date = date(
year=self.future.year, month=self.future.month, day=self.future.day
)
def test_get_bill_ids_from_provider(self):
"""Test that bill IDs are returned for an AWS provider."""
date_accessor = DateAccessor()
creator = ReportObjectCreator(self.schema, self.column_map)
expected_bill_ids = []
end_date = date_accessor.today_with_timezone('utc').replace(day=1)
start_date = end_date
for i in range(2):
start_date = start_date - relativedelta(months=i)
bill = creator.create_cost_entry_bill(
provider_uuid=self.aws_provider_uuid, bill_date=start_date)
with schema_context(self.schema):
expected_bill_ids.append(str(bill.id))
bills = utils.get_bills_from_provider(self.aws_provider_uuid,
self.schema)
with schema_context(self.schema):
bill_ids = [str(bill.id) for bill in bills]
self.assertEqual(sorted(bill_ids), sorted(expected_bill_ids))
def _generate_ocp_on_azure_data(self):
"""Generate OpenShift and Azure data sufficient for matching."""
creator = ReportObjectCreator(self.schema, self.column_map)
bill_table_name = AZURE_REPORT_TABLE_MAP['bill']
with AzureReportDBAccessor(self.schema, self.column_map) as accessor:
accessor._get_db_obj_query(bill_table_name).all().delete()
bill_ids = []
today = DateAccessor().today_with_timezone('UTC')
last_month = today - relativedelta(months=1)
instance_id = '/subscriptions/99999999-9999-9999-9999-999999999999'\
+ '/resourceGroups/koku-99hqd-rg/providers/Microsoft.Compute/'\
+ 'virtualMachines/koku-99hqd-worker-eastus1-jngbr'
node = instance_id.split('/')[8]
with schema_context(self.schema):
for cost_entry_date in (today, last_month):
bill = creator.create_azure_cost_entry_bill(
provider_uuid=self.azure_provider.uuid,
bill_date=cost_entry_date
)
bill_ids.append(str(bill.id))
product = creator.create_azure_cost_entry_product(
provider_uuid=self.azure_provider.uuid,
instance_id=instance_id
)
meter = creator.create_azure_meter(
provider_uuid=self.azure_provider.uuid
)
creator.create_azure_cost_entry_line_item(
bill, product, meter, usage_date_time=cost_entry_date
)
with OCPReportDBAccessor(self.schema, self.column_map) as ocp_accessor:
cluster_id = 'my-ocp-cluster-1'
for cost_entry_date in (today, last_month):
period = creator.create_ocp_report_period(
self.ocp_test_provider_uuid,
period_date=cost_entry_date,
cluster_id=cluster_id
)
report = creator.create_ocp_report(period, cost_entry_date)
creator.create_ocp_usage_line_item(
period, report, node=node
)
ocp_report_table_name = OCP_REPORT_TABLE_MAP['report']
with schema_context(self.schema):
report_table = getattr(ocp_accessor.report_schema, ocp_report_table_name)
report_entry = report_table.objects.all().aggregate(
Min('interval_start'), Max('interval_start')
)
start_date = report_entry['interval_start__min']
end_date = report_entry['interval_start__max']
start_date = start_date.replace(hour=0, minute=0, second=0, microsecond=0)
end_date = end_date.replace(hour=0, minute=0, second=0, microsecond=0)
ocp_accessor.populate_line_item_daily_table(
start_date, end_date, cluster_id
)
ocp_accessor.populate_line_item_daily_summary_table(
start_date, end_date, cluster_id
)
return bill_ids
def setUp(self):
"""Set up a test with database objects."""
super().setUp()
# Use an OCP provider that does not have a cost model. Any OCP-on-X OCP provider will do
self.provider_uuid = self.ocpaws_provider_uuid
self.creator = ReportObjectCreator(self.schema)
reporting_period = self.creator.create_ocp_report_period(
provider_uuid=self.provider_uuid)
report = self.creator.create_ocp_report(reporting_period)
self.creator.create_ocp_usage_line_item(reporting_period, report)
self.creator.create_ocp_node_label_line_item(reporting_period, report)
self.rates = [
{
"metric": {
"name": "node_cost_per_month",
"label_metric": "Node",
"label_measurement": "Count",
"label_measurement_unit": "node-month",
},
"description": "",
"tag_rates": {
"tag_key":
"app",
"tag_values": [{
"unit": "USD",
"usage": {
"unit": "USD",
"usage_end": "2020-11-11",
"usage_start": "2020-11-11"
},
"value": 123,
"default": True,
"tag_value": "smoke",
"description": "",
}],
},
"cost_type": "Infrastructure",
},
{
"metric": {
"name": "node_cost_per_month",
"label_metric": "Node",
"label_measurement": "Count",
"label_measurement_unit": "node-month",
},
"description": "",
"tag_rates": {
"tag_key":
"web",
"tag_values": [{
"unit": "USD",
"usage": {
"unit": "USD",
"usage_end": "2020-11-11",
"usage_start": "2020-11-11"
},
"value": 456,
"default": True,
"tag_value": "smoker",
"description": "",
}],
},
"cost_type": "Infrastructure",
},
]
self.cost_model = self.creator.create_cost_model(
self.provider_uuid, Provider.PROVIDER_OCP, self.rates)