Line data Source code
1 : /**
2 : * @file
3 : *
4 : * @brief Tests for the Backend builder class
5 : *
6 : * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
7 : *
8 : */
9 :
10 : #define ELEKTRA_PLUGINSPEC_WITH_COMPARE
11 :
12 : #include <backendbuilder.hpp>
13 :
14 : #include <backend.hpp>
15 : #include <backends.hpp>
16 : #include <plugindatabase.hpp>
17 :
18 : #include <algorithm>
19 : #include <iostream>
20 : #include <string>
21 : #include <unordered_map>
22 :
23 : #include <gtest/gtest.h>
24 : #include <kdb.hpp>
25 : #include <kdbconfig.h>
26 : #include <kdbhelper.h>
27 :
28 : // We disable certain tests on ASAN enabled builds: https://travis-ci.org/sanssecours/elektra/jobs/418573941
29 : #ifdef ENABLE_ASAN
30 : #define GTEST_DISABLE_ASAN(name) DISABLED_##name
31 : #else
32 : #define GTEST_DISABLE_ASAN(name) name
33 : #endif
34 :
35 20 : TEST (BackendBuilder, withDatabase)
36 : {
37 : using namespace kdb;
38 : using namespace kdb::tools;
39 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
40 24 : mpd->data[PluginSpec ("a")]["ordering"] = "c";
41 24 : mpd->data[PluginSpec ("b")]["ordering"] = "c";
42 22 : mpd->data[PluginSpec ("c")]["ordering"];
43 6 : BackendBuilderInit bbi (mpd);
44 4 : BackendBuilder bb (bbi);
45 10 : bb.addPlugin (PluginSpec ("a"));
46 10 : bb.addPlugin (PluginSpec ("b"));
47 10 : bb.addPlugin (PluginSpec ("c"));
48 :
49 16 : EXPECT_EQ (bb.cbegin ()[0], PluginSpec ("a"));
50 18 : EXPECT_EQ (bb.cbegin ()[1], PluginSpec ("b"));
51 18 : EXPECT_EQ (bb.cbegin ()[2], PluginSpec ("c"));
52 2 : }
53 :
54 :
55 20 : TEST (BackendBuilder, withDatabaseIrrelevantDep)
56 : {
57 : using namespace kdb;
58 : using namespace kdb::tools;
59 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
60 24 : mpd->data[PluginSpec ("a")]["ordering"] = "d";
61 24 : mpd->data[PluginSpec ("b")]["ordering"] = "d";
62 22 : mpd->data[PluginSpec ("c")]["ordering"];
63 6 : BackendBuilderInit bbi (mpd);
64 4 : BackendBuilder bb (bbi);
65 10 : bb.addPlugin (PluginSpec ("a"));
66 10 : bb.addPlugin (PluginSpec ("b"));
67 10 : bb.addPlugin (PluginSpec ("c"));
68 :
69 16 : EXPECT_EQ (bb.cbegin ()[0], PluginSpec ("a"));
70 18 : EXPECT_EQ (bb.cbegin ()[1], PluginSpec ("b"));
71 18 : EXPECT_EQ (bb.cbegin ()[2], PluginSpec ("c"));
72 2 : }
73 :
74 :
75 20 : TEST (MountBackendBuilder, basicAddRem)
76 : {
77 : using namespace kdb;
78 : using namespace kdb::tools;
79 : try
80 : {
81 4 : Backend b;
82 10 : b.addPlugin (PluginSpec ("resolver"));
83 10 : b.addPlugin (PluginSpec ("dump"));
84 : }
85 0 : catch (std::exception const & e)
86 : {
87 0 : std::cout << "Plugin missing, abort test case: " << e.what () << std::endl;
88 : return;
89 : }
90 4 : MountBackendBuilder bb;
91 12 : bb.addPlugin (PluginSpec ("resolver"));
92 6 : EXPECT_FALSE (bb.validated ());
93 :
94 12 : bb.addPlugin (PluginSpec ("dump"));
95 6 : EXPECT_TRUE (bb.validated ());
96 :
97 10 : bb.remPlugin (PluginSpec ("dump"));
98 6 : EXPECT_FALSE (bb.validated ());
99 :
100 12 : bb.addPlugin (PluginSpec ("dump"));
101 6 : EXPECT_TRUE (bb.validated ());
102 : }
103 :
104 20 : TEST (GTEST_DISABLE_ASAN (MountBackendBuilder), basicSort)
105 : {
106 : using namespace kdb;
107 : using namespace kdb::tools;
108 : try
109 : {
110 4 : Backend b;
111 10 : b.addPlugin (PluginSpec ("resolver"));
112 10 : b.addPlugin (PluginSpec ("glob"));
113 10 : b.addPlugin (PluginSpec ("keytometa"));
114 10 : b.addPlugin (PluginSpec ("augeas"));
115 : }
116 0 : catch (std::exception const & e)
117 : {
118 0 : std::cout << "Plugin missing, abort test case: " << e.what () << std::endl;
119 : return;
120 : }
121 4 : MountBackendBuilder bb;
122 12 : bb.addPlugin (PluginSpec ("resolver"));
123 6 : EXPECT_FALSE (bb.validated ());
124 :
125 12 : bb.addPlugin (PluginSpec ("keytometa"));
126 6 : EXPECT_FALSE (bb.validated ());
127 :
128 12 : bb.addPlugin (PluginSpec ("glob"));
129 6 : EXPECT_FALSE (bb.validated ());
130 :
131 10 : bb.addPlugin (PluginSpec ("augeas"));
132 :
133 : // std::cout << "Solution: ";
134 : // for (auto const & p : bb) std::cout << p.getName() << " ";
135 : // std::cout << std::endl;
136 :
137 6 : EXPECT_TRUE (bb.validated ()) << "Reordering not successful?";
138 : }
139 :
140 20 : TEST (GTEST_DISABLE_ASAN (MountBackendBuilder), allSort)
141 : {
142 : using namespace kdb;
143 : using namespace kdb::tools;
144 : try
145 : {
146 4 : Backend b;
147 10 : b.addPlugin (PluginSpec ("resolver"));
148 10 : b.addPlugin (PluginSpec ("glob"));
149 10 : b.addPlugin (PluginSpec ("keytometa"));
150 10 : b.addPlugin (PluginSpec ("augeas"));
151 : // b.addPlugin (PluginSpec ("type"));
152 : // b.addPlugin (PluginSpec ("validation"));
153 : // b.addPlugin (PluginSpec ("struct", KeySet(5, *Key("user/module", KEY_END), KS_END)));
154 : }
155 0 : catch (std::exception const & e)
156 : {
157 0 : std::cout << "Plugin missing, abort test case: " << e.what () << std::endl;
158 : return;
159 : }
160 :
161 : std::vector<std::string> permutation = {
162 : "augeas", "glob", "keytometa", "resolver"
163 : // , "type", "validation"
164 26 : };
165 :
166 48 : do
167 : {
168 : // for (auto const & p : permutation) std::cout << p << " ";
169 : // std::cout << std::endl;
170 :
171 96 : MountBackendBuilder bb;
172 240 : bb.addPlugin (PluginSpec (permutation[0]));
173 240 : bb.addPlugin (PluginSpec (permutation[1]));
174 240 : bb.addPlugin (PluginSpec (permutation[2]));
175 240 : bb.addPlugin (PluginSpec (permutation[3]));
176 : // bb.addPlugin (PluginSpec (permutation[4]));
177 : // bb.addPlugin (PluginSpec (permutation[5]));
178 : // bb.addPlugin (PluginSpec (permutation[6]));
179 :
180 : // std::cout << "Solution: ";
181 : // for (auto const & p : bb) std::cout << p.getName() << " ";
182 : // std::cout << std::endl;
183 144 : EXPECT_TRUE (bb.validated ()) << "Reordering not successful?";
184 96 : } while (std::next_permutation (permutation.begin (), permutation.end ()));
185 : }
186 :
187 20 : TEST (MountBackendBuilder, resolveNeeds)
188 : {
189 : using namespace kdb;
190 : using namespace kdb::tools;
191 : try
192 : {
193 4 : Backend b;
194 10 : b.addPlugin (PluginSpec ("resolver"));
195 10 : b.addPlugin (PluginSpec ("line"));
196 10 : b.addPlugin (PluginSpec ("null"));
197 : }
198 0 : catch (std::exception const & e)
199 : {
200 0 : std::cout << "Plugin missing, abort test case: " << e.what () << std::endl;
201 : return;
202 : }
203 4 : MountBackendBuilder bb;
204 12 : bb.addPlugin (PluginSpec ("resolver"));
205 6 : EXPECT_FALSE (bb.validated ()) << "resolver+null should be missing";
206 12 : bb.addPlugin (PluginSpec ("line"));
207 6 : EXPECT_FALSE (bb.validated ()) << "null should be missing";
208 2 : bb.resolveNeeds ();
209 6 : EXPECT_TRUE (bb.validated ()) << "Did not add null automatically";
210 : }
211 :
212 :
213 20 : TEST (BackendBuilder, resolveDoubleNeeds)
214 : {
215 : using namespace kdb;
216 : using namespace kdb::tools;
217 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
218 24 : mpd->data[PluginSpec ("a")]["needs"] = "c v";
219 24 : mpd->data[PluginSpec ("c")]["provides"] = "v";
220 24 : mpd->data[PluginSpec ("resolver")]["provides"] = "resolver";
221 6 : BackendBuilderInit bbi (mpd);
222 4 : BackendBuilder bb (bbi);
223 10 : bb.addPlugin (PluginSpec ("resolver"));
224 10 : bb.addPlugin (PluginSpec ("a"));
225 12 : EXPECT_EQ (std::distance (bb.cbegin (), bb.cend ()), 2);
226 2 : bb.resolveNeeds ();
227 12 : EXPECT_EQ (std::distance (bb.cbegin (), bb.cend ()), 3);
228 16 : EXPECT_EQ (bb.cbegin ()[0], PluginSpec ("resolver"));
229 18 : EXPECT_EQ (bb.cbegin ()[1], PluginSpec ("a"));
230 18 : EXPECT_EQ (bb.cbegin ()[2], PluginSpec ("c"));
231 2 : }
232 :
233 20 : TEST (BackendBuilder, resolveDoubleNeedsVirtual)
234 : {
235 : using namespace kdb;
236 : using namespace kdb::tools;
237 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
238 24 : mpd->data[PluginSpec ("a")]["needs"] = "v c";
239 24 : mpd->data[PluginSpec ("c")]["provides"] = "v";
240 24 : mpd->data[PluginSpec ("resolver")]["provides"] = "resolver";
241 24 : EXPECT_EQ (mpd->lookupInfo (PluginSpec ("c"), "provides"), "v");
242 30 : EXPECT_EQ (mpd->lookupInfo (PluginSpec ("c", "v"), "provides"), "v");
243 6 : BackendBuilderInit bbi (mpd);
244 4 : BackendBuilder bb (bbi);
245 10 : bb.addPlugin (PluginSpec ("resolver"));
246 10 : bb.addPlugin (PluginSpec ("a"));
247 12 : EXPECT_EQ (std::distance (bb.cbegin (), bb.cend ()), 2);
248 2 : bb.resolveNeeds ();
249 12 : EXPECT_EQ (std::distance (bb.cbegin (), bb.cend ()), 3);
250 16 : EXPECT_EQ (bb.cbegin ()[0], PluginSpec ("resolver"));
251 18 : EXPECT_EQ (bb.cbegin ()[1], PluginSpec ("a"));
252 24 : EXPECT_EQ (bb.cbegin ()[2], PluginSpec ("c", "v")) << "remember it was virtual";
253 2 : }
254 :
255 20 : TEST (BackendBuilder, doubleAddWithConf)
256 : {
257 : using namespace kdb;
258 : using namespace kdb::tools;
259 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
260 24 : mpd->data[PluginSpec ("a")]["needs"] = "v c";
261 24 : mpd->data[PluginSpec ("c")]["provides"] = "v";
262 24 : mpd->data[PluginSpec ("resolver")]["provides"] = "resolver";
263 6 : BackendBuilderInit bbi (mpd);
264 4 : BackendBuilder bb (bbi);
265 10 : bb.addPlugin (PluginSpec ("resolver"));
266 10 : bb.addPlugin (PluginSpec ("a"));
267 14 : bb.addPlugin (PluginSpec ("c", KeySet (2, *Key ("user/abc", KEY_END), KS_END)));
268 14 : bb.addPlugin (PluginSpec ("v", KeySet (2, *Key ("user/vef", KEY_END), KS_END)));
269 12 : EXPECT_EQ (std::distance (bb.cbegin (), bb.cend ()), 4);
270 16 : EXPECT_EQ (bb.cbegin ()[0], PluginSpec ("resolver"));
271 18 : EXPECT_EQ (bb.cbegin ()[1], PluginSpec ("a"));
272 22 : EXPECT_EQ (bb.cbegin ()[2], PluginSpec ("c", KeySet (2, *Key ("user/abc", KEY_END), KS_END)));
273 28 : EXPECT_EQ (bb.cbegin ()[3], PluginSpec ("c", "v", KeySet (2, *Key ("user/vef", KEY_END), KS_END))) << "remember it was virtual";
274 2 : bb.resolveNeeds ();
275 12 : EXPECT_EQ (std::distance (bb.cbegin (), bb.cend ()), 4);
276 2 : }
277 :
278 :
279 20 : TEST (BackendBuilder, doubleAddWithConfVirtual)
280 : {
281 : using namespace kdb;
282 : using namespace kdb::tools;
283 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
284 24 : mpd->data[PluginSpec ("a")]["needs"] = "v c";
285 24 : mpd->data[PluginSpec ("c")]["provides"] = "v";
286 24 : mpd->data[PluginSpec ("noresolver")]["provides"] = "resolver";
287 6 : BackendBuilderInit bbi (mpd);
288 4 : BackendBuilder bb (bbi);
289 10 : bb.addPlugin (PluginSpec ("resolver"));
290 10 : bb.addPlugin (PluginSpec ("a"));
291 14 : bb.addPlugin (PluginSpec ("v", KeySet (2, *Key ("user/vef", KEY_END), KS_END)));
292 14 : bb.addPlugin (PluginSpec ("c", KeySet (2, *Key ("user/abc", KEY_END), KS_END)));
293 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 4);
294 22 : EXPECT_EQ (bb.cbegin ()[0], PluginSpec ("noresolver", "resolver"));
295 18 : EXPECT_EQ (bb.cbegin ()[1], PluginSpec ("a"));
296 28 : EXPECT_EQ (bb.cbegin ()[2], PluginSpec ("c", "v", KeySet (2, *Key ("user/vef", KEY_END), KS_END)));
297 22 : EXPECT_EQ (bb.cbegin ()[3], PluginSpec ("c", KeySet (2, *Key ("user/abc", KEY_END), KS_END)));
298 2 : bb.resolveNeeds ();
299 12 : EXPECT_EQ (std::distance (bb.cbegin (), bb.cend ()), 4);
300 : }
301 :
302 20 : TEST (BackendBuilder, directPluginLoading)
303 : {
304 : using namespace kdb;
305 : using namespace kdb::tools;
306 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
307 24 : mpd->data[PluginSpec ("a")]["plugins"] = "x a=b";
308 24 : mpd->data[PluginSpec ("a")]["needs"] = "resolver";
309 24 : mpd->data[PluginSpec ("x")]["provides"] = "x";
310 24 : mpd->data[PluginSpec ("noresolver")]["provides"] = "resolver";
311 6 : BackendBuilderInit bbi (mpd);
312 4 : BackendBuilder bb (bbi);
313 10 : bb.addPlugin (PluginSpec ("a"));
314 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 1);
315 16 : EXPECT_EQ (bb.cbegin ()[0], PluginSpec ("a"));
316 2 : bb.resolveNeeds ();
317 12 : EXPECT_EQ (std::distance (bb.cbegin (), bb.cend ()), 3);
318 16 : EXPECT_EQ (bb.cbegin ()[0], PluginSpec ("a"));
319 22 : EXPECT_EQ (bb.cbegin ()[1], PluginSpec ("x", KeySet (2, *Key ("user/a", KEY_VALUE, "b", KEY_END), KS_END)));
320 24 : EXPECT_EQ (bb.cbegin ()[2], PluginSpec ("noresolver", "resolver"));
321 : }
322 :
323 20 : TEST (BackendBuilder, metadata)
324 : {
325 : using namespace kdb;
326 : using namespace kdb::tools;
327 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
328 24 : mpd->data[PluginSpec ("r")]["metadata"] = "rename/toupper";
329 6 : BackendBuilderInit bbi (mpd);
330 4 : BackendBuilder bb (bbi);
331 8 : bb.needMetadata ("rename/toupper");
332 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 0);
333 2 : bb.resolveNeeds ();
334 12 : EXPECT_EQ (std::distance (bb.cbegin (), bb.cend ()), 1);
335 16 : EXPECT_EQ (bb.cbegin ()[0], PluginSpec ("r"));
336 : }
337 :
338 20 : TEST (BackendBuilder, metadataTwo)
339 : {
340 : using namespace kdb;
341 : using namespace kdb::tools;
342 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
343 24 : mpd->data[PluginSpec ("r1")]["metadata"] = "rename/toupper";
344 24 : mpd->data[PluginSpec ("r1")]["status"] = "unittest";
345 24 : mpd->data[PluginSpec ("r2")]["metadata"] = "rename/toupper rename/tolower";
346 24 : mpd->data[PluginSpec ("r2")]["status"] = "memleak";
347 6 : BackendBuilderInit bbi (mpd);
348 4 : BackendBuilder bb (bbi);
349 8 : bb.needMetadata ("rename/toupper rename/tolower");
350 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 0);
351 2 : bb.resolveNeeds ();
352 12 : EXPECT_EQ (std::distance (bb.cbegin (), bb.cend ()), 1);
353 16 : EXPECT_EQ (bb.cbegin ()[0], PluginSpec ("r2"));
354 : }
355 :
356 20 : TEST (BackendBuilder, metadataTwoRev)
357 : {
358 : using namespace kdb;
359 : using namespace kdb::tools;
360 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
361 24 : mpd->data[PluginSpec ("r1")]["metadata"] = "rename/tolower"; // relevant
362 24 : mpd->data[PluginSpec ("r1")]["status"] = "unittest";
363 24 : mpd->data[PluginSpec ("r2")]["metadata"] = "rename/toupper rename/tolower";
364 24 : mpd->data[PluginSpec ("r2")]["status"] = "memleak";
365 6 : BackendBuilderInit bbi (mpd);
366 4 : BackendBuilder bb (bbi);
367 8 : bb.needMetadata ("rename/tolower rename/toupper"); // order not relevant
368 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 0);
369 2 : bb.resolveNeeds ();
370 12 : EXPECT_EQ (std::distance (bb.cbegin (), bb.cend ()), 2);
371 16 : EXPECT_EQ (bb.cbegin ()[0], PluginSpec ("r1"));
372 18 : EXPECT_EQ (bb.cbegin ()[1], PluginSpec ("r2"));
373 : }
374 :
375 20 : TEST (BackendBuilder, manualNeeds)
376 : {
377 : using namespace kdb;
378 : using namespace kdb::tools;
379 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
380 24 : mpd->data[PluginSpec ("n")]["provides"] = "x";
381 6 : BackendBuilderInit bbi (mpd);
382 4 : BackendBuilder bb (bbi);
383 8 : bb.needPlugin ("n");
384 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 0);
385 2 : bb.resolveNeeds ();
386 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 1);
387 16 : EXPECT_EQ (bb.cbegin ()[0], PluginSpec ("n"));
388 : }
389 :
390 :
391 20 : TEST (BackendBuilder, manualNeedsProvides)
392 : {
393 : using namespace kdb;
394 : using namespace kdb::tools;
395 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
396 24 : mpd->data[PluginSpec ("n")]["provides"] = "x";
397 6 : BackendBuilderInit bbi (mpd);
398 4 : BackendBuilder bb (bbi);
399 8 : bb.needPlugin ("x");
400 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 0);
401 2 : bb.resolveNeeds ();
402 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 1);
403 22 : EXPECT_EQ (bb.cbegin ()[0], PluginSpec ("n", "x"));
404 : }
405 :
406 :
407 20 : TEST (BackendBuilder, manualMultipleNeeds)
408 : {
409 : using namespace kdb;
410 : using namespace kdb::tools;
411 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
412 24 : mpd->data[PluginSpec ("n")]["provides"] = "x";
413 24 : mpd->data[PluginSpec ("y")]["provides"] = "z";
414 6 : BackendBuilderInit bbi (mpd);
415 4 : BackendBuilder bb (bbi);
416 8 : bb.needPlugin ("n");
417 8 : bb.needPlugin ("n");
418 8 : bb.needPlugin ("x");
419 8 : bb.needPlugin ("x");
420 8 : bb.needPlugin ("y");
421 8 : bb.needPlugin ("y");
422 8 : bb.needPlugin ("z");
423 8 : bb.needPlugin ("z");
424 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 0);
425 2 : bb.resolveNeeds ();
426 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 2);
427 16 : EXPECT_EQ (bb.cbegin ()[0], PluginSpec ("n"));
428 18 : EXPECT_EQ (bb.cbegin ()[1], PluginSpec ("y"));
429 : }
430 :
431 20 : TEST (BackendBuilder, manualMultipleNeedsSingleLine)
432 : {
433 : using namespace kdb;
434 : using namespace kdb::tools;
435 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
436 24 : mpd->data[PluginSpec ("n")]["provides"] = "x";
437 24 : mpd->data[PluginSpec ("y")]["provides"] = "z";
438 6 : BackendBuilderInit bbi (mpd);
439 4 : BackendBuilder bb (bbi);
440 8 : bb.needPlugin ("n n x x y y z z");
441 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 0);
442 2 : bb.resolveNeeds ();
443 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 2);
444 16 : EXPECT_EQ (bb.cbegin ()[0], PluginSpec ("n"));
445 18 : EXPECT_EQ (bb.cbegin ()[1], PluginSpec ("y"));
446 : }
447 :
448 :
449 20 : TEST (BackendBuilder, manualRecommends)
450 : {
451 : using namespace kdb;
452 : using namespace kdb::tools;
453 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
454 24 : mpd->data[PluginSpec ("n")]["provides"] = "x";
455 6 : BackendBuilderInit bbi (mpd);
456 4 : BackendBuilder bb (bbi);
457 8 : bb.recommendPlugin ("n");
458 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 0);
459 2 : bb.resolveNeeds ();
460 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 1);
461 16 : EXPECT_EQ (bb.cbegin ()[0], PluginSpec ("n"));
462 : }
463 :
464 :
465 20 : TEST (BackendBuilder, manualNoRecommends)
466 : {
467 : using namespace kdb;
468 : using namespace kdb::tools;
469 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
470 24 : mpd->data[PluginSpec ("n")]["provides"] = "x";
471 6 : BackendBuilderInit bbi (mpd);
472 4 : BackendBuilder bb (bbi);
473 8 : bb.recommendPlugin ("n");
474 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 0);
475 2 : bb.resolveNeeds (false);
476 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 0);
477 : }
478 :
479 :
480 20 : TEST (BackendBuilder, manualRecommendsProvides)
481 : {
482 : using namespace kdb;
483 : using namespace kdb::tools;
484 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
485 24 : mpd->data[PluginSpec ("n")]["provides"] = "x";
486 6 : BackendBuilderInit bbi (mpd);
487 4 : BackendBuilder bb (bbi);
488 8 : bb.recommendPlugin ("x");
489 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 0);
490 2 : bb.resolveNeeds (true);
491 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 1);
492 22 : EXPECT_EQ (bb.cbegin ()[0], PluginSpec ("n", "x"));
493 : }
494 :
495 :
496 20 : TEST (BackendBuilder, manualMultipleRecommends)
497 : {
498 : using namespace kdb;
499 : using namespace kdb::tools;
500 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
501 24 : mpd->data[PluginSpec ("n")]["provides"] = "x";
502 24 : mpd->data[PluginSpec ("y")]["provides"] = "z";
503 6 : BackendBuilderInit bbi (mpd);
504 4 : BackendBuilder bb (bbi);
505 8 : bb.recommendPlugin ("n");
506 8 : bb.recommendPlugin ("n");
507 8 : bb.recommendPlugin ("x");
508 8 : bb.recommendPlugin ("x");
509 8 : bb.recommendPlugin ("y");
510 8 : bb.recommendPlugin ("y");
511 8 : bb.recommendPlugin ("z");
512 8 : bb.recommendPlugin ("z");
513 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 0);
514 2 : bb.resolveNeeds ();
515 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 2);
516 16 : EXPECT_EQ (bb.cbegin ()[0], PluginSpec ("n"));
517 18 : EXPECT_EQ (bb.cbegin ()[1], PluginSpec ("y"));
518 : }
519 :
520 20 : TEST (BackendBuilder, manualMultipleRecommendsSingleLine)
521 : {
522 : using namespace kdb;
523 : using namespace kdb::tools;
524 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
525 24 : mpd->data[PluginSpec ("n")]["provides"] = "x";
526 24 : mpd->data[PluginSpec ("y")]["provides"] = "z";
527 6 : BackendBuilderInit bbi (mpd);
528 4 : BackendBuilder bb (bbi);
529 8 : bb.recommendPlugin ("n n x x y y z z");
530 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 0);
531 2 : bb.resolveNeeds ();
532 12 : ASSERT_EQ (std::distance (bb.cbegin (), bb.cend ()), 2);
533 16 : EXPECT_EQ (bb.cbegin ()[0], PluginSpec ("n"));
534 18 : EXPECT_EQ (bb.cbegin ()[1], PluginSpec ("y"));
535 : }
536 :
537 20 : TEST (BackendBuilder, resolveDoubleRecommends)
538 : {
539 : using namespace kdb;
540 : using namespace kdb::tools;
541 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
542 24 : mpd->data[PluginSpec ("a")]["recommends"] = "c v";
543 24 : mpd->data[PluginSpec ("c")]["provides"] = "v";
544 24 : mpd->data[PluginSpec ("resolver")]["provides"] = "resolver";
545 6 : BackendBuilderInit bbi (mpd);
546 4 : BackendBuilder bb (bbi);
547 10 : bb.addPlugin (PluginSpec ("resolver"));
548 10 : bb.addPlugin (PluginSpec ("a"));
549 12 : EXPECT_EQ (std::distance (bb.cbegin (), bb.cend ()), 2);
550 2 : bb.resolveNeeds ();
551 12 : EXPECT_EQ (std::distance (bb.cbegin (), bb.cend ()), 3);
552 16 : EXPECT_EQ (bb.cbegin ()[0], PluginSpec ("resolver"));
553 18 : EXPECT_EQ (bb.cbegin ()[1], PluginSpec ("a"));
554 18 : EXPECT_EQ (bb.cbegin ()[2], PluginSpec ("c"));
555 2 : }
556 :
557 4 : static int checkconfLookup (ckdb::Key * errorKey ELEKTRA_UNUSED, ckdb::KeySet * config)
558 : {
559 4 : ckdb::Key * k = ckdb::ksLookupByName (config, "/a", 0);
560 4 : if (k)
561 : {
562 : return 0;
563 : }
564 2 : return -1;
565 : }
566 :
567 20 : TEST (BackendBuilder, checkconfOkNoChange)
568 : {
569 : using namespace kdb;
570 : using namespace kdb::tools;
571 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
572 24 : mpd->data[PluginSpec ("checkconf1")]["provides"] = "test123";
573 2 : mpd->setCheckconfFunction (checkconfLookup);
574 6 : BackendBuilderInit bbi (mpd);
575 4 : BackendBuilder bb (bbi);
576 12 : PluginSpec spec ("checkconf1");
577 4 : KeySet pluginConfig;
578 4 : Key a;
579 8 : a.setName ("user/a");
580 10 : a.setString ("abc");
581 2 : pluginConfig.append (a);
582 4 : spec.appendConfig (pluginConfig);
583 2 : bb.addPlugin (spec);
584 2 : }
585 :
586 20 : TEST (BackendBuilder, checkconfNotOKmissing)
587 : {
588 : using namespace kdb;
589 : using namespace kdb::tools;
590 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
591 24 : mpd->data[PluginSpec ("checkconf3")]["c"] = "something";
592 2 : mpd->setCheckconfFunction (checkconfLookup);
593 6 : BackendBuilderInit bbi (mpd);
594 4 : BackendBuilder bb (bbi);
595 14 : EXPECT_THROW (bb.addPlugin (PluginSpec ("checkconf3")), PluginConfigInvalid);
596 2 : }
597 :
598 2 : static int checkconfAppend (ckdb::Key * errorKey ELEKTRA_UNUSED, ckdb::KeySet * config)
599 : {
600 2 : ckdb::ksAppendKey (config, ckdb::keyNew ("user/b", KEY_VALUE, "test", KEY_END));
601 2 : return 1;
602 : }
603 :
604 20 : TEST (BackendBuilder, checkconfOkChanged)
605 : {
606 : using namespace kdb;
607 : using namespace kdb::tools;
608 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
609 24 : mpd->data[PluginSpec ("checkconf1")]["provides"] = "test123";
610 2 : mpd->setCheckconfFunction (checkconfAppend);
611 6 : BackendBuilderInit bbi (mpd);
612 4 : BackendBuilder bb (bbi);
613 12 : PluginSpec spec ("checkconf1");
614 4 : KeySet pluginConfig;
615 4 : spec.appendConfig (pluginConfig);
616 2 : bb.addPlugin (spec);
617 : // we expect b to be added now
618 2 : spec = *bb.begin ();
619 18 : EXPECT_EQ (spec.getConfig ().get<std::string> ("user/b"), "test");
620 2 : }
621 :
622 4 : static int checkconfDelete (ckdb::Key * errorKey ELEKTRA_UNUSED, ckdb::KeySet * config)
623 : {
624 4 : ckdb::ksCopy (config, NULL);
625 4 : return 1;
626 : }
627 :
628 20 : TEST (BackendBuilder, checkconfOkRemovedPluginConfig)
629 : {
630 : using namespace kdb;
631 : using namespace kdb::tools;
632 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
633 24 : mpd->data[PluginSpec ("checkconf1")]["provides"] = "test123";
634 2 : mpd->setCheckconfFunction (checkconfDelete);
635 6 : BackendBuilderInit bbi (mpd);
636 4 : BackendBuilder bb (bbi);
637 12 : PluginSpec spec ("checkconf1");
638 4 : KeySet pluginConfig;
639 4 : Key a;
640 8 : a.setName ("user/a");
641 10 : a.setString ("abc");
642 2 : pluginConfig.append (a);
643 4 : spec.appendConfig (pluginConfig);
644 2 : bb.addPlugin (spec);
645 : // we expect a to be removed now
646 2 : spec = *bb.begin ();
647 8 : EXPECT_THROW (spec.getConfig ().get<std::string> ("user/a"), KeyNotFoundException);
648 2 : }
649 :
650 20 : TEST (BackendBuilder, checkconfOkRemovedBackendConfig)
651 : {
652 : using namespace kdb;
653 : using namespace kdb::tools;
654 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
655 24 : mpd->data[PluginSpec ("checkconf1")]["provides"] = "test123";
656 2 : mpd->setCheckconfFunction (checkconfDelete);
657 6 : BackendBuilderInit bbi (mpd);
658 4 : BackendBuilder bb (bbi);
659 12 : PluginSpec spec ("checkconf1");
660 4 : KeySet pluginConfig;
661 4 : spec.appendConfig (pluginConfig);
662 4 : KeySet backendConfig;
663 4 : Key b;
664 8 : b.setName ("system/b");
665 10 : b.setString ("xyz");
666 2 : backendConfig.append (b);
667 2 : bb.setBackendConfig (backendConfig);
668 2 : bb.addPlugin (spec);
669 : // we expect b to be removed now
670 2 : spec = *bb.begin ();
671 8 : EXPECT_THROW (bb.getBackendConfig ().get<std::string> ("system/b"), KeyNotFoundException);
672 2 : }
673 :
674 2 : static int checkconfAppendBackendConf (ckdb::Key * errorKey ELEKTRA_UNUSED, ckdb::KeySet * config)
675 : {
676 2 : ckdb::ksAppendKey (config, ckdb::keyNew ("system/a", KEY_VALUE, "abc", KEY_END));
677 2 : return 1;
678 : }
679 :
680 20 : TEST (BackendBuilder, checkconfOkAppendBackendConfig)
681 : {
682 : using namespace kdb;
683 : using namespace kdb::tools;
684 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
685 24 : mpd->data[PluginSpec ("checkconf1")]["provides"] = "test123";
686 2 : mpd->setCheckconfFunction (checkconfAppendBackendConf);
687 6 : BackendBuilderInit bbi (mpd);
688 4 : BackendBuilder bb (bbi);
689 12 : PluginSpec spec ("checkconf1");
690 4 : KeySet pluginConfig;
691 4 : spec.appendConfig (pluginConfig);
692 2 : bb.addPlugin (spec);
693 : // we expect b to be added now
694 2 : spec = *bb.begin ();
695 18 : EXPECT_EQ (bb.getBackendConfig ().get<std::string> ("system/a"), "abc");
696 8 : }
|