LCOV - code coverage report
Current view: top level - src/libs/tools/tests - testtool_mergingkdb.cpp (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 68 104 65.4 %
Date: 2019-09-12 12:28:41 Functions: 13 23 56.5 %

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief Tests for MergingKDB
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  *
       8             :  */
       9             : 
      10             : #include <chrono>
      11             : #include <gtest/gtest-elektra.h>
      12             : #include <gtest/gtest.h>
      13             : #include <merging/automergeconfiguration.hpp>
      14             : #include <merging/mergingkdb.hpp>
      15             : #include <merging/threewaymerge.hpp>
      16             : #include <thread>
      17             : 
      18             : 
      19             : using namespace kdb;
      20             : using namespace tools::merging;
      21             : 
      22          30 : class MergingKDBTest : public ::testing::Test
      23             : {
      24             : protected:
      25             :         static const std::string testRoot;
      26             :         static const std::string configFile;
      27             : 
      28             : 
      29             :         KeySet firstReturned;
      30             :         KeySet secondReturned;
      31             : 
      32             :         ThreeWayMerge merger;
      33             : 
      34             :         testing::Namespaces namespaces;
      35             :         testing::MountpointPtr mp;
      36             : 
      37          30 :         MergingKDBTest () : namespaces ()
      38             :         {
      39           6 :         }
      40             : 
      41           6 :         void clearConfigFile ()
      42             :         {
      43          12 :                 KDB repo;
      44          12 :                 KeySet ks;
      45           6 :                 repo.get (ks, testRoot);
      46           6 :                 ks.clear ();
      47           6 :                 repo.set (ks, testRoot);
      48           6 :         }
      49             : 
      50           6 :         virtual void SetUp () override
      51             :         {
      52          30 :                 mp.reset (new testing::Mountpoint (testRoot, configFile));
      53           6 :                 clearConfigFile ();
      54           6 :         }
      55             : 
      56           6 :         virtual void TearDown () override
      57             :         {
      58          12 :                 mp.reset ();
      59           6 :         }
      60             : };
      61             : 
      62           6 : const std::string MergingKDBTest::configFile = "kdbFile.dump";
      63           6 : const std::string MergingKDBTest::testRoot = "/tests/merging/";
      64             : 
      65          20 : TEST_F (MergingKDBTest, HandlesUnconflictingKeySets)
      66             : {
      67           4 :         KDB first;
      68           4 :         MergingKDB mergingKDB;
      69             : 
      70           6 :         Key parent (testRoot, KEY_END);
      71             : 
      72           2 :         first.get (firstReturned, parent);
      73          10 :         firstReturned.append (Key ("system" + testRoot + "key", KEY_VALUE, "value", KEY_END));
      74           2 :         first.set (firstReturned, parent);
      75             : 
      76           2 :         mergingKDB.get (secondReturned, parent);
      77          10 :         secondReturned.append (Key ("system" + testRoot + "key2", KEY_VALUE, "value2", KEY_END));
      78           2 :         mergingKDB.synchronize (secondReturned, parent, merger);
      79           2 : }
      80             : 
      81          20 : TEST_F (MergingKDBTest, ThrowsIfNoConflictStrategyRegistered)
      82             : {
      83           4 :         KDB first;
      84           4 :         MergingKDB mergingKDB;
      85           6 :         Key parent (testRoot, KEY_END);
      86             : 
      87           2 :         first.get (firstReturned, parent);
      88           2 :         mergingKDB.get (secondReturned, parent);
      89           4 :         std::this_thread::sleep_for (std::chrono::milliseconds (100));
      90             : 
      91          10 :         firstReturned.append (Key ("system" + testRoot + "key", KEY_VALUE, "value", KEY_END));
      92           2 :         first.set (firstReturned, parent);
      93             : 
      94          10 :         secondReturned.append (Key ("system" + testRoot + "key2", KEY_VALUE, "value2", KEY_END));
      95           4 :         EXPECT_THROW (mergingKDB.synchronize (secondReturned, parent, merger), MergingKDBException);
      96           2 : }
      97             : 
      98          20 : TEST_F (MergingKDBTest, MergesResolvableConflicts)
      99             : {
     100           4 :         KDB first;
     101           4 :         MergingKDB mergingKDB;
     102           6 :         Key parent (testRoot, KEY_END);
     103             : 
     104           4 :         AutoMergeConfiguration configuration;
     105           2 :         configuration.configureMerger (merger);
     106             : 
     107           2 :         first.get (firstReturned, parent);
     108           2 :         mergingKDB.get (secondReturned, parent);
     109           4 :         std::this_thread::sleep_for (std::chrono::milliseconds (100));
     110             : 
     111           8 :         Key key1 ("system" + testRoot + "key1", KEY_VALUE, "value", KEY_END);
     112           4 :         firstReturned.append (key1);
     113           2 :         first.set (firstReturned, parent);
     114             : 
     115           8 :         Key key2 ("system" + testRoot + "key2", KEY_VALUE, "value2", KEY_END);
     116           4 :         secondReturned.append (key2);
     117           2 :         mergingKDB.synchronize (secondReturned, parent, merger);
     118             : 
     119           2 :         first.get (firstReturned, parent);
     120          10 :         Key resultKey1 = firstReturned.lookup ("system" + testRoot + "key1");
     121          10 :         Key resultKey2 = firstReturned.lookup ("system" + testRoot + "key2");
     122           8 :         EXPECT_EQ (2, firstReturned.size ()) << "Written KeySet has a wrong size";
     123           4 :         ASSERT_TRUE (resultKey1);
     124           4 :         EXPECT_EQ (key1, resultKey1) << "Key1 was not written correctly";
     125           4 :         ASSERT_TRUE (resultKey2);
     126           4 :         EXPECT_EQ (key2, resultKey2) << "Key2 was not written correctly";
     127             : }
     128             : 
     129          14 : TEST_F (MergingKDBTest, DISABLED_RemoveKey)
     130             : {
     131           0 :         Key parent (testRoot, KEY_END);
     132             : 
     133             :         {
     134           0 :                 KeySet ks (3, *Key ("system" + testRoot + "key", KEY_VALUE, "value", KEY_END), KS_END);
     135           0 :                 EXPECT_EQ (1, ks.size ());
     136           0 :                 KDB keyAdder;
     137           0 :                 KeySet discard;
     138           0 :                 keyAdder.get (discard, parent);
     139           0 :                 keyAdder.set (ks, parent);
     140             :         }
     141             : 
     142           0 :         MergingKDB mergingKDB;
     143           0 :         mergingKDB.get (secondReturned, parent);
     144             : 
     145             :         {
     146           0 :                 KDB first;
     147           0 :                 first.get (firstReturned, parent);
     148           0 :                 EXPECT_EQ (1, firstReturned.size ());
     149           0 :                 firstReturned.lookup ("system" + testRoot + "key", KDB_O_POP);
     150           0 :                 EXPECT_EQ (0, firstReturned.size ());
     151           0 :                 EXPECT_EQ (1, first.set (firstReturned, parent));
     152             :         }
     153             : 
     154           0 :         mergingKDB.synchronize (secondReturned, parent, merger);
     155           0 :         EXPECT_EQ (0, secondReturned.size ());
     156           0 : }
     157             : 
     158          14 : TEST_F (MergingKDBTest, DISABLED_RemoveKey2)
     159             : {
     160           0 :         Key parent (testRoot, KEY_END);
     161             : 
     162             :         {
     163           0 :                 KeySet ks (3, *Key ("system" + testRoot + "key1", KEY_VALUE, "value", KEY_END),
     164           0 :                            *Key ("system" + testRoot + "key2", KEY_VALUE, "value", KEY_END), KS_END);
     165           0 :                 EXPECT_EQ (1, ks.size ());
     166           0 :                 KDB keyAdder;
     167           0 :                 KeySet discard;
     168           0 :                 keyAdder.get (discard, parent);
     169           0 :                 keyAdder.set (ks, parent);
     170             :         }
     171             : 
     172           0 :         MergingKDB mergingKDB;
     173           0 :         mergingKDB.get (secondReturned, parent);
     174             : 
     175             :         {
     176           0 :                 KDB first;
     177           0 :                 first.get (firstReturned, parent);
     178           0 :                 EXPECT_EQ (2, firstReturned.size ());
     179           0 :                 firstReturned.lookup ("system" + testRoot + "key2", KDB_O_POP);
     180           0 :                 EXPECT_EQ (1, firstReturned.size ());
     181           0 :                 EXPECT_EQ (1, first.set (firstReturned, parent));
     182             :         }
     183             : 
     184           0 :         mergingKDB.synchronize (secondReturned, parent, merger);
     185           0 :         EXPECT_EQ (1, secondReturned.size ());
     186           6 : }

Generated by: LCOV version 1.13