LCOV - code coverage report
Current view: top level - tests/kdb - testkdb_conflict.cpp (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 82 125 65.6 %
Date: 2019-09-12 12:28:41 Functions: 23 34 67.6 %

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief Tests for KDB
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  *
       8             :  */
       9             : 
      10             : #include <keysetio.hpp>
      11             : 
      12             : #include <gtest/gtest-elektra.h>
      13             : 
      14             : 
      15          48 : class Conflict : public ::testing::TestWithParam<bool>
      16             : {
      17             : protected:
      18             :         static const std::string testRoot;
      19             :         static const std::string configFile;
      20             : 
      21             :         testing::Namespaces namespaces;
      22             :         testing::MountpointPtr mp;
      23             : 
      24          48 :         Conflict () : namespaces ()
      25             :         {
      26          16 :         }
      27             : 
      28           8 :         void createConfigFile ()
      29             :         {
      30             :                 using namespace kdb;
      31          16 :                 KDB repo;
      32          16 :                 KeySet ks;
      33           8 :                 repo.get (ks, testRoot);
      34          32 :                 ks.append (Key ("system" + testRoot, KEY_END));
      35           8 :                 repo.set (ks, testRoot);
      36           8 :         }
      37             : 
      38          16 :         virtual void SetUp () override
      39             :         {
      40          80 :                 mp.reset (new testing::Mountpoint (testRoot, configFile));
      41          16 :                 if (GetParam ())
      42             :                 {
      43           8 :                         createConfigFile ();
      44             :                 }
      45          16 :         }
      46             : 
      47          16 :         virtual void TearDown () override
      48             :         {
      49          32 :                 mp.reset ();
      50          16 :         }
      51             : };
      52             : 
      53           6 : const std::string Conflict::configFile = "kdbFile.dump";
      54           6 : const std::string Conflict::testRoot = "/tests/kdb/";
      55             : 
      56          28 : TEST_P (Conflict, ConflictWithFile)
      57             : {
      58             :         using namespace kdb;
      59             : 
      60          12 :         Key parent (testRoot, KEY_END);
      61             : 
      62           8 :         KDB first;
      63           8 :         KeySet firstReturned;
      64           4 :         first.get (firstReturned, parent);
      65             : 
      66           8 :         KDB second;
      67           8 :         KeySet secondReturned;
      68           4 :         second.get (secondReturned, parent);
      69             : 
      70          20 :         firstReturned.append (Key ("system" + testRoot + "key1", KEY_VALUE, "value1", KEY_END));
      71          20 :         secondReturned.append (Key ("system" + testRoot + "key2", KEY_VALUE, "value2", KEY_END));
      72          20 :         secondReturned.append (Key ("system" + testRoot + "key3", KEY_VALUE, "value3", KEY_END));
      73             : 
      74           4 :         second.set (secondReturned, parent);
      75           8 :         EXPECT_THROW (first.set (firstReturned, parent), KDBException);
      76           4 :         printWarnings (std::cout, parent, true, true);
      77           4 : }
      78             : 
      79          16 : TEST_P (Conflict, DISABLED_ConflictWithFileLoop)
      80             : {
      81             :         using namespace kdb;
      82             : 
      83           0 :         Key parent (testRoot, KEY_END);
      84             : 
      85           0 :         KDB first;
      86           0 :         KeySet firstReturned;
      87           0 :         first.get (firstReturned, parent);
      88             : 
      89           0 :         KDB second;
      90           0 :         KeySet secondReturned;
      91             : 
      92           0 :         const int retries = 10;
      93           0 :         for (int j = 0; j < retries; j++)
      94             :         {
      95           0 :                 second.get (secondReturned, parent);
      96             : 
      97           0 :                 firstReturned.append (Key ("system" + testRoot + "key1", KEY_VALUE, "value1", KEY_END));
      98           0 :                 secondReturned.append (Key ("system" + testRoot + "key2", KEY_VALUE, "value2", KEY_END));
      99           0 :                 secondReturned.append (Key ("system" + testRoot + "key3", KEY_VALUE, "value3", KEY_END));
     100             : 
     101           0 :                 for (int i = 0; i < retries; ++i)
     102             :                 {
     103           0 :                         second.set (secondReturned, parent);
     104           0 :                         EXPECT_THROW (first.set (firstReturned, parent), KDBException);
     105             :                 }
     106             :         }
     107           0 :         printWarnings (std::cout, parent, true, true);
     108           0 : }
     109             : 
     110          28 : TEST_P (Conflict, ConflictWithFileSameKey)
     111             : {
     112             :         using namespace kdb;
     113             : 
     114          12 :         Key parent (testRoot, KEY_END);
     115             : 
     116           8 :         KDB first;
     117           8 :         KeySet firstReturned;
     118           4 :         first.get (firstReturned, parent);
     119             : 
     120           8 :         KDB second;
     121           8 :         KeySet secondReturned;
     122           4 :         second.get (secondReturned, parent);
     123             : 
     124          20 :         firstReturned.append (Key ("system" + testRoot + "key1", KEY_VALUE, "value1", KEY_END));
     125          20 :         secondReturned.append (Key ("system" + testRoot + "key1", KEY_VALUE, "value2", KEY_END));
     126             : 
     127           4 :         second.set (secondReturned, parent);
     128           8 :         EXPECT_THROW (first.set (firstReturned, parent), KDBException);
     129           4 :         printWarnings (std::cout, parent, true, true);
     130           4 : }
     131             : 
     132          28 : TEST_P (Conflict, ConflictWithFileSameKeyValue)
     133             : {
     134             :         using namespace kdb;
     135             : 
     136          12 :         Key parent (testRoot, KEY_END);
     137             : 
     138           8 :         KDB first;
     139           8 :         KeySet firstReturned;
     140           4 :         first.get (firstReturned, parent);
     141             : 
     142           8 :         KDB second;
     143           8 :         KeySet secondReturned;
     144           4 :         second.get (secondReturned, parent);
     145             : 
     146          20 :         firstReturned.append (Key ("system" + testRoot + "key1", KEY_VALUE, "value1", KEY_END));
     147          20 :         secondReturned.append (Key ("system" + testRoot + "key1", KEY_VALUE, "value1", KEY_END));
     148             : 
     149           4 :         second.set (secondReturned, parent);
     150           8 :         EXPECT_THROW (first.set (firstReturned, parent), KDBException);
     151           4 :         printWarnings (std::cout, parent, true, true);
     152           4 : }
     153             : 
     154          28 : TEST_P (Conflict, ConflictWithRemoval)
     155             : {
     156             :         using namespace kdb;
     157             : 
     158          12 :         Key parent (testRoot, KEY_END);
     159             : 
     160           8 :         KDB first;
     161           8 :         KeySet firstReturned;
     162           4 :         first.get (firstReturned, parent);
     163             : 
     164           8 :         KDB second;
     165           8 :         KeySet secondReturned;
     166           4 :         second.get (secondReturned, parent);
     167             : 
     168          20 :         firstReturned.append (Key ("system" + testRoot + "key1", KEY_VALUE, "value1", KEY_END));
     169           4 :         secondReturned.clear (); // remove file
     170             : 
     171           4 :         second.set (secondReturned, parent);
     172           4 :         if (GetParam ())
     173             :         {
     174           4 :                 EXPECT_THROW (first.set (firstReturned, parent), KDBException);
     175             :         }
     176             :         else
     177             :         {
     178           2 :                 EXPECT_NO_THROW (first.set (firstReturned, parent)) << "file should be still removed, should be ok to write to a new file";
     179             :         }
     180           4 :         printWarnings (std::cout, parent, true, true);
     181           4 : }
     182             : 
     183          16 : TEST_P (Conflict, DISABLED_ConflictWithRemovalLoop)
     184             : {
     185             :         using namespace kdb;
     186             : 
     187           0 :         Key parent (testRoot, KEY_END);
     188             : 
     189           0 :         KDB first;
     190           0 :         KeySet firstReturned;
     191           0 :         first.get (firstReturned, parent);
     192             : 
     193           0 :         KDB second;
     194           0 :         KeySet secondReturned;
     195           0 :         second.get (secondReturned, parent);
     196             : 
     197           0 :         firstReturned.append (Key ("system" + testRoot + "key1", KEY_VALUE, "value1", KEY_END));
     198           0 :         secondReturned.clear (); // remove file
     199             : 
     200           0 :         second.set (secondReturned, parent);
     201           0 :         if (GetParam ())
     202             :         {
     203           0 :                 EXPECT_THROW (first.set (firstReturned, parent), KDBException);
     204             :         }
     205             :         else
     206             :         {
     207           0 :                 EXPECT_NO_THROW (first.set (firstReturned, parent)) << "file should be still removed, should be ok to write to a new file";
     208             :         }
     209             :         const int retries = 100;
     210           0 :         for (int j = 0; j < retries; j++)
     211             :         {
     212           0 :                 secondReturned.clear ();
     213           0 :                 second.get (secondReturned, parent);
     214           0 :                 second.set (secondReturned, parent);
     215             : 
     216           0 :                 firstReturned.append (Key ("system" + testRoot + "key1", KEY_VALUE, "value1", KEY_END));
     217           0 :                 EXPECT_THROW (first.set (firstReturned, parent), KDBException) << "should be conflict with removed file";
     218             : 
     219             :                 // create file
     220           0 :                 first.get (firstReturned, parent);
     221           0 :                 firstReturned.append (Key ("system" + testRoot + "key1", KEY_VALUE, "value1", KEY_END));
     222           0 :                 first.set (firstReturned, parent);
     223             : 
     224           0 :                 secondReturned.clear ();
     225           0 :                 EXPECT_THROW (second.set (secondReturned, parent), KDBException) << "should be conflict with existing file";
     226             :         }
     227           0 :         printWarnings (std::cout, parent, true, true);
     228           0 : }
     229             : 
     230             : 
     231          82 : INSTANTIATE_TEST_CASE_P (Conflict, Conflict, ::testing::Values (true, false), );

Generated by: LCOV version 1.13