yardstick/tests/unit/benchmark/scenarios/energy/test_energy.py

   1 ##############################################################################
   2 # Copyright (c) 2019 Lenovo Group Limited Co.,Ltd and others.
   3 #
   4 # All rights reserved. This program and the accompanying materials
   5 # are made available under the terms of the Apache License, Version 2.0
   6 # which accompanies this distribution, and is available at
   7 # http://www.apache.org/licenses/LICENSE-2.0
   8 ##############################################################################
   9
  10 # Unittest for yardstick.benchmark.scenarios.energy.energy.Energy
  11
  12 from __future__ import absolute_import
  13 import unittest
  14 import mock
  15 import os
  16 from yardstick.benchmark.scenarios.energy import energy
  17
  18
  19 class EnergyTestCase(unittest.TestCase):
  20
  21     def setUp(self):
  22         self.ctx = {
  23             'target': {
  24                 'ip': '172.16.0.137',
  25                 'user': 'root',
  26                 'password': 'passw0rd',
  27                 'redfish_ip': '10.229.17.105',
  28                 'redfish_user': 'USERID',
  29                 'redfish_pwd': "PASSW0RD",
  30             }
  31         }
  32         self.result = {}
  33
  34     @mock.patch('yardstick.benchmark.scenarios.'
  35                 'energy.energy.Energy._send_request')
  36     def test_setup_response_success(self, mock_send_request):
  37         args = {}
  38         p = energy.Energy(args, self.ctx)
  39         mock_send_request.return_value.status_code = 200
  40         p.setup()
  41         self.assertTrue(p.get_response)
  42         self.assertTrue(p.setup_done)
  43
  44     @mock.patch('yardstick.benchmark.scenarios.'
  45                 'energy.energy.Energy._send_request')
  46     def test_setup_response_failed(self, mock_send_request):
  47         args = {}
  48         p = energy.Energy(args, self.ctx)
  49         mock_send_request.return_value.status_code = 404
  50         p.setup()
  51         self.assertFalse(p.get_response)
  52         self.assertTrue(p.setup_done)
  53
  54     @mock.patch('yardstick.benchmark.scenarios.'
  55                 'energy.energy.Energy._send_request')
  56     def test_load_chassis_list_success(self, mock_send_request):
  57         args = {}
  58         p = energy.Energy(args, self.ctx)
  59         expect_result = self._read_file("energy_sample_chassis_output.txt")
  60         expect_result = str(expect_result)
  61         expect_result = expect_result.replace("'", '"')
  62         mock_send_request.return_value.status_code = 200
  63         mock_send_request.return_value.text = expect_result
  64         self.result = p.load_chassis_list()
  65         self.assertEqual(self.result, ["/redfish/v1/Chassis/1"])
  66
  67     @mock.patch('yardstick.benchmark.scenarios.'
  68                 'energy.energy.Energy._send_request')
  69     def test_load_chassis_response_fail(self, mock_send_request):
  70         args = {}
  71         p = energy.Energy(args, self.ctx)
  72         mock_send_request.return_value.status_code = 404
  73         self.result = p.load_chassis_list()
  74         self.assertEqual(self.result, [])
  75
  76     @mock.patch('yardstick.benchmark.scenarios.'
  77                 'energy.energy.Energy._send_request')
  78     def test_load_chassis_wrongtype_response(self, mock_send_request):
  79         args = {}
  80         p = energy.Energy(args, self.ctx)
  81         mock_send_request.return_value.status_code = 200
  82         expect_result = {}
  83         mock_send_request.return_value.text = expect_result
  84         self.result = p.load_chassis_list()
  85         self.assertEqual(self.result, [])
  86
  87     @mock.patch('yardstick.benchmark.scenarios.'
  88                 'energy.energy.Energy._send_request')
  89     def test_load_chassis_inproper_key(self, mock_send_request):
  90         args = {}
  91         p = energy.Energy(args, self.ctx)
  92         mock_send_request.return_value.status_code = 200
  93         expect_result = '{"some_key": "some_value"}'
  94         mock_send_request.return_value.text = expect_result
  95         self.result = p.load_chassis_list()
  96         self.assertEqual(self.result, [])
  97
  98     @mock.patch('yardstick.benchmark.scenarios.'
  99                 'energy.energy.Energy._send_request')
 100     def test_energy_getpower_success(self, mock_send_request):
 101         args = {}
 102         p = energy.Energy(args, self.ctx)
 103         expect_result = self._read_file("energy_sample_power_metrics.txt")
 104         expect_result = str(expect_result)
 105         expect_result = expect_result.replace("'", '"')
 106         mock_send_request.return_value.status_code = 200
 107         mock_send_request.return_value.text = expect_result
 108         self.result = p.get_power("/redfish/v1/Chassis/1")
 109         self.assertEqual(self.result, 344)
 110
 111     @mock.patch('yardstick.benchmark.scenarios.'
 112                 'energy.energy.Energy._send_request')
 113     def test_energy_getpower_response_fail(self, mock_send_request):
 114         args = {}
 115         p = energy.Energy(args, self.ctx)
 116         mock_send_request.return_value.status_code = 404
 117         self.result = p.get_power("/redfish/v1/Chassis/1")
 118         self.assertEqual(self.result, -1)
 119
 120     @mock.patch('yardstick.benchmark.scenarios.'
 121                 'energy.energy.Energy._send_request')
 122     def test_energy_getpower_wrongtype_response(self, mock_send_request):
 123         args = {}
 124         p = energy.Energy(args, self.ctx)
 125         mock_send_request.return_value.status_code = 200
 126         expect_result = {}
 127         mock_send_request.return_value.text = expect_result
 128         self.result = p.get_power("/redfish/v1/Chassis/1")
 129         self.assertEqual(self.result, -1)
 130
 131     @mock.patch('yardstick.benchmark.scenarios.'
 132                 'energy.energy.Energy._send_request')
 133     def test_energy_getpower_inproper_key(self, mock_send_request):
 134         args = {}
 135         p = energy.Energy(args, self.ctx)
 136         mock_send_request.return_value.status_code = 200
 137         expect_result = '{"some_key": "some_value"}'
 138         mock_send_request.return_value.text = expect_result
 139         self.result = p.get_power("/redfish/v1/Chassis/1")
 140         self.assertEqual(self.result, -1)
 141
 142     @mock.patch('yardstick.benchmark.scenarios.'
 143                 'energy.energy.Energy._send_request')
 144     def test_run_success(self, mock_send_request):
 145         args = {}
 146         p = energy.Energy(args, self.ctx)
 147         mock_send_request.return_value.status_code = 200
 148         chassis_list = mock.Mock(return_value=["/redfish/v1/Chassis/1"])
 149         p.load_chassis_list = chassis_list
 150         power = mock.Mock(return_value=344)
 151         p.get_power = power
 152         p.run(self.result)
 153         self.assertEqual(self.result, {"power": 344})
 154
 155     @mock.patch('yardstick.benchmark.scenarios.'
 156                 'energy.energy.Energy._send_request')
 157     def test_run_no_response(self, mock_send_request):
 158         args = {}
 159         p = energy.Energy(args, self.ctx)
 160         mock_send_request.return_value.status_code = 404
 161         chassis_list = mock.Mock(return_value=["/redfish/v1/Chassis/1"])
 162         p.load_chassis_list = chassis_list
 163         p.run(self.result)
 164         self.assertEqual(self.result, {"power": -1})
 165
 166     @mock.patch('yardstick.benchmark.scenarios.'
 167                 'energy.energy.Energy._send_request')
 168     def test_run_wrong_chassis(self, mock_send_request):
 169         args = {}
 170         p = energy.Energy(args, self.ctx)
 171         mock_send_request.return_value.status_code = 200
 172         chassis_list = mock.Mock(return_value=[])
 173         p.load_chassis_list = chassis_list
 174         p.run(self.result)
 175         self.assertEqual(self.result, {"power": -1})
 176
 177     def _read_file(self, filename):
 178         curr_path = os.path.dirname(os.path.abspath(__file__))
 179         output = os.path.join(curr_path, filename)
 180         with open(output) as f:
 181             sample_output = f.read()
 182         return sample_output