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

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief Tests for the Backend class
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  *
       8             :  */
       9             : 
      10             : 
      11             : #include <backend.hpp>
      12             : #include <keysetio.hpp>
      13             : 
      14             : #include <gtest/gtest.h>
      15             : 
      16          20 : TEST (SameMountpoint, setMountpoints)
      17             : {
      18             :         using namespace kdb;
      19             :         using namespace kdb::tools;
      20           4 :         KeySet ks;
      21             : 
      22           4 :         Backend b1;
      23           6 :         b1.setMountpoint (Key ("user/hello", KEY_END), ks);
      24           8 :         EXPECT_EQ (b1.getMountpoint (), "user/hello");
      25             : 
      26           6 :         b1.setMountpoint (Key ("user//hello", KEY_END), ks);
      27           8 :         EXPECT_EQ (b1.getMountpoint (), "user/hello");
      28             : 
      29           6 :         b1.setMountpoint (Key ("user////hello", KEY_END), ks);
      30           8 :         EXPECT_EQ (b1.getMountpoint (), "user/hello");
      31             : 
      32           6 :         b1.setMountpoint (Key ("user////hello//", KEY_END), ks);
      33           8 :         EXPECT_EQ (b1.getMountpoint (), "user/hello");
      34             : 
      35           6 :         b1.setMountpoint (Key ("user////hello////.", KEY_END), ks);
      36           8 :         EXPECT_EQ (b1.getMountpoint (), "user/hello");
      37             : 
      38           6 :         b1.setMountpoint (Key ("user////hello////.//", KEY_END), ks);
      39           8 :         EXPECT_EQ (b1.getMountpoint (), "user/hello");
      40             : 
      41           6 :         b1.setMountpoint (Key ("user////hello////.//x/..", KEY_END), ks);
      42           8 :         EXPECT_EQ (b1.getMountpoint (), "user/hello");
      43           2 : }
      44             : 
      45          20 : TEST (SameMountpoint, setMountpointsNamespaces)
      46             : {
      47             :         using namespace kdb;
      48             :         using namespace kdb::tools;
      49           4 :         KeySet ks;
      50             : 
      51           4 :         Backend b1;
      52             : 
      53           6 :         b1.setMountpoint (Key ("dir", KEY_END), ks);
      54           8 :         EXPECT_EQ (b1.getMountpoint (), "dir");
      55             : 
      56           6 :         b1.setMountpoint (Key ("system", KEY_END), ks);
      57           8 :         EXPECT_EQ (b1.getMountpoint (), "system");
      58             : 
      59           6 :         b1.setMountpoint (Key ("user", KEY_END), ks);
      60           8 :         EXPECT_EQ (b1.getMountpoint (), "user");
      61             : 
      62           6 :         b1.setMountpoint (Key ("spec", KEY_END), ks);
      63           8 :         EXPECT_EQ (b1.getMountpoint (), "spec");
      64           2 : }
      65             : 
      66          20 : TEST (SameMountpoint, strangeMountpoints)
      67             : {
      68             :         using namespace kdb;
      69             :         using namespace kdb::tools;
      70           4 :         KeySet ks;
      71             : 
      72           4 :         Backend b1;
      73           6 :         b1.setMountpoint (Key ("user/..", KEY_END), ks);
      74           8 :         EXPECT_EQ (b1.getMountpoint (), "user");
      75             : 
      76           6 :         b1.setMountpoint (Key ("user/elektras", KEY_END), ks);
      77           8 :         EXPECT_EQ (b1.getMountpoint (), "user/elektras");
      78             : 
      79           6 :         b1.setMountpoint (Key ("user/elektra/..", KEY_END), ks);
      80           8 :         EXPECT_EQ (b1.getMountpoint (), "user");
      81             : 
      82           6 :         b1.setMountpoint (Key ("user/elektra\\/", KEY_END), ks);
      83           8 :         EXPECT_EQ (b1.getMountpoint (), "user/elektra\\/");
      84             : 
      85           6 :         b1.setMountpoint (Key ("user//../..", KEY_END), ks);
      86           8 :         EXPECT_EQ (b1.getMountpoint (), "user");
      87             : 
      88           6 :         b1.setMountpoint (Key ("user//../..////../", KEY_END), ks);
      89           8 :         EXPECT_EQ (b1.getMountpoint (), "user");
      90             : 
      91           6 :         b1.setMountpoint (Key ("spec//..//hello//..//.//..////../..", KEY_END), ks);
      92           8 :         EXPECT_EQ (b1.getMountpoint (), "spec");
      93             : 
      94           6 :         b1.setMountpoint (Key ("dir//..//hello//..//.//..////../..", KEY_END), ks);
      95           8 :         EXPECT_EQ (b1.getMountpoint (), "dir");
      96             : 
      97           6 :         b1.setMountpoint (Key ("user//..//hello//..//.//..////../..", KEY_END), ks);
      98           8 :         EXPECT_EQ (b1.getMountpoint (), "user");
      99             : 
     100           6 :         b1.setMountpoint (Key ("system//..//hello//..//.//..////../..", KEY_END), ks);
     101           8 :         EXPECT_EQ (b1.getMountpoint (), "system");
     102             : 
     103           6 :         b1.setMountpoint (Key ("/..//hello//..//.//..////../..", KEY_END), ks);
     104           8 :         EXPECT_EQ (b1.getMountpoint (), "/");
     105             : 
     106           6 :         b1.setMountpoint (Key ("//..//hello//..//.//..////../..", KEY_END), ks);
     107           8 :         EXPECT_EQ (b1.getMountpoint (), "/");
     108             : 
     109           6 :         b1.setMountpoint (Key ("/is//../a//../complex/..///.", KEY_END), ks);
     110           8 :         EXPECT_EQ (b1.getMountpoint (), "/");
     111           2 : }
     112             : 
     113          20 : TEST (SameMountpoint, wrongMountpoints)
     114             : {
     115             :         using namespace kdb;
     116             :         using namespace kdb::tools;
     117           4 :         KeySet ks;
     118             : 
     119           4 :         Backend b1;
     120          10 :         ASSERT_THROW (b1.setMountpoint (Key (static_cast<ckdb::Key *> (nullptr)), ks), kdb::tools::MountpointAlreadyInUseException);
     121           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     122           8 :         ASSERT_THROW (b1.setMountpoint (Key ("", KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);
     123           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     124           8 :         ASSERT_THROW (b1.setMountpoint (Key (".", KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);
     125           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     126           8 :         ASSERT_THROW (b1.setMountpoint (Key ("invalid", KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);
     127           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     128           8 :         ASSERT_THROW (b1.setMountpoint (Key ("proc", KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);
     129           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     130           8 :         ASSERT_THROW (b1.setMountpoint (Key ("proc/something", KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);
     131           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     132           8 :         ASSERT_THROW (b1.setMountpoint (Key ("proc//..//hello//..//.//..////../..", KEY_END), ks),
     133             :                       kdb::tools::MountpointAlreadyInUseException);
     134           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     135             : }
     136             : 
     137          20 : TEST (SameMountpoint, wrongElektraMountpoints)
     138             : {
     139             :         using namespace kdb;
     140             :         using namespace kdb::tools;
     141           4 :         KeySet ks;
     142             : 
     143           4 :         Backend b1;
     144           8 :         ASSERT_THROW (b1.setMountpoint (Key ("proc", KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);
     145           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     146           8 :         ASSERT_THROW (b1.setMountpoint (Key ("proc/elektra", KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);
     147           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     148           8 :         ASSERT_THROW (b1.setMountpoint (Key ("spec/elektra", KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);
     149           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     150           8 :         ASSERT_THROW (b1.setMountpoint (Key ("dir/elektra", KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);
     151           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     152           8 :         ASSERT_THROW (b1.setMountpoint (Key ("system/elektra", KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);
     153           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     154           8 :         ASSERT_THROW (b1.setMountpoint (Key ("system/elektra/mountpoints", KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);
     155           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     156           8 :         ASSERT_THROW (b1.setMountpoint (Key ("system/elektra/globalplugins", KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);
     157           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     158           8 :         ASSERT_THROW (b1.setMountpoint (Key ("system/elektra/something", KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);
     159           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     160           8 :         ASSERT_THROW (b1.setMountpoint (Key ("system/elektra/something/deep/below", KEY_END), ks),
     161             :                       kdb::tools::MountpointAlreadyInUseException);
     162           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     163           8 :         ASSERT_THROW (b1.setMountpoint (Key ("user/elektra", KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);
     164           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     165           8 :         ASSERT_THROW (b1.setMountpoint (Key ("user/elektra/mountpoints", KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);
     166           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     167           8 :         ASSERT_THROW (b1.setMountpoint (Key ("user/elektra/globalplugins", KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);
     168           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     169           8 :         ASSERT_THROW (b1.setMountpoint (Key ("user/elektra/something", KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);
     170           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     171           8 :         ASSERT_THROW (b1.setMountpoint (Key ("user/elektra/something/deep/below", KEY_END), ks),
     172             :                       kdb::tools::MountpointAlreadyInUseException);
     173           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     174           8 :         ASSERT_THROW (b1.setMountpoint (Key ("/elektra", KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);
     175           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     176           8 :         ASSERT_THROW (b1.setMountpoint (Key ("/elektra/mountpoints", KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);
     177           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     178           8 :         ASSERT_THROW (b1.setMountpoint (Key ("/elektra/globalplugins", KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);
     179           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     180           8 :         ASSERT_THROW (b1.setMountpoint (Key ("/elektra/something", KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);
     181           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     182           8 :         ASSERT_THROW (b1.setMountpoint (Key ("/elektra/something/deep/below", KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);
     183           8 :         EXPECT_EQ (b1.getMountpoint (), "");
     184             : }
     185             : 
     186             : 
     187          20 : TEST (SameMountpoint, notSame)
     188             : {
     189             :         using namespace kdb;
     190             :         using namespace kdb::tools;
     191           4 :         KeySet ks;
     192             : 
     193           4 :         Backend b1;
     194           6 :         b1.setMountpoint (Key ("user/hello", KEY_END), ks);
     195           8 :         EXPECT_EQ (b1.getMountpoint (), "user/hello");
     196           2 :         b1.serialize (ks);
     197             : 
     198           4 :         Backend b2;
     199           6 :         b2.setMountpoint (Key ("user/else", KEY_END), ks);
     200           8 :         EXPECT_EQ (b2.getMountpoint (), "user/else");
     201           2 :         b2.serialize (ks);
     202             : 
     203           4 :         Backend b3;
     204           6 :         b2.setMountpoint (Key ("/somewhere", KEY_END), ks);
     205           8 :         EXPECT_EQ (b2.getMountpoint (), "/somewhere");
     206           2 :         b2.serialize (ks);
     207           2 : }
     208             : 
     209             : #define checkSame(name1, name2)                                                                                                            \
     210             :         {                                                                                                                                  \
     211             :                 using namespace kdb;                                                                                                       \
     212             :                 using namespace kdb::tools;                                                                                                \
     213             :                 KeySet ks;                                                                                                                 \
     214             :                                                                                                                                            \
     215             :                 Backend b1;                                                                                                                \
     216             :                 EXPECT_EQ (b1.getMountpoint (), "");                                                                                       \
     217             :                 b1.setMountpoint (Key (name1, KEY_END), ks);                                                                               \
     218             :                 EXPECT_EQ (b1.getMountpoint (), name1);                                                                                    \
     219             :                 b1.serialize (ks);                                                                                                         \
     220             :                                                                                                                                            \
     221             :                 Backend b2;                                                                                                                \
     222             :                 EXPECT_EQ (b2.getMountpoint (), "");                                                                                       \
     223             :                 ASSERT_THROW (b2.setMountpoint (Key (name2, KEY_END), ks), kdb::tools::MountpointAlreadyInUseException);                   \
     224             :                 EXPECT_EQ (b2.getMountpoint (), "");                                                                                       \
     225             :         }
     226             : 
     227             : #define checkAllow(name1, name2)                                                                                                           \
     228             :         {                                                                                                                                  \
     229             :                 using namespace kdb;                                                                                                       \
     230             :                 using namespace kdb::tools;                                                                                                \
     231             :                 KeySet ks;                                                                                                                 \
     232             :                                                                                                                                            \
     233             :                 Backend b1;                                                                                                                \
     234             :                 EXPECT_EQ (b1.getMountpoint (), "");                                                                                       \
     235             :                 b1.setMountpoint (Key (name1, KEY_END), ks);                                                                               \
     236             :                 EXPECT_EQ (b1.getMountpoint (), name1);                                                                                    \
     237             :                 b1.serialize (ks);                                                                                                         \
     238             :                                                                                                                                            \
     239             :                 Backend b2;                                                                                                                \
     240             :                 EXPECT_EQ (b2.getMountpoint (), "");                                                                                       \
     241             :                 ASSERT_NO_THROW (b2.setMountpoint (Key (name2, KEY_END), ks));                                                             \
     242             :                 EXPECT_EQ (b2.getMountpoint (), name2);                                                                                    \
     243             :         }
     244             : 
     245             : 
     246          20 : TEST (SameMountpoint, exactlySameHelloSpec)
     247             : {
     248          50 :         checkSame ("spec/hello", "spec/hello");
     249             : }
     250          20 : TEST (SameMountpoint, exactlySameHelloDir)
     251             : {
     252          50 :         checkSame ("dir/hello", "dir/hello");
     253             : }
     254          20 : TEST (SameMountpoint, exactlySameHelloUser)
     255             : {
     256          50 :         checkSame ("user/hello", "user/hello");
     257             : }
     258          20 : TEST (SameMountpoint, exactlySameHelloSystem)
     259             : {
     260          50 :         checkSame ("system/hello", "system/hello");
     261             : }
     262             : 
     263          20 : TEST (SameMountpoint, cascadingFirstSameHelloSpec)
     264             : {
     265          48 :         checkAllow ("/hello", "spec/hello");
     266             : }
     267          20 : TEST (SameMountpoint, cascadingFirstSameHelloUser)
     268             : {
     269          50 :         checkSame ("/hello", "user/hello");
     270             : }
     271          20 : TEST (SameMountpoint, cascadingFirstSameHelloSystem)
     272             : {
     273          50 :         checkSame ("/hello", "system/hello");
     274             : }
     275             : 
     276          20 : TEST (SameMountpoint, cascadingSameHelloSpec)
     277             : {
     278          48 :         checkAllow ("spec/hello", "/hello");
     279             : }
     280          20 : TEST (SameMountpoint, cascadingSameHelloDir)
     281             : {
     282          50 :         checkSame ("dir/hello", "/hello");
     283             : }
     284          20 : TEST (SameMountpoint, cascadingSameHelloUser)
     285             : {
     286          50 :         checkSame ("user/hello", "/hello");
     287             : }
     288          20 : TEST (SameMountpoint, cascadingSameHelloSystem)
     289             : {
     290          50 :         checkSame ("system/hello", "/hello");
     291             : }
     292             : 
     293          20 : TEST (SameMountpoint, exactlySameSpec)
     294             : {
     295          50 :         checkSame ("spec/an/more/involved/deeper/mountpoint", "spec/an/more/involved/deeper/mountpoint");
     296             : }
     297          20 : TEST (SameMountpoint, exactlySameDir)
     298             : {
     299          50 :         checkSame ("dir/an/more/involved/deeper/mountpoint", "dir/an/more/involved/deeper/mountpoint");
     300             : }
     301          20 : TEST (SameMountpoint, exactlySameUser)
     302             : {
     303          50 :         checkSame ("user/an/more/involved/deeper/mountpoint", "user/an/more/involved/deeper/mountpoint");
     304             : }
     305          20 : TEST (SameMountpoint, exactlySameSystem)
     306             : {
     307          50 :         checkSame ("system/an/more/involved/deeper/mountpoint", "system/an/more/involved/deeper/mountpoint");
     308             : }
     309             : 
     310          20 : TEST (SameMountpoint, cascadingFirstSameSpec)
     311             : {
     312          48 :         checkAllow ("/an/more/involved/deeper/mountpoint", "spec/an/more/involved/deeper/mountpoint");
     313             : }
     314          20 : TEST (SameMountpoint, cascadingFirstSameDir)
     315             : {
     316          50 :         checkSame ("/an/more/involved/deeper/mountpoint", "dir/an/more/involved/deeper/mountpoint");
     317             : }
     318          20 : TEST (SameMountpoint, cascadingFirstSameUser)
     319             : {
     320          50 :         checkSame ("/an/more/involved/deeper/mountpoint", "user/an/more/involved/deeper/mountpoint");
     321             : }
     322          20 : TEST (SameMountpoint, cascadingFirstSameSystem)
     323             : {
     324          50 :         checkSame ("/an/more/involved/deeper/mountpoint", "system/an/more/involved/deeper/mountpoint");
     325             : }
     326             : 
     327          20 : TEST (SameMountpoint, cascadingSameSpec)
     328             : {
     329          48 :         checkAllow ("spec/an/more/involved/deeper/mountpoint", "/an/more/involved/deeper/mountpoint");
     330             : }
     331          20 : TEST (SameMountpoint, cascadingSameDir)
     332             : {
     333          50 :         checkSame ("dir/an/more/involved/deeper/mountpoint", "/an/more/involved/deeper/mountpoint");
     334             : }
     335          20 : TEST (SameMountpoint, cascadingSameUser)
     336             : {
     337          50 :         checkSame ("user/an/more/involved/deeper/mountpoint", "/an/more/involved/deeper/mountpoint");
     338             : }
     339          20 : TEST (SameMountpoint, cascadingSameSystem)
     340             : {
     341          50 :         checkSame ("system/an/more/involved/deeper/mountpoint", "/an/more/involved/deeper/mountpoint");
     342             : }
     343             : 
     344          20 : TEST (SameMountpoint, sameRoot)
     345             : {
     346          50 :         checkSame ("/", "/");
     347             : }
     348          20 : TEST (SameMountpoint, sameRootSpec)
     349             : {
     350          50 :         checkSame ("/", "spec");
     351             : }
     352          20 : TEST (SameMountpoint, sameRootDir)
     353             : {
     354          50 :         checkSame ("/", "dir");
     355             : }
     356          20 : TEST (SameMountpoint, sameRootUser)
     357             : {
     358          50 :         checkSame ("/", "user");
     359             : }
     360          20 : TEST (SameMountpoint, sameRootSystem)
     361             : {
     362          50 :         checkSame ("/", "system");
     363             : }
     364             : 
     365          20 : TEST (SameMountpoint, sameRootSlashSpec)
     366             : {
     367          50 :         checkSame ("/", "spec/");
     368             : }
     369          20 : TEST (SameMountpoint, sameRootSlashDir)
     370             : {
     371          50 :         checkSame ("/", "dir/");
     372             : }
     373          20 : TEST (SameMountpoint, sameRootSlashUser)
     374             : {
     375          50 :         checkSame ("/", "user/");
     376             : }
     377          20 : TEST (SameMountpoint, sameRootSlashSystem)
     378             : {
     379          50 :         checkSame ("/", "system/");
     380           6 : }

Generated by: LCOV version 1.13