Merge branch 'bugfix/integration-tests-mac-openssl-error' of https://github.com/firebase/firebase-cpp-sdk into bugfix/integration-tests-mac-openssl-error

Author: vimanyu

CMakeLists.txt

@@ -45,6 +45,9 @@ option(FIREBASE_INCLUDE_FIRESTORE
 option(FIREBASE_INCLUDE_FUNCTIONS
        "Include the Cloud Functions for Firebase library."
        ${FIREBASE_INCLUDE_LIBRARY_DEFAULT})
+option(FIREBASE_INCLUDE_INSTALLATIONS
+       "Include the Firebase Installations library."
+       ${FIREBASE_INCLUDE_LIBRARY_DEFAULT})
 option(FIREBASE_INCLUDE_INSTANCE_ID
        "Include the Firebase Instance ID library."
        ${FIREBASE_INCLUDE_LIBRARY_DEFAULT})
@@ -548,6 +551,9 @@ endif()
 if (FIREBASE_INCLUDE_FUNCTIONS)
   add_subdirectory(functions)
 endif()
+if (FIREBASE_INCLUDE_INSTALLATIONS)
+  add_subdirectory(installations)
+endif()
 if (FIREBASE_INCLUDE_INSTANCE_ID)
   add_subdirectory(instance_id)
 endif()

build_scripts/packaging.conf

@@ -2,5 +2,5 @@
 
 # List of all Firebase products to include in the binary SDK package.
 readonly -a product_list=(admob analytics app auth database
-dynamic_links firestore functions instance_id messaging remote_config
-storage)
+dynamic_links firestore functions installations instance_id messaging
+remote_config storage)

database/integration_test/src/integration_test.cc

@@ -112,59 +112,149 @@ TEST(TimestampIsNear, Matcher) {
   EXPECT_THAT(firebase::Variant::EmptyString(), Not(TimestampIsNear(0)));
 }
 
+
 class FirebaseDatabaseTest : public FirebaseTest {
  public:
   FirebaseDatabaseTest();
   ~FirebaseDatabaseTest() override;
 
+  // Called once before all tests.
+  static void SetUpTestSuite();
+  // Called once after all tests.
+  static void TearDownTestSuite();
+
+  // Called at the start of each test.
   void SetUp() override;
+  // Called after each test.
   void TearDown() override;
 
  protected:
-  // Initialize Firebase App, Firebase Auth, and Firebase Database.
-  void Initialize();
-  // Shut down Firebase Database, Firebase Auth, and Firebase App.
-  void Terminate();
+  // Initialize Firebase App and Firebase Auth.
+  static void InitializeAppAndAuth();
+  // Shut down Firebase App and Firebase Auth.
+  static void TerminateAppAndAuth();
+
   // Sign in an anonymous user.
-  void SignIn();
+  static void SignIn();
   // Sign out the current user, if applicable.
-  void SignOut();
+  static void SignOut();
+
+  // Initialize Firebase Database.
+  void InitializeDatabase();
+  // Shut down Firebase Database.
+  void TerminateDatabase();
 
   firebase::database::DatabaseReference CreateWorkingPath(
       bool suppress_cleanup = false);
 
+  static firebase::App* shared_app_;
+  static firebase::auth::Auth* shared_auth_;
+  
   static bool first_time_;
 
   bool initialized_;
-  firebase::auth::Auth* auth_;
   firebase::database::Database* database_;
 
   std::vector<firebase::database::DatabaseReference> cleanup_paths_;
 };
 
+// Initialization flow looks like this:
+//  - Once, before any tests run:
+//  -   SetUpTestSuite: Initialize App and Auth. Sign in.
+//  - For each test:
+//    - SetUp: Initialize Database.
+//    - Run the test.
+//    - TearDown: Shut down Database.
+//  - Once, after all tests are finished:
+//  -   TearDownTestSuite: Sign out. Shut down Auth and App.
+  
+firebase::App* FirebaseDatabaseTest::shared_app_;
+firebase::auth::Auth* FirebaseDatabaseTest::shared_auth_;
+
 bool FirebaseDatabaseTest::first_time_ = true;
 
+void FirebaseDatabaseTest::SetUpTestSuite() {
+  InitializeAppAndAuth();
+}
+
+void FirebaseDatabaseTest::InitializeAppAndAuth() {
+  LogDebug("Initialize Firebase App.");
+
+  FindFirebaseConfig(FIREBASE_CONFIG_STRING);
+
+#if defined(__ANDROID__)
+  shared_app_ = ::firebase::App::Create(app_framework::GetJniEnv(),
+                                        app_framework::GetActivity());
+#else
+  shared_app_ = ::firebase::App::Create();
+#endif  // defined(__ANDROID__)
+
+  ASSERT_NE(shared_app_, nullptr);
+
+  LogDebug("Initializing Auth.");
+
+  // Initialize Firebase Auth.
+  ::firebase::ModuleInitializer initializer;
+  initializer.Initialize(
+      shared_app_, &shared_auth_, [](::firebase::App* app, void* target) {
+        LogDebug("Attempting to initialize Firebase Auth.");
+        ::firebase::InitResult result;
+        *reinterpret_cast<firebase::auth::Auth**>(target) =
+          ::firebase::auth::Auth::GetAuth(app, &result);
+        return result;
+      });
+
+  WaitForCompletion(initializer.InitializeLastResult(), "InitializeAuth");
+
+  ASSERT_EQ(initializer.InitializeLastResult().error(), 0)
+      << initializer.InitializeLastResult().error_message();
+
+  LogDebug("Successfully initialized Auth.");
+
+  ASSERT_NE(shared_auth_, nullptr);
+
+  // Sign in anonymously.
+  SignIn();
+}
+
+void FirebaseDatabaseTest::TearDownTestSuite() {
+  TerminateAppAndAuth();
+}
+
+void FirebaseDatabaseTest::TerminateAppAndAuth() {
+  if (shared_auth_) {
+    LogDebug("Signing out.");
+    SignOut();
+    LogDebug("Shutdown Auth.");
+    delete shared_auth_;
+    shared_auth_ = nullptr;
+  }
+  if (shared_app_) {
+    LogDebug("Shutdown App.");
+    delete shared_app_;
+    shared_app_ = nullptr;
+  }
+}
+
 FirebaseDatabaseTest::FirebaseDatabaseTest()
-    : initialized_(false), auth_(nullptr), database_(nullptr) {
+    : initialized_(false), database_(nullptr) {
   FindFirebaseConfig(FIREBASE_CONFIG_STRING);
 }
 
 FirebaseDatabaseTest::~FirebaseDatabaseTest() {
   // Must be cleaned up on exit.
-  assert(app_ == nullptr);
-  assert(auth_ == nullptr);
   assert(database_ == nullptr);
 }
 
 void FirebaseDatabaseTest::SetUp() {
   FirebaseTest::SetUp();
-  Initialize();
+  InitializeDatabase();
 }
 
 void FirebaseDatabaseTest::TearDown() {
   // Delete the shared path, if there is one.
   if (initialized_) {
-    if (!cleanup_paths_.empty() && database_ && app_) {
+    if (!cleanup_paths_.empty() && database_ && shared_app_) {
       LogDebug("Cleaning up...");
       std::vector<firebase::Future<void>> cleanups;
       cleanups.reserve(cleanup_paths_.size());
@@ -177,55 +267,30 @@ void FirebaseDatabaseTest::TearDown() {
       }
       cleanup_paths_.clear();
     }
-    
-    SignOut();
-    Terminate();
   }
-  
+  TerminateDatabase();
   FirebaseTest::TearDown();
 }
 
-void FirebaseDatabaseTest::Initialize() {
-  if (initialized_) return;
-
-  InitializeApp();
-
-  LogDebug("Initializing Firebase Auth and Firebase Database.");
-
-  // 0th element has a reference to this object, the rest have the initializer
-  // targets.
-  void* initialize_targets[] = {&auth_, &database_};
+void FirebaseDatabaseTest::InitializeDatabase() {
+  LogDebug("Initializing Firebase Database.");
 
-  const firebase::ModuleInitializer::InitializerFn initializers[] = {
-      [](::firebase::App* app, void* data) {
-        void** targets = reinterpret_cast<void**>(data);
-        LogDebug("Attempting to initialize Firebase Auth.");
-        ::firebase::InitResult result;
-        *reinterpret_cast<::firebase::auth::Auth**>(targets[0]) =
-            ::firebase::auth::Auth::GetAuth(app, &result);
-        return result;
-      },
-      [](::firebase::App* app, void* data) {
-        void** targets = reinterpret_cast<void**>(data);
+  ::firebase::ModuleInitializer initializer;
+  initializer.Initialize(
+      shared_app_, &database_, [](::firebase::App* app, void* target) {
         LogDebug("Attempting to initialize Firebase Database.");
         ::firebase::InitResult result;
-        firebase::database::Database* database =
-            firebase::database::Database::GetInstance(app, &result);
-        *reinterpret_cast<::firebase::database::Database**>(targets[1]) =
-            database;
+        *reinterpret_cast<firebase::database::Database**>(target) =
+          firebase::database::Database::GetInstance(app, &result);
         return result;
-      }};
-
-  ::firebase::ModuleInitializer initializer;
-  initializer.Initialize(app_, initialize_targets, initializers,
-                         sizeof(initializers) / sizeof(initializers[0]));
+      });
 
-  WaitForCompletion(initializer.InitializeLastResult(), "Initialize");
+  WaitForCompletion(initializer.InitializeLastResult(), "InitializeDatabase");
 
   ASSERT_EQ(initializer.InitializeLastResult().error(), 0)
       << initializer.InitializeLastResult().error_message();
 
-  LogDebug("Successfully initialized Firebase Auth and Firebase Database.");
+  LogDebug("Successfully initialized Firebase Database.");
 
   // The first time we initialize database, enable persistence on mobile.
   // We need to do this here because on iOS you can only enable persistence
@@ -238,31 +303,27 @@ void FirebaseDatabaseTest::Initialize() {
   initialized_ = true;
 }
 
-void FirebaseDatabaseTest::Terminate() {
+void FirebaseDatabaseTest::TerminateDatabase() {
   if (!initialized_) return;
 
   if (database_) {
     LogDebug("Shutdown the Database library.");
     delete database_;
     database_ = nullptr;
   }
-  if (auth_) {
-    LogDebug("Shutdown the Auth library.");
-    delete auth_;
-    auth_ = nullptr;
-  }
-
-  TerminateApp();
-
   initialized_ = false;
 
   ProcessEvents(100);
 }
 
 void FirebaseDatabaseTest::SignIn() {
+  if (shared_auth_->current_user() != nullptr) {
+    // Already signed in.
+    return;
+  }
   LogDebug("Signing in.");
   firebase::Future<firebase::auth::User*> sign_in_future =
-      auth_->SignInAnonymously();
+      shared_auth_->SignInAnonymously();
   WaitForCompletion(sign_in_future, "SignInAnonymously");
   if (sign_in_future.error() != 0) {
     FAIL() << "Ensure your application has the Anonymous sign-in provider "
@@ -272,22 +333,22 @@ void FirebaseDatabaseTest::SignIn() {
 }
 
 void FirebaseDatabaseTest::SignOut() {
-  if (auth_ == nullptr) {
+  if (shared_auth_ == nullptr) {
     // Auth is not set up.
     return;
   }
-  if (auth_->current_user() == nullptr) {
+  if (shared_auth_->current_user() == nullptr) {
     // Already signed out.
     return;
   }
 
-  auth_->SignOut();
+  shared_auth_->SignOut();
 
   // Wait for the sign-out to finish.
-  while (auth_->current_user() != nullptr) {
+  while (shared_auth_->current_user() != nullptr) {
     if (ProcessEvents(100)) break;
   }
-  EXPECT_EQ(auth_->current_user(), nullptr);
+  EXPECT_EQ(shared_auth_->current_user(), nullptr);
 }
 
 firebase::database::DatabaseReference FirebaseDatabaseTest::CreateWorkingPath(
@@ -306,8 +367,7 @@ TEST_F(FirebaseDatabaseTest, TestInitializeAndTerminate) {
 }
 
 TEST_F(FirebaseDatabaseTest, TestSignIn) {
-  SignIn();
-  EXPECT_NE(auth_->current_user(), nullptr);
+  EXPECT_NE(shared_auth_->current_user(), nullptr);
 }
 
 TEST_F(FirebaseDatabaseTest, TestCreateWorkingPath) {
@@ -456,7 +516,7 @@ TEST_F(FirebaseDatabaseTest, TestReadingFromPersistanceWhileOffline) {
   // Shut down the realtime database and restart it, to make sure that
   // persistence persists across database object instances.
   delete database_;
-  database_ = ::firebase::database::Database::GetInstance(app_);
+  database_ = ::firebase::database::Database::GetInstance(shared_app_);
 
   // Offline mode.  If persistence works, we should still be able to fetch
   // our value even though we're offline.
@@ -1090,15 +1150,20 @@ TEST_F(FirebaseDatabaseTest, TestInvalidatingReferencesWhenDeletingApp) {
 
   // Deleting App should invalidate all the objects and Futures, same as
   // deleting Database.
-  delete app_;
-  app_ = nullptr;
+  delete shared_app_;
+  shared_app_ = nullptr;
 
   EXPECT_FALSE(ref.is_valid());
   EXPECT_FALSE(query.is_valid());
   EXPECT_FALSE(snapshot.is_valid());
   EXPECT_EQ(set_future.status(), firebase::kFutureStatusInvalid);
   EXPECT_EQ(get_future.status(), firebase::kFutureStatusInvalid);
   EXPECT_EQ(delete_future.status(), firebase::kFutureStatusInvalid);
+
+  // Fully shut down App and Auth so they can be reinitialized.
+  TerminateAppAndAuth();
+  // Reinitialize App and Auth.
+  InitializeAppAndAuth();
 }
 
 TEST_F(FirebaseDatabaseTest, TestInfoConnected) {