diff --git a/rsd_lib/resources/v2_2/system/processor.py b/rsd_lib/resources/v2_2/system/processor.py index 9d77f13..8cc8200 100644 --- a/rsd_lib/resources/v2_2/system/processor.py +++ b/rsd_lib/resources/v2_2/system/processor.py @@ -22,77 +22,90 @@ from rsd_lib.resources.v2_2.system import processor_metrics from rsd_lib import utils as rsd_lib_utils -class OnPackageMemoryField(base.ListField): +class ProcessorMemoryCollectionField(base.ListField): + """ProcessorMemory field - memory_type = base.Field('Type') - """Type of memory""" + On die processor memory + """ - capacity_mb = base.Field('CapacityMB', adapter=rsd_lib_utils.num_or_none) - """Memory capacity""" + type = base.Field("Type") + """Type of memory.""" - speed_mhz = base.Field('SpeedMHz', adapter=rsd_lib_utils.num_or_none) - """Memory speed""" + capacity_mb = base.Field("CapacityMB", adapter=rsd_lib_utils.num_or_none) + """Memory capacity.""" + + speed_mhz = base.Field("SpeedMHz", adapter=rsd_lib_utils.num_or_none) + """Memory speed.""" -class FpgaField(base.CompositeField): +class FPGAField(base.CompositeField): + """FPGA field - fpga_type = base.Field('Type') - """Type of FPGA""" + FPGA properties + """ - bit_stream_version = base.Field('BitStreamVersion') - """Version of BitStream loaded on FPGA""" + type = base.Field("Type") + """FPGA type.""" - hssi_configuration = base.Field('HSSIConfiguration') - """High Speed Serial Interface configuration""" + bit_stream_version = base.Field("BitStreamVersion") + """Version of BitStream loaded on FPGA.""" - hssi_sideband = base.Field('HSSISideband') - """High Speed Serial Interface sideband interface type""" + hssi_configuration = base.Field("HSSIConfiguration") + """High Speed Serial Interface configuration.""" + + hssi_sideband = base.Field("HSSISideband") + """High Speed Serial Interface sideband interface type.""" reconfiguration_slots = base.Field( - 'ReconfigurationSlots', adapter=rsd_lib_utils.num_or_none) - """Number of supported reconfiguration slots""" + "ReconfigurationSlots", adapter=rsd_lib_utils.num_or_none + ) + """Number of supported reconfiguration slots.""" class IntelRackScaleField(processor.IntelRackScaleField): - on_package_memory = OnPackageMemoryField('OnPackageMemory') - """An array of references to the endpoints that connect to this processor + brand = base.Field("Brand") + """This indicates processor brand""" + + capabilities = base.Field("Capabilities") + """This indicates array of processor capabilities""" + + on_package_memory = ProcessorMemoryCollectionField("OnPackageMemory") + """An array of references to the endpoints that connect to this processor. """ thermal_design_power_watt = base.Field( - 'ThermalDesignPowerWatt', adapter=rsd_lib_utils.num_or_none) - """Thermal Design Power (TDP) of this processor""" + "ThermalDesignPowerWatt", adapter=rsd_lib_utils.num_or_none + ) + """Thermal Design Power (TDP) of this processor.""" - metrics = base.Field( - 'Metrics', adapter=rsd_lib_utils.get_resource_identity) - """A reference to the Metrics associated with this Processor""" + fpga = FPGAField("FPGA") + """FPGA specific properties for FPGA ProcessorType.""" extended_identification_registers = rsd_lib_base.DynamicField( - 'ExtendedIdentificationRegisters') + "ExtendedIdentificationRegisters" + ) """Extended contents of the Identification Registers (CPUID) for this processor """ - fpga = FpgaField('FPGA') - """FPGA specific properties for FPGA ProcessorType""" + metrics = base.Field( + "Metrics", adapter=rsd_lib_utils.get_resource_identity + ) + """A reference to the Metrics associated with this Processor""" class OemField(base.CompositeField): - intel_rackscale = IntelRackScaleField('Intel_RackScale') + intel_rackscale = IntelRackScaleField("Intel_RackScale") """Intel Rack Scale Design extensions ('Intel_RackScale' object)""" class Processor(processor.Processor): - oem = OemField('Oem') + oem = OemField("Oem") """Oem extension object""" - def _get_metrics_path(self): - """Helper function to find the System process metrics path""" - return utils.get_sub_resource_path_by( - self, ['Oem', 'Intel_RackScale', 'Metrics']) - @property @utils.cache_it def metrics(self): @@ -102,12 +115,15 @@ class Processor(processor.Processor): this property is reset. """ return processor_metrics.ProcessorMetrics( - self._conn, self._get_metrics_path(), - redfish_version=self.redfish_version) + self._conn, + utils.get_sub_resource_path_by( + self, ["Oem", "Intel_RackScale", "Metrics"] + ), + redfish_version=self.redfish_version, + ) class ProcessorCollection(processor.ProcessorCollection): - @property def _resource_type(self): return Processor diff --git a/rsd_lib/resources/v2_2/system/processor_metrics.py b/rsd_lib/resources/v2_2/system/processor_metrics.py index f220c1e..67dcccb 100644 --- a/rsd_lib/resources/v2_2/system/processor_metrics.py +++ b/rsd_lib/resources/v2_2/system/processor_metrics.py @@ -15,34 +15,41 @@ from sushy.resources import base +from rsd_lib import base as rsd_lib_base from rsd_lib import utils as rsd_lib_utils -class ProcessorMetrics(base.ResourceBase): - name = base.Field('Name') - """The metrics name""" +class ProcessorMetrics(rsd_lib_base.ResourceBase): + """ProcessorMetrics resource class - description = base.Field('Description') - """The metrics description""" + ProcessorMetrics contains usage and health statistics for a Processor + (all Cores) . + """ - identity = base.Field('Id') - """The metrics identity""" + bandwidth_percent = base.Field( + "BandwidthPercent", adapter=rsd_lib_utils.num_or_none + ) + """CPU Bandwidth in [%]""" - average_frequency_mhz = base.Field('AverageFrequencyMHz', - adapter=rsd_lib_utils.num_or_none) - """The processor average frequency mhz""" + average_frequency_mhz = base.Field( + "AverageFrequencyMHz", adapter=rsd_lib_utils.num_or_none + ) + """Average frequency [MHz]""" - throttling_celsius = base.Field('ThrottlingCelsius', - adapter=rsd_lib_utils.num_or_none) - """The processor throttling celsius""" + throttling_celsius = base.Field( + "ThrottlingCelsius", adapter=rsd_lib_utils.num_or_none + ) + """CPU Margin to throttle (temperature offset in degree Celsius)""" - temperature_celsius = base.Field('TemperatureCelsius', - adapter=rsd_lib_utils.num_or_none) - """The processor temperature celsius""" + temperature_celsius = base.Field( + "TemperatureCelsius", adapter=rsd_lib_utils.num_or_none + ) + """Temperature of the Processor resource""" - consumed_power_watt = base.Field('ConsumedPowerWatt', - adapter=rsd_lib_utils.num_or_none) - """The processor consumed power watt""" + consumed_power_watt = base.Field( + "ConsumedPowerWatt", adapter=rsd_lib_utils.num_or_none + ) + """Power consumed by Processor resource""" - health = base.Field('Health') - """The detail health information""" + health = base.Field("Health") + """CPU Health as a discrete sensor reading""" diff --git a/rsd_lib/tests/unit/resources/v2_2/system/test_processor.py b/rsd_lib/tests/unit/resources/v2_2/system/test_processor.py index 4ac88c7..41cb1bf 100644 --- a/rsd_lib/tests/unit/resources/v2_2/system/test_processor.py +++ b/rsd_lib/tests/unit/resources/v2_2/system/test_processor.py @@ -17,266 +17,317 @@ import json import mock import testtools -from sushy import exceptions - from rsd_lib.resources.v2_2.system import processor from rsd_lib.resources.v2_2.system import processor_metrics class ProcessorTestCase(testtools.TestCase): - def setUp(self): super(ProcessorTestCase, self).setUp() self.conn = mock.Mock() - with open('rsd_lib/tests/unit/json_samples/v2_2/processor.json', - 'r') as f: + with open( + "rsd_lib/tests/unit/json_samples/v2_2/processor.json", "r" + ) as f: self.conn.get.return_value.json.return_value = json.loads(f.read()) self.processor_inst = processor.Processor( - self.conn, '/redfish/v1/Systems/System1/Processors/CPU1', - redfish_version='1.1.0') + self.conn, + "/redfish/v1/Systems/System1/Processors/CPU1", + redfish_version="1.1.0", + ) def test__parse_attributes(self): self.processor_inst._parse_attributes() - self.assertEqual('1.1.0', self.processor_inst.redfish_version) - self.assertEqual('CPU1', self.processor_inst.identity) - self.assertEqual('Processor', self.processor_inst.name) + self.assertEqual("1.1.0", self.processor_inst.redfish_version) + self.assertEqual("CPU1", self.processor_inst.identity) + self.assertEqual("Processor", self.processor_inst.name) self.assertEqual(None, self.processor_inst.description) - self.assertEqual('CPU 1', self.processor_inst.socket) - self.assertEqual('CPU', self.processor_inst.processor_type) - self.assertEqual('x86', self.processor_inst.processor_architecture) - self.assertEqual('x86-64', self.processor_inst.instruction_set) - self.assertEqual('Intel(R) Corporation', - self.processor_inst.manufacturer) - self.assertEqual('Multi-Core Intel(R) Xeon(R) processor 7xxx Series', - self.processor_inst.model) + self.assertEqual("CPU 1", self.processor_inst.socket) + self.assertEqual("CPU", self.processor_inst.processor_type) + self.assertEqual("x86", self.processor_inst.processor_architecture) + self.assertEqual("x86-64", self.processor_inst.instruction_set) + self.assertEqual( + "Intel(R) Corporation", self.processor_inst.manufacturer + ) + self.assertEqual( + "Multi-Core Intel(R) Xeon(R) processor 7xxx Series", + self.processor_inst.model, + ) self.assertEqual(3700, self.processor_inst.max_speed_mhz) self.assertEqual( - '0x42', self.processor_inst.processor_id.effective_family) + "0x42", self.processor_inst.processor_id.effective_family + ) self.assertEqual( - '0x61', self.processor_inst.processor_id.effective_model) + "0x61", self.processor_inst.processor_id.effective_model + ) self.assertEqual( - '0x34AC34DC8901274A', - self.processor_inst.processor_id.identification_registers) + "0x34AC34DC8901274A", + self.processor_inst.processor_id.identification_registers, + ) self.assertEqual( - '0x429943', self.processor_inst.processor_id.microcode_info) - self.assertEqual('0x1', self.processor_inst.processor_id.step) + "0x429943", self.processor_inst.processor_id.microcode_info + ) + self.assertEqual("0x1", self.processor_inst.processor_id.step) self.assertEqual( - 'GenuineIntel', self.processor_inst.processor_id.vendor_id) - self.assertEqual('OK', self.processor_inst.status.health) - self.assertEqual('OK', self.processor_inst.status.health_rollup) - self.assertEqual('Enabled', self.processor_inst.status.state) + "GenuineIntel", self.processor_inst.processor_id.vendor_id + ) + self.assertEqual("OK", self.processor_inst.status.health) + self.assertEqual("OK", self.processor_inst.status.health_rollup) + self.assertEqual("Enabled", self.processor_inst.status.state) self.assertEqual(8, self.processor_inst.total_cores) self.assertEqual(16, self.processor_inst.total_threads) - self.assertEqual('E5', self.processor_inst.oem.intel_rackscale.brand) + self.assertEqual("E5", self.processor_inst.oem.intel_rackscale.brand) self.assertEqual( - ['sse', 'sse2', 'sse3'], - self.processor_inst.oem.intel_rackscale.capabilities) + ["sse", "sse2", "sse3"], + self.processor_inst.oem.intel_rackscale.capabilities, + ) self.assertEqual( - 'L2Cache', - self.processor_inst.oem.intel_rackscale.on_package_memory[0]. - memory_type) + "L2Cache", + self.processor_inst.oem.intel_rackscale.on_package_memory[0].type, + ) self.assertEqual( 2, - self.processor_inst.oem.intel_rackscale.on_package_memory[0]. - capacity_mb) + self.processor_inst.oem.intel_rackscale.on_package_memory[ + 0 + ].capacity_mb, + ) self.assertEqual( None, - self.processor_inst.oem.intel_rackscale.on_package_memory[0]. - speed_mhz) + self.processor_inst.oem.intel_rackscale.on_package_memory[ + 0 + ].speed_mhz, + ) self.assertEqual( - 'L3Cache', - self.processor_inst.oem.intel_rackscale.on_package_memory[1]. - memory_type) + "L3Cache", + self.processor_inst.oem.intel_rackscale.on_package_memory[1].type, + ) self.assertEqual( 20, - self.processor_inst.oem.intel_rackscale.on_package_memory[1]. - capacity_mb) + self.processor_inst.oem.intel_rackscale.on_package_memory[ + 1 + ].capacity_mb, + ) self.assertEqual( None, - self.processor_inst.oem.intel_rackscale.on_package_memory[1]. - speed_mhz) + self.processor_inst.oem.intel_rackscale.on_package_memory[ + 1 + ].speed_mhz, + ) self.assertEqual( 160, - self.processor_inst.oem.intel_rackscale.thermal_design_power_watt) + self.processor_inst.oem.intel_rackscale.thermal_design_power_watt, + ) self.assertEqual( - '/redfish/v1/Systems/System1/Processors/CPU1/Metrics', - self.processor_inst.oem.intel_rackscale.metrics) + "/redfish/v1/Systems/System1/Processors/CPU1/Metrics", + self.processor_inst.oem.intel_rackscale.metrics, + ) self.assertEqual( "0x0429943FFFFFFFFF", self.processor_inst.oem.intel_rackscale. - extended_identification_registers.eax_00h) + extended_identification_registers.eax_00h, + ) self.assertEqual( "0x0429943FFFFFFFFF", self.processor_inst.oem.intel_rackscale. - extended_identification_registers.eax_01h) + extended_identification_registers.eax_01h, + ) self.assertEqual( "0x0429943FFFFFFFFF", self.processor_inst.oem.intel_rackscale. - extended_identification_registers.eax_02h) + extended_identification_registers.eax_02h, + ) self.assertEqual( "0x0429943FFFFFFFFF", self.processor_inst.oem.intel_rackscale. - extended_identification_registers.eax_03h) + extended_identification_registers.eax_03h, + ) self.assertEqual( "0x0429943FFFFFFFFF", self.processor_inst.oem.intel_rackscale. - extended_identification_registers.eax_04h) + extended_identification_registers.eax_04h, + ) self.assertEqual( "0x0429943FFFFFFFFF", self.processor_inst.oem.intel_rackscale. - extended_identification_registers.eax_05h) + extended_identification_registers.eax_05h, + ) self.assertEqual( "0x0429943FFFFFFFFF", self.processor_inst.oem.intel_rackscale. - extended_identification_registers.eax_07h) + extended_identification_registers.eax_07h, + ) self.assertEqual( "0x0429943FFFFFFFFF", self.processor_inst.oem.intel_rackscale. - extended_identification_registers.eax_80000000h) + extended_identification_registers.eax_80000000h, + ) self.assertEqual( "0x0429943FFFFFFFFF", self.processor_inst.oem.intel_rackscale. - extended_identification_registers.eax_80000001h) + extended_identification_registers.eax_80000001h, + ) self.assertEqual( "0x0429943FFFFFFFFF", self.processor_inst.oem.intel_rackscale. - extended_identification_registers.eax_80000002h) + extended_identification_registers.eax_80000002h, + ) self.assertEqual( "0x0429943FFFFFFFFF", self.processor_inst.oem.intel_rackscale. - extended_identification_registers.eax_80000003h) + extended_identification_registers.eax_80000003h, + ) self.assertEqual( "0x0429943FFFFFFFFF", self.processor_inst.oem.intel_rackscale. - extended_identification_registers.eax_80000004h) + extended_identification_registers.eax_80000004h, + ) self.assertEqual( "0x0429943FFFFFFFFF", self.processor_inst.oem.intel_rackscale. - extended_identification_registers.eax_80000005h) + extended_identification_registers.eax_80000005h, + ) self.assertEqual( "0x0429943FFFFFFFFF", self.processor_inst.oem.intel_rackscale. - extended_identification_registers.eax_80000006h) + extended_identification_registers.eax_80000006h, + ) self.assertEqual( "0x0429943FFFFFFFFF", self.processor_inst.oem.intel_rackscale. - extended_identification_registers.eax_80000007h) + extended_identification_registers.eax_80000007h, + ) self.assertEqual( "0x0429943FFFFFFFFF", self.processor_inst.oem.intel_rackscale. - extended_identification_registers.eax_80000008h) + extended_identification_registers.eax_80000008h, + ) self.assertEqual( - 'Integrated', - self.processor_inst.oem.intel_rackscale.fpga.fpga_type) + "Integrated", self.processor_inst.oem.intel_rackscale.fpga.type + ) self.assertEqual( - 'Blue1', - self.processor_inst.oem.intel_rackscale.fpga.bit_stream_version) + "Blue1", + self.processor_inst.oem.intel_rackscale.fpga.bit_stream_version, + ) self.assertEqual( - '4x10G', - self.processor_inst.oem.intel_rackscale.fpga.hssi_configuration) + "4x10G", + self.processor_inst.oem.intel_rackscale.fpga.hssi_configuration, + ) self.assertEqual( - 'I2C', self.processor_inst.oem.intel_rackscale.fpga.hssi_sideband) + "I2C", self.processor_inst.oem.intel_rackscale.fpga.hssi_sideband + ) self.assertEqual( 1, - self.processor_inst.oem.intel_rackscale.fpga.reconfiguration_slots) - - def test__get_metrics_path(self): - self.assertEqual('/redfish/v1/Systems/System1/Processors/CPU1/Metrics', - self.processor_inst._get_metrics_path()) - - def test__get_metrics_path_missing_attr(self): - self.processor_inst._json.get('Oem').get('Intel_RackScale')\ - .pop('Metrics') - with self.assertRaisesRegex(exceptions.MissingAttributeError, - 'attribute Oem/Intel_RackScale/Metrics'): - self.processor_inst._get_metrics_path() + self.processor_inst.oem.intel_rackscale.fpga.reconfiguration_slots, + ) def test_metrics(self): # | GIVEN | self.conn.get.return_value.json.reset_mock() - with open('rsd_lib/tests/unit/json_samples/v2_2/' - 'processor_metrics.json', 'r') as f: + with open( + "rsd_lib/tests/unit/json_samples/v2_2/" "processor_metrics.json", + "r", + ) as f: self.conn.get.return_value.json.return_value = json.loads(f.read()) # | WHEN | actual_metrics = self.processor_inst.metrics # | THEN | - self.assertIsInstance(actual_metrics, - processor_metrics.ProcessorMetrics) + self.assertIsInstance( + actual_metrics, processor_metrics.ProcessorMetrics + ) self.conn.get.return_value.json.assert_called_once_with() # reset mock self.conn.get.return_value.json.reset_mock() # | WHEN & THEN | # tests for same object on invoking subsequently - self.assertIs(actual_metrics, - self.processor_inst.metrics) + self.assertIs(actual_metrics, self.processor_inst.metrics) self.conn.get.return_value.json.assert_not_called() def test_metrics_on_refresh(self): # | GIVEN | - with open('rsd_lib/tests/unit/json_samples/v2_2/' - 'processor_metrics.json', 'r') as f: + with open( + "rsd_lib/tests/unit/json_samples/v2_2/" "processor_metrics.json", + "r", + ) as f: self.conn.get.return_value.json.return_value = json.loads(f.read()) # | WHEN & THEN | - self.assertIsInstance(self.processor_inst.metrics, - processor_metrics.ProcessorMetrics) + self.assertIsInstance( + self.processor_inst.metrics, processor_metrics.ProcessorMetrics + ) # On refreshing the processor instance... - with open('rsd_lib/tests/unit/json_samples/v2_2/processor.json', - 'r') as f: + with open( + "rsd_lib/tests/unit/json_samples/v2_2/processor.json", "r" + ) as f: self.conn.get.return_value.json.return_value = json.loads(f.read()) self.processor_inst.invalidate() self.processor_inst.refresh(force=False) # | GIVEN | - with open('rsd_lib/tests/unit/json_samples/v2_2/' - 'processor_metrics.json', 'r') as f: + with open( + "rsd_lib/tests/unit/json_samples/v2_2/" "processor_metrics.json", + "r", + ) as f: self.conn.get.return_value.json.return_value = json.loads(f.read()) # | WHEN & THEN | - self.assertIsInstance(self.processor_inst.metrics, - processor_metrics.ProcessorMetrics) + self.assertIsInstance( + self.processor_inst.metrics, processor_metrics.ProcessorMetrics + ) class ProcessorCollectionTestCase(testtools.TestCase): - def setUp(self): super(ProcessorCollectionTestCase, self).setUp() self.conn = mock.Mock() - with open('rsd_lib/tests/unit/json_samples/v2_2/' - 'processor_collection.json', 'r') as f: + with open( + "rsd_lib/tests/unit/json_samples/v2_2/" + "processor_collection.json", + "r", + ) as f: self.conn.get.return_value.json.return_value = json.loads(f.read()) self.processor_col = processor.ProcessorCollection( - self.conn, '/redfish/v1/Systems/System1/Processors', - redfish_version='1.1.0') + self.conn, + "/redfish/v1/Systems/System1/Processors", + redfish_version="1.1.0", + ) def test__parse_attributes(self): self.processor_col._parse_attributes() - self.assertEqual('1.1.0', self.processor_col.redfish_version) - self.assertEqual(('/redfish/v1/Systems/System1/Processors/CPU1', - '/redfish/v1/Systems/System1/Processors/CPU2'), - self.processor_col.members_identities) + self.assertEqual("1.1.0", self.processor_col.redfish_version) + self.assertEqual( + ( + "/redfish/v1/Systems/System1/Processors/CPU1", + "/redfish/v1/Systems/System1/Processors/CPU2", + ), + self.processor_col.members_identities, + ) - @mock.patch.object(processor, 'Processor', autospec=True) + @mock.patch.object(processor, "Processor", autospec=True) def test_get_member(self, mock_system): self.processor_col.get_member( - '/redfish/v1/Systems/System1/Processors/CPU1') + "/redfish/v1/Systems/System1/Processors/CPU1" + ) mock_system.assert_called_once_with( self.processor_col._conn, - '/redfish/v1/Systems/System1/Processors/CPU1', - redfish_version=self.processor_col.redfish_version) + "/redfish/v1/Systems/System1/Processors/CPU1", + redfish_version=self.processor_col.redfish_version, + ) - @mock.patch.object(processor, 'Processor', autospec=True) + @mock.patch.object(processor, "Processor", autospec=True) def test_get_members(self, mock_system): members = self.processor_col.get_members() calls = [ - mock.call(self.processor_col._conn, - '/redfish/v1/Systems/System1/Processors/CPU1', - redfish_version=self.processor_col.redfish_version), - mock.call(self.processor_col._conn, - '/redfish/v1/Systems/System1/Processors/CPU2', - redfish_version=self.processor_col.redfish_version) + mock.call( + self.processor_col._conn, + "/redfish/v1/Systems/System1/Processors/CPU1", + redfish_version=self.processor_col.redfish_version, + ), + mock.call( + self.processor_col._conn, + "/redfish/v1/Systems/System1/Processors/CPU2", + redfish_version=self.processor_col.redfish_version, + ), ] mock_system.assert_has_calls(calls) self.assertIsInstance(members, list) diff --git a/rsd_lib/tests/unit/resources/v2_2/system/test_processor_metrics.py b/rsd_lib/tests/unit/resources/v2_2/system/test_processor_metrics.py index 0e35d7c..62376f5 100644 --- a/rsd_lib/tests/unit/resources/v2_2/system/test_processor_metrics.py +++ b/rsd_lib/tests/unit/resources/v2_2/system/test_processor_metrics.py @@ -22,31 +22,40 @@ from rsd_lib.resources.v2_2.system import processor_metrics class ProcessorMetricsTestCase(testtools.TestCase): - def setUp(self): super(ProcessorMetricsTestCase, self).setUp() self.conn = mock.Mock() - with open('rsd_lib/tests/unit/json_samples/v2_2/' - 'processor_metrics.json', 'r') as f: + with open( + "rsd_lib/tests/unit/json_samples/v2_2/" "processor_metrics.json", + "r", + ) as f: self.conn.get.return_value.json.return_value = json.loads(f.read()) self.processor_metrics_inst = processor_metrics.ProcessorMetrics( - self.conn, '/redfish/v1/Systems/System1/Metrics', - redfish_version='1.1.0') + self.conn, + "/redfish/v1/Systems/System1/Metrics", + redfish_version="1.1.0", + ) def test__parse_attributes(self): self.processor_metrics_inst._parse_attributes() - self.assertEqual('1.1.0', self.processor_metrics_inst.redfish_version) - self.assertEqual('ProcessorMetrics for CPU1', - self.processor_metrics_inst.name) - self.assertEqual('description-as-string', - self.processor_metrics_inst.description) - self.assertEqual('Metrics for CPU1', - self.processor_metrics_inst.identity) + self.assertEqual("1.1.0", self.processor_metrics_inst.redfish_version) self.assertEqual( - 3014, self.processor_metrics_inst.average_frequency_mhz) + "ProcessorMetrics for CPU1", self.processor_metrics_inst.name + ) + self.assertEqual( + "description-as-string", self.processor_metrics_inst.description + ) + self.assertEqual( + "Metrics for CPU1", self.processor_metrics_inst.identity + ) + self.assertEqual( + 3014, self.processor_metrics_inst.average_frequency_mhz + ) self.assertEqual(19, self.processor_metrics_inst.throttling_celsius) self.assertEqual(73, self.processor_metrics_inst.temperature_celsius) self.assertEqual(153, self.processor_metrics_inst.consumed_power_watt) - self.assertEqual(["FRB1 BIST Failure", "Processor Throttled"], - self.processor_metrics_inst.health) + self.assertEqual( + ["FRB1 BIST Failure", "Processor Throttled"], + self.processor_metrics_inst.health, + )