feat: environment-variable override of the spanner endpoint (#1269)

devbww · web-flow · commit 527001892023 · 2020-02-18T18:00:03.000-05:00
When the `SPANNER_EMULATOR_HOST` environment variable is set, the endpoint/credentials for data and admin connections are overridden by `${SPANNER_EMULATOR_HOST}` and `grpc::InsecureChannelCredentials()` respectively. Fixes #1200.
diff --git a/google/cloud/spanner/connection_options.cc b/google/cloud/spanner/connection_options.cc
@@ -33,14 +33,22 @@ std::string BaseUserAgentPrefix() {
 
 ConnectionOptions::ConnectionOptions(
     std::shared_ptr<grpc::ChannelCredentials> credentials)
-    : credentials_(std::move(credentials)),
+    : emulator_override_(false),
+      credentials_(std::move(credentials)),
       endpoint_("spanner.googleapis.com"),
       num_channels_(4),
       user_agent_prefix_(internal::BaseUserAgentPrefix()),
       background_threads_factory_([] {
         return google::cloud::internal::make_unique<
             google::cloud::internal::AutomaticallyCreatedBackgroundThreads>();
       }) {
+  auto emulator_addr = google::cloud::internal::GetEnv("SPANNER_EMULATOR_HOST");
+  if (emulator_addr.has_value()) {
+    emulator_override_ = true;
+    credentials_ = grpc::InsecureChannelCredentials();
+    endpoint_ = *emulator_addr;
+  }
+
   auto tracing =
       google::cloud::internal::GetEnv("GOOGLE_CLOUD_CPP_ENABLE_TRACING");
   if (tracing.has_value()) {
diff --git a/google/cloud/spanner/connection_options.h b/google/cloud/spanner/connection_options.h
@@ -52,7 +52,7 @@ class ConnectionOptions {
   /// `grpc::GoogleDefaultCredentials()`.
   ConnectionOptions& set_credentials(
       std::shared_ptr<grpc::ChannelCredentials> v) {
-    credentials_ = std::move(v);
+    if (!emulator_override_) credentials_ = std::move(v);
     return *this;
   }
 
@@ -69,7 +69,7 @@ class ConnectionOptions {
    * simulator, or (2) to use a beta or EAP version of the service.
    */
   ConnectionOptions& set_endpoint(std::string v) {
-    endpoint_ = std::move(v);
+    if (!emulator_override_) endpoint_ = std::move(v);
     return *this;
   }
 
@@ -197,6 +197,7 @@ class ConnectionOptions {
   }
 
  private:
+  bool emulator_override_;  // credentials_ and endpoint_ frozen
   std::shared_ptr<grpc::ChannelCredentials> credentials_;
   std::string endpoint_;
   int num_channels_;
diff --git a/google/cloud/spanner/connection_options_test.cc b/google/cloud/spanner/connection_options_test.cc
@@ -29,6 +29,9 @@ using ::testing::HasSubstr;
 using ::testing::StartsWith;
 
 TEST(ConnectionOptionsTest, Credentials) {
+  EnvironmentVariableRestore restore("SPANNER_EMULATOR_HOST");
+  google::cloud::internal::UnsetEnv("SPANNER_EMULATOR_HOST");
+
   // In the CI environment grpc::GoogleDefaultCredentials() may assert. Use the
   // insecure credentials to initialize the options in any unit test.
   auto expected = grpc::InsecureChannelCredentials();
@@ -42,12 +45,35 @@ TEST(ConnectionOptionsTest, Credentials) {
 }
 
 TEST(ConnectionOptionsTest, AdminEndpoint) {
+  EnvironmentVariableRestore restore("SPANNER_EMULATOR_HOST");
+  google::cloud::internal::UnsetEnv("SPANNER_EMULATOR_HOST");
+
   ConnectionOptions options(grpc::InsecureChannelCredentials());
   EXPECT_EQ("spanner.googleapis.com", options.endpoint());
   options.set_endpoint("invalid-endpoint");
   EXPECT_EQ("invalid-endpoint", options.endpoint());
 }
 
+TEST(ConnectionOptionsTest, SpannerEmulator) {
+  EnvironmentVariableRestore restore("SPANNER_EMULATOR_HOST");
+  google::cloud::internal::SetEnv("SPANNER_EMULATOR_HOST", "localhost:9010");
+
+  ConnectionOptions options(std::shared_ptr<grpc::ChannelCredentials>{});
+
+  // When SPANNER_EMULATOR_HOST is set, the passed credentials are overridden
+  // (by grpc::InsecureChannelCredentials()) and further updates are ignored.
+  EXPECT_NE(std::shared_ptr<grpc::ChannelCredentials>{}, options.credentials());
+  auto other_credentials = grpc::InsecureChannelCredentials();
+  options.set_credentials(other_credentials);
+  EXPECT_NE(other_credentials, options.credentials());
+
+  // When SPANNER_EMULATOR_HOST is set, the default endpoint is overridden (by
+  // ${SPANNER_EMULATOR_HOST}), and further updates are ignored.
+  EXPECT_EQ("localhost:9010", options.endpoint());
+  options.set_endpoint("invalid-endpoint");
+  EXPECT_EQ("localhost:9010", options.endpoint());
+}
+
 TEST(ConnectionOptionsTest, NumChannels) {
   ConnectionOptions options(grpc::InsecureChannelCredentials());
   int num_channels = options.num_channels();
diff --git a/google/cloud/spanner/integration_tests/client_integration_test.cc b/google/cloud/spanner/integration_tests/client_integration_test.cc
@@ -34,6 +34,10 @@ using ::testing::UnorderedElementsAreArray;
 
 class ClientIntegrationTest : public ::testing::Test {
  public:
+  ClientIntegrationTest()
+      : emulator_(google::cloud::internal::GetEnv("SPANNER_EMULATOR_HOST")
+                      .has_value()) {}
+
   static void SetUpTestSuite() {
     client_ = google::cloud::internal::make_unique<Client>(
         MakeConnection(spanner_testing::DatabaseEnvironment::GetDatabase()));
@@ -60,6 +64,7 @@ class ClientIntegrationTest : public ::testing::Test {
   static void TearDownTestSuite() { client_ = nullptr; }
 
  protected:
+  bool emulator_;
   static std::unique_ptr<Client> client_;
 };
 
@@ -335,6 +340,8 @@ TEST_F(ClientIntegrationTest, ExecuteQueryDml) {
 
 /// @test Test ExecutePartitionedDml
 TEST_F(ClientIntegrationTest, ExecutePartitionedDml) {
+  if (emulator_) return;
+
   auto& client = *client_;
   auto insert_result =
       client_->Commit([&client](Transaction txn) -> StatusOr<Mutations> {
@@ -546,6 +553,8 @@ StatusOr<std::vector<std::vector<Value>>> AddSingerDataToTable(Client client) {
 }
 
 TEST_F(ClientIntegrationTest, PartitionRead) {
+  if (emulator_) return;
+
   auto expected_rows = AddSingerDataToTable(*client_);
   ASSERT_STATUS_OK(expected_rows);
 
@@ -587,6 +596,8 @@ TEST_F(ClientIntegrationTest, PartitionRead) {
 }
 
 TEST_F(ClientIntegrationTest, PartitionQuery) {
+  if (emulator_) return;
+
   auto expected_rows = AddSingerDataToTable(*client_);
   ASSERT_STATUS_OK(expected_rows);
 
@@ -628,6 +639,8 @@ TEST_F(ClientIntegrationTest, PartitionQuery) {
 }
 
 TEST_F(ClientIntegrationTest, ExecuteBatchDml) {
+  if (emulator_) return;
+
   auto statements = {
       SqlStatement("INSERT INTO Singers (SingerId, FirstName, LastName) "
                    "VALUES(1, 'Foo1', 'Bar1')"),
@@ -685,6 +698,8 @@ TEST_F(ClientIntegrationTest, ExecuteBatchDml) {
 }
 
 TEST_F(ClientIntegrationTest, ExecuteBatchDmlMany) {
+  if (emulator_) return;
+
   std::vector<SqlStatement> v;
   constexpr auto kBatchSize = 200;
   for (int i = 0; i < kBatchSize; ++i) {
@@ -755,6 +770,8 @@ TEST_F(ClientIntegrationTest, ExecuteBatchDmlMany) {
 }
 
 TEST_F(ClientIntegrationTest, ExecuteBatchDmlFailure) {
+  if (emulator_) return;
+
   auto statements = {
       SqlStatement("INSERT INTO Singers (SingerId, FirstName, LastName) "
                    "VALUES(1, 'Foo1', 'Bar1')"),
@@ -785,6 +802,8 @@ TEST_F(ClientIntegrationTest, ExecuteBatchDmlFailure) {
 }
 
 TEST_F(ClientIntegrationTest, AnalyzeSql) {
+  if (emulator_) return;
+
   auto txn = MakeReadOnlyTransaction();
   auto sql = SqlStatement(
       "SELECT * FROM Singers  "
@@ -810,9 +829,11 @@ TEST_F(ClientIntegrationTest, ProfileQuery) {
   EXPECT_TRUE(stats);
   EXPECT_GT(stats->size(), 0);
 
-  auto plan = rows.ExecutionPlan();
-  EXPECT_TRUE(plan);
-  EXPECT_GT(plan->plan_nodes_size(), 0);
+  if (!emulator_) {
+    auto plan = rows.ExecutionPlan();
+    EXPECT_TRUE(plan);
+    EXPECT_GT(plan->plan_nodes_size(), 0);
+  }
 }
 
 TEST_F(ClientIntegrationTest, ProfileDml) {
@@ -836,9 +857,11 @@ TEST_F(ClientIntegrationTest, ProfileDml) {
   EXPECT_TRUE(stats);
   EXPECT_GT(stats->size(), 0);
 
-  auto plan = profile_result.ExecutionPlan();
-  EXPECT_TRUE(plan);
-  EXPECT_GT(plan->plan_nodes_size(), 0);
+  if (!emulator_) {
+    auto plan = profile_result.ExecutionPlan();
+    EXPECT_TRUE(plan);
+    EXPECT_GT(plan->plan_nodes_size(), 0);
+  }
 }
 
 }  // namespace
diff --git a/google/cloud/spanner/integration_tests/database_admin_integration_test.cc b/google/cloud/spanner/integration_tests/database_admin_integration_test.cc
@@ -33,6 +33,8 @@ using ::testing::EndsWith;
 
 /// @test Verify the basic CRUD operations for databases work.
 TEST(DatabaseAdminClient, DatabaseBasicCRUD) {
+  auto emulator =
+      google::cloud::internal::GetEnv("SPANNER_EMULATOR_HOST").has_value();
   auto project_id =
       google::cloud::internal::GetEnv("GOOGLE_CLOUD_PROJECT").value_or("");
   ASSERT_FALSE(project_id.empty());
@@ -44,7 +46,7 @@ TEST(DatabaseAdminClient, DatabaseBasicCRUD) {
   auto test_iam_service_account =
       google::cloud::internal::GetEnv("GOOGLE_CLOUD_CPP_SPANNER_IAM_TEST_SA")
           .value_or("");
-  ASSERT_FALSE(test_iam_service_account.empty());
+  ASSERT_TRUE(emulator || !test_iam_service_account.empty());
 
   Instance const in(project_id, *instance_id);
 
@@ -85,55 +87,57 @@ TEST(DatabaseAdminClient, DatabaseBasicCRUD) {
   ASSERT_STATUS_OK(get_result);
   EXPECT_EQ(database->name(), get_result->name());
 
-  auto current_policy = client.GetIamPolicy(db);
-  ASSERT_STATUS_OK(current_policy);
-  EXPECT_EQ(0, current_policy->bindings_size());
-
-  std::string const reader_role = "roles/spanner.databaseReader";
-  std::string const writer_role = "roles/spanner.databaseUser";
-  std::string const expected_member =
-      "serviceAccount:" + test_iam_service_account;
-  auto& binding = *current_policy->add_bindings();
-  binding.set_role(reader_role);
-  *binding.add_members() = expected_member;
-
-  auto updated_policy = client.SetIamPolicy(db, *current_policy);
-  ASSERT_STATUS_OK(updated_policy);
-  EXPECT_EQ(1, updated_policy->bindings_size());
-  ASSERT_EQ(reader_role, updated_policy->bindings().Get(0).role());
-  ASSERT_EQ(1, updated_policy->bindings().Get(0).members().size());
-  ASSERT_EQ(expected_member,
-            updated_policy->bindings().Get(0).members().Get(0));
-
-  // Perform a different update using the the OCC loop API:
-  updated_policy =
-      client.SetIamPolicy(db, [&test_iam_service_account,
-                               &writer_role](google::iam::v1::Policy current) {
-        std::string const expected_member =
-            "serviceAccount:" + test_iam_service_account;
-        auto& binding = *current.add_bindings();
-        binding.set_role(writer_role);
-        *binding.add_members() = expected_member;
-        return current;
-      });
-  ASSERT_STATUS_OK(updated_policy);
-  EXPECT_EQ(2, updated_policy->bindings_size());
-  ASSERT_EQ(writer_role, updated_policy->bindings().Get(1).role());
-  ASSERT_EQ(1, updated_policy->bindings().Get(1).members().size());
-  ASSERT_EQ(expected_member,
-            updated_policy->bindings().Get(1).members().Get(0));
-
-  // Fetch the Iam Policy again.
-  current_policy = client.GetIamPolicy(db);
-  ASSERT_STATUS_OK(current_policy);
-  EXPECT_THAT(*updated_policy, IsProtoEqual(*current_policy));
-
-  auto test_iam_permission_result =
-      client.TestIamPermissions(db, {"spanner.databases.read"});
-  ASSERT_STATUS_OK(test_iam_permission_result);
-  ASSERT_EQ(1, test_iam_permission_result->permissions_size());
-  ASSERT_EQ("spanner.databases.read",
-            test_iam_permission_result->permissions(0));
+  if (!emulator) {
+    auto current_policy = client.GetIamPolicy(db);
+    ASSERT_STATUS_OK(current_policy);
+    EXPECT_EQ(0, current_policy->bindings_size());
+
+    std::string const reader_role = "roles/spanner.databaseReader";
+    std::string const writer_role = "roles/spanner.databaseUser";
+    std::string const expected_member =
+        "serviceAccount:" + test_iam_service_account;
+    auto& binding = *current_policy->add_bindings();
+    binding.set_role(reader_role);
+    *binding.add_members() = expected_member;
+
+    auto updated_policy = client.SetIamPolicy(db, *current_policy);
+    ASSERT_STATUS_OK(updated_policy);
+    EXPECT_EQ(1, updated_policy->bindings_size());
+    ASSERT_EQ(reader_role, updated_policy->bindings().Get(0).role());
+    ASSERT_EQ(1, updated_policy->bindings().Get(0).members().size());
+    ASSERT_EQ(expected_member,
+              updated_policy->bindings().Get(0).members().Get(0));
+
+    // Perform a different update using the the OCC loop API:
+    updated_policy =
+        client.SetIamPolicy(db, [&test_iam_service_account, &writer_role](
+                                    google::iam::v1::Policy current) {
+          std::string const expected_member =
+              "serviceAccount:" + test_iam_service_account;
+          auto& binding = *current.add_bindings();
+          binding.set_role(writer_role);
+          *binding.add_members() = expected_member;
+          return current;
+        });
+    ASSERT_STATUS_OK(updated_policy);
+    EXPECT_EQ(2, updated_policy->bindings_size());
+    ASSERT_EQ(writer_role, updated_policy->bindings().Get(1).role());
+    ASSERT_EQ(1, updated_policy->bindings().Get(1).members().size());
+    ASSERT_EQ(expected_member,
+              updated_policy->bindings().Get(1).members().Get(0));
+
+    // Fetch the Iam Policy again.
+    current_policy = client.GetIamPolicy(db);
+    ASSERT_STATUS_OK(current_policy);
+    EXPECT_THAT(*updated_policy, IsProtoEqual(*current_policy));
+
+    auto test_iam_permission_result =
+        client.TestIamPermissions(db, {"spanner.databases.read"});
+    ASSERT_STATUS_OK(test_iam_permission_result);
+    ASSERT_EQ(1, test_iam_permission_result->permissions_size());
+    ASSERT_EQ("spanner.databases.read",
+              test_iam_permission_result->permissions(0));
+  }
 
   auto get_ddl_result = client.GetDatabaseDdl(db);
   ASSERT_STATUS_OK(get_ddl_result);
diff --git a/google/cloud/spanner/integration_tests/instance_admin_integration_test.cc b/google/cloud/spanner/integration_tests/instance_admin_integration_test.cc
@@ -39,6 +39,8 @@ class InstanceAdminClientTest : public testing::Test {
 
  protected:
   void SetUp() override {
+    emulator_ =
+        google::cloud::internal::GetEnv("SPANNER_EMULATOR_HOST").has_value();
     project_id_ =
         google::cloud::internal::GetEnv("GOOGLE_CLOUD_PROJECT").value_or("");
     instance_id_ =
@@ -52,6 +54,7 @@ class InstanceAdminClientTest : public testing::Test {
             .value_or("");
   }
   InstanceAdminClient client_;
+  bool emulator_;
   std::string project_id_;
   std::string instance_id_;
   std::string run_slow_integration_tests_;
@@ -170,21 +173,23 @@ TEST_F(InstanceAdminClientTestWithCleanup, InstanceCRUDOperations) {
   EXPECT_THAT(instance->name(), HasSubstr(instance_id));
   EXPECT_EQ("test-display-name", instance->display_name());
   EXPECT_NE(0, instance->node_count());
-  EXPECT_NE(0, instance->labels_size());
-  EXPECT_EQ(instance_config, instance->config());
-  EXPECT_EQ("label-value", instance->labels().at("label-key"));
-
-  // Then update the instance
-  f = client_.UpdateInstance(UpdateInstanceRequestBuilder(*instance)
-                                 .SetDisplayName("New display name")
-                                 .AddLabels({{"new-key", "new-value"}})
-                                 .SetNodeCount(2)
-                                 .Build());
-  instance = f.get();
-  EXPECT_EQ("New display name", instance->display_name());
-  EXPECT_EQ(2, instance->labels_size());
-  EXPECT_EQ("new-value", instance->labels().at("new-key"));
-  EXPECT_EQ(2, instance->node_count());
+  if (!emulator_) {
+    EXPECT_NE(0, instance->labels_size());
+    EXPECT_EQ(instance_config, instance->config());
+    EXPECT_EQ("label-value", instance->labels().at("label-key"));
+
+    // Then update the instance
+    f = client_.UpdateInstance(UpdateInstanceRequestBuilder(*instance)
+                                   .SetDisplayName("New display name")
+                                   .AddLabels({{"new-key", "new-value"}})
+                                   .SetNodeCount(2)
+                                   .Build());
+    instance = f.get();
+    EXPECT_EQ("New display name", instance->display_name());
+    EXPECT_EQ(2, instance->labels_size());
+    EXPECT_EQ("new-value", instance->labels().at("new-key"));
+    EXPECT_EQ(2, instance->node_count());
+  }
   auto status = client_.DeleteInstance(in);
   EXPECT_STATUS_OK(status);
 }
@@ -213,6 +218,8 @@ TEST_F(InstanceAdminClientTest, InstanceConfig) {
 }
 
 TEST_F(InstanceAdminClientTest, InstanceIam) {
+  if (emulator_) return;
+
   ASSERT_FALSE(project_id_.empty());
   ASSERT_FALSE(instance_id_.empty());
   ASSERT_FALSE(test_iam_service_account_.empty());
diff --git a/google/cloud/spanner/internal/spanner_stub_test.cc b/google/cloud/spanner/internal/spanner_stub_test.cc
diff --git a/google/cloud/spanner/samples/samples.cc b/google/cloud/spanner/samples/samples.cc
