1 /**
2  * Copyright © 2019 IBM Corporation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 #include "action_environment.hpp"
17 #include "device.hpp"
18 #include "id_map.hpp"
19 #include "rule.hpp"
20 
21 #include <cstddef> // for size_t
22 #include <exception>
23 #include <memory>
24 #include <stdexcept>
25 #include <vector>
26 
27 #include <gtest/gtest.h>
28 
29 using namespace phosphor::power::regulators;
30 
31 TEST(ActionEnvironmentTests, Constructor)
32 {
33     // Create IDMap
34     IDMap idMap{};
35     Device reg1{"regulator1"};
36     idMap.addDevice(reg1);
37 
38     // Verify object state after constructor
39     try
40     {
41         ActionEnvironment env{idMap, "regulator1"};
42         EXPECT_EQ(env.getDevice().getID(), "regulator1");
43         EXPECT_EQ(env.getDeviceID(), "regulator1");
44         EXPECT_EQ(env.getRuleDepth(), 0);
45         EXPECT_THROW(env.getVolts(), std::logic_error);
46         EXPECT_EQ(env.hasVolts(), false);
47     }
48     catch (const std::exception& error)
49     {
50         ADD_FAILURE() << "Should not have caught exception.";
51     }
52 }
53 
54 TEST(ActionEnvironmentTests, DecrementRuleDepth)
55 {
56     IDMap idMap{};
57     ActionEnvironment env{idMap, ""};
58     EXPECT_EQ(env.getRuleDepth(), 0);
59     env.incrementRuleDepth("set_voltage_rule");
60     env.incrementRuleDepth("set_voltage_rule");
61     EXPECT_EQ(env.getRuleDepth(), 2);
62     env.decrementRuleDepth();
63     EXPECT_EQ(env.getRuleDepth(), 1);
64     env.decrementRuleDepth();
65     EXPECT_EQ(env.getRuleDepth(), 0);
66     env.decrementRuleDepth();
67     EXPECT_EQ(env.getRuleDepth(), 0);
68 }
69 
70 TEST(ActionEnvironmentTests, GetDevice)
71 {
72     // Create IDMap
73     IDMap idMap{};
74     Device reg1{"regulator1"};
75     idMap.addDevice(reg1);
76 
77     ActionEnvironment env{idMap, "regulator1"};
78 
79     // Test where current device ID is in the IDMap
80     try
81     {
82         Device& device = env.getDevice();
83         EXPECT_EQ(device.getID(), "regulator1");
84         EXPECT_EQ(&device, &reg1);
85     }
86     catch (const std::exception& error)
87     {
88         ADD_FAILURE() << "Should not have caught exception.";
89     }
90 
91     // Test where current device ID is not in the IDMap
92     env.setDeviceID("regulator2");
93     try
94     {
95         env.getDevice();
96         ADD_FAILURE() << "Should not have reached this line.";
97     }
98     catch (const std::invalid_argument& ia_error)
99     {
100         EXPECT_STREQ(ia_error.what(),
101                      "Unable to find device with ID \"regulator2\"");
102     }
103     catch (const std::exception& error)
104     {
105         ADD_FAILURE() << "Should not have caught exception.";
106     }
107 }
108 
109 TEST(ActionEnvironmentTests, GetDeviceID)
110 {
111     IDMap idMap{};
112     ActionEnvironment env{idMap, ""};
113     EXPECT_EQ(env.getDeviceID(), "");
114     env.setDeviceID("regulator1");
115     EXPECT_EQ(env.getDeviceID(), "regulator1");
116 }
117 
118 TEST(ActionEnvironmentTests, GetRule)
119 {
120     // Create IDMap
121     IDMap idMap{};
122     Rule setVoltageRule{"set_voltage_rule",
123                         std::vector<std::unique_ptr<Action>>{}};
124     idMap.addRule(setVoltageRule);
125 
126     ActionEnvironment env{idMap, ""};
127 
128     // Test where rule ID is in the IDMap
129     try
130     {
131         Rule& rule = env.getRule("set_voltage_rule");
132         EXPECT_EQ(rule.getID(), "set_voltage_rule");
133         EXPECT_EQ(&rule, &setVoltageRule);
134     }
135     catch (const std::exception& error)
136     {
137         ADD_FAILURE() << "Should not have caught exception.";
138     }
139 
140     // Test where rule ID is not in the IDMap
141     try
142     {
143         env.getRule("set_voltage_rule2");
144         ADD_FAILURE() << "Should not have reached this line.";
145     }
146     catch (const std::invalid_argument& ia_error)
147     {
148         EXPECT_STREQ(ia_error.what(),
149                      "Unable to find rule with ID \"set_voltage_rule2\"");
150     }
151     catch (const std::exception& error)
152     {
153         ADD_FAILURE() << "Should not have caught exception.";
154     }
155 }
156 
157 TEST(ActionEnvironmentTests, GetRuleDepth)
158 {
159     IDMap idMap{};
160     ActionEnvironment env{idMap, ""};
161     EXPECT_EQ(env.getRuleDepth(), 0);
162     env.incrementRuleDepth("set_voltage_rule");
163     EXPECT_EQ(env.getRuleDepth(), 1);
164     env.incrementRuleDepth("set_voltage_rule");
165     EXPECT_EQ(env.getRuleDepth(), 2);
166     env.decrementRuleDepth();
167     EXPECT_EQ(env.getRuleDepth(), 1);
168     env.decrementRuleDepth();
169     EXPECT_EQ(env.getRuleDepth(), 0);
170 }
171 
172 TEST(ActionEnvironmentTests, GetVolts)
173 {
174     IDMap idMap{};
175     ActionEnvironment env{idMap, ""};
176     EXPECT_EQ(env.hasVolts(), false);
177 
178     // Test where a volts value has not been set
179     try
180     {
181         env.getVolts();
182     }
183     catch (const std::logic_error& l_error)
184     {
185         EXPECT_STREQ(l_error.what(), "No volts value has been set.");
186     }
187     catch (const std::exception& error)
188     {
189         ADD_FAILURE() << "Should not have caught exception.";
190     }
191 
192     // Test where a volts value has been set
193     env.setVolts(1.31);
194     try
195     {
196         double volts = env.getVolts();
197         EXPECT_EQ(volts, 1.31);
198     }
199     catch (const std::exception& error)
200     {
201         ADD_FAILURE() << "Should not have caught exception.";
202     }
203 }
204 
205 TEST(ActionEnvironmentTests, HasVolts)
206 {
207     IDMap idMap{};
208     ActionEnvironment env{idMap, ""};
209     EXPECT_EQ(env.hasVolts(), false);
210     env.setVolts(1.31);
211     EXPECT_EQ(env.hasVolts(), true);
212 }
213 
214 TEST(ActionEnvironmentTests, IncrementRuleDepth)
215 {
216     IDMap idMap{};
217     ActionEnvironment env{idMap, ""};
218     EXPECT_EQ(env.getRuleDepth(), 0);
219 
220     // Test where rule depth has not exceeded maximum
221     try
222     {
223         for (size_t i = 1; i <= env.maxRuleDepth; ++i)
224         {
225             env.incrementRuleDepth("set_voltage_rule");
226             EXPECT_EQ(env.getRuleDepth(), i);
227         }
228     }
229     catch (const std::exception& error)
230     {
231         ADD_FAILURE() << "Should not have caught exception.";
232     }
233 
234     // Test where rule depth has exceeded maximum
235     try
236     {
237         env.incrementRuleDepth("set_voltage_rule");
238     }
239     catch (const std::runtime_error& r_error)
240     {
241         EXPECT_STREQ(r_error.what(),
242                      "Maximum rule depth exceeded by rule set_voltage_rule.");
243     }
244     catch (const std::exception& error)
245     {
246         ADD_FAILURE() << "Should not have caught exception.";
247     }
248 }
249 
250 TEST(ActionEnvironmentTests, SetDeviceID)
251 {
252     IDMap idMap{};
253     Device reg1{"regulator1"};
254     idMap.addDevice(reg1);
255     ActionEnvironment env{idMap, "regulator1"};
256 
257     EXPECT_EQ(env.getDeviceID(), "regulator1");
258     env.setDeviceID("regulator2");
259     EXPECT_EQ(env.getDeviceID(), "regulator2");
260 }
261 
262 TEST(ActionEnvironmentTests, SetVolts)
263 {
264     try
265     {
266         IDMap idMap{};
267         ActionEnvironment env{idMap, ""};
268         EXPECT_EQ(env.hasVolts(), false);
269         env.setVolts(2.35);
270         EXPECT_EQ(env.hasVolts(), true);
271         EXPECT_EQ(env.getVolts(), 2.35);
272     }
273     catch (const std::exception& error)
274     {
275         ADD_FAILURE() << "Should not have caught exception.";
276     }
277 }
278