Make C++ validation tests run on all platforms (#511)

Also:
* updated the GoogleTest version (to be able to use the `Throws` matcher);
* enabled exceptions in Firestore integration tests (otherwise validation tests would be ignored);
* add some missing validation (see the linked bug for remaining gaps);
* replace all usage of `FIREBASE_ASSERT` macros with `SIMPLE_HARD_ASSERT` (which throws an exception on Unity / crash in C++).

See b/136012313 for more context.

Author: var-const

cmake/external/googletest.cmake

@@ -18,20 +18,20 @@ if(TARGET googletest OR NOT DOWNLOAD_GOOGLETEST)
   return()
 endif()
 
-set(version 1.10.0)
+set(version 1.11.0) # June 2021
 
 ExternalProject_Add(
   googletest
 
   DOWNLOAD_DIR ${FIREBASE_DOWNLOAD_DIR}
   DOWNLOAD_NAME googletest-${version}.tar.gz
   URL https://github.com/google/googletest/archive/release-${version}.tar.gz
-  URL_HASH SHA256=9dc9157a9a1551ec7a7e43daea9a694a0bb5fb8bec81235d8a1e6ef64c716dcb
+  URL_HASH SHA256=b4870bf121ff7795ba20d20bcdd8627b8e088f2d1dab299a031c1034eddc93d5
 
   PREFIX ${PROJECT_BINARY_DIR}
 
   CONFIGURE_COMMAND ""
   BUILD_COMMAND ""
   INSTALL_COMMAND ""
   TEST_COMMAND ""
-)
+)

firestore/integration_test_internal/CMakeLists.txt

@@ -378,5 +378,9 @@ add_subdirectory(${FIREBASE_CPP_SDK_DIR} bin/ EXCLUDE_FROM_ALL)
 # Note that firebase_app needs to be last in the list.
 set(firebase_libs firebase_firestore firebase_auth firebase_app)
 set(gtest_libs gtest gmock)
+# Validation tests need exceptions to be enabled in order to run. The only
+# library that explicitly disables exceptions is App (but it gets propagated
+# everywhere), so overriding that effectively reenables exceptions.
+target_compile_options(firebase_app PUBLIC -fexceptions)
 target_link_libraries(${integration_test_target_name} ${firebase_libs}
   ${gtest_libs} ${ADDITIONAL_LIBS})

firestore/integration_test_internal/src/cleanup_test.cc

@@ -245,18 +245,18 @@ void ExpectAllMethodsAreNoOps(QuerySnapshot* ptr) {
   EXPECT_EQ(ptr->size(), 0);
 }
 
-void ExpectAllMethodsAreNoOps(WriteBatch* ptr) {
+void ExpectAllMethodsAreNoOps(WriteBatch* ptr, const DocumentReference& doc) {
   EXPECT_FALSE(ptr->is_valid());
 
   // `WriteBatch` isn't equality comparable.
   ExpectCopyableAndMoveable(ptr);
 
-  ptr->Set(DocumentReference(), MapFieldValue());
+  ptr->Set(doc, MapFieldValue());
 
-  ptr->Update(DocumentReference(), MapFieldValue());
-  ptr->Update(DocumentReference(), MapFieldPathValue());
+  ptr->Update(doc, MapFieldValue());
+  ptr->Update(doc, MapFieldPathValue());
 
-  ptr->Delete(DocumentReference());
+  ptr->Delete(doc);
 
   EXPECT_EQ(ptr->Commit(), FailedFuture<void>());
 }
@@ -409,17 +409,20 @@ TEST_F(CleanupTest, QuerySnapshotIsBlankAfterCleanup) {
 // case where a user could be accessing a "blank" transaction.
 
 TEST_F(CleanupTest, WriteBatchIsBlankAfterCleanup) {
+  // Need a valid `DocumentReference` to avoid `WriteBatch` methods throwing.
+  DocumentReference doc = Document();
+
   {
     WriteBatch default_constructed;
     SCOPED_TRACE("WriteBatch.DefaultConstructed");
-    ExpectAllMethodsAreNoOps(&default_constructed);
+    ExpectAllMethodsAreNoOps(&default_constructed, doc);
   }
 
   Firestore* db = TestFirestore();
   WriteBatch batch = db->batch();
   DeleteFirestore(db);
   SCOPED_TRACE("WriteBatch.AfterCleanup");
-  ExpectAllMethodsAreNoOps(&batch);
+  ExpectAllMethodsAreNoOps(&batch, doc);
 }
 
 }  // namespace

firestore/integration_test_internal/src/firestore_integration_test.cc

@@ -118,14 +118,19 @@ FirestoreIntegrationTest::FirestoreIntegrationTest() {
 
 Firestore* FirestoreIntegrationTest::TestFirestore(
     const std::string& name) const {
+  return TestFirestoreWithProjectId(name, /*project_id=*/"");
+}
+
+Firestore* FirestoreIntegrationTest::TestFirestoreWithProjectId(
+    const std::string& name, const std::string& project_id) const {
   for (const auto& entry : firestores_) {
     const FirestoreInfo& firestore_info = entry.second;
     if (firestore_info.name() == name) {
       return firestore_info.firestore();
     }
   }
 
-  App* app = GetApp(name.c_str());
+  App* app = GetApp(name.c_str(), project_id);
   if (apps_.find(app) == apps_.end()) {
     apps_[app] = std::unique_ptr<App>(app);
   }

firestore/integration_test_internal/src/firestore_integration_test.h

@@ -37,7 +37,7 @@ FirestoreInternal* CreateTestFirestoreInternal(App* app);
 void InitializeFirestore(Firestore* instance);
 
 App* GetApp();
-App* GetApp(const char* name);
+App* GetApp(const char* name, const std::string& override_project_id);
 bool ProcessEvents(int msec);
 
 // Converts a Firestore error code to a human-friendly name. The `error_code`
@@ -184,6 +184,11 @@ class FirestoreIntegrationTest : public testing::Test {
   // if `DeleteApp()` is called with the `App` of the returned `Firestore`.
   Firestore* TestFirestore(const std::string& name = kDefaultAppName) const;
 
+  // Returns a Firestore instance for an app with the given `name`, associated
+  // with the database with the given `project_id`.
+  Firestore* TestFirestoreWithProjectId(const std::string& name,
+                                        const std::string& project_id) const;
+
   // Deletes the given `Firestore` instance, which must have been returned by a
   // previous invocation of `TestFirestore()`, and removes it from the cache of
   // instances returned from `TestFirestore()`. Note that all `Firestore`

firestore/integration_test_internal/src/util/integration_test_util.cc

@@ -32,7 +32,7 @@ struct TestFriend {
   }
 };
 
-App* GetApp(const char* name) {
+App* GetApp(const char* name, const std::string& override_project_id) {
   // TODO(varconst): try to avoid using a real project ID when possible. iOS
   // unit tests achieve this by using fake options:
   // https://github.com/firebase/firebase-ios-sdk/blob/9a5afbffc17bb63b7bb7f51b9ea9a6a9e1c88a94/Firestore/core/test/firebase/firestore/testutil/app_testing.mm#L29
@@ -48,16 +48,22 @@ App* GetApp(const char* name) {
     App* default_app = App::GetInstance();
     SIMPLE_HARD_ASSERT(default_app,
                        "Cannot create a named app before the default app");
+
+    AppOptions options = default_app->options();
+    if (!override_project_id.empty()) {
+      options.set_project_id(override_project_id.c_str());
+    }
+
 #if defined(__ANDROID__)
-    return App::Create(default_app->options(), name, app_framework::GetJniEnv(),
+    return App::Create(options, name, app_framework::GetJniEnv(),
                        app_framework::GetActivity());
 #else
-    return App::Create(default_app->options(), name);
+    return App::Create(options, name);
 #endif  // defined(__ANDROID__)
   }
 }
 
-App* GetApp() { return GetApp(nullptr); }
+App* GetApp() { return GetApp(/*name=*/nullptr, /*project_id=*/""); }
 
 FirestoreInternal* CreateTestFirestoreInternal(App* app) {
   return TestFriend::CreateTestFirestoreInternal(app);