test: CPP-820: Adding the ability to run against DDAC using CCM (#304)

Author: mikefero

cpp-driver/gtests/src/integration/integration.cpp

@@ -65,7 +65,7 @@ Integration::Integration()
   // Determine if the schema keyspaces table should be updated
   // TODO: Make cass_version (and dse_version) available for all tests
   CCM::CassVersion cass_version = server_version_;
-  if (Options::is_dse()) {
+  if (!Options::is_cassandra()) {
     cass_version = static_cast<CCM::DseVersion>(cass_version).get_cass_version();
   }
   if (cass_version >= "3.0.0") {
@@ -145,7 +145,7 @@ void Integration::SetUp() {
       // Create and start the CCM cluster (if not already created)
       ccm_ = new CCM::Bridge(
           server_version_, Options::use_git(), Options::branch_tag(), Options::use_install_dir(),
-          Options::install_dir(), Options::is_dse(), dse_workload_, Options::cluster_prefix(),
+          Options::install_dir(), Options::server_type(), dse_workload_, Options::cluster_prefix(),
           Options::dse_credentials(), Options::dse_username(), Options::dse_password(),
           Options::deployment_type(), Options::authentication_type(), Options::host(),
           Options::port(), Options::username(), Options::password(), Options::public_key(),
@@ -319,6 +319,10 @@ void Integration::connect(Cluster cluster) {
 
   // Update the server version if branch_tag was specified
   if (Options::use_git() && !Options::branch_tag().empty()) {
+    if (Options::is_ddac()) {
+      FAIL() << "Unable to build DDAC from Branch/Tag";
+      return;
+    }
     if (Options::is_dse()) {
       server_version_ = ccm_->get_dse_version();
     } else {

cpp-driver/gtests/src/integration/integration.hpp

@@ -83,7 +83,7 @@
 #define CHECK_VERSION(version)                                                      \
   do {                                                                              \
     CCM::CassVersion cass_version = this->server_version_;                          \
-    if (Options::is_dse()) {                                                        \
+    if (!Options::is_cassandra()) {                                                 \
       cass_version = static_cast<CCM::DseVersion>(cass_version).get_cass_version(); \
     }                                                                               \
     if (cass_version < #version) {                                                  \
@@ -98,7 +98,7 @@
 
 #define CHECK_VALUE_TYPE_VERSION(type)                                            \
   CCM::CassVersion cass_version = this->server_version_;                          \
-  if (Options::is_dse()) {                                                        \
+  if (!Options::is_cassandra()) {                                                 \
     cass_version = static_cast<CCM::DseVersion>(cass_version).get_cass_version(); \
   }                                                                               \
   if (cass_version < type::supported_server_version()) {                          \

cpp-driver/gtests/src/integration/options.cpp

@@ -24,15 +24,15 @@
 #include <iostream>
 
 #define DEFAULT_OPTIONS_CASSSANDRA_VERSION CCM::CassVersion("3.11.4")
-#define DEFAULT_OPTIONS_DSE_VERSION CCM::DseVersion("6.0.8")
+#define DEFAULT_OPTIONS_DSE_VERSION CCM::DseVersion("6.7.5")
+#define DEFAULT_OPTIONS_DDAC_VERSION CCM::DseVersion("5.1.17")
 
 // Initialize the defaults for all the options
 bool Options::is_initialized_ = false;
 bool Options::is_help_ = false;
 bool Options::is_keep_clusters_ = false;
 bool Options::is_log_tests_ = true;
 CCM::CassVersion Options::server_version_ = DEFAULT_OPTIONS_CASSSANDRA_VERSION;
-bool Options::is_dse_ = false;
 bool Options::use_git_ = false;
 std::string Options::branch_tag_;
 bool Options::use_install_dir_ = false;
@@ -55,6 +55,7 @@ CCM::DseCredentialsType Options::dse_credentials_type_;
 CCM::AuthenticationType Options::authentication_type_;
 CCM::DeploymentType Options::deployment_type_;
 std::set<TestCategory> Options::categories_;
+CCM::ServerType Options::server_type_;
 
 bool Options::initialize(int argc, char* argv[]) {
   // Only allow initialization to occur once
@@ -63,6 +64,7 @@ bool Options::initialize(int argc, char* argv[]) {
     dse_credentials_type_ = CCM::DseCredentialsType::USERNAME_PASSWORD;
     authentication_type_ = CCM::AuthenticationType::USERNAME_PASSWORD;
     deployment_type_ = CCM::DeploymentType::LOCAL;
+    server_type_ = CCM::ServerType::CASSANDRA;
 
     // Check for the help argument first (keeps defaults for help display)
     for (int i = 1; i < argc; ++i) {
@@ -77,6 +79,8 @@ bool Options::initialize(int argc, char* argv[]) {
     for (int i = 1; i < argc; ++i) {
       if (std::string(argv[i]) == "--dse") {
         server_version_ = DEFAULT_OPTIONS_DSE_VERSION;
+      } else if (std::string(argv[i]) == "--ddac") {
+        server_version_ = DEFAULT_OPTIONS_DDAC_VERSION;
       }
     }
 
@@ -107,7 +111,9 @@ bool Options::initialize(int argc, char* argv[]) {
                     << std::endl;
         }
       } else if (key == "--dse") {
-        is_dse_ = true;
+        server_type_ = CCM::ServerType::DSE;
+      } else if (key == "--ddac") {
+        server_type_ = CCM::ServerType::DDAC;
       } else if (key == "--dse-username") {
         if (!value.empty()) {
           dse_username_ = value;
@@ -129,7 +135,7 @@ bool Options::initialize(int argc, char* argv[]) {
           }
         }
         if (!is_found) {
-          std::cerr << "Invalid DSE Credentials Type: Using default "
+          std::cerr << "Invalid DSE/DDAC Credentials Type: Using default "
                     << dse_credentials_type_.to_string() << std::endl;
         }
       } else if (key == "--git") {
@@ -272,7 +278,7 @@ bool Options::initialize(int argc, char* argv[]) {
       for (TestCategory::iterator iterator = TestCategory::begin(); iterator != TestCategory::end();
            ++iterator) {
         // Only add the DSE test category if DSE is enabled
-        if (*iterator != TestCategory::DSE || is_dse_) {
+        if (*iterator != TestCategory::DSE || is_dse()) {
           categories_.insert(*iterator);
         } else {
           std::cerr << "DSE Category Will be Ignored: DSE is not enabled [--dse]" << std::endl;
@@ -282,11 +288,11 @@ bool Options::initialize(int argc, char* argv[]) {
     if (deployment_type_ == CCM::DeploymentType::LOCAL) {
       host_ = "127.0.0.1";
     }
-    if (is_dse_ && !use_install_dir_) {
-      // Determine if the DSE credentials type should be updated
+    if (!is_cassandra() && !use_install_dir_) {
+      // Determine if the DSE/DDAC credentials type should be updated
       if (dse_credentials_type_ == CCM::DseCredentialsType::USERNAME_PASSWORD) {
         if (dse_username_.empty() || dse_password_.empty()) {
-          std::cerr << "Invalid Username and/or Password: Default to INI_FILE DSE credentials"
+          std::cerr << "Invalid Username and/or Password: Default to INI_FILE DSE/DDAC credentials"
                     << std::endl;
           dse_credentials_type_ = CCM::DseCredentialsType::INI_FILE;
         }
@@ -309,10 +315,11 @@ void Options::print_help() {
   std::cout << std::endl << "CCM Options:" << std::endl;
   std::cout << "  --version=[VERSION]" << std::endl
             << "      "
-            << "Cassandra/DSE version to use." << std::endl
+            << "Cassandra/DSE/DDAC version to use." << std::endl
             << "      Default:" << std::endl
             << "        Cassandra Version: " << server_version().to_string() << std::endl
-            << "        DSE Version: " << DEFAULT_OPTIONS_DSE_VERSION.to_string() << std::endl;
+            << "        DSE Version: " << DEFAULT_OPTIONS_DSE_VERSION.to_string() << std::endl
+            << "        DDAC Version: " << DEFAULT_OPTIONS_DDAC_VERSION.to_string() << std::endl;
   std::string categories;
   for (TestCategory::iterator iterator = TestCategory::begin(); iterator != TestCategory::end();
        ++iterator) {
@@ -330,16 +337,20 @@ void Options::print_help() {
   std::cout << "  --dse" << std::endl
             << "      "
             << "Indicate server version supplied is DSE." << std::endl;
+  std::cout << "  --ddac" << std::endl
+            << "      "
+            << "Indicate server version supplied is DDAC." << std::endl;
   std::cout << "  --dse-credentials=(USERNAME_PASSWORD|INI_FILE)" << std::endl
             << "      "
-            << "DSE credentials to use for download authentication. The default is " << std::endl
+            << "DSE/DDAC credentials to use for download authentication. The default is "
+            << std::endl
             << "      " << dse_credentials().to_string() << "." << std::endl;
   std::cout << "  --dse-username=[USERNAME]" << std::endl
             << "      "
-            << "Username to use for DSE download authentication." << std::endl;
+            << "Username to use for DSE/DDAC download authentication." << std::endl;
   std::cout << "  --dse-password=[PASSWORD]" << std::endl
             << "      "
-            << "Password to use for DSE download authentication." << std::endl;
+            << "Password to use for DSE/DDAC download authentication." << std::endl;
   std::cout << "  --git" << std::endl
             << "      "
             << "Indicate Cassandra/DSE server download should be obtained from" << std::endl
@@ -408,18 +419,20 @@ void Options::print_settings() {
   if (log_tests()) {
     std::cout << "  Logging driver messages" << std::endl;
   }
-  if (is_dse()) {
-    std::cout << "  DSE Version: " << CCM::DseVersion(server_version()).to_string() << std::endl;
+  if (!is_cassandra()) {
+    std::cout << "  " << server_type_.to_string()
+              << " Version: " << CCM::DseVersion(server_version()).to_string() << std::endl;
     if (!use_install_dir()) {
       if (dse_credentials() == CCM::DseCredentialsType::USERNAME_PASSWORD) {
         std::cout << "      Username: " << dse_username() << std::endl;
         std::cout << "      Password: " << dse_password() << std::endl;
       } else {
-        std::cout << "      Using INI file for DSE download authentication" << std::endl;
+        std::cout << "      Using INI file for DSE/DDAC download authentication" << std::endl;
       }
     }
   } else {
-    std::cout << "  Cassandra Version: " << server_version().to_string() << std::endl;
+    std::cout << "  " << server_type_.to_string() << " Version: " << server_version().to_string()
+              << std::endl;
   }
   if (use_install_dir()) {
     std::cout << "    Using installation directory [" << install_dir() << "]" << std::endl;
@@ -456,7 +469,13 @@ bool Options::log_tests() { return is_log_tests_; }
 
 CCM::CassVersion Options::server_version() { return server_version_; }
 
-bool Options::is_dse() { return is_dse_; }
+CCM::ServerType Options::server_type() { return server_type_; }
+
+bool Options::is_cassandra() { return server_type_ == CCM::ServerType::CASSANDRA; }
+
+bool Options::is_dse() { return server_type_ == CCM::ServerType::DSE; }
+
+bool Options::is_ddac() { return server_type_ == CCM::ServerType::DDAC; }
 
 CCM::DseCredentialsType Options::dse_credentials() {
   // Static initialization cannot be guaranteed
@@ -514,7 +533,7 @@ const std::string& Options::private_key() { return private_key_; }
 
 SharedPtr<CCM::Bridge, StdDeleter<CCM::Bridge> > Options::ccm() {
   return new CCM::Bridge(Options::server_version(), Options::use_git(), Options::branch_tag(),
-                         Options::use_install_dir(), Options::install_dir(), Options::is_dse(),
+                         Options::use_install_dir(), Options::install_dir(), Options::server_type(),
                          CCM::Bridge::DEFAULT_DSE_WORKLOAD, Options::cluster_prefix(),
                          Options::dse_credentials(), Options::dse_username(),
                          Options::dse_password(), Options::deployment_type(),

cpp-driver/gtests/src/integration/options.hpp

@@ -67,17 +67,35 @@ class Options {
    */
   static bool log_tests();
   /**
-   * Get the server version (Cassandra/DSE) to use
+   * Get the server version (Cassandra/DSE/DDAC) to use
    *
-   * @return Cassandra/DSE version to use
+   * @return Cassandra/DSE/DDAC version to use
    */
   static CCM::CassVersion server_version();
+  /**
+   * Get the server type (Cassandra/DSE/DDAC)
+   *
+   * @return Server type
+   */
+  static CCM::ServerType server_type();
+  /**
+   * Flag to determine if Cassandra should be used or not
+   *
+   * @return True if Cassandra should be used; false otherwise
+   */
+  static bool is_cassandra();
   /**
    * Flag to determine if DSE should be used or not
    *
    * @return True if DSE should be used; false otherwise
    */
   static bool is_dse();
+  /**
+   * Flag to determine if DDAC should be used or not
+   *
+   * @return True if DDAC should be used; false otherwise
+   */
+  static bool is_ddac();
   /**
    * Get the DSE credentials type (username|password/INI file)
    *
@@ -240,13 +258,13 @@ class Options {
    */
   static bool is_log_tests_;
   /**
-   * Server version to use (Cassandra/DSE)
+   * Server version to use (Cassandra/DSE/DDAC)
    */
   static CCM::CassVersion server_version_;
   /**
-   * Flag to indicate if DSE should be used instead of Cassandra
+   * Server type to use
    */
-  static bool is_dse_;
+  static CCM::ServerType server_type_;
   /**
    * Flag to determine if Cassandra should be built from ASF git (github if DSE)
    */

cpp-driver/gtests/src/integration/simulacron/simulacron_cluster.cpp

@@ -66,7 +66,7 @@ test::SimulacronCluster::SimulacronCluster()
 
   // Determine the release version (for priming nodes)
   CCM::CassVersion cassandra_version = Options::server_version();
-  if (Options::is_dse()) {
+  if (!Options::is_cassandra()) {
     CCM::DseVersion dse_version(cassandra_version);
     cassandra_version = dse_version.get_cass_version();
     if (cassandra_version == "0.0.0") {
@@ -127,7 +127,7 @@ void test::SimulacronCluster::create_cluster(
   }
 
   // Add the DSE version (if applicable)
-  if (Options::is_dse()) {
+  if (!Options::is_cassandra()) {
     paramters << "&dse_version=" << dse_version_;
     cluster_name << dse_version_;
   } else {

cpp-driver/gtests/src/integration/tests/test_auth.cpp

@@ -200,7 +200,7 @@ CASSANDRA_INTEGRATION_TEST_F(AuthenticationTests, BadCredentials) {
 
   // Add the proper logging criteria (based on server version)
   CCM::CassVersion cass_version = this->server_version_;
-  if (Options::is_dse()) {
+  if (!Options::is_cassandra()) {
     cass_version = static_cast<CCM::DseVersion>(cass_version).get_cass_version();
   }
   if (cass_version >= "3.10") {
@@ -242,7 +242,7 @@ CASSANDRA_INTEGRATION_TEST_F(AuthenticationTests, AuthenticatorSetErrorNull) {
 
   // Add the proper logging criteria (based on server version)
   CCM::CassVersion cass_version = this->server_version_;
-  if (Options::is_dse()) {
+  if (!Options::is_cassandra()) {
     cass_version = static_cast<CCM::DseVersion>(cass_version).get_cass_version();
   }
   if (cass_version >= "3.10") {

cpp-driver/gtests/src/integration/tests/test_basics.cpp

@@ -334,7 +334,7 @@ CASSANDRA_INTEGRATION_TEST_F(BasicsTests, NoCompactEnabledConnection) {
   CHECK_VERSION(3.0.16);
   CHECK_VERSION(3.11.2);
   CCM::CassVersion cass_version = server_version_;
-  if (Options::is_dse()) {
+  if (!Options::is_cassandra()) {
     if (server_version_ >= "6.0.0") {
       SKIP_TEST("Unsupported for DataStax Enterprise Version "
                 << server_version_.to_string()

cpp-driver/gtests/src/integration/tests/test_exec_profile.cpp

@@ -302,8 +302,12 @@ CASSANDRA_INTEGRATION_TEST_F(ExecutionProfileTest, Consistency) {
   batch.set_execution_profile("consistency");
   result = session_.execute(batch, false);
   ASSERT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, result.error_code());
+  CCM::CassVersion cass_version = server_version_;
+  if (!Options::is_cassandra()) {
+    cass_version = static_cast<CCM::DseVersion>(cass_version).get_cass_version();
+  }
   std::string expected_message = "SERIAL is not supported as conditional update commit consistency";
-  if (server_version_ >= "4.0.0") {
+  if (cass_version >= "4.0.0") {
     expected_message = "You must use conditional updates for serializable writes";
   }
   ASSERT_TRUE(contains(result.error_message(), expected_message));

cpp-driver/gtests/src/integration/tests/test_session.cpp

@@ -140,7 +140,7 @@ CASSANDRA_INTEGRATION_TEST_F(SessionTest, ExternalHostListener) {
   // Restart node 1 (up event)
   ccm_->start_node(1);
   CCM::CassVersion cass_version = this->server_version_;
-  if (Options::is_dse()) {
+  if (!Options::is_cassandra()) {
     cass_version = static_cast<CCM::DseVersion>(cass_version).get_cass_version();
   }
   if (cass_version >= "2.2") {

cpp-driver/gtests/src/integration/tests/test_startup_options.cpp

@@ -19,7 +19,7 @@
 /**
  * Startup options integration tests
  */
-class StartupOptionssTests : public Integration {};
+class StartupOptionsTests : public Integration {};
 
 /**
  * Verify driver name and version are assigned in startup options.
@@ -34,10 +34,10 @@ class StartupOptionssTests : public Integration {};
  * @cassandra_version 4.0.0
  * @expected_result Driver startup options are validated.
  */
-CASSANDRA_INTEGRATION_TEST_F(StartupOptionssTests, DriverOptions) {
+CASSANDRA_INTEGRATION_TEST_F(StartupOptionsTests, DriverOptions) {
   CHECK_FAILURE;
   CHECK_VERSION(4.0.0);
-  if (Options::is_dse()) {
+  if (!Options::is_cassandra()) {
     SKIP_TEST("Unsupported for DataStax Enterprise Version "
               << server_version_.to_string() << ": 'system_views.clients' is unavailable");
   }