TEST_F (Simple, SetSystemGetAppend2)
{
using namespace kdb;
KDB kdb;
KeySet ks;
Key parentKey (testRoot, KEY_END);
ks.append (Key ("system" + testRoot + "key", KEY_VALUE, "value1", KEY_END));
kdb.get (ks, parentKey);
ASSERT_EQ (ks.size (), 1) << "got keys from freshly mounted backends";
ks.rewind ();
ks.next ();
EXPECT_EQ (ks.current ().getName (), "system/tests/kdb/key") << "name of element in keyset wrong";
EXPECT_EQ (ks.current ().getString (), "value1") << "string of element in keyset wrong";
kdb.set (ks, parentKey);
kdb.close (parentKey);
KeySet ks2;
ks2.append (Key ("system" + testRoot + "key2", KEY_VALUE, "value2", KEY_END));
kdb.open (parentKey);
kdb.get (ks2, parentKey);
ks2.rewind ();
ks2.next ();
ASSERT_EQ (ks2.size (), 1) << "wrong size";
EXPECT_EQ (ks2.current ().getName (), "system/tests/kdb/key") << "name of element in keyset wrong";
EXPECT_EQ (ks2.current ().getString (), "value1") << "string of element in keyset wrong";
}
TEST_F (Simple, GetSystem)
{
using namespace kdb;
KDB kdb;
KeySet ks;
Key parentKey ("system" + testRoot, KEY_END);
ks.append (Key (parentKey.getName () + "/key", KEY_END));
EXPECT_NE (kdb.get (ks, parentKey), -1);
ASSERT_EQ (ks.size (), 1) << "no key stayed" << ks;
ks.rewind ();
ks.next ();
EXPECT_EQ (ks.current ().getName (), "system/tests/kdb/key") << "name of element in keyset wrong";
EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
ASSERT_NE (kdb.set (ks, parentKey), -1);
ks.rewind ();
ks.next ();
EXPECT_EQ (ks.current ().getName (), "system/tests/kdb/key") << "name of element in keyset wrong";
EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
kdb.close (parentKey);
KeySet ks2;
kdb.open (parentKey);
kdb.get (ks2, parentKey);
ks.rewind ();
ks.next ();
EXPECT_EQ (ks.current ().getName (), "system/tests/kdb/key") << "name of element in keyset wrong";
EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
}
TEST_F (Simple, GetAppendMeta)
{
using namespace kdb;
KDB kdb;
KeySet ks;
ks.append (Key ("meta/key", KEY_META_NAME, KEY_END));
Key parentKey (testRoot, KEY_END);
kdb.get (ks, parentKey);
ASSERT_EQ (ks.size (), 1) << "no key stayed";
ks.rewind ();
ks.next ();
EXPECT_EQ (ks.current ().getName (), "meta/key") << "name of element in keyset wrong";
EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
kdb.set (ks, parentKey);
ks.rewind ();
ks.next ();
EXPECT_EQ (ks.current ().getName (), "meta/key") << "name of element in keyset wrong";
EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
kdb.close (parentKey);
KeySet ks2;
kdb.open (parentKey);
kdb.get (ks2, parentKey);
ASSERT_EQ (ks2.size (), 0) << "got keys from freshly mounted backends";
}
TEST_F (Simple, RemoveFile)
{
using namespace kdb;
KDB kdb;
KeySet ks;
kdb.get (ks, testRoot);
ks.append (Key ("system" + testRoot + "remove", KEY_END));
ASSERT_EQ (ks.size (), 1) << "could not append key\n" << ks;
kdb.set (ks, testRoot);
ASSERT_EQ (ks.size (), 1) << "key gone after kdb.set?\n" << ks;
struct stat buf;
ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), 0) << "found no file";
Key parentKey;
kdb.close (parentKey);
kdb.open (parentKey);
kdb.get (ks, testRoot);
ks.clear ();
ASSERT_EQ (ks.size (), 0) << "keyset should be empty after clearing it\n" << ks;
kdb.set (ks, testRoot);
ASSERT_EQ (stat (mp->systemConfigFile.c_str (), &buf), -1) << "found wrong file";
}
kdb::Key mountBackend (int iteration)
{
using namespace kdb;
using namespace kdb::tools;
Key mp = getMountpointForIteration<VARIANT> (iteration);
std::string cf = "benchmark_" + plugin_variant_names[VARIANT] + "_" + std::to_string (iteration) + ".ecf";
unlink (cf.c_str ());
KDB kdb;
KeySet mountConfig;
kdb.get (mountConfig, "system/elektra/mountpoints");
MountBackendBuilder b;
b.setMountpoint (mp, KeySet (0, KS_END));
b.addPlugin (PluginSpec ("resolver"));
b.useConfigFile (cf);
b.addPlugin (PluginSpec ("dump"));
if (VARIANT != NO_CRYPTO)
{
KeySet pluginConfig;
pluginConfig.append (Key ("user/encrypt/key", KEY_VALUE, GPG_TEST_KEY_ID, KEY_END));
pluginConfig.append (Key ("user/gpg/unit_test", KEY_VALUE, "1", KEY_END));
b.addPlugin (PluginSpec (plugin_variant_names[VARIANT], pluginConfig));
}
b.validated ();
b.serialize (mountConfig);
kdb.set (mountConfig, "system/elektra/mountpoints");
kdb.close ();
return mp;
}
TEST_F (Simple, WrongStateSystem)
{
using namespace kdb;
KDB kdb;
KeySet ks;
Key parentKey ("system" + testRoot, KEY_END);
EXPECT_THROW (kdb.set (ks, parentKey), kdb::KDBException) << "kdb set without prior kdb get should have 107 Wrong State";
kdb.close (parentKey);
ASSERT_EQ (ks.size (), 0) << "got keys from freshly mounted backends" << ks;
}
TEST_F (Simple, GetCascading)
{
using namespace kdb;
KDB kdb;
KeySet ks;
Key parentKey (testRoot, KEY_END);
kdb.get (ks, parentKey);
ASSERT_EQ (ks.size (), 0) << "got keys from freshly mounted backends" << ks;
Key setParentKey ("system" + testRoot, KEY_END);
kdb.set (ks, setParentKey);
kdb.close (parentKey);
}
TEST_F (Simple, GetAppendCascading)
{
using namespace kdb;
KDB kdb;
KeySet ks;
ks.append (Key (testRoot + "key", KEY_END));
Key parentKey (testRoot, KEY_END);
std::string myRoot = testRoot.substr (0, testRoot.length () - 1);
EXPECT_EQ (parentKey.getName (), myRoot);
EXPECT_EQ (parentKey.getString (), "");
kdb.get (ks, parentKey);
EXPECT_EQ (parentKey.getName (), myRoot);
std::string fn = parentKey.getString ();
EXPECT_EQ (fn.substr (fn.find_last_of ('/') + 1), "kdbFile.dump");
parentKey.setString ("");
ASSERT_EQ (ks.size (), 1) << "no key stayed" << ks;
ks.rewind ();
ks.next ();
EXPECT_EQ (ks.current ().getName (), "/tests/kdb/key") << "name of element in keyset wrong";
EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
kdb.set (ks, parentKey);
EXPECT_EQ (parentKey.getName (), myRoot);
EXPECT_EQ (parentKey.getString (), "");
ks.rewind ();
ks.next ();
EXPECT_EQ (ks.current ().getName (), "/tests/kdb/key") << "name of element in keyset wrong";
EXPECT_EQ (ks.current ().getString (), "") << "string of element in keyset wrong";
kdb.close (parentKey);
EXPECT_EQ (parentKey.getName (), myRoot);
EXPECT_EQ (parentKey.getString (), "");
KeySet ks2;
kdb.open (parentKey);
EXPECT_EQ (parentKey.getName (), myRoot);
EXPECT_EQ (parentKey.getString (), "");
kdb.get (ks2, parentKey);
EXPECT_EQ (parentKey.getName (), myRoot);
fn = parentKey.getString ();
EXPECT_EQ (fn.substr (fn.find_last_of ('/') + 1), "kdbFile.dump");
ASSERT_EQ (ks2.size (), 0) << "got keys from freshly mounted backends";
}
__attribute__ ((noinline)) void benchmark_crypto_set (int iteration)
{
using namespace kdb;
using namespace kdb::tools;
static Timer t (plugin_variant_names[VARIANT]);
Key mp = mountBackend<VARIANT> (iteration);
{
KDB kdb;
KeySet ks;
kdb.get (ks, mp);
for (int i = 0; i < nr_keys; ++i)
{
// clang-format off
ks.append (Key (mp.getName () + "/k" + std::to_string (i),
KEY_VALUE, "value",
KEY_META, "crypto/encrypt", "1",
KEY_END));
// clang-format on
}
/***************************************************************************
* start of measurement
**************************************************************************/
t.start ();
kdb.set (ks, mp);
t.stop ();
/***************************************************************************
* end of measurement
**************************************************************************/
kdb.close ();
}
std::cout << t;
}
__attribute__ ((noinline)) void benchmark_crypto_get (int iteration)
{
using namespace kdb;
using namespace kdb::tools;
static Timer t (plugin_variant_names[VARIANT]);
KDB kdb;
KeySet ks;
Key mp = getMountpointForIteration<VARIANT> (iteration);
/***************************************************************************
* start of measurement
**************************************************************************/
t.start ();
kdb.get (ks, mp);
t.stop ();
/***************************************************************************
* end of measurement
**************************************************************************/
kdb.close ();
std::cout << t;
}
