blob: 86e86e9709d0c5e184c265c11f7e8f62206a3708 [file] [log] [blame]
Tom Tung043af592023-11-24 13:37:05 +08001#include "estoraged_conf.hpp"
John Wedigd32b9662022-04-13 18:12:25 -07002#include "getConfig.hpp"
3
John Wedigd32b9662022-04-13 18:12:25 -07004#include <boost/container/flat_map.hpp>
John Edward Broadbent5d799bb2022-03-22 16:14:24 -07005#include <util.hpp>
6
John Wedigd32b9662022-04-13 18:12:25 -07007#include <filesystem>
John Edward Broadbent5d799bb2022-03-22 16:14:24 -07008#include <fstream>
9
10#include <gmock/gmock-matchers.h>
11#include <gmock/gmock.h>
12#include <gtest/gtest.h>
13
14namespace estoraged_test
15{
16using estoraged::util::findPredictedMediaLifeLeftPercent;
John Wedigb4838302022-07-22 13:51:16 -070017using estoraged::util::getPartNumber;
18using estoraged::util::getSerialNumber;
John Edward Broadbent5d799bb2022-03-22 16:14:24 -070019
20TEST(utilTest, passFindPredictedMediaLife)
21{
22 std::string prefixName = ".";
23 std::string testFileName = prefixName + "/life_time";
24 std::ofstream testFile;
25 testFile.open(testFileName,
26 std::ios::out | std::ios::binary | std::ios::trunc);
27 testFile << "0x07 0x04";
28 testFile.close();
29 EXPECT_EQ(findPredictedMediaLifeLeftPercent(prefixName), 40);
John Wedigb4838302022-07-22 13:51:16 -070030 EXPECT_TRUE(std::filesystem::remove(testFileName));
John Edward Broadbent5d799bb2022-03-22 16:14:24 -070031}
32
33TEST(utilTest, estimatesSame)
34{
John Edward Broadbent5d799bb2022-03-22 16:14:24 -070035 std::string prefixName = ".";
36 std::string testFileName = prefixName + "/life_time";
37 std::ofstream testFile;
38 testFile.open(testFileName,
39 std::ios::out | std::ios::binary | std::ios::trunc);
40 testFile << "0x04 0x04";
41 testFile.close();
42
43 EXPECT_EQ(findPredictedMediaLifeLeftPercent(prefixName), 70);
John Wedigb4838302022-07-22 13:51:16 -070044 EXPECT_TRUE(std::filesystem::remove(testFileName));
John Edward Broadbent5d799bb2022-03-22 16:14:24 -070045}
46
47TEST(utilTest, estimatesNotAvailable)
48{
John Edward Broadbent5d799bb2022-03-22 16:14:24 -070049 std::string prefixName = ".";
50 std::string testFileName = prefixName + "/life_time";
51 std::ofstream testFile;
52 testFile.open(testFileName,
53 std::ios::out | std::ios::binary | std::ios::trunc);
54 testFile.close();
55
56 EXPECT_EQ(findPredictedMediaLifeLeftPercent(prefixName), 255);
John Wedigb4838302022-07-22 13:51:16 -070057 EXPECT_TRUE(std::filesystem::remove(testFileName));
58}
59
60TEST(utilTest, getPartNumberFail)
61{
62 std::string prefixName = ".";
63 std::string testFileName = prefixName + "/name";
64 /* The part name file won't exist for this test. */
65 EXPECT_EQ(getPartNumber(prefixName), "unknown");
66}
67
68TEST(utilTest, getPartNumberPass)
69{
70 std::string prefixName = ".";
71 std::string testFileName = prefixName + "/name";
72 std::ofstream testFile;
73 testFile.open(testFileName,
74 std::ios::out | std::ios::binary | std::ios::trunc);
75 testFile << "ABCD1234";
76 testFile.close();
77 EXPECT_EQ(getPartNumber(prefixName), "ABCD1234");
78 EXPECT_TRUE(std::filesystem::remove(testFileName));
79}
80
81TEST(utilTest, getSerialNumberFail)
82{
83 std::string prefixName = ".";
84 std::string testFileName = prefixName + "/serial";
85 /* The serial number file won't exist for this test. */
86 EXPECT_EQ(getSerialNumber(prefixName), "unknown");
87}
88
89TEST(utilTest, getSerialNumberPass)
90{
91 std::string prefixName = ".";
92 std::string testFileName = prefixName + "/serial";
93 std::ofstream testFile;
94 testFile.open(testFileName,
95 std::ios::out | std::ios::binary | std::ios::trunc);
96 testFile << "0x12345678";
97 testFile.close();
98 EXPECT_EQ(getSerialNumber(prefixName), "0x12345678");
99 EXPECT_TRUE(std::filesystem::remove(testFileName));
John Edward Broadbent5d799bb2022-03-22 16:14:24 -0700100}
101
John Wedigd32b9662022-04-13 18:12:25 -0700102/* Test case where we successfully find the device file. */
103TEST(utilTest, findDevicePass)
104{
105 estoraged::StorageData data;
106
107 /* Set up the map of properties. */
108 data.emplace(std::string("Type"),
109 estoraged::BasicVariantType("EmmcDevice"));
110 data.emplace(std::string("Name"), estoraged::BasicVariantType("emmc"));
Rahul Kapoor19825052023-05-27 01:52:23 +0000111 data.emplace(std::string("LocationCode"),
112 estoraged::BasicVariantType("U102020"));
John Wedigd32b9662022-04-13 18:12:25 -0700113
John Wedigf78215f2022-06-07 13:39:22 -0700114 /* Create a dummy device. */
115 std::filesystem::create_directories("abc/device");
116 const std::string dummyTypeFileName("abc/device/type");
117 std::ofstream dummyTypeFile(dummyTypeFileName,
118 std::ios::out | std::ios::trunc);
119 dummyTypeFile << "SSD";
120 dummyTypeFile.close();
John Wedigd32b9662022-04-13 18:12:25 -0700121
John Wedigf78215f2022-06-07 13:39:22 -0700122 /* Another device. */
123 std::filesystem::create_directories("def/device");
124
125 /* Create a dummy eMMC device. */
126 std::filesystem::create_directories("mmcblk0/device");
127 const std::string typeFileName("mmcblk0/device/type");
128 std::ofstream typeFile(typeFileName, std::ios::out | std::ios::trunc);
129 typeFile << "MMC";
130 typeFile.close();
John Wedigd32b9662022-04-13 18:12:25 -0700131
132 /* Look for the device file. */
133 std::filesystem::path deviceFile, sysfsDir;
Rahul Kapoor19825052023-05-27 01:52:23 +0000134 std::string luksName, locationCode;
Tom Tung043af592023-11-24 13:37:05 +0800135 auto result = estoraged::util::findDevice(data,
136 std::filesystem::path("./"));
137 EXPECT_TRUE(result.has_value());
John Wedigd32b9662022-04-13 18:12:25 -0700138
139 /* Validate the results. */
Tom Tung043af592023-11-24 13:37:05 +0800140 EXPECT_EQ("/dev/mmcblk0", result->deviceFile.string());
141 EXPECT_EQ("./mmcblk0/device", result->sysfsDir.string());
142 EXPECT_EQ("luks-mmcblk0", result->luksName);
143 EXPECT_EQ("U102020", result->locationCode);
144 EXPECT_EQ(ERASE_MAX_GEOMETRY, result->eraseMaxGeometry);
145 EXPECT_EQ(ERASE_MIN_GEOMETRY, result->eraseMinGeometry);
John Wedigd7be42b2024-01-19 16:07:19 -0800146 EXPECT_EQ("SSD", result->driveType);
Tom Tung043af592023-11-24 13:37:05 +0800147
148 /* Delete the dummy files. */
149 EXPECT_EQ(3U, std::filesystem::remove_all("mmcblk0"));
150 EXPECT_EQ(3U, std::filesystem::remove_all("abc"));
151 EXPECT_EQ(2U, std::filesystem::remove_all("def"));
152}
153
154/* Test case where we successfully find the device file with updating the
155 * min/max geometry. */
156TEST(utilTest, findDeviceWithMaxAndMinGeometryPass)
157{
158 estoraged::StorageData data;
159
160 /* Set up the map of properties. */
161 data.emplace(std::string("Type"),
162 estoraged::BasicVariantType("EmmcDevice"));
163 data.emplace(std::string("Name"), estoraged::BasicVariantType("emmc"));
164 data.emplace(std::string("LocationCode"),
165 estoraged::BasicVariantType("U102020"));
166 data.emplace(std::string("EraseMaxGeometry"),
167 estoraged::BasicVariantType((uint64_t)5566));
168 data.emplace(std::string("EraseMinGeometry"),
169 estoraged::BasicVariantType((uint64_t)1234));
170
171 /* Create a dummy device. */
172 std::filesystem::create_directories("abc/device");
173 const std::string dummyTypeFileName("abc/device/type");
174 std::ofstream dummyTypeFile(dummyTypeFileName,
175 std::ios::out | std::ios::trunc);
176 dummyTypeFile << "SSD";
177 dummyTypeFile.close();
178
179 /* Another device. */
180 std::filesystem::create_directories("def/device");
181
182 /* Create a dummy eMMC device. */
183 std::filesystem::create_directories("mmcblk0/device");
184 const std::string typeFileName("mmcblk0/device/type");
185 std::ofstream typeFile(typeFileName, std::ios::out | std::ios::trunc);
186 typeFile << "MMC";
187 typeFile.close();
188
189 /* Look for the device file. */
190 std::filesystem::path deviceFile, sysfsDir;
191 std::string luksName, locationCode;
192 auto result = estoraged::util::findDevice(data,
193 std::filesystem::path("./"));
194 EXPECT_TRUE(result.has_value());
195
196 /* Validate the results. */
197 EXPECT_EQ("/dev/mmcblk0", result->deviceFile.string());
198 EXPECT_EQ("./mmcblk0/device", result->sysfsDir.string());
199 EXPECT_EQ("luks-mmcblk0", result->luksName);
200 EXPECT_EQ("U102020", result->locationCode);
201 EXPECT_EQ(5566, result->eraseMaxGeometry);
202 EXPECT_EQ(1234, result->eraseMinGeometry);
John Wedigd7be42b2024-01-19 16:07:19 -0800203 EXPECT_EQ("SSD", result->driveType);
John Wedigd32b9662022-04-13 18:12:25 -0700204
205 /* Delete the dummy files. */
John Edward Broadbent9e639822022-06-10 10:16:05 -0700206 EXPECT_EQ(3U, std::filesystem::remove_all("mmcblk0"));
207 EXPECT_EQ(3U, std::filesystem::remove_all("abc"));
208 EXPECT_EQ(2U, std::filesystem::remove_all("def"));
John Wedigd32b9662022-04-13 18:12:25 -0700209}
210
211/* Test case where the "Type" property doesn't exist. */
212TEST(utilTest, findDeviceNoTypeFail)
213{
214 estoraged::StorageData data;
215
216 /* Set up the map of properties (with the "Type" property missing). */
217 data.emplace(std::string("Name"), estoraged::BasicVariantType("emmc"));
218
John Wedigf78215f2022-06-07 13:39:22 -0700219 /* Create a dummy device. */
220 std::filesystem::create_directories("abc/device");
221 const std::string dummyTypeFileName("abc/device/type");
222 std::ofstream dummyTypeFile(dummyTypeFileName,
223 std::ios::out | std::ios::trunc);
224 dummyTypeFile << "SSD";
225 dummyTypeFile.close();
John Wedigd32b9662022-04-13 18:12:25 -0700226
John Wedigf78215f2022-06-07 13:39:22 -0700227 /* Another device. */
228 std::filesystem::create_directories("def/device");
229
230 /* Create a dummy eMMC device. */
231 std::filesystem::create_directories("mmcblk0/device");
232 const std::string typeFileName("mmcblk0/device/type");
233 std::ofstream typeFile(typeFileName, std::ios::out | std::ios::trunc);
234 typeFile << "MMC";
235 typeFile.close();
John Wedigd32b9662022-04-13 18:12:25 -0700236
237 /* Look for the device file. */
Tom Tung043af592023-11-24 13:37:05 +0800238 auto result = estoraged::util::findDevice(data,
239 std::filesystem::path("./"));
240 EXPECT_FALSE(result.has_value());
John Wedigd32b9662022-04-13 18:12:25 -0700241
242 /* Delete the dummy files. */
John Edward Broadbent9e639822022-06-10 10:16:05 -0700243 EXPECT_EQ(3U, std::filesystem::remove_all("mmcblk0"));
244 EXPECT_EQ(3U, std::filesystem::remove_all("abc"));
245 EXPECT_EQ(2U, std::filesystem::remove_all("def"));
John Wedigd32b9662022-04-13 18:12:25 -0700246}
247
248/* Test case where the device type is not supported. */
249TEST(utilTest, findDeviceUnsupportedTypeFail)
250{
251 estoraged::StorageData data;
252
253 /* Set up the map of properties (with an unsupported "Type"). */
254 data.emplace(std::string("Type"), estoraged::BasicVariantType("NvmeDrive"));
255 data.emplace(std::string("Name"),
256 estoraged::BasicVariantType("some_drive"));
257
John Wedigf78215f2022-06-07 13:39:22 -0700258 /* Create a dummy device. */
259 std::filesystem::create_directories("abc/device");
260 const std::string dummyTypeFileName("abc/device/type");
261 std::ofstream dummyTypeFile(dummyTypeFileName,
262 std::ios::out | std::ios::trunc);
263 dummyTypeFile << "SSD";
264 dummyTypeFile.close();
John Wedigd32b9662022-04-13 18:12:25 -0700265
John Wedigf78215f2022-06-07 13:39:22 -0700266 /* Another device. */
267 std::filesystem::create_directories("def/device");
268
269 /* Create a dummy eMMC device. */
270 std::filesystem::create_directories("mmcblk0/device");
271 const std::string typeFileName("mmcblk0/device/type");
272 std::ofstream typeFile(typeFileName, std::ios::out | std::ios::trunc);
273 typeFile << "MMC";
274 typeFile.close();
John Wedigd32b9662022-04-13 18:12:25 -0700275
276 /* Look for the device file. */
Tom Tung043af592023-11-24 13:37:05 +0800277 auto result = estoraged::util::findDevice(data,
278 std::filesystem::path("./"));
279 EXPECT_FALSE(result.has_value());
John Wedigd32b9662022-04-13 18:12:25 -0700280
281 /* Delete the dummy files. */
John Edward Broadbent9e639822022-06-10 10:16:05 -0700282 EXPECT_EQ(3U, std::filesystem::remove_all("mmcblk0"));
283 EXPECT_EQ(3U, std::filesystem::remove_all("abc"));
284 EXPECT_EQ(2U, std::filesystem::remove_all("def"));
John Wedigd32b9662022-04-13 18:12:25 -0700285}
286
287/* Test case where we can't find the device file. */
288TEST(utilTest, findDeviceNotFoundFail)
289{
290 estoraged::StorageData data;
291
292 /* Set up the map of properties. */
293 data.emplace(std::string("Type"),
294 estoraged::BasicVariantType("EmmcDevice"));
295 data.emplace(std::string("Name"), estoraged::BasicVariantType("emmc"));
296
John Wedigf78215f2022-06-07 13:39:22 -0700297 /* Create a dummy device. */
298 std::filesystem::create_directories("abc/device");
299 const std::string dummyTypeFileName("abc/device/type");
300 std::ofstream dummyTypeFile(dummyTypeFileName,
301 std::ios::out | std::ios::trunc);
302 dummyTypeFile << "SSD";
303 dummyTypeFile.close();
304
305 /* Another device. */
306 std::filesystem::create_directories("def/device");
John Wedigd32b9662022-04-13 18:12:25 -0700307
308 /* Look for the device file. */
Tom Tung043af592023-11-24 13:37:05 +0800309 auto result = estoraged::util::findDevice(data,
310 std::filesystem::path("./"));
311 EXPECT_FALSE(result.has_value());
John Wedigd32b9662022-04-13 18:12:25 -0700312
John Wedigf78215f2022-06-07 13:39:22 -0700313 /* Delete the dummy files. */
John Edward Broadbent9e639822022-06-10 10:16:05 -0700314 EXPECT_EQ(3U, std::filesystem::remove_all("abc"));
315 EXPECT_EQ(2U, std::filesystem::remove_all("def"));
John Wedigd32b9662022-04-13 18:12:25 -0700316}
317
John Edward Broadbent5d799bb2022-03-22 16:14:24 -0700318} // namespace estoraged_test