class CostModelDBAccessorTestNoRateOrMarkup(MasuTestCase):
"""Test Cases for the CostModelDBAccessor object."""
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 test_initializer_no_rate_no_markup(self):
"""Test initializer."""
with CostModelDBAccessor(self.schema, self.provider_uuid,
self.column_map) as cost_model_accessor:
self.assertIsNotNone(cost_model_accessor.report_schema)
def test_get_rates(self):
"""Test get rates."""
with CostModelDBAccessor(self.schema, self.provider_uuid,
self.column_map) as cost_model_accessor:
cpu_usage_rate = cost_model_accessor.get_rates(
'cpu_core_usage_per_hour')
self.assertIsNone(cpu_usage_rate)
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 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 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 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 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.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 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 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 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)
class CostModelDBAccessorTestNoRateOrMarkup(MasuTestCase):
"""Test Cases for the CostModelDBAccessor object."""
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(
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.cost_model = self.creator.create_cost_model(
self.provider_uuid, Provider.PROVIDER_OCP)
def test_initializer_no_rate_no_markup(self):
"""Test initializer."""
with CostModelDBAccessor(self.schema,
self.provider_uuid) as cost_model_accessor:
self.assertEqual(cost_model_accessor.provider_uuid,
self.provider_uuid)
def test_get_rates(self):
"""Test get rates."""
with CostModelDBAccessor(self.schema,
self.provider_uuid) as cost_model_accessor:
cpu_usage_rate = cost_model_accessor.get_rates(
"cpu_core_usage_per_hour")
self.assertIsNone(cpu_usage_rate)
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 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 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.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 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 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.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 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 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 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 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
)
class OCPUtilTests(MasuTestCase):
"""Test the OCP utility functions."""
def setUp(self):
"""Shared variables used by ocp common tests."""
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 test_get_cluster_id_from_provider(self):
"""Test that the cluster ID is returned from OCP provider."""
cluster_id = utils.get_cluster_id_from_provider(self.ocp_test_provider_uuid)
self.assertIsNotNone(cluster_id)
def test_get_cluster_id_from_non_ocp_provider(self):
"""Test that None is returned when getting cluster ID on non-OCP provider."""
cluster_id = utils.get_cluster_id_from_provider(self.aws_provider_uuid)
self.assertIsNone(cluster_id)
def test_get_provider_uuid_from_cluster_id(self):
"""Test that the provider uuid is returned for a cluster ID."""
cluster_id = self.ocp_provider_resource_name
provider_uuid = utils.get_provider_uuid_from_cluster_id(cluster_id)
try:
UUID(provider_uuid)
except ValueError:
self.fail('{} is not a valid uuid.'.format(str(provider_uuid)))
def test_get_provider_uuid_from_invalid_cluster_id(self):
"""Test that the provider uuid is not returned for an invalid cluster ID."""
cluster_id = 'bad_cluster_id'
provider_uuid = utils.get_provider_uuid_from_cluster_id(cluster_id)
self.assertIsNone(provider_uuid)
def test_poll_ingest_override_for_provider(self):
"""Test that OCP polling override returns True if insights local path exists."""
fake_dir = tempfile.mkdtemp()
with patch.object(Config, 'INSIGHTS_LOCAL_REPORT_DIR', fake_dir):
cluster_id = utils.get_cluster_id_from_provider(self.ocp_test_provider_uuid)
expected_path = '{}/{}/'.format(Config.INSIGHTS_LOCAL_REPORT_DIR, cluster_id)
os.makedirs(expected_path, exist_ok=True)
self.assertTrue(utils.poll_ingest_override_for_provider(self.ocp_test_provider_uuid))
shutil.rmtree(fake_dir)
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 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 _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