tst/databaseconfigurationimpl_test.cpp

   1 /*
   2    Copyright (c) 2018-2019 Nokia.
   3
   4    Licensed under the Apache License, Version 2.0 (the "License");
   5    you may not use this file except in compliance with the License.
   6    You may obtain a copy of the License at
   7
   8        http://www.apache.org/licenses/LICENSE-2.0
   9
  10    Unless required by applicable law or agreed to in writing, software
  11    distributed under the License is distributed on an "AS IS" BASIS,
  12    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13    See the License for the specific language governing permissions and
  14    limitations under the License.
  15 */
  16
  17 /*
  18  * This source code is part of the near-RT RIC (RAN Intelligent Controller)
  19  * platform project (RICP).
  20 */
  21
  22 #include <gtest/gtest.h>
  23 #include <gmock/gmock.h>
  24 #include <arpa/inet.h>
  25 #include "private/databaseconfigurationimpl.hpp"
  26
  27 using namespace shareddatalayer;
  28 using namespace testing;
  29
  30 namespace
  31 {
  32     class DatabaseConfigurationImplTest: public testing::Test
  33     {
  34     public:
  35         std::unique_ptr<DatabaseConfigurationImpl> databaseConfigurationImpl;
  36
  37         DatabaseConfigurationImplTest()
  38         {
  39             InSequence dummy;
  40             databaseConfigurationImpl.reset(new DatabaseConfigurationImpl());
  41         }
  42     };
  43 }
  44
  45 TEST_F(DatabaseConfigurationImplTest, CanReturnDefaultAddress)
  46 {
  47     const auto retAddresses(databaseConfigurationImpl->getDefaultServerAddresses());
  48     EXPECT_EQ(1U, retAddresses.size());
  49     EXPECT_EQ("localhost", retAddresses.back().getHost());
  50     EXPECT_EQ(6379U, ntohs(retAddresses.back().getPort()));
  51 }
  52
  53 TEST_F(DatabaseConfigurationImplTest, CanReturnEmptyAddressListIfNoAddressesAreApplied)
  54 {
  55     const auto retAddresses(databaseConfigurationImpl->getServerAddresses());
  56     EXPECT_TRUE(retAddresses.empty());
  57 }
  58
  59 TEST_F(DatabaseConfigurationImplTest, CanReturnUnknownTypeIfNoRedisDbTypeIsApplied)
  60 {
  61     const auto retDbType(databaseConfigurationImpl->getDbType());
  62     EXPECT_EQ(DatabaseConfiguration::DbType::UNKNOWN, retDbType);
  63 }
  64
  65 TEST_F(DatabaseConfigurationImplTest, CanApplyRedisDbTypeStringAndReturnType)
  66 {
  67     databaseConfigurationImpl->checkAndApplyDbType("redis-standalone");
  68     const auto retDbType(databaseConfigurationImpl->getDbType());
  69     EXPECT_EQ(DatabaseConfiguration::DbType::REDIS_STANDALONE, retDbType);
  70 }
  71
  72 TEST_F(DatabaseConfigurationImplTest, CanApplyRedisClusterDbTypeStringAndReturnType)
  73 {
  74     databaseConfigurationImpl->checkAndApplyDbType("redis-cluster");
  75     const auto retDbType(databaseConfigurationImpl->getDbType());
  76     EXPECT_EQ(DatabaseConfiguration::DbType::REDIS_CLUSTER, retDbType);
  77 }
  78
  79 TEST_F(DatabaseConfigurationImplTest, CanApplyRedisSentinelDbTypeStringAndReturnType)
  80 {
  81     databaseConfigurationImpl->checkAndApplyDbType("redis-sentinel");
  82     const auto retDbType(databaseConfigurationImpl->getDbType());
  83     EXPECT_EQ(DatabaseConfiguration::DbType::REDIS_SENTINEL, retDbType);
  84 }
  85
  86 TEST_F(DatabaseConfigurationImplTest, CanApplySdlStandaloneClusterDbTypeStringAndReturnType)
  87 {
  88     databaseConfigurationImpl->checkAndApplyDbType("sdl-standalone-cluster");
  89     const auto retDbType(databaseConfigurationImpl->getDbType());
  90     EXPECT_EQ(DatabaseConfiguration::DbType::SDL_STANDALONE_CLUSTER, retDbType);
  91 }
  92
  93 TEST_F(DatabaseConfigurationImplTest, CanApplySdlSentinelClusterDbTypeStringAndReturnType)
  94 {
  95     databaseConfigurationImpl->checkAndApplyDbType("sdl-sentinel-cluster");
  96     const auto retDbType(databaseConfigurationImpl->getDbType());
  97     EXPECT_EQ(DatabaseConfiguration::DbType::SDL_SENTINEL_CLUSTER, retDbType);
  98 }
  99
 100 TEST_F(DatabaseConfigurationImplTest, CanApplyNewAddressesOneByOneAndReturnAllAddresses)
 101 {
 102     databaseConfigurationImpl->checkAndApplyServerAddress("dummydatabaseaddress.local");
 103     databaseConfigurationImpl->checkAndApplyServerAddress("10.20.30.40:65535");
 104     const auto retAddresses(databaseConfigurationImpl->getServerAddresses());
 105     EXPECT_EQ(2U, retAddresses.size());
 106     EXPECT_EQ("dummydatabaseaddress.local", retAddresses.at(0).getHost());
 107     EXPECT_EQ(6379U, ntohs(retAddresses.at(0).getPort()));
 108     EXPECT_EQ("10.20.30.40", retAddresses.at(1).getHost());
 109     EXPECT_EQ(65535U, ntohs(retAddresses.at(1).getPort()));
 110 }
 111
 112 TEST_F(DatabaseConfigurationImplTest, CanGetAddressesOneByOneWithAddressIndex)
 113 {
 114     databaseConfigurationImpl->checkAndApplyServerAddress("server0.local");
 115     databaseConfigurationImpl->checkAndApplyServerAddress("10.20.30.40:65535");
 116     const auto addresses(databaseConfigurationImpl->getServerAddresses(boost::none));
 117     const auto addresses0(databaseConfigurationImpl->getServerAddresses(0));
 118     const auto addresses1(databaseConfigurationImpl->getServerAddresses(1));
 119     EXPECT_EQ(2U, addresses.size());
 120     EXPECT_EQ(1U, addresses0.size());
 121     EXPECT_EQ(1U, addresses1.size());
 122     EXPECT_EQ("server0.local", addresses0.at(0).getHost());
 123     EXPECT_EQ(6379U, ntohs(addresses0.at(0).getPort()));
 124     EXPECT_EQ("10.20.30.40", addresses1.at(0).getHost());
 125     EXPECT_EQ(65535U, ntohs(addresses1.at(0).getPort()));
 126 }
 127
 128 TEST_F(DatabaseConfigurationImplTest, CanThrowIfIllegalDbTypeIsApplied)
 129 {
 130     EXPECT_THROW(databaseConfigurationImpl->checkAndApplyDbType("bad_db_type"), DatabaseConfiguration::InvalidDbType);
 131 }
 132
 133 TEST_F(DatabaseConfigurationImplTest, CanApplyIPv6AddressAndReturnIt)
 134 {
 135     databaseConfigurationImpl->checkAndApplyServerAddress("[2001::123]:12345");
 136     const auto retAddresses(databaseConfigurationImpl->getServerAddresses());
 137     EXPECT_EQ(1U, retAddresses.size());
 138     EXPECT_EQ("2001::123", retAddresses.at(0).getHost());
 139     EXPECT_EQ(12345U, ntohs(retAddresses.at(0).getPort()));
 140 }
 141
 142 TEST_F(DatabaseConfigurationImplTest, IsEmptyReturnsCorrectInformation)
 143 {
 144     EXPECT_TRUE(databaseConfigurationImpl->isEmpty());
 145     databaseConfigurationImpl->checkAndApplyServerAddress("[2001::123]:12345");
 146     EXPECT_FALSE(databaseConfigurationImpl->isEmpty());
 147 }
 148
 149 TEST_F(DatabaseConfigurationImplTest, DefaultSentinelAddressIsNone)
 150 {
 151     EXPECT_EQ(boost::none, databaseConfigurationImpl->getSentinelAddress(boost::none));
 152 }
 153
 154 TEST_F(DatabaseConfigurationImplTest, CanApplyAndReturnSentinelAddress)
 155 {
 156     databaseConfigurationImpl->checkAndApplySentinelAddress("dummydatabaseaddress.local:1234");
 157     auto address = databaseConfigurationImpl->getSentinelAddress(boost::none);
 158     EXPECT_NE(boost::none, databaseConfigurationImpl->getSentinelAddress(boost::none));
 159     EXPECT_EQ("dummydatabaseaddress.local", address->getHost());
 160     EXPECT_EQ(1234, ntohs(address->getPort()));
 161 }
 162
 163 TEST_F(DatabaseConfigurationImplTest, DefaultSentinelMasterNameIsEmpty)
 164 {
 165     EXPECT_EQ("", databaseConfigurationImpl->getSentinelMasterName());
 166 }
 167
 168 TEST_F(DatabaseConfigurationImplTest, CanApplyAndReturnSentinelMasterName)
 169 {
 170     databaseConfigurationImpl->checkAndApplySentinelMasterName("mymaster");
 171     EXPECT_EQ("mymaster", databaseConfigurationImpl->getSentinelMasterName());
 172 }
 173
 174 TEST_F(DatabaseConfigurationImplTest, CanReturnSDLSentinelClusterAddress)
 175 {
 176     databaseConfigurationImpl->checkAndApplyDbType("sdl-sentinel-cluster");
 177     databaseConfigurationImpl->checkAndApplyServerAddress("cluster-0.local");
 178     databaseConfigurationImpl->checkAndApplyServerAddress("cluster-1.local");
 179     databaseConfigurationImpl->checkAndApplyServerAddress("cluster-2.local");
 180     databaseConfigurationImpl->checkAndApplySentinelAddress("cluster-0.local:54321");
 181     auto address0 = databaseConfigurationImpl->getSentinelAddress(0);
 182     auto address1 = databaseConfigurationImpl->getSentinelAddress(1);
 183     auto address2 = databaseConfigurationImpl->getSentinelAddress(2);
 184     EXPECT_NE(boost::none, databaseConfigurationImpl->getSentinelAddress(0));
 185     EXPECT_NE(boost::none, databaseConfigurationImpl->getSentinelAddress(1));
 186     EXPECT_NE(boost::none, databaseConfigurationImpl->getSentinelAddress(2));
 187     EXPECT_EQ("cluster-0.local", address0->getHost());
 188     EXPECT_EQ("cluster-1.local", address1->getHost());
 189     EXPECT_EQ("cluster-2.local", address2->getHost());
 190     EXPECT_EQ(54321, ntohs(address0->getPort()));
 191 }
 192
 193 TEST_F(DatabaseConfigurationImplTest, CanReturnDefaultPortForSDLClusterAddress)
 194 {
 195     databaseConfigurationImpl->checkAndApplyServerAddress("cluster-0.local");
 196     databaseConfigurationImpl->checkAndApplySentinelAddress("cluster-0.local");
 197     auto address0 = databaseConfigurationImpl->getSentinelAddress(0);
 198     EXPECT_NE(boost::none, databaseConfigurationImpl->getSentinelAddress(0));
 199     EXPECT_EQ("cluster-0.local", address0->getHost());
 200     EXPECT_EQ(26379, ntohs(address0->getPort()));
 201 }