LCOV - code coverage report
Current view: top level - src/libs/tools/tests - testtool_mergecases.cpp (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 105 105 100.0 %
Date: 2019-09-12 12:28:41 Functions: 23 44 52.3 %

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief Tests for the ThreeWayMerge
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  *
       8             :  */
       9             : 
      10             : #include "mergetestutils.cpp"
      11             : #include <gtest/gtest.h>
      12             : #include <iostream>
      13             : #include <kdbprivate.h>
      14             : 
      15             : using namespace kdb;
      16             : using namespace kdb::tools::merging;
      17             : 
      18          80 : class ThreeWayMergeTest : public MergeTest
      19             : {
      20             : protected:
      21             :         ThreeWayMerge merger;
      22             : };
      23             : 
      24             : // TODO: test all the cases from automergestrategy here too (they were moved)
      25             : 
      26          22 : TEST_F (ThreeWayMergeTest, EqualKeySetsMerge)
      27             : {
      28           4 :         MergeResult result = merger.mergeKeySet (base, ours, theirs, mergeParent);
      29           6 :         EXPECT_FALSE (result.hasConflicts ()) << "Invalid conflict detected";
      30             : 
      31           4 :         KeySet merged = result.getMergedKeys ();
      32             : 
      33           6 :         EXPECT_EQ (5, merged.size ());
      34           2 :         compareAllKeys (merged);
      35           2 : }
      36             : 
      37          22 : TEST_F (ThreeWayMergeTest, EqualKeySetsWontCauseSync)
      38             : {
      39           2 :         unsyncKeys (ours);
      40           2 :         unsyncKeys (theirs);
      41           2 :         unsyncKeys (base);
      42             : 
      43           4 :         MergeResult result = merger.mergeKeySet (base, ours, theirs, ourParent);
      44           6 :         EXPECT_FALSE (result.hasConflicts ()) << "Invalid conflict detected";
      45             : 
      46           4 :         KeySet merged = result.getMergedKeys ();
      47             : 
      48           4 :         Key current;
      49             :         merged.rewind ();
      50          58 :         while ((current = merged.next ()))
      51             :         {
      52          30 :                 EXPECT_FALSE (current.needSync ());
      53             :         }
      54           2 : }
      55             : 
      56          22 : TEST_F (ThreeWayMergeTest, CascadingParentsCauseNoCascadingKeys)
      57             : {
      58           4 :         Key root ("/", KEY_END);
      59          10 :         MergeResult result = merger.mergeKeySet (MergeTask (BaseMergeKeys (base, Key ("/parentb", KEY_END)),
      60           8 :                                                             OurMergeKeys (ours, Key ("/parento", KEY_END)),
      61          12 :                                                             TheirMergeKeys (theirs, Key ("/parentt", KEY_END)), root));
      62           6 :         EXPECT_FALSE (result.hasConflicts ()) << "Invalid conflict detected";
      63             : 
      64           4 :         Key current;
      65           4 :         KeySet merged = result.getMergedKeys ();
      66             :         merged.rewind ();
      67          58 :         while ((current = merged.next ()))
      68             :         {
      69          50 :                 EXPECT_FALSE (current.getNamespace () == "/");
      70             :         }
      71           2 : }
      72             : 
      73          22 : TEST_F (ThreeWayMergeTest, SameDeletedKeyMerge)
      74             : {
      75          12 :         ours.lookup ("user/parento/config/key1", KDB_O_POP);
      76          12 :         theirs.lookup ("user/parentt/config/key1", KDB_O_POP);
      77             : 
      78           4 :         MergeResult result = merger.mergeKeySet (base, ours, theirs, mergeParent);
      79             : 
      80           6 :         EXPECT_FALSE (result.hasConflicts ()) << "Invalid conflict detected";
      81           4 :         KeySet merged = result.getMergedKeys ();
      82           6 :         EXPECT_EQ (4, merged.size ());
      83           2 :         compareAllExceptKey1 (merged);
      84           2 : }
      85             : 
      86          22 : TEST_F (ThreeWayMergeTest, DeleteModifyConflict)
      87             : {
      88          12 :         ours.lookup ("user/parento/config/key1", KDB_O_POP);
      89          20 :         theirs.lookup ("user/parentt/config/key1").setString ("modifiedvalue");
      90             : 
      91           4 :         MergeResult result = merger.mergeKeySet (base, ours, theirs, mergeParent);
      92             : 
      93           6 :         EXPECT_TRUE (result.hasConflicts ()) << "No conflict detected although conflicts should exist";
      94           4 :         KeySet conflicts = result.getConflictSet ();
      95           6 :         ASSERT_EQ (1, conflicts.size ()) << "Wrong number of conflicts";
      96           6 :         testConflictMeta (conflicts.at (0), CONFLICT_DELETE, CONFLICT_MODIFY);
      97           4 :         KeySet merged = result.getMergedKeys ();
      98           6 :         EXPECT_EQ (4, merged.size ());
      99           2 :         compareAllExceptKey1 (merged);
     100             : }
     101             : 
     102          22 : TEST_F (ThreeWayMergeTest, ModifyDeleteConflict)
     103             : {
     104          20 :         ours.lookup ("user/parento/config/key1").setString ("modifiedvalue");
     105          12 :         theirs.lookup ("user/parentt/config/key1", KDB_O_POP);
     106             : 
     107           4 :         MergeResult result = merger.mergeKeySet (base, ours, theirs, mergeParent);
     108           6 :         ASSERT_TRUE (result.hasConflicts ()) << "No conflict detected although conflicts should exist";
     109             : 
     110           4 :         KeySet conflicts = result.getConflictSet ();
     111           6 :         EXPECT_EQ (1, conflicts.size ()) << "Wrong number of conflicts";
     112           6 :         testConflictMeta (conflicts.at (0), CONFLICT_MODIFY, CONFLICT_DELETE);
     113             : 
     114           4 :         KeySet merged = result.getMergedKeys ();
     115           6 :         EXPECT_EQ (4, merged.size ());
     116           2 :         compareAllExceptKey1 (merged);
     117             : }
     118             : 
     119          22 : TEST_F (ThreeWayMergeTest, SameModifyConflict)
     120             : {
     121          20 :         ours.lookup ("user/parento/config/key1").setString ("modifiedvalueours");
     122          20 :         theirs.lookup ("user/parentt/config/key1").setString ("modifiedvaluetheirs");
     123             : 
     124           4 :         MergeResult result = merger.mergeKeySet (base, ours, theirs, mergeParent);
     125           6 :         ASSERT_TRUE (result.hasConflicts ()) << "No conflict detected although conflicts should exist";
     126             : 
     127           4 :         KeySet conflicts = result.getConflictSet ();
     128           6 :         EXPECT_EQ (1, conflicts.size ());
     129           6 :         testConflictMeta (conflicts.at (0), CONFLICT_MODIFY, CONFLICT_MODIFY);
     130             : 
     131           4 :         KeySet merged = result.getMergedKeys ();
     132             : 
     133           6 :         EXPECT_EQ (4, merged.size ());
     134           2 :         compareAllExceptKey1 (merged);
     135             : }
     136             : 
     137          22 : TEST_F (ThreeWayMergeTest, SameAddedEqualValueMerges)
     138             : {
     139           6 :         ours.append (Key ("user/parento/config/key5", KEY_VALUE, "newvalue", KEY_END));
     140           6 :         theirs.append (Key ("user/parentt/config/key5", KEY_VALUE, "newvalue", KEY_END));
     141             : 
     142           4 :         MergeResult result = merger.mergeKeySet (base, ours, theirs, mergeParent);
     143           6 :         EXPECT_FALSE (result.hasConflicts ()) << "Invalid conflict detected";
     144             : 
     145           4 :         KeySet merged = result.getMergedKeys ();
     146             : 
     147           6 :         EXPECT_EQ (6, merged.size ());
     148           2 :         compareAllKeys (merged);
     149             : 
     150           8 :         compareKeys (Key ("user/parentm/config/key5", KEY_VALUE, "newvalue", KEY_END), merged.lookup (mk5));
     151           2 : }
     152             : 
     153          22 : TEST_F (ThreeWayMergeTest, SameAddedDifferentValueConflict)
     154             : {
     155           6 :         ours.append (Key ("user/parento/config/key5", KEY_VALUE, "newvalueours", KEY_END));
     156           6 :         theirs.append (Key ("user/parentt/config/key5", KEY_VALUE, "newvaluetheirs", KEY_END));
     157             : 
     158           4 :         MergeResult result = merger.mergeKeySet (base, ours, theirs, mergeParent);
     159             : 
     160           6 :         ASSERT_TRUE (result.hasConflicts ()) << "No conflict detected although conflicts should exist";
     161             : 
     162           4 :         KeySet conflicts = result.getConflictSet ();
     163           6 :         EXPECT_EQ (1, conflicts.size ());
     164           6 :         testConflictMeta (conflicts.at (0), CONFLICT_ADD, CONFLICT_ADD);
     165             : 
     166           4 :         KeySet merged = result.getMergedKeys ();
     167             : 
     168           6 :         EXPECT_EQ (5, merged.size ());
     169             : 
     170           2 :         compareAllKeys (merged);
     171             : }
     172             : 
     173          22 : TEST_F (ThreeWayMergeTest, SameMetaKeyModifyConflict)
     174             : {
     175          24 :         ours.lookup ("user/parento/config/key1").setMeta<std::string> ("testmeta", "ourvalue");
     176          24 :         theirs.lookup ("user/parentt/config/key1").setMeta<std::string> ("testmeta", "theirvalue");
     177             : 
     178           4 :         MergeResult result = merger.mergeKeySet (base, ours, theirs, mergeParent);
     179             : 
     180           6 :         ASSERT_TRUE (result.hasConflicts ()) << "No conflict detected although conflicts should exist";
     181           4 :         KeySet conflicts = result.getConflictSet ();
     182           6 :         EXPECT_EQ (1, conflicts.size ());
     183           6 :         testConflictMeta (conflicts.at (0), CONFLICT_META, CONFLICT_META);
     184           4 :         KeySet merged = result.getMergedKeys ();
     185           6 :         EXPECT_EQ (4, merged.size ());
     186           2 :         compareAllExceptKey1 (merged);
     187           6 : }

Generated by: LCOV version 1.13