Line data Source code
1 : /**
2 : * @file
3 : *
4 : * @brief Tests for KDB
5 : *
6 : * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
7 : *
8 : */
9 :
10 : #include <keysetio.hpp>
11 :
12 : #include <gtest/gtest-elektra.h>
13 :
14 :
15 84 : class Simple : public ::testing::Test
16 : {
17 : protected:
18 : static const std::string testRoot;
19 : static const std::string configFile;
20 :
21 : testing::Namespaces namespaces;
22 : testing::MountpointPtr mp;
23 :
24 84 : Simple () : namespaces ()
25 : {
26 42 : }
27 :
28 42 : virtual void SetUp () override
29 : {
30 210 : mp.reset (new testing::Mountpoint (testRoot, configFile));
31 42 : }
32 :
33 42 : virtual void TearDown () override
34 : {
35 84 : mp.reset ();
36 42 : }
37 : };
38 :
39 6 : const std::string Simple::configFile = "kdbFile.dump";
40 6 : const std::string Simple::testRoot = "/tests/kdb/";
41 :
42 20 : TEST_F (Simple, GetNothing)
43 : {
44 : using namespace kdb;
45 4 : KDB kdb;
46 4 : KeySet ks;
47 2 : kdb.get (ks, testRoot);
48 8 : ASSERT_EQ (ks.size (), 0) << "got keys from freshly mounted backends" << ks;
49 : struct stat buf;
50 12 : ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), -1) << "found wrong file";
51 : }
52 :
53 20 : TEST_F (Simple, SetNothing)
54 : {
55 : using namespace kdb;
56 4 : KDB kdb;
57 4 : KeySet ks;
58 2 : kdb.get (ks, testRoot);
59 8 : ASSERT_EQ (ks.size (), 0) << "got keys from freshly mounted backends" << ks;
60 2 : kdb.set (ks, testRoot);
61 8 : ASSERT_EQ (ks.size (), 0) << "got keys from freshly mounted backends" << ks;
62 : struct stat buf;
63 12 : ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), -1) << "found wrong file";
64 : }
65 :
66 20 : TEST_F (Simple, TryChangeAfterSet)
67 : {
68 : using namespace kdb;
69 4 : KDB kdb;
70 4 : KeySet ks;
71 6 : std::string name = "system" + testRoot + "try_change";
72 6 : Key k (name, KEY_END);
73 8 : EXPECT_EQ (k.getName (), name);
74 2 : ks.append (k);
75 6 : EXPECT_THROW (k.setName ("user/x"), kdb::KeyInvalidName);
76 8 : EXPECT_EQ (k.getName (), name);
77 2 : kdb.get (ks, testRoot);
78 8 : ASSERT_EQ (ks.size (), 1) << "lost keys in get\n" << ks;
79 2 : kdb.set (ks, testRoot);
80 6 : EXPECT_THROW (k.setName ("user/x"), kdb::KeyInvalidName);
81 8 : EXPECT_EQ (k.getName (), name);
82 8 : ASSERT_EQ (ks.size (), 1) << "got no keys\n" << ks;
83 : struct stat buf;
84 12 : ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), 0) << "did not find config file";
85 : }
86 :
87 20 : TEST_F (Simple, MetaInSet)
88 : {
89 : using namespace kdb;
90 4 : KDB kdb;
91 4 : KeySet ks;
92 6 : Key parent (testRoot, KEY_END);
93 2 : kdb.get (ks, parent);
94 8 : ASSERT_EQ (ks.size (), 0) << "got keys from freshly mounted backend" << ks;
95 :
96 10 : ks.append (Key ("meta" + testRoot + "wrong_meta_key", KEY_META_NAME, KEY_END));
97 :
98 8 : ASSERT_EQ (ks.size (), 1) << "key not inserted:\n" << ks;
99 2 : kdb.set (ks, parent);
100 2 : printError (std::cout, parent, true, true);
101 2 : printWarnings (std::cout, parent, true, true);
102 8 : ASSERT_EQ (ks.size (), 1) << "got wrong keys:\n" << ks;
103 : struct stat buf;
104 12 : ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), -1) << "did find config file";
105 : }
106 :
107 20 : TEST_F (Simple, InvalidKeysInSet)
108 : {
109 : using namespace kdb;
110 4 : KDB kdb;
111 4 : KeySet ks;
112 6 : Key parent (testRoot, KEY_END);
113 2 : kdb.get (ks, parent);
114 8 : ASSERT_EQ (ks.size (), 0) << "got keys from freshly mounted backend" << ks;
115 :
116 8 : ks.append (Key (testRoot + "wrong_cascading_key", KEY_END));
117 10 : ks.append (Key ("meta" + testRoot + "wrong_meta_key", KEY_META_NAME, KEY_END));
118 :
119 8 : ASSERT_EQ (ks.size (), 2) << "keys not inserted:\n" << ks;
120 2 : kdb.set (ks, parent);
121 2 : printError (std::cout, parent, true, true);
122 2 : printWarnings (std::cout, parent, true, true);
123 8 : ASSERT_EQ (ks.size (), 2) << "got wrong keys:\n" << ks;
124 : struct stat buf;
125 12 : ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), -1) << "did find config file";
126 : }
127 :
128 8 : kdb::KeySet getAll ()
129 : {
130 : using namespace ckdb;
131 : return
132 : #include <data_allns.c>
133 : }
134 :
135 : // TODO: replace with proper ContainerEq
136 4 : void compareKeySet (kdb::KeySet ks1, kdb::KeySet ks2)
137 : {
138 : using namespace kdb;
139 4 : KeySet::iterator i1 = ks1.begin ();
140 8580 : for (KeySet::iterator i2 = ks2.begin (); i2 != ks2.end (); ++i1, ++i2)
141 : {
142 17136 : EXPECT_EQ (*i1, *i2);
143 : }
144 12 : EXPECT_EQ (i1, ks1.end ()) << "second iterator not at end";
145 4 : }
146 :
147 20 : TEST_F (Simple, EverythingInGetSet)
148 : {
149 : using namespace kdb;
150 4 : KDB kdb;
151 4 : KeySet ks = getAll ();
152 6 : Key parent (testRoot, KEY_END);
153 2 : kdb.get (ks, parent);
154 8 : ASSERT_EQ (ks.size (), 714) << "did not keep" << ks;
155 :
156 2 : kdb.set (ks, parent);
157 2 : printError (std::cout, parent, true, true);
158 2 : printWarnings (std::cout, parent, true, true);
159 8 : ASSERT_EQ (ks.size (), 714) << "got wrong keys:\n" << ks;
160 : // KeySet cmp = getAll();
161 : // ASSERT_EQ(ks, cmp);
162 : // ASSERT_THAT(ks, ContainerEq(cmp));
163 8 : compareKeySet (ks, getAll ());
164 : struct stat buf;
165 12 : ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), -1) << "did find config file";
166 : }
167 :
168 20 : TEST_F (Simple, EverythingInSet)
169 : {
170 : using namespace kdb;
171 4 : KDB kdb;
172 4 : KeySet ks;
173 6 : Key parent (testRoot, KEY_END);
174 2 : kdb.get (ks, parent);
175 8 : ASSERT_EQ (ks.size (), 0) << "got from freshly mounted" << ks;
176 6 : ks.append (getAll ());
177 8 : ASSERT_EQ (ks.size (), 714) << "did not keep" << ks;
178 :
179 2 : kdb.set (ks, parent);
180 2 : printError (std::cout, parent, true, true);
181 2 : printWarnings (std::cout, parent, true, true);
182 8 : ASSERT_EQ (ks.size (), 714) << "got wrong keys:\n" << ks;
183 : // KeySet cmp = getAll();
184 : // ASSERT_EQ(ks, cmp);
185 : // ASSERT_THAT(ks, ContainerEq(cmp));
186 8 : compareKeySet (ks, getAll ());
187 : struct stat buf;
188 12 : ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), -1) << "did find config file";
189 : }
190 :
191 :
192 20 : TEST_F (Simple, RemoveFile)
193 : {
194 : using namespace kdb;
195 4 : KDB kdb;
196 4 : KeySet ks;
197 2 : kdb.get (ks, testRoot);
198 10 : ks.append (Key ("system" + testRoot + "remove", KEY_END));
199 8 : ASSERT_EQ (ks.size (), 1) << "could not append key\n" << ks;
200 2 : kdb.set (ks, testRoot);
201 8 : ASSERT_EQ (ks.size (), 1) << "key gone after kdb.set?\n" << ks;
202 :
203 : struct stat buf;
204 12 : ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), 0) << "found no file";
205 :
206 4 : Key parentKey;
207 2 : kdb.close (parentKey);
208 2 : kdb.open (parentKey);
209 :
210 2 : kdb.get (ks, testRoot);
211 2 : ks.clear ();
212 8 : ASSERT_EQ (ks.size (), 0) << "keyset should be empty after clearing it\n" << ks;
213 2 : kdb.set (ks, testRoot);
214 :
215 12 : ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), -1) << "found wrong file";
216 : }
217 :
218 :
219 14 : TEST_F (Simple, DISABLED_GetNothingEmpty)
220 : {
221 : using namespace kdb;
222 0 : KDB kdb;
223 0 : KeySet ks;
224 0 : Key k;
225 : try
226 : {
227 0 : ASSERT_EQ (kdb.get (ks, k), 1);
228 : }
229 0 : catch (std::exception const & e)
230 : {
231 0 : std::cout << "Could not get everything from keydatabase: " << e.what () << std::endl;
232 : }
233 0 : ASSERT_EQ (k.getMeta<int> ("warnings/#00/number"), 105) << "did not get warning for empty key";
234 : // got everything, so make no assumption of size
235 : }
236 :
237 20 : TEST_F (Simple, GetSystem)
238 : {
239 : using namespace kdb;
240 4 : KDB kdb;
241 4 : KeySet ks;
242 6 : Key parentKey ("system" + testRoot, KEY_END);
243 10 : ks.append (Key (parentKey.getName () + "/key", KEY_END));
244 4 : EXPECT_NE (kdb.get (ks, parentKey), -1);
245 8 : ASSERT_EQ (ks.size (), 1) << "no key stayed" << ks;
246 2 : ks.rewind ();
247 4 : ks.next ();
248 10 : EXPECT_EQ (ks.current ().getName (), "system/tests/kdb/key") << "name of element in keyset wrong";
249 10 : EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
250 :
251 4 : ASSERT_NE (kdb.set (ks, parentKey), -1);
252 2 : ks.rewind ();
253 4 : ks.next ();
254 10 : EXPECT_EQ (ks.current ().getName (), "system/tests/kdb/key") << "name of element in keyset wrong";
255 10 : EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
256 2 : kdb.close (parentKey);
257 :
258 4 : KeySet ks2;
259 2 : kdb.open (parentKey);
260 2 : kdb.get (ks2, parentKey);
261 2 : ks.rewind ();
262 4 : ks.next ();
263 10 : EXPECT_EQ (ks.current ().getName (), "system/tests/kdb/key") << "name of element in keyset wrong";
264 10 : EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
265 : }
266 :
267 20 : TEST_F (Simple, WrongStateSystem)
268 : {
269 : using namespace kdb;
270 4 : KDB kdb;
271 4 : KeySet ks;
272 6 : Key parentKey ("system" + testRoot, KEY_END);
273 4 : EXPECT_THROW (kdb.set (ks, parentKey), kdb::KDBException) << "kdb set without prior kdb get should have 107 Wrong State";
274 2 : kdb.close (parentKey);
275 8 : ASSERT_EQ (ks.size (), 0) << "got keys from freshly mounted backends" << ks;
276 : }
277 :
278 :
279 20 : TEST_F (Simple, WrongStateUser)
280 : {
281 : using namespace kdb;
282 4 : KDB kdb;
283 4 : KeySet ks;
284 6 : Key parentKey ("user" + testRoot, KEY_END);
285 4 : EXPECT_THROW (kdb.set (ks, parentKey), kdb::KDBException) << "kdb set without prior kdb get should have 107 Wrong State";
286 8 : ASSERT_EQ (ks.size (), 0) << "got keys from freshly mounted backends" << ks;
287 : }
288 :
289 :
290 20 : TEST_F (Simple, WrongStateCascading)
291 : {
292 : using namespace kdb;
293 4 : KDB kdb;
294 4 : KeySet ks;
295 6 : Key parentKey (testRoot, KEY_END);
296 4 : EXPECT_THROW (kdb.set (ks, parentKey), kdb::KDBException) << "kdb set without prior kdb get should have 107 Wrong State";
297 8 : ASSERT_EQ (ks.size (), 0) << "got keys from freshly mounted backends" << ks;
298 : }
299 :
300 20 : TEST_F (Simple, GetCascading)
301 : {
302 : using namespace kdb;
303 4 : KDB kdb;
304 4 : KeySet ks;
305 6 : Key parentKey (testRoot, KEY_END);
306 2 : kdb.get (ks, parentKey);
307 8 : ASSERT_EQ (ks.size (), 0) << "got keys from freshly mounted backends" << ks;
308 :
309 6 : Key setParentKey ("system" + testRoot, KEY_END);
310 2 : kdb.set (ks, setParentKey);
311 2 : kdb.close (parentKey);
312 : }
313 :
314 :
315 20 : TEST_F (Simple, GetAppendCascading)
316 : {
317 : using namespace kdb;
318 4 : KDB kdb;
319 4 : KeySet ks;
320 8 : ks.append (Key (testRoot + "key", KEY_END));
321 6 : Key parentKey (testRoot, KEY_END);
322 4 : std::string myRoot = testRoot.substr (0, testRoot.length () - 1);
323 8 : EXPECT_EQ (parentKey.getName (), myRoot);
324 8 : EXPECT_EQ (parentKey.getString (), "");
325 2 : kdb.get (ks, parentKey);
326 8 : EXPECT_EQ (parentKey.getName (), myRoot);
327 4 : std::string fn = parentKey.getString ();
328 8 : EXPECT_EQ (fn.substr (fn.find_last_of ('/') + 1), "kdbFile.dump");
329 10 : parentKey.setString ("");
330 :
331 8 : ASSERT_EQ (ks.size (), 1) << "no key stayed" << ks;
332 2 : ks.rewind ();
333 4 : ks.next ();
334 10 : EXPECT_EQ (ks.current ().getName (), "/tests/kdb/key") << "name of element in keyset wrong";
335 10 : EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
336 2 : kdb.set (ks, parentKey);
337 8 : EXPECT_EQ (parentKey.getName (), myRoot);
338 8 : EXPECT_EQ (parentKey.getString (), "");
339 2 : ks.rewind ();
340 4 : ks.next ();
341 10 : EXPECT_EQ (ks.current ().getName (), "/tests/kdb/key") << "name of element in keyset wrong";
342 10 : EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
343 2 : kdb.close (parentKey);
344 8 : EXPECT_EQ (parentKey.getName (), myRoot);
345 8 : EXPECT_EQ (parentKey.getString (), "");
346 :
347 4 : KeySet ks2;
348 2 : kdb.open (parentKey);
349 8 : EXPECT_EQ (parentKey.getName (), myRoot);
350 8 : EXPECT_EQ (parentKey.getString (), "");
351 2 : kdb.get (ks2, parentKey);
352 8 : EXPECT_EQ (parentKey.getName (), myRoot);
353 4 : fn = parentKey.getString ();
354 8 : EXPECT_EQ (fn.substr (fn.find_last_of ('/') + 1), "kdbFile.dump");
355 8 : ASSERT_EQ (ks2.size (), 0) << "got keys from freshly mounted backends";
356 : }
357 :
358 20 : TEST_F (Simple, GetAppendMeta)
359 : {
360 : using namespace kdb;
361 4 : KDB kdb;
362 4 : KeySet ks;
363 6 : ks.append (Key ("meta/key", KEY_META_NAME, KEY_END));
364 6 : Key parentKey (testRoot, KEY_END);
365 2 : kdb.get (ks, parentKey);
366 8 : ASSERT_EQ (ks.size (), 1) << "no key stayed";
367 2 : ks.rewind ();
368 4 : ks.next ();
369 10 : EXPECT_EQ (ks.current ().getName (), "meta/key") << "name of element in keyset wrong";
370 10 : EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
371 2 : kdb.set (ks, parentKey);
372 2 : ks.rewind ();
373 4 : ks.next ();
374 10 : EXPECT_EQ (ks.current ().getName (), "meta/key") << "name of element in keyset wrong";
375 10 : EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
376 2 : kdb.close (parentKey);
377 :
378 4 : KeySet ks2;
379 2 : kdb.open (parentKey);
380 2 : kdb.get (ks2, parentKey);
381 8 : ASSERT_EQ (ks2.size (), 0) << "got keys from freshly mounted backends";
382 : }
383 :
384 20 : TEST_F (Simple, GetAppendNamespaces)
385 : {
386 : using namespace kdb;
387 16 : for (size_t i = 0; i < namespaces.size (); ++i)
388 : {
389 12 : KDB kdb;
390 12 : KeySet ks;
391 36 : ks.append (Key (namespaces[i].name + testRoot + "key", KEY_END));
392 6 : kdb.get (ks, testRoot);
393 24 : ASSERT_EQ (ks.size (), 1) << "did not got key appended first with namespace " << namespaces[i].name;
394 6 : ks.rewind ();
395 12 : ks.next ();
396 48 : EXPECT_EQ (ks.current ().getName (), namespaces[i].name + "/tests/kdb/key") << "name of element in keyset wrong";
397 30 : EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
398 : }
399 : }
400 :
401 20 : TEST_F (Simple, SetSystemKey)
402 : {
403 : using namespace kdb;
404 4 : KDB kdb;
405 4 : KeySet ks;
406 6 : Key parentKey (testRoot, KEY_END);
407 10 : ks.append (Key ("system" + testRoot + "key", KEY_END));
408 2 : kdb.get (ks, parentKey);
409 8 : ASSERT_EQ (ks.size (), 1) << "got keys from freshly mounted backends";
410 2 : ks.rewind ();
411 4 : ks.next ();
412 16 : EXPECT_EQ (ks.current ().getName (), "system" + testRoot + "key") << "name of element in keyset wrong";
413 10 : EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
414 2 : kdb.set (ks, parentKey);
415 2 : kdb.close (parentKey);
416 :
417 4 : KeySet ks2;
418 2 : kdb.open (parentKey);
419 2 : kdb.get (ks2, parentKey);
420 8 : ASSERT_EQ (ks2.size (), 1) << "wrong size";
421 2 : ks2.rewind ();
422 4 : ks2.next ();
423 16 : EXPECT_EQ (ks2.current ().getName (), "system" + testRoot + "key") << "name of element in keyset wrong";
424 10 : EXPECT_EQ (ks2.current ().getString (), "") << "string of element in keyset wrong";
425 : }
426 :
427 20 : TEST_F (Simple, SetSystemGetAppend)
428 : {
429 : using namespace kdb;
430 4 : KDB kdb;
431 4 : KeySet ks;
432 6 : Key parentKey (testRoot, KEY_END);
433 10 : ks.append (Key ("system" + testRoot + "key", KEY_VALUE, "value1", KEY_END));
434 4 : ASSERT_NE (kdb.get (ks, parentKey), -1);
435 8 : ASSERT_EQ (ks.size (), 1) << "got keys from freshly mounted backends";
436 2 : ks.rewind ();
437 4 : ks.next ();
438 10 : EXPECT_EQ (ks.current ().getName (), "system/tests/kdb/key") << "name of element in keyset wrong";
439 10 : EXPECT_EQ (ks.current ().getString (), "value1") << "string of element in keyset wrong";
440 6 : ASSERT_EQ (kdb.set (ks, parentKey), 1);
441 2 : kdb.close (parentKey);
442 :
443 4 : KeySet ks2;
444 10 : ks2.append (Key ("system" + testRoot + "key", KEY_VALUE, "value2", KEY_END));
445 2 : kdb.open (parentKey);
446 6 : ASSERT_EQ (kdb.get (ks2, parentKey), 1);
447 8 : ASSERT_EQ (ks2.size (), 1) << "wrong size";
448 2 : ks2.rewind ();
449 4 : ks2.next ();
450 10 : EXPECT_EQ (ks2.current ().getName (), "system/tests/kdb/key") << "name of element in keyset wrong";
451 10 : EXPECT_EQ (ks2.current ().getString (), "value1") << "string of element in keyset wrong";
452 : }
453 :
454 20 : TEST_F (Simple, SetSystemGetAppend2)
455 : {
456 : using namespace kdb;
457 4 : KDB kdb;
458 4 : KeySet ks;
459 6 : Key parentKey (testRoot, KEY_END);
460 10 : ks.append (Key ("system" + testRoot + "key", KEY_VALUE, "value1", KEY_END));
461 2 : kdb.get (ks, parentKey);
462 8 : ASSERT_EQ (ks.size (), 1) << "got keys from freshly mounted backends";
463 2 : ks.rewind ();
464 4 : ks.next ();
465 10 : EXPECT_EQ (ks.current ().getName (), "system/tests/kdb/key") << "name of element in keyset wrong";
466 10 : EXPECT_EQ (ks.current ().getString (), "value1") << "string of element in keyset wrong";
467 2 : kdb.set (ks, parentKey);
468 2 : kdb.close (parentKey);
469 :
470 4 : KeySet ks2;
471 10 : ks2.append (Key ("system" + testRoot + "key2", KEY_VALUE, "value2", KEY_END));
472 2 : kdb.open (parentKey);
473 2 : kdb.get (ks2, parentKey);
474 2 : ks2.rewind ();
475 4 : ks2.next ();
476 8 : ASSERT_EQ (ks2.size (), 1) << "wrong size";
477 10 : EXPECT_EQ (ks2.current ().getName (), "system/tests/kdb/key") << "name of element in keyset wrong";
478 10 : EXPECT_EQ (ks2.current ().getString (), "value1") << "string of element in keyset wrong";
479 : }
480 :
481 20 : TEST_F (Simple, WrongParent)
482 : {
483 : using namespace kdb;
484 4 : KDB kdb;
485 4 : Key parent ("meta", KEY_META_NAME, KEY_END);
486 4 : KeySet ks;
487 4 : EXPECT_THROW (kdb.set (ks, parent), kdb::KDBException);
488 8 : ASSERT_EQ (ks.size (), 0) << "got keys from freshly mounted backends" << ks;
489 : }
490 :
491 20 : TEST_F (Simple, TriggerError)
492 : {
493 : using namespace kdb;
494 4 : KDB kdb;
495 4 : KeySet ks;
496 6 : EXPECT_EQ (kdb.get (ks, testRoot), 0) << "nothing to do in get";
497 10 : ks.append (Key ("system" + testRoot + "a", KEY_END));
498 10 : ks.append (Key ("system" + testRoot + "k", KEY_META, "trigger/error", "10", KEY_END));
499 10 : ks.append (Key ("system" + testRoot + "z", KEY_END));
500 : struct stat buf;
501 12 : ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), -1) << "found wrong file";
502 4 : EXPECT_THROW (kdb.set (ks, testRoot), kdb::KDBException) << "could not trigger error";
503 8 : ASSERT_EQ (ks.size (), 3) << "key suddenly missing";
504 16 : EXPECT_EQ (ks.current ().getName (), "system" + testRoot + "k") << "ks should point to error key";
505 12 : ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), -1) << "created file even though error triggered";
506 6 : }
|