LCOV - code coverage report
Current view: top level - src/libs/tools/tests - testtool_backendbuilder.cpp (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 432 440 98.2 %
Date: 2019-09-12 12:28:41 Functions: 66 126 52.4 %

          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 : }

Generated by: LCOV version 1.13