CPP-843 - Port logging tests to Google test framework (#326)

mikefero · web-flow · commit 77efd8df2d77 · 2019-11-08T11:18:03.000-05:00
diff --git a/cpp-driver/gtests/src/integration/tests/test_logging.cpp b/cpp-driver/gtests/src/integration/tests/test_logging.cpp
@@ -0,0 +1,39 @@
+/*
+  Copyright (c) DataStax, Inc.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+#include "integration.hpp"
+
+class LoggingTests : public Integration {
+public:
+  LoggingTests() { is_ccm_requested_ = false; }
+
+  static void log(const CassLogMessage* log, void* data) {
+    bool* is_triggered = static_cast<bool*>(data);
+    *is_triggered = true;
+  }
+};
+
+/**
+ * Ensure the driver is calling the client logging callback
+ */
+CASSANDRA_INTEGRATION_TEST_F(LoggingTests, Callback) {
+  CHECK_FAILURE;
+
+  bool is_triggered = false;
+  cass_log_set_callback(LoggingTests::log, &is_triggered);
+  default_cluster().connect("", false);
+  EXPECT_TRUE(is_triggered);
+}
diff --git a/cpp-driver/gtests/src/unit/tests/test_logging.cpp b/cpp-driver/gtests/src/unit/tests/test_logging.cpp
@@ -0,0 +1,118 @@
+/*
+  Copyright (c) DataStax, Inc.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+#include "unit.hpp"
+
+#include "session.hpp"
+
+using datastax::String;
+using datastax::internal::get_time_monotonic_ns;
+using datastax::internal::core::Address;
+using datastax::internal::core::Config;
+using datastax::internal::core::Future;
+using datastax::internal::core::Session;
+using datastax::internal::core::StringMultimap;
+using mockssandra::Options;
+using test::Utils;
+
+class LoggingUnitTest : public Unit {
+public:
+  void TearDown() {
+    EXPECT_TRUE(session_.close()->wait_for(WAIT_FOR_TIME));
+
+    Unit::TearDown();
+  }
+
+  Future::Ptr connect_async(const Config& config = Config()) {
+    Config temp(config);
+    temp.contact_points().push_back(Address("127.0.0.1", 9042));
+    return session_.connect(temp);
+  }
+
+  bool wait_for_logger(int expected_count) {
+    // Wait for about 60 seconds
+    for (int i = 0; i < 600 && logging_criteria_count() < expected_count; ++i) {
+      Utils::msleep(100);
+    }
+    return logging_criteria_count() >= expected_count;
+  }
+
+private:
+  Session session_;
+};
+
+/**
+ * On a new control connection, logger message severity should be high (e.g.
+ * CASS_LOG_ERROR).
+ *
+ * @jira_ticket CPP-337
+ * @since 2.4.0
+ */
+TEST_F(LoggingUnitTest, ControlConnectionSeverityHigh) {
+  add_logging_critera("Unable to establish a control connection to host 127.0.0.1", CASS_LOG_ERROR);
+  Future::Ptr connect_future = connect_async();
+  EXPECT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
+  EXPECT_EQ(1u, logging_criteria_count());
+}
+
+/**
+ * On a established control connection, logger message severity should be reduced
+ * (e.g. CASS_LOG_WARN).
+ *
+ * @jira_ticket CPP-337
+ * @since 2.4.0
+ */
+TEST_F(LoggingUnitTest, ControlConnectionSeverityReduced) {
+  mockssandra::SimpleCluster cluster(simple());
+  ASSERT_EQ(cluster.start_all(), 0);
+
+  add_logging_critera("Lost control connection to host 127.0.0.1", CASS_LOG_WARN);
+  Future::Ptr connect_future = connect_async();
+  EXPECT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
+  EXPECT_EQ(0u, logging_criteria_count());
+  cluster.stop_all();
+  EXPECT_TRUE(wait_for_logger(1));
+}
+
+/**
+ * On a established connection the first connection pool logger message severity should be high
+ * while subsequent messages should have reduced severity.
+ *
+ * @jira_ticket CPP-337
+ * @since 2.4.0
+ */
+TEST_F(LoggingUnitTest, ConnectionPoolSeverityReduced) {
+  mockssandra::SimpleCluster cluster(simple(), 2);
+  ASSERT_EQ(cluster.start(1), 0);
+
+  add_logging_critera(
+      "Connection pool was unable to connect to host 127.0.0.2 because of the following error",
+      CASS_LOG_ERROR);
+  Config config;
+  config.set_connection_heartbeat_interval_secs(1);
+  config.set_connection_idle_timeout_secs(1);
+  config.set_request_timeout(1000);
+  config.set_constant_reconnect(100);
+  Future::Ptr connect_future = connect_async(config);
+  EXPECT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
+  EXPECT_TRUE(wait_for_logger(1));
+
+  reset_logging_criteria();
+  add_logging_critera(
+      "Connection pool was unable to reconnect to host 127.0.0.2 because of the following error",
+      CASS_LOG_WARN);
+  EXPECT_TRUE(wait_for_logger(1));
+}
diff --git a/cpp-driver/gtests/src/unit/unit.cpp b/cpp-driver/gtests/src/unit/unit.cpp
@@ -15,6 +15,8 @@
 */
 #include "unit.hpp"
 
+#include "scoped_lock.hpp"
+
 using namespace datastax;
 using namespace datastax::internal;
 using namespace datastax::internal::core;
@@ -99,11 +101,13 @@ Unit::Unit()
     , logging_criteria_count_(0) {
   Logger::set_log_level(CASS_LOG_TRACE);
   Logger::set_callback(on_log, this);
+  uv_mutex_init(&mutex_);
 }
 
 Unit::~Unit() {
   Logger::set_log_level(CASS_LOG_DISABLED);
   Logger::set_callback(NULL, NULL);
+  uv_mutex_destroy(&mutex_);
 }
 
 void Unit::set_output_log_level(CassLogLevel output_log_level) {
@@ -132,9 +136,22 @@ ConnectionSettings Unit::use_ssl(mockssandra::Cluster* cluster, const String& cn
   return settings;
 }
 
-void Unit::add_logging_critera(const String& criteria) { logging_criteria_.push_back(criteria); }
+void Unit::add_logging_critera(const String& criteria,
+                               CassLogLevel severity /*= CASS_LOG_LAST_ENTRY*/) {
+  ScopedMutex l(&mutex_);
+  logging_criteria_[severity].push_back(criteria);
+}
 
-int Unit::logging_criteria_count() { return logging_criteria_count_.load(); }
+int Unit::logging_criteria_count() {
+  ScopedMutex l(&mutex_);
+  return logging_criteria_count_;
+}
+
+void Unit::reset_logging_criteria() {
+  ScopedMutex l(&mutex_);
+  logging_criteria_.clear();
+  logging_criteria_count_ = 0;
+}
 
 void Unit::on_log(const CassLogMessage* message, void* data) {
   Unit* instance = static_cast<Unit*>(data);
@@ -148,11 +165,18 @@ void Unit::on_log(const CassLogMessage* message, void* data) {
   }
 
   // Determine if the log message matches any of the criteria
-  for (Vector<String>::const_iterator it = instance->logging_criteria_.begin(),
-                                      end = instance->logging_criteria_.end();
-       it != end; ++it) {
-    if (strstr(message->message, it->c_str()) != NULL) {
-      instance->logging_criteria_count_.fetch_add(1);
+  ScopedMutex l(&instance->mutex_);
+  for (Map<CassLogLevel, Vector<String> >::iterator level_it = instance->logging_criteria_.begin(),
+                                                    level_end = instance->logging_criteria_.end();
+       level_it != level_end; ++level_it) {
+    CassLogLevel level = level_it->first;
+    Vector<String> criteria = level_it->second;
+    for (Vector<String>::const_iterator it = criteria.begin(), end = criteria.end(); it != end;
+         ++it) {
+      if ((level == CASS_LOG_LAST_ENTRY || level == message->severity) &&
+          strstr(message->message, it->c_str()) != NULL) {
+        ++instance->logging_criteria_count_;
+      }
     }
   }
 }
diff --git a/cpp-driver/gtests/src/unit/unit.hpp b/cpp-driver/gtests/src/unit/unit.hpp
@@ -209,18 +209,24 @@ class Unit : public testing::Test {
                                                        const datastax::String& cn = "");
 
   /**
-   * Add criteria to the search criteria for incoming log messages
+   * Add criteria to the search criteria for incoming log messages.
    *
-   * @param criteria Criteria to add
+   * @param criteria Criteria to add.
+   * @param severity Severity level to match (Optional: defaults to any severity).
    */
-  void add_logging_critera(const datastax::String& criteria);
+  void add_logging_critera(const String& criteria, CassLogLevel severity = CASS_LOG_LAST_ENTRY);
   /**
-   * Get the number of log messages that matched the search criteria
+   * Get the number of log messages that matched the search criteria.
    *
-   * @return Number of matched log messages
+   * @return Number of matched log messages.
    */
   int logging_criteria_count();
 
+  /**
+   * Reset the logging criteria; clears all criteria and resets count.
+   */
+  void reset_logging_criteria();
+
 private:
   /**
    * Log the message from the driver (callback).
@@ -232,8 +238,11 @@ class Unit : public testing::Test {
 
 private:
   CassLogLevel output_log_level_;
-  datastax::internal::Vector<datastax::String> logging_criteria_;
-  datastax::internal::Atomic<int> logging_criteria_count_;
+  datastax::internal::Map<CassLogLevel, datastax::internal::Vector<datastax::String> >
+      logging_criteria_;
+  int logging_criteria_count_;
+  uv_mutex_t mutex_;
+  uint64_t start_time_;
 };
 
 #endif // UNIT_TEST_HPP
diff --git a/cpp-driver/test/integration_tests/src/test_logging.cpp b/cpp-driver/test/integration_tests/src/test_logging.cpp
