test: add integration test

Author: diegomarquezp

google/cloud/spanner/integration_tests/client_integration_test.cc

@@ -16,9 +16,11 @@
 #include "google/cloud/spanner/client.h"
 #include "google/cloud/spanner/database.h"
 #include "google/cloud/spanner/mutations.h"
+#include "google/cloud/spanner/options.h"
 #include "google/cloud/spanner/testing/database_integration_test.h"
 #include "google/cloud/credentials.h"
 #include "google/cloud/internal/random.h"
+#include "google/cloud/log.h"
 #include "google/cloud/testing_util/status_matchers.h"
 #include <gmock/gmock.h>
 #include <map>
@@ -36,6 +38,7 @@ using ::google::cloud::testing_util::IsOk;
 using ::google::cloud::testing_util::StatusIs;
 using ::testing::AllOf;
 using ::testing::AnyOf;
+using ::testing::Contains;
 using ::testing::Eq;
 using ::testing::Ge;
 using ::testing::HasSubstr;
@@ -768,6 +771,49 @@ void CheckExecuteQueryWithSingleUseOptions(
   EXPECT_THAT(actual_rows, UnorderedElementsAreArray(expected_rows));
 }
 
+/// @test Verify the `ReadLockMode` option is sent in the RPC by creating a
+/// situation where a transaction A perfomrs a commit while a transaction B
+/// performed one after tx A started.
+TEST_F(ClientIntegrationTest, ReadLockModeOptionIsSent) {
+  if (UsingEmulator()) {
+    GTEST_SKIP() << "Optimistic locks not supported by emulator";
+  }
+  auto const singer_id = 101;
+
+  auto mutation_helper = [singer_id] (std::string new_name) {
+    return Mutations{MakeInsertOrUpdateMutation("Singers", {"SingerId", "FirstName"}, singer_id, new_name)};
+  };
+
+  // initial insert
+  auto insert = client_->Commit(mutation_helper("InitialName"));
+  ASSERT_STATUS_OK(insert);
+
+  // transaction A will do a DML after another transaction has executed DML
+  // If optimistic, we expect transaction A to be aborted
+  auto test_helper = [&mutation_helper, singer_id] (Transaction::ReadLockMode read_lock_mode) -> StatusOr<CommitResult> {
+    // here we create tx A and confirm it can perform a read.
+    auto tx_a = MakeReadWriteTransaction(Transaction::ReadWriteOptions(read_lock_mode));
+    auto tx_a_read_result = client_->Read(tx_a, "Singers", KeySet().AddKey(MakeKey(singer_id)), {"SingerId"});
+    for (auto row : StreamOf<std::tuple<std::int64_t>>(tx_a_read_result)) {
+      EXPECT_STATUS_OK(row);
+    }
+
+    // now a separate tx b will perform a write operation before tx A is finished.
+    auto tx_b = client_->Commit(mutation_helper("FirstModifiedName"));
+    EXPECT_STATUS_OK(tx_b);
+
+    // depending on the read lock mode, the result of the next write operation
+    // in tx A will vary.
+    return client_->Commit(tx_a, mutation_helper("SecondModifiedName"));
+  };
+
+  auto optimistic_result = test_helper(Transaction::ReadLockMode::kOptimistic);
+  auto pessimistic_result = test_helper(Transaction::ReadLockMode::kPessimistic);
+
+  EXPECT_STATUS_OK(pessimistic_result);
+  EXPECT_THAT(optimistic_result, StatusIs(StatusCode::kAborted));
+}
+
 /// @test Test ExecuteQuery() with bounded staleness set by a timestamp.
 TEST_F(ClientIntegrationTest, ExecuteQueryBoundedStalenessTimestamp) {
   CheckExecuteQueryWithSingleUseOptions(