diff options
Diffstat (limited to 'src/lib/process/tests/config_base_unittests.cc')
-rw-r--r-- | src/lib/process/tests/config_base_unittests.cc | 230 |
1 files changed, 230 insertions, 0 deletions
diff --git a/src/lib/process/tests/config_base_unittests.cc b/src/lib/process/tests/config_base_unittests.cc new file mode 100644 index 0000000..cec4582 --- /dev/null +++ b/src/lib/process/tests/config_base_unittests.cc @@ -0,0 +1,230 @@ +// Copyright (C) 2018-2019 Internet Systems Consortium, Inc. ("ISC") +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#include <config.h> + +#include <exceptions/exceptions.h> +#include <process/config_base.h> +#include <util/optional.h> + +#include <gtest/gtest.h> + +using namespace isc; +using namespace isc::process; +using namespace isc::util; + +/// @brief Derived ConfigBase class +/// We use this derivation to test the +/// copy and equality functions. +class ConfigBaseImpl : public ConfigBase { +public: + void + copy(ConfigBaseImpl& other) const { + ConfigBase::copy(other); + } +}; + +// Verifies construction, copy, and equality of +// ConfigBase with respect to ConfigControInfo. +TEST(ConfigBase, configControlInfoTests) { + + // Create a control info instance + ConfigControlInfoPtr ctl_info1(new ConfigControlInfo()); + ctl_info1->addConfigDatabase("type=mysql host=example.com"); + ctl_info1->addConfigDatabase("type=mysql host=example2.com"); + + // Create a ConfigBase + ConfigBaseImpl base1; + base1.setConfigControlInfo(ctl_info1); + + // Clone the ConfigBase + ConfigBaseImpl base2; + base1.copy(base2); + + // They should be equal. + EXPECT_TRUE(base1.equals(base2)); + + // Reset control info for one of them. + base1.setConfigControlInfo(ConfigControlInfoPtr()); + + // They should not be equal. + EXPECT_FALSE(base1.equals(base2)); + + // Reset control info for the other one. + base2.setConfigControlInfo(ConfigControlInfoPtr()); + + // They should be equal again. + EXPECT_TRUE(base1.equals(base2)); +} + +// Verifies that logging information can be merged to another. +TEST(ConfigBase, mergeLoggingInfo) { + // Create first logging info. + LoggingInfo log_info1; + log_info1.name_ = "foo"; + + // Create second logging info. + LoggingInfo log_info2; + log_info2.name_ = "bar"; + + // Create first config base instance. + ConfigBaseImpl base1; + base1.addLoggingInfo(log_info1); + + // Copy the first instance to keep it as reference. + ConfigBaseImpl base1_copy; + base1_copy.copy(base1); + + // Create second config base instance. + ConfigBaseImpl base2; + ASSERT_NO_THROW(base1.merge(base2)); + EXPECT_TRUE(base1.equals(base1_copy)); + + // Set some data for the second config. + base2.addLoggingInfo(log_info2); + + // This time the merge should replace the original config. + ASSERT_NO_THROW(base1.merge(base2)); + EXPECT_TRUE(base1.equals(base2)); +} + +// Verifies that config control can be merged to another. +TEST(ConfigBase, mergeConfigControl) { + // Create first config control info. + ConfigControlInfoPtr ctl_info1(new ConfigControlInfo()); + ctl_info1->addConfigDatabase("type=mysql host=example.com"); + ctl_info1->addConfigDatabase("type=mysql host=example2.com"); + + // Create second config control info. + ConfigControlInfoPtr ctl_info2(new ConfigControlInfo()); + ctl_info2->addConfigDatabase("type=pgsql host=example.com"); + ctl_info2->addConfigDatabase("type=pgsql host=example2.com"); + + // Create first config base instance. + ConfigBaseImpl base1; + base1.setConfigControlInfo(ctl_info1); + + // Copy the first instance to keep it as reference. + ConfigBaseImpl base1_copy; + base1_copy.copy(base1); + + // Create second config base instance. + ConfigBaseImpl base2; + + // Merged base is empty, so the original should be preserved. + ASSERT_NO_THROW(base1.merge(base2)); + EXPECT_TRUE(base1.equals(base1_copy)); + + // Set some data for the second config. + base2.setConfigControlInfo(ctl_info2); + + // This time the merge should replace the original config. + ASSERT_NO_THROW(base1.merge(base2)); + EXPECT_TRUE(base1.equals(base2)); +} + +// Verifies that server-tag may be configured. +TEST(ConfigBase, serverTag) { + ConfigBaseImpl conf; + + // Check that the default is an unspecified and empty string. + EXPECT_TRUE(conf.getServerTag().unspecified()); + EXPECT_TRUE(conf.getServerTag().empty()); + + // Check that it can be modified. + conf.setServerTag("boo"); + EXPECT_FALSE(conf.getServerTag().unspecified()); + EXPECT_EQ("boo", conf.getServerTag().get()); +} + +// Verifies that server tag can be merged to another config. +TEST(ConfigBase, mergeServerTag) { + ConfigBaseImpl base1; + ConfigBaseImpl base2; + + // Initially the server tags in both config should be + // unspecified. + EXPECT_TRUE(base1.getServerTag().unspecified()); + EXPECT_TRUE(base2.getServerTag().unspecified()); + + // Merging the config with unspecified server tag should + // not modify the target config. + ASSERT_NO_THROW(base1.merge(base2)); + EXPECT_TRUE(base1.getServerTag().unspecified()); + EXPECT_TRUE(base2.getServerTag().unspecified()); + + // Set server tag for base2 and merge it. + base2.setServerTag(std::string("base2")); + ASSERT_NO_THROW(base1.merge(base2)); + + // The server tag should be copied into the base1. Both + // should now be unspecified. + EXPECT_FALSE(base1.getServerTag().unspecified()); + EXPECT_FALSE(base2.getServerTag().unspecified()); + + // They should also hold the same value. + EXPECT_EQ("base2", base1.getServerTag().get()); + EXPECT_EQ("base2", base2.getServerTag().get()); + + // Reset the server tag to unspecified. + base2.setServerTag(Optional<std::string>()); + EXPECT_FALSE(base1.getServerTag().unspecified()); + EXPECT_TRUE(base2.getServerTag().unspecified()); + + // Merging the config with unspecified server tag should + // result in no change in the target config. + ASSERT_NO_THROW(base1.merge(base2)); + EXPECT_FALSE(base1.getServerTag().unspecified()); + EXPECT_TRUE(base2.getServerTag().unspecified()); + + // The server tag should remain the same. + EXPECT_EQ("base2", base1.getServerTag().get()); + + // Set the explicit server tag in the source config. + base2.setServerTag("new-base2"); + + // Merge again. + ASSERT_NO_THROW(base1.merge(base2)); + + // The new value should be stored in the target config, so + // both should be specified and have the same value. + EXPECT_FALSE(base1.getServerTag().unspecified()); + EXPECT_FALSE(base2.getServerTag().unspecified()); + EXPECT_EQ("new-base2", base1.getServerTag().get()); + EXPECT_EQ("new-base2", base2.getServerTag().get()); +} + +// Verifies that server tag can be copied to another config. +TEST(ConfigBase, copyServerTag) { + ConfigBaseImpl base1; + ConfigBaseImpl base2; + + // Set server tag for the base2. + base2.setServerTag(std::string("base2")); + + // The base1 has server tag unspecified. Copying it to the + // base2 should result in unspecified server tag in base2. + ASSERT_NO_THROW(base1.copy(base2)); + EXPECT_TRUE(base2.getServerTag().unspecified()); + + // Set server tag for base1 and copy it to base2. + base1.setServerTag(std::string("base1")); + ASSERT_NO_THROW(base1.copy(base2)); + + // The base2 should now hold the value from base1. + EXPECT_FALSE(base2.getServerTag().unspecified()); + EXPECT_EQ("base1", base2.getServerTag().get()); + + // Set base1 value to a different value. + base1.setServerTag(std::string("new-base1")); + + // Copy again. + ASSERT_NO_THROW(base1.copy(base2)); + + // It should override the value in the base2. + EXPECT_FALSE(base2.getServerTag().unspecified()); + EXPECT_EQ("new-base1", base2.getServerTag().get()); +} |