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

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief Tests for the AutoMergeStrategy
       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 <merging/automergestrategy.hpp>
      13             : 
      14             : using namespace std;
      15             : using namespace kdb;
      16             : using namespace kdb::tools::merging;
      17             : 
      18          72 : class AutoMergeStrategyTest : public MergeTest
      19             : {
      20             : protected:
      21             :         AutoMergeStrategy strategy;
      22             :         MergeResult result;
      23             :         MergeTask task;
      24             :         KeySet conflicts;
      25             : 
      26          18 :         AutoMergeStrategyTest ()
      27         144 :         : task (MergeTask (BaseMergeKeys (base, baseParent), OurMergeKeys (ours, ourParent), TheirMergeKeys (theirs, theirParent),
      28          90 :                            mergeParent))
      29             :         {
      30          54 :                 result = MergeResult (conflicts, mergeKeys);
      31          18 :         }
      32             : };
      33             : 
      34          20 : TEST_F (AutoMergeStrategyTest, DeleteEqualsMerges)
      35             : {
      36          12 :         task.ours.lookup ("user/parento/config/key1", KDB_O_POP);
      37           6 :         Key conflictKey = mergeKeys.lookup (mk1);
      38           2 :         result.addConflict (conflictKey, CONFLICT_DELETE, CONFLICT_SAME);
      39          12 :         conflictKey = result.getConflictSet ().at (0);
      40             : 
      41           2 :         strategy.resolveConflict (task, conflictKey, result);
      42             : 
      43           8 :         EXPECT_FALSE (result.hasConflicts ()) << "Invalid conflict detected";
      44           6 :         KeySet merged = result.getMergedKeys ();
      45             :         // cout << merged << endl;
      46           6 :         EXPECT_EQ (3, merged.size ());
      47             : 
      48             :         /* key with index 1 should be deleted */
      49           2 :         compareAllExceptKey1 (merged);
      50           2 : }
      51             : 
      52          20 : TEST_F (AutoMergeStrategyTest, EqualsDeleteMerges)
      53             : {
      54          12 :         task.theirs.lookup ("user/parentt/config/key1", KDB_O_POP);
      55           6 :         Key conflictKey = mergeKeys.lookup (mk1);
      56           2 :         result.addConflict (conflictKey, CONFLICT_SAME, CONFLICT_DELETE);
      57          12 :         conflictKey = result.getConflictSet ().at (0);
      58             : 
      59           2 :         strategy.resolveConflict (task, conflictKey, result);
      60             : 
      61           8 :         EXPECT_FALSE (result.hasConflicts ()) << "Invalid conflict detected";
      62           6 :         KeySet merged = result.getMergedKeys ();
      63           6 :         EXPECT_EQ (3, merged.size ());
      64             : 
      65             :         /* key with index 1 should be deleted */
      66           2 :         compareAllExceptKey1 (merged);
      67           2 : }
      68             : 
      69          20 : TEST_F (AutoMergeStrategyTest, EqualsModifyMerges)
      70             : {
      71          20 :         task.theirs.lookup ("user/parentt/config/key1").setString ("modifiedvalue");
      72           6 :         Key conflictKey = mergeKeys.lookup (mk1);
      73           2 :         result.addConflict (conflictKey, CONFLICT_SAME, CONFLICT_MODIFY);
      74          12 :         conflictKey = result.getConflictSet ().at (0);
      75             : 
      76           2 :         strategy.resolveConflict (task, conflictKey, result);
      77             : 
      78           8 :         EXPECT_FALSE (result.hasConflicts ()) << "Invalid conflict detected";
      79           6 :         KeySet merged = result.getMergedKeys ();
      80           6 :         EXPECT_EQ (4, merged.size ());
      81             : 
      82          10 :         EXPECT_EQ (mk1, merged.lookup (mk1));
      83          12 :         EXPECT_EQ ("modifiedvalue", merged.lookup (mk1).getString ()) << "Key " << merged.lookup (mk1) << "was not modified correctly";
      84             : 
      85           2 :         compareAllExceptKey1 (merged);
      86           2 : }
      87             : 
      88             : // the expected behaviour is the same for EqualsModify, EqualsDelete and EqualsAdd
      89          20 : TEST_F (AutoMergeStrategyTest, EqualsModifyRespectsBinaryData)
      90             : {
      91          14 :         task.theirs.lookup ("user/parentt/config/key1").setBinary ("modifiedvalue", 13);
      92           6 :         Key conflictKey = mergeKeys.lookup (mk1);
      93           2 :         result.addConflict (conflictKey, CONFLICT_SAME, CONFLICT_MODIFY);
      94          12 :         conflictKey = result.getConflictSet ().at (0);
      95             : 
      96           2 :         strategy.resolveConflict (task, conflictKey, result);
      97             : 
      98           6 :         EXPECT_TRUE (conflictKey.isBinary ());
      99           2 : }
     100             : 
     101          20 : TEST_F (AutoMergeStrategyTest, EqualsModifyRespectsNullData)
     102             : {
     103          12 :         Key l = task.theirs.lookup ("user/parentt/config/key1");
     104           2 :         l.setBinary (nullptr, 0);
     105           6 :         EXPECT_TRUE (l.isBinary ());
     106           8 :         EXPECT_EQ (l.getValue (), nullptr);
     107             : 
     108           6 :         Key conflictKey = mergeKeys.lookup (mk1);
     109           2 :         result.addConflict (conflictKey, CONFLICT_SAME, CONFLICT_MODIFY);
     110          12 :         conflictKey = result.getConflictSet ().at (0);
     111             : 
     112           2 :         strategy.resolveConflict (task, conflictKey, result);
     113             : 
     114           6 :         EXPECT_TRUE (conflictKey.isBinary ());
     115           8 :         EXPECT_EQ (conflictKey.getValue (), nullptr);
     116           2 : }
     117             : 
     118             : 
     119          20 : TEST_F (AutoMergeStrategyTest, ModifyEqualsMerges)
     120             : {
     121          20 :         task.ours.lookup ("user/parento/config/key1").setString ("modifiedvalue");
     122           6 :         Key conflictKey = mergeKeys.lookup (mk1);
     123           2 :         result.addConflict (conflictKey, CONFLICT_MODIFY, CONFLICT_SAME);
     124          12 :         conflictKey = result.getConflictSet ().at (0);
     125             : 
     126           2 :         strategy.resolveConflict (task, conflictKey, result);
     127             : 
     128           8 :         EXPECT_FALSE (result.hasConflicts ()) << "Invalid conflict detected";
     129           6 :         KeySet merged = result.getMergedKeys ();
     130           6 :         EXPECT_EQ (4, merged.size ());
     131             : 
     132          10 :         EXPECT_EQ (mk1, merged.lookup (mk1));
     133          12 :         EXPECT_EQ ("modifiedvalue", merged.lookup (mk1).getString ()) << "Key " << merged.lookup (mk1) << "was not modified correctly";
     134             : 
     135           2 :         compareAllExceptKey1 (merged);
     136           2 : }
     137             : 
     138             : // the expected behaviour is the same for ModifyEquals, DeleteEquals and AddEquals
     139          18 : TEST_F (AutoMergeStrategyTest, ModifyEqualsRespectsBinaryData)
     140             : {
     141          14 :         task.ours.lookup ("user/parento/config/key1").setBinary ("modifiedvalue", 13);
     142           6 :         Key conflictKey = mergeKeys.lookup (mk1);
     143           2 :         result.addConflict (conflictKey, CONFLICT_MODIFY, CONFLICT_SAME);
     144          12 :         conflictKey = result.getConflictSet ().at (0);
     145             : 
     146           2 :         strategy.resolveConflict (task, conflictKey, result);
     147             : 
     148           6 :         EXPECT_TRUE (conflictKey.isBinary ());
     149           2 : }
     150             : 
     151          20 : TEST_F (AutoMergeStrategyTest, AddEqualsKeyMerge)
     152             : {
     153           4 :         Key addedKey = Key ("user/parento/config/key5", KEY_VALUE, "value5", KEY_END);
     154           4 :         task.ours.append (addedKey);
     155           4 :         mergeKeys.append (mk5);
     156           6 :         Key conflictKey = mergeKeys.lookup (mk5);
     157           2 :         result.addConflict (conflictKey, CONFLICT_ADD, CONFLICT_SAME);
     158          12 :         conflictKey = result.getConflictSet ().at (0);
     159             : 
     160           2 :         strategy.resolveConflict (task, conflictKey, result);
     161             : 
     162           8 :         EXPECT_FALSE (result.hasConflicts ()) << "Invalid conflict detected";
     163           6 :         KeySet merged = result.getMergedKeys ();
     164           6 :         EXPECT_EQ (5, merged.size ());
     165           2 :         compareAllKeys (merged);
     166           2 : }
     167             : 
     168          20 : TEST_F (AutoMergeStrategyTest, EqualsAddKeyMerge)
     169             : {
     170           4 :         Key addedKey = Key ("user/parentt/config/key5", KEY_VALUE, "value5", KEY_END);
     171           4 :         task.theirs.append (addedKey);
     172           4 :         mergeKeys.append (mk5);
     173           6 :         Key conflictKey = mergeKeys.lookup (mk5);
     174           2 :         result.addConflict (conflictKey, CONFLICT_SAME, CONFLICT_ADD);
     175          12 :         conflictKey = result.getConflictSet ().at (0);
     176             : 
     177           2 :         strategy.resolveConflict (task, conflictKey, result);
     178             : 
     179           8 :         EXPECT_FALSE (result.hasConflicts ()) << "Invalid conflict detected";
     180           6 :         KeySet merged = result.getMergedKeys ();
     181           6 :         EXPECT_EQ (5, merged.size ());
     182           2 :         compareAllKeys (merged);
     183           8 : }

Generated by: LCOV version 1.13