CPP-835 Port prepare from existing tests to Google test framework (#316)

Author: mpenick

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

@@ -217,6 +217,21 @@ class Session : public Object<CassSession, cass_session_free> {
     return Prepared(cass_future_get_prepared(prepare_future.get()));
   }
 
+  /**
+   * Create a prepared statement from an existing statement inheriting the existing statement's
+   * settings.
+   *
+   * @param statement The existing statement
+   * @param assert_ok True if error code for future should be asserted
+   *                  CASS_OK; false otherwise (default: true)
+   * @return Prepared statement generated by the server for the query
+   */
+  Prepared prepare_from_existing(Statement statement, bool assert_ok = true) {
+    Future prepare_future = cass_session_prepare_from_existing(get(), statement.get());
+    prepare_future.wait(assert_ok);
+    return Prepared(cass_future_get_prepared(prepare_future.get()));
+  }
+
   /**
    * Get a schema snapshot
    *

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

@@ -15,6 +15,9 @@
 */
 
 #include "integration.hpp"
+#include "testing.hpp"
+
+using namespace datastax::internal::testing;
 
 /**
  * Prepared integration tests; common operations
@@ -108,3 +111,89 @@ CASSANDRA_INTEGRATION_TEST_F(PreparedTests, PreparedIDUnchangedDuringReprepare)
   EXPECT_EQ(CASS_OK, result.error_code());
   EXPECT_EQ(1u, logger_.count());
 }
+
+/**
+ * Verify that a statement is correctly prepared from an existing simple
+ * statement. The settings from the original statement should be inherited.
+ *
+ * @since 2.8
+ */
+CASSANDRA_INTEGRATION_TEST_F(PreparedTests, PrepareFromExistingSimpleStatement) {
+  CHECK_FAILURE;
+
+  use_keyspace(keyspace_name_);
+
+  session_.execute(
+      format_string(CASSANDRA_KEY_VALUE_TABLE_FORMAT, table_name_.c_str(), "int", "int"));
+  session_.execute(
+      format_string(CASSANDRA_KEY_VALUE_INSERT_FORMAT, table_name_.c_str(), "1", "99"));
+
+  DowngradingConsistencyRetryPolicy retry_policy;
+  Statement statement(format_string(CASSANDRA_SELECT_VALUE_FORMAT, table_name_.c_str(), "?"), 1);
+
+  // Set unique settings to validate later
+  statement.set_consistency(CASS_CONSISTENCY_LOCAL_QUORUM);
+  statement.set_serial_consistency(CASS_CONSISTENCY_SERIAL);
+  statement.set_request_timeout(99999u);
+  statement.set_retry_policy(retry_policy);
+
+  // Prepare from the existing bound statement
+  Statement bound_statement = session_.prepare_from_existing(statement).bind();
+
+  // Validate that the bound statement inherited the settings from the original statement
+  EXPECT_EQ(get_consistency(bound_statement.get()), CASS_CONSISTENCY_LOCAL_QUORUM);
+  EXPECT_EQ(get_serial_consistency(bound_statement.get()), CASS_CONSISTENCY_SERIAL);
+  EXPECT_EQ(get_request_timeout_ms(bound_statement.get()), 99999u);
+  EXPECT_EQ(get_retry_policy(bound_statement.get()), retry_policy.get());
+
+  bound_statement.bind<Integer>(0, Integer(1));
+
+  Result result = session_.execute(bound_statement);
+  ASSERT_EQ(result.row_count(), 1);
+  EXPECT_EQ(result.first_row().column_by_name<Integer>("value").value(), 99);
+}
+
+/**
+ * Verify that a statement is correctly prepared from an existing bound
+ * statement. The settings from the original bound statement should be
+ * inherited.
+ *
+ * @since 2.8
+ */
+CASSANDRA_INTEGRATION_TEST_F(PreparedTests, PrepareFromExistingBoundStatement) {
+  CHECK_FAILURE;
+
+  use_keyspace(keyspace_name_);
+
+  session_.execute(
+      format_string(CASSANDRA_KEY_VALUE_TABLE_FORMAT, table_name_.c_str(), "int", "int"));
+  session_.execute(
+      format_string(CASSANDRA_KEY_VALUE_INSERT_FORMAT, table_name_.c_str(), "1", "99"));
+
+  Statement bound_statement1 =
+      session_.prepare(format_string(CASSANDRA_SELECT_VALUE_FORMAT, table_name_.c_str(), "?"))
+          .bind();
+
+  DowngradingConsistencyRetryPolicy retry_policy;
+
+  // Set unique settings to validate later
+  bound_statement1.set_consistency(CASS_CONSISTENCY_LOCAL_QUORUM);
+  bound_statement1.set_serial_consistency(CASS_CONSISTENCY_SERIAL);
+  bound_statement1.set_request_timeout(99999u);
+  bound_statement1.set_retry_policy(retry_policy);
+
+  // Prepare from the existing bound statement
+  Statement bound_statement2 = session_.prepare_from_existing(bound_statement1).bind();
+
+  // Validate that the bound statement inherited the settings from the original statement
+  EXPECT_EQ(get_consistency(bound_statement2.get()), CASS_CONSISTENCY_LOCAL_QUORUM);
+  EXPECT_EQ(get_serial_consistency(bound_statement2.get()), CASS_CONSISTENCY_SERIAL);
+  EXPECT_EQ(get_request_timeout_ms(bound_statement2.get()), 99999u);
+  EXPECT_EQ(get_retry_policy(bound_statement2.get()), retry_policy.get());
+
+  bound_statement2.bind<Integer>(0, Integer(1));
+
+  Result result = session_.execute(bound_statement2);
+  ASSERT_EQ(result.row_count(), 1);
+  EXPECT_EQ(result.first_row().column_by_name<Integer>("value").value(), 99);
+}

cpp-driver/src/testing.cpp

@@ -27,6 +27,7 @@
 #include "request_handler.hpp"
 #include "result_response.hpp"
 #include "session.hpp"
+#include "statement.hpp"
 
 namespace datastax { namespace internal { namespace testing {
 
@@ -77,4 +78,20 @@ uint64_t get_host_latency_average(CassSession* session, String ip_address, int p
   return 0;
 }
 
+CassConsistency get_consistency(const CassStatement* statement) {
+  return statement->from()->consistency();
+}
+
+CassConsistency get_serial_consistency(const CassStatement* statement) {
+  return statement->from()->serial_consistency();
+}
+
+uint64_t get_request_timeout_ms(const CassStatement* statement) {
+  return statement->from()->request_timeout_ms();
+}
+
+const CassRetryPolicy* get_retry_policy(const CassStatement* statement) {
+  return CassRetryPolicy::to(statement->from()->retry_policy().get());
+}
+
 }}} // namespace datastax::internal::testing

cpp-driver/src/testing.hpp

@@ -39,6 +39,14 @@ CASS_EXPORT uint64_t get_time_since_epoch_in_ms();
 
 CASS_EXPORT uint64_t get_host_latency_average(CassSession* session, String ip_address, int port);
 
+CASS_EXPORT CassConsistency get_consistency(const CassStatement* statement);
+
+CASS_EXPORT CassConsistency get_serial_consistency(const CassStatement* statement);
+
+CASS_EXPORT uint64_t get_request_timeout_ms(const CassStatement* statement);
+
+CASS_EXPORT const CassRetryPolicy* get_retry_policy(const CassStatement* statement);
+
 }}} // namespace datastax::internal::testing
 
 #endif

cpp-driver/test/ccm_bridge/src/process.cpp

@@ -127,4 +127,4 @@ void Process::on_read(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) {
   delete[] buf->base;
 }
 
-}; // namespace utils
+} // namespace utils