integration_test.cc

// Copyright 2019 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include<inttypes.h>

#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<ctime>
#include<string>

#include"app_framework.h"// NOLINT
#include"firebase/app.h"
#include"firebase/auth.h"
#include"firebase/auth/credential.h"
#include"firebase/auth/user.h"
#include"firebase/util.h"
#include"firebase/variant.h"
#include"firebase_test_framework.h"// NOLINT

// The TO_STRING macro is useful for command line defined strings as the quotes
// get stripped.
#defineTO_STRING_EXPAND(X) #X
#defineTO_STRING(X) TO_STRING_EXPAND(X)

// Path to the Firebase config file to load.
#ifdef FIREBASE_CONFIG
#defineFIREBASE_CONFIG_STRINGTO_STRING(FIREBASE_CONFIG)
#else
#defineFIREBASE_CONFIG_STRING""
#endif// FIREBASE_CONFIG

namespacefirebase_testapp_automated {

// Set kCustomTestEmail and kCustomTestPassword if you want to test email and
// password login using a custom account you've already set up on your Firebase
// project.
staticconstcharkCustomTestEmail[] = "put_custom_test_account_here@gmail.com";
staticconstcharkCustomTestPassword[] = "";

staticconstintkWaitIntervalMs = 300; // NOLINT
staticconstintkPhoneAuthCodeSendWaitMs = 600000; // NOLINT
staticconstintkPhoneAuthCompletionWaitMs = 8000; // NOLINT
staticconstintkPhoneAuthTimeoutMs = 0; // NOLINT

// Set these in Firebase Console for your app.
staticconstchar* kPhoneAuthTestPhoneNumbers[] = {
"+12345556780", "+12345556781", "+12345556782", "+12345556783",
"+12345556784", "+12345556785", "+12345556786", "+12345556787",
"+12345556788", "+12345556789"}; // NOLINT
staticconstcharkPhoneAuthTestVerificationCode[] = "123456"; // NOLINT
staticconstintkPhoneAuthTestNumPhoneNumbers =
sizeof(kPhoneAuthTestPhoneNumbers) / sizeof(kPhoneAuthTestPhoneNumbers[0]);

staticconstcharkTestPassword[] = "testEmailPassword123";
staticconstcharkTestEmailBad[] = "bad.test.email@example.com";
staticconstcharkTestPasswordBad[] = "badTestPassword";
staticconstcharkTestIdTokenBad[] = "bad id token for testing";
staticconstcharkTestAccessTokenBad[] = "bad access token for testing";
staticconstcharkTestPasswordUpdated[] = "testpasswordupdated";
staticconstcharkTestIdProviderIdBad[] = "bad provider id for testing";
staticconstcharkTestServerAuthCodeBad[] = "bad server auth code"; // NOLINT

using app_framework::LogDebug;
using app_framework::LogError; // NOLINT
using app_framework::LogInfo;
using app_framework::ProcessEvents;

using firebase_test_framework::FirebaseTest;

classFirebaseAuthTest : publicFirebaseTest {
public:
FirebaseAuthTest();
~FirebaseAuthTest() override;

voidSetUp() override;
voidTearDown() override;

protected:
// Initialize Firebase App and Firebase Auth.
voidInitialize();
// Shut down Firebase App and Firebase Auth.
voidTerminate();

// Sign out of any user we were signed into. This is automatically called
// before and after every test.
voidSignOut();

// Delete the current user if it's currently signed in.
voidDeleteUser();

// Passthrough method to the base class's WaitForCompletion.
boolWaitForCompletion(firebase::Future<std::string> future, constchar* fn,
int expected_error = firebase::auth::kAuthErrorNone) {
returnFirebaseTest::WaitForCompletion(future, fn, expected_error);
 }

// Passthrough method to the base class's WaitForCompletion.
boolWaitForCompletion(firebase::Future<void> future, constchar* fn,
int expected_error = firebase::auth::kAuthErrorNone) {
returnFirebaseTest::WaitForCompletion(future, fn, expected_error);
 }

// Custom WaitForCompletion that checks if User matches afterwards.
boolWaitForCompletion(firebase::Future<firebase::auth::User> future,
constchar* fn,
int expected_error = firebase::auth::kAuthErrorNone);

// Custom WaitForCompletion that checks if User is valid afterwards.
boolWaitForCompletion(firebase::Future<firebase::auth::AuthResult> future,
constchar* fn,
int expected_error = firebase::auth::kAuthErrorNone);

// Custom WaitForCompletions which checks if user's Provider ID matches
// afterwards.
boolWaitForCompletion(firebase::Future<firebase::auth::AuthResult> future,
constchar* fn, const std::string& provider_id);

// Waits for the future to be marked as either complete or invalid.
voidWaitForCompletionOrInvalidStatus(const firebase::FutureBase& future,
constchar* name) {
app_framework::LogDebug("WaitForCompletionOrInvalidStatus %s", name);
while (future.status() == firebase::kFutureStatusPending) {
app_framework::ProcessEvents(100);
 }
 }

voidSignInAnonymously() {
FLAKY_TEST_SECTION_BEGIN();
WaitForCompletion(auth_->SignInAnonymously(), "SignInAnonymously");
FLAKY_TEST_SECTION_END();
 }

bool initialized_;
 firebase::auth::Auth* auth_;
};

FirebaseAuthTest::FirebaseAuthTest() : initialized_(false), auth_(nullptr) {
FindFirebaseConfig(FIREBASE_CONFIG_STRING);
}

FirebaseAuthTest::~FirebaseAuthTest() {
// Must be cleaned up on exit.
assert(app_ == nullptr);
assert(auth_ == nullptr);
}

voidFirebaseAuthTest::SetUp() {
FirebaseTest::SetUp();
Initialize();
SignOut();
}

voidFirebaseAuthTest::TearDown() {
SignOut();
Terminate();
FirebaseTest::TearDown();
}

voidFirebaseAuthTest::Initialize() {
if (initialized_) return;

InitializeApp();

LogDebug("Initializing Firebase Auth.");

 ::firebase::ModuleInitializer initializer;
 initializer.Initialize(app_, &auth_, [](::firebase::App* app, void* target) {
LogDebug("Try to initialize Firebase Auth");
 firebase::InitResult result;
 firebase::auth::Auth** auth_ptr =
reinterpret_cast<firebase::auth::Auth**>(target);
 *auth_ptr = firebase::auth::Auth::GetAuth(app, &result);
return result;
 });

FirebaseTest::WaitForCompletion(initializer.InitializeLastResult(),
"Initialize");

ASSERT_EQ(initializer.InitializeLastResult().error(), 0)
 << initializer.InitializeLastResult().error_message();

LogDebug("Successfully initialized Firebase Auth.");

 initialized_ = true;
}

voidFirebaseAuthTest::Terminate() {
if (!initialized_) return;

if (auth_) {
LogDebug("Shutdown the Auth library.");
delete auth_;
 auth_ = nullptr;
 }

TerminateApp();

 initialized_ = false;

ProcessEvents(100);
}

boolFirebaseAuthTest::WaitForCompletion(
 firebase::Future<firebase::auth::User> future, constchar* fn,
int expected_error) {
bool succeeded = FirebaseTest::WaitForCompletion(future, fn, expected_error);

if (succeeded) {
if (expected_error == ::firebase::auth::kAuthErrorNone) {
const firebase::auth::User* future_result_user = future.result();
const firebase::auth::User auth_user = auth_->current_user();
EXPECT_TRUE(auth_user.is_valid());
EXPECT_TRUE(future_result_user->is_valid());
EXPECT_EQ(future_result_user->uid(), auth_user.uid())
 << "User returned by Future doesn't match User in Auth";
return auth_user.is_valid() &&
 (auth_user.uid() == future_result_user->uid());
 }
 }
return succeeded;
}

boolFirebaseAuthTest::WaitForCompletion(
 firebase::Future<firebase::auth::AuthResult> future, constchar* fn,
int expected_error) {
bool succeeded = FirebaseTest::WaitForCompletion(future, fn, expected_error);

if (succeeded) {
if (expected_error == ::firebase::auth::kAuthErrorNone) {
if (future.result() != nullptr) {
EXPECT_TRUE(future.result()->user.is_valid());
EXPECT_TRUE(auth_->current_user().is_valid());
EXPECT_EQ(future.result()->user.uid(), auth_->current_user().uid())
 << "User returned by Future doesn't match User in Auth";
// Expect no crash.
// TODO(b/281590792): Properly validate AuthResult fields case-by-case.
 (void)future.result()->credential.is_valid();
 succeeded = future.result()->user.is_valid() &&
 auth_->current_user().is_valid();
 }
 }
 }
return succeeded;
}

boolFirebaseAuthTest::WaitForCompletion(
 firebase::Future<firebase::auth::AuthResult> future, constchar* fn,
const std::string& provider_id) {
bool succeeded = FirebaseTest::WaitForCompletion(future, fn);
if (succeeded) {
const firebase::auth::AuthResult* result_ptr = future.result();
EXPECT_TRUE(result_ptr->user.is_valid());
EXPECT_EQ(result_ptr->additional_user_info.provider_id, provider_id);
EXPECT_EQ(result_ptr->user.uid(), auth_->current_user().uid());
EXPECT_TRUE(auth_->current_user().is_valid());
// Expect no crash.
// TODO(b/281590792): Properly validate AuthResult fields case-by-case.
 (void)result_ptr->credential.is_valid();
 }
return succeeded;
}

voidFirebaseAuthTest::SignOut() {
if (auth_ == nullptr) {
// Auth is not set up.
return;
 }
if (!auth_->current_user().is_valid()) {
// Already signed out.
return;
 }
 auth_->SignOut();
// Wait for the sign-out to finish.
while (auth_->current_user().is_valid()) {
if (ProcessEvents(100)) break;
 }
ProcessEvents(100);
EXPECT_FALSE(auth_->current_user().is_valid());
}

voidFirebaseAuthTest::DeleteUser() {
if (auth_ != nullptr && auth_->current_user().is_valid()) {
FirebaseTest::WaitForCompletion(auth_->current_user().Delete(),
"Delete User");
ProcessEvents(100);
 }
}

TEST_F(FirebaseAuthTest, TestInitialization) {
// Initialized in SetUp and terminated in TearDown.
EXPECT_NE(app_, nullptr);
EXPECT_NE(auth_, nullptr);
}

TEST_F(FirebaseAuthTest, TestAnonymousSignin) {
// Test notification on SignIn().

SignInAnonymously();
EXPECT_TRUE(auth_->current_user().is_valid());
EXPECT_TRUE(auth_->current_user().is_anonymous());
DeleteUser();
}

// TODO(jonsimantov): Add TestDeleteUser.

TEST_F(FirebaseAuthTest, TestCredentialCopy) {
// --- Credential copy tests -------------------------------------------------
 {
 firebase::auth::Credential email_cred =
firebase::auth::EmailAuthProvider::GetCredential(kCustomTestEmail,
kTestPassword);
 firebase::auth::Credential facebook_cred =
firebase::auth::FacebookAuthProvider::GetCredential(
kTestAccessTokenBad);

 std::string email_provider = email_cred.provider();
 std::string facebook_provider = facebook_cred.provider();

// Test copy constructor.
 firebase::auth::Credential cred_copy(email_cred);
EXPECT_EQ(cred_copy.provider(), email_provider);
// Test assignment operator.
 cred_copy = facebook_cred;
EXPECT_EQ(cred_copy.provider(), facebook_provider);
 }
}

classTestAuthStateListener : publicfirebase::auth::AuthStateListener {
public:
virtualvoidOnAuthStateChanged(firebase::auth::Auth* auth) { // NOLINT
// Log the provider ID.
 std::string provider;
if (auth->current_user().is_valid()) {
 provider = auth->current_user().provider_id();
 }
LogDebug("OnAuthStateChanged called, provider=%s", provider.c_str());
if (auth_states_.empty() || auth_states_.back() != provider) {
// Only log unique events.
 auth_states_.push_back(provider);
 }
 }
const std::vector<std::string>& auth_states() { return auth_states_; }

private:
 std::vector<std::string> auth_states_;
};

classTestIdTokenListener : publicfirebase::auth::IdTokenListener {
public:
virtualvoidOnIdTokenChanged(firebase::auth::Auth* auth) { // NOLINT
// Log the auth token (if available).
 std::string token = "";
if (auth->current_user().is_valid()) {
 firebase::Future<std::string> token_future =
 auth->current_user().GetToken(false);
if (token_future.status() == firebase::kFutureStatusComplete) {
if (token_future.error() == 0) {
 token = *token_future.result();
 }
 } else {
 token = "[in progress]";
 }
 }
LogDebug("OnIdTokenChanged called, token=%s", token.c_str());
if (token_states_.empty() || !token.empty() ||
 token_states_.back() != token) {
// Only log unique empty events.
 token_states_.push_back(token);
 }
 }

const std::vector<std::string>& token_states() { return token_states_; }

private:
 std::vector<std::string> token_states_;
};

using testing::AnyOf;
using testing::ElementsAre;
using testing::Not;
using testing::StrCaseEq;

TEST_F(FirebaseAuthTest, TestTokensAndAuthStateListeners) {
 TestAuthStateListener listener;
 TestIdTokenListener token_listener;
 auth_->AddAuthStateListener(&listener);
 auth_->AddIdTokenListener(&token_listener);
SignInAnonymously();
// Get an initial token.
 firebase::Future<std::string> token_future =
 auth_->current_user().GetToken(false);
WaitForCompletion(token_future, "GetToken(false)");
 std::string first_token = *token_future.result();
// Force a token refresh.
ProcessEvents(1000);
 token_future = auth_->current_user().GetToken(true);
WaitForCompletion(token_future, "GetToken(true)");
EXPECT_NE(*token_future.result(), "");
 std::string second_token = *token_future.result();
EXPECT_NE(first_token, second_token);

DeleteUser();
SignOut();
 auth_->RemoveAuthStateListener(&listener);
 auth_->RemoveIdTokenListener(&token_listener);
// Providers should be blank, then Firebase, then blank.
EXPECT_THAT(listener.auth_states(),
ElementsAre("", StrCaseEq("Firebase"), ""));
// We should have blank, then two (or sometimes three) tokens, then blank.
EXPECT_THAT(token_listener.token_states(),
AnyOf(ElementsAre("", Not(""), Not(""), ""),
ElementsAre("", Not(""), Not(""), Not(""), "")));
}

static std::string GenerateEmailAddress() {
char time_string[22];
snprintf(time_string, sizeof(time_string), "%lld",
app_framework::GetCurrentTimeInMicroseconds());
 std::string email = "random_user_";
 email.append(time_string);
 email.append("@gmail.com");
LogDebug("Generated email address: %s", email.c_str());
return email;
}

TEST_F(FirebaseAuthTest, TestEmailAndPasswordSignin) {
 std::string email = GenerateEmailAddress();
// Register a random email and password. This signs us in as that user.
 std::string password = kTestPassword;
 firebase::Future<firebase::auth::AuthResult> auth_result_future =
 auth_->CreateUserWithEmailAndPassword(email.c_str(), password.c_str());
WaitForCompletion(auth_result_future, "CreateUserWithEmailAndPassword");

EXPECT_TRUE(auth_->current_user().is_valid());
if (auth_result_future.result() != nullptr) {
EXPECT_TRUE(auth_result_future.result()->user.is_valid());
 }
// Sign out and log in using SignInWithCredential(EmailCredential).
SignOut();
 {
 firebase::auth::Credential email_credential =
firebase::auth::EmailAuthProvider::GetCredential(email.c_str(),
 password.c_str());
 firebase::Future<firebase::auth::User> user_future =
 auth_->SignInWithCredential(email_credential);
WaitForCompletion(user_future, "SignInWithCredential");
EXPECT_TRUE(auth_->current_user().is_valid());
if (user_future.result() != nullptr) {
EXPECT_TRUE(user_future.result()->is_valid());
EXPECT_EQ(user_future.result()->email(), email);
 }
 }
// Sign out and log in using
// SignInAndRetrieveDataWithCredential(EmailCredential).
SignOut();
 {
 firebase::auth::Credential email_credential =
firebase::auth::EmailAuthProvider::GetCredential(email.c_str(),
 password.c_str());
WaitForCompletion(
 auth_->SignInAndRetrieveDataWithCredential(email_credential),
"SignAndRetrieveDataInWithCredential");
EXPECT_TRUE(auth_->current_user().is_valid());
 }
SignOut();
// Sign in with SignInWithEmailAndPassword values.
 auth_result_future =
 auth_->SignInWithEmailAndPassword(email.c_str(), password.c_str());
WaitForCompletion(auth_result_future, "SignInWithEmailAndPassword");
EXPECT_TRUE(auth_->current_user().is_valid());
if (auth_result_future.result() != nullptr) {
EXPECT_TRUE(auth_result_future.result()->user.is_valid());
EXPECT_EQ(auth_result_future.result()->user.uid(),
 auth_->current_user().uid());
EXPECT_EQ(auth_result_future.result()->user.email(), email);
 }

// Then delete the account.
 firebase::Future<void> delete_user = auth_->current_user().Delete();
WaitForCompletion(delete_user, "Delete");
EXPECT_FALSE(auth_->current_user().is_valid());
 auth_result_future =
 auth_->SignInWithEmailAndPassword(email.c_str(), password.c_str());
WaitForCompletion(auth_result_future,
"SignInWithEmailAndPassword (invalid user)",
 firebase::auth::kAuthErrorUserNotFound);
EXPECT_FALSE(auth_->current_user().is_valid());
}

TEST_F(FirebaseAuthTest, TestCopyUser) {
SignInAnonymously();
EXPECT_TRUE(auth_->current_user().is_valid());
if (!auth_->current_user().is_valid()) return;

EXPECT_TRUE(auth_->current_user().is_anonymous());
EXPECT_NE(auth_->current_user().uid().size(), 0);

// Copy Constructor
 firebase::auth::User copy_of_user(auth_->current_user());
EXPECT_TRUE(copy_of_user.is_valid());
EXPECT_TRUE(copy_of_user.is_anonymous());
EXPECT_EQ(auth_->current_user().uid(), copy_of_user.uid());

// Assignment operator
 firebase::auth::User assigned_user = copy_of_user;
EXPECT_TRUE(assigned_user.is_valid());
EXPECT_TRUE(assigned_user.is_anonymous());
EXPECT_EQ(auth_->current_user().uid(), assigned_user.uid());

DeleteUser();

EXPECT_FALSE(copy_of_user.is_valid());
EXPECT_FALSE(assigned_user.is_valid());
EXPECT_EQ(copy_of_user.uid(), "");
EXPECT_EQ(assigned_user.uid(), "");
}

TEST_F(FirebaseAuthTest, TestRetainedUser) {
 std::string email = GenerateEmailAddress();
// Register a random email and password. This signs us in as that user.
 std::string password = kTestPassword;
 firebase::Future<firebase::auth::AuthResult> auth_result_future =
 auth_->CreateUserWithEmailAndPassword(email.c_str(), password.c_str());
WaitForCompletion(auth_result_future, "CreateUserWithEmailAndPassword");
EXPECT_TRUE(auth_->current_user().is_valid());
if (!auth_->current_user().is_valid()) return;

 firebase::auth::User retained_user = auth_->current_user();

DeleteUser();

EXPECT_EQ(retained_user.uid(), "");
EXPECT_EQ(retained_user.email(), "");

// Sign in a new account.
 email = GenerateEmailAddress();
 auth_result_future =
 auth_->CreateUserWithEmailAndPassword(email.c_str(), password.c_str());
WaitForCompletion(auth_result_future, "CreateUserWithEmailAndPassword");
EXPECT_TRUE(auth_->current_user().is_valid());

EXPECT_NE(retained_user.uid(), "");
EXPECT_NE(retained_user.email(), "");
EXPECT_EQ(retained_user.uid(), auth_->current_user().uid());
EXPECT_EQ(retained_user.email(), auth_->current_user().email());

// Then delete the retained user.
 firebase::Future<void> delete_user = retained_user.Delete();
WaitForCompletion(delete_user, "Delete retained user");

EXPECT_FALSE(auth_->current_user().is_valid());
EXPECT_FALSE(retained_user.is_valid());
}

TEST_F(FirebaseAuthTest, TestOperationsOnInvalidUser) {
EXPECT_FALSE(auth_->current_user().is_valid());

 firebase::auth::User invalid_user = auth_->current_user();
 firebase::Future<firebase::auth::AuthResult> auth_result_future;
 firebase::Future<std::string> string_future;
 firebase::Future<firebase::auth::User> user_future;
 firebase::Future<firebase::auth::User*> user_ptr_future;
 firebase::Future<void> void_future;

LogDebug("Attempting to use invalid user.");
 string_future = invalid_user.GetToken(/*force_refresh=*/true);
WaitForCompletionOrInvalidStatus(string_future, "GetToken");
EXPECT_NE(string_future.error(), firebase::auth::kAuthErrorNone);

LogDebug("Update Email");
 void_future = invalid_user.UpdateEmail(GenerateEmailAddress().c_str());
WaitForCompletionOrInvalidStatus(void_future, "UpdateEmail");
EXPECT_NE(void_future.error(), firebase::auth::kAuthErrorNone);

LogDebug("Update Password");
 void_future = invalid_user.UpdatePassword(kTestPassword);
WaitForCompletionOrInvalidStatus(void_future, "UpdatePassword");
EXPECT_NE(void_future.error(), firebase::auth::kAuthErrorNone);

 firebase::auth::Credential email_cred =
firebase::auth::EmailAuthProvider::GetCredential(
GenerateEmailAddress().c_str(), kTestPasswordUpdated);
LogDebug("Reauthenticate");
 void_future = invalid_user.Reauthenticate(email_cred);
WaitForCompletionOrInvalidStatus(void_future, "Reauthenticate");
EXPECT_NE(void_future.error(), firebase::auth::kAuthErrorNone);

LogDebug("ReauthenticateAndRetrieveData");
 auth_result_future = invalid_user.ReauthenticateAndRetrieveData(email_cred);
WaitForCompletionOrInvalidStatus(auth_result_future,
"ReauthenticateAndRetrieveData");
EXPECT_NE(auth_result_future.error(), firebase::auth::kAuthErrorNone);

LogDebug("SendEmailVerification");
 void_future = invalid_user.SendEmailVerification();
WaitForCompletionOrInvalidStatus(void_future, "SendEmailVerification");
EXPECT_NE(void_future.error(), firebase::auth::kAuthErrorNone);

LogDebug("SendEmailVerificationBeforeUpdatingEmail");
 void_future = invalid_user.SendEmailVerificationBeforeUpdatingEmail(
GenerateEmailAddress().c_str());
WaitForCompletionOrInvalidStatus(void_future,
"SendEmailVerificationBeforeUpdatingEmail");
EXPECT_NE(void_future.error(), firebase::auth::kAuthErrorNone);

LogDebug("UpdateUserProfile");
 firebase::auth::User::UserProfile profile;
 void_future = invalid_user.UpdateUserProfile(profile);
WaitForCompletionOrInvalidStatus(void_future, "UpdateUserProfile");
EXPECT_NE(void_future.error(), firebase::auth::kAuthErrorNone);

LogDebug("LinkWithCredential");
 auth_result_future = invalid_user.LinkWithCredential(email_cred);
WaitForCompletionOrInvalidStatus(auth_result_future, "LinkWithCredential");
EXPECT_NE(auth_result_future.error(), firebase::auth::kAuthErrorNone);

LogDebug("Unlink");
 auth_result_future = invalid_user.Unlink(email_cred.provider().c_str());
WaitForCompletionOrInvalidStatus(auth_result_future, "Unlink");
EXPECT_NE(user_ptr_future.error(), firebase::auth::kAuthErrorNone);

LogDebug("Reload");
 void_future = invalid_user.Reload();
WaitForCompletionOrInvalidStatus(void_future, "Reload");
EXPECT_NE(void_future.error(), firebase::auth::kAuthErrorNone);

LogDebug("Delete");
 void_future = invalid_user.Delete();
WaitForCompletionOrInvalidStatus(void_future, "Delete");
EXPECT_NE(void_future.error(), firebase::auth::kAuthErrorNone);
}

TEST_F(FirebaseAuthTest, TestUpdateUserProfile) {
 std::string email = GenerateEmailAddress();
 firebase::Future<firebase::auth::AuthResult> create_user =
 auth_->CreateUserWithEmailAndPassword(email.c_str(), kTestPassword);
WaitForCompletion(create_user, "CreateUserWithEmailAndPassword");
EXPECT_TRUE(auth_->current_user().is_valid());

// Set some user profile properties.
 firebase::auth::User user = create_user.result()->user;
constcharkDisplayName[] = "Hello World";
constcharkPhotoUrl[] = "http://example.com/image.jpg";
 firebase::auth::User::UserProfile user_profile;
 user_profile.display_name = kDisplayName;
 user_profile.photo_url = kPhotoUrl;
 firebase::Future<void> update_profile = user.UpdateUserProfile(user_profile);
WaitForCompletion(update_profile, "UpdateUserProfile");
 user = auth_->current_user();
EXPECT_EQ(user.display_name(), kDisplayName);
EXPECT_EQ(user.photo_url(), kPhotoUrl);

// Validate that the new properties are present after signing out and in.
SignOut();
WaitForCompletion(
 auth_->SignInWithEmailAndPassword(email.c_str(), kTestPassword),
"SignInWithEmailAndPassword");
 user = auth_->current_user();
EXPECT_EQ(user.display_name(), kDisplayName);
EXPECT_EQ(user.photo_url(), kPhotoUrl);
DeleteUser();
}

TEST_F(FirebaseAuthTest, TestUpdateUserProfileNull) {
 std::string email = GenerateEmailAddress();
 firebase::Future<firebase::auth::AuthResult> create_user =
 auth_->CreateUserWithEmailAndPassword(email.c_str(), kTestPassword);
WaitForCompletion(create_user, "CreateUserWithEmailAndPassword");
EXPECT_TRUE(auth_->current_user().is_valid());

// Set some user profile properties.
 firebase::auth::User user = create_user.result()->user;
constcharkDisplayName[] = "Hello World";
constcharkPhotoUrl[] = "http://example.com/image.jpg";
 firebase::auth::User::UserProfile user_profile;
 user_profile.display_name = kDisplayName;
 user_profile.photo_url = kPhotoUrl;
 firebase::Future<void> update_profile = user.UpdateUserProfile(user_profile);
WaitForCompletion(update_profile, "UpdateUserProfile");
 user = auth_->current_user();
EXPECT_EQ(user.display_name(), kDisplayName);
EXPECT_EQ(user.photo_url(), kPhotoUrl);

// Setting the entries to null should leave the old values
 firebase::auth::User::UserProfile user_profile_null;
 user_profile_null.display_name = nullptr;
 user_profile_null.photo_url = nullptr;
 firebase::Future<void> update_profile_null =
 user.UpdateUserProfile(user_profile_null);
WaitForCompletion(update_profile_null, "UpdateUserProfileNull");
 user = auth_->current_user();
EXPECT_EQ(user.display_name(), kDisplayName);
EXPECT_EQ(user.photo_url(), kPhotoUrl);

// Validate that the new properties are present after signing out and in.
SignOut();
WaitForCompletion(
 auth_->SignInWithEmailAndPassword(email.c_str(), kTestPassword),
"SignInWithEmailAndPassword");
 user = auth_->current_user();
EXPECT_EQ(user.display_name(), kDisplayName);
EXPECT_EQ(user.photo_url(), kPhotoUrl);
DeleteUser();
}

TEST_F(FirebaseAuthTest, TestUpdateUserProfileEmpty) {
 std::string email = GenerateEmailAddress();
 firebase::Future<firebase::auth::AuthResult> create_user =
 auth_->CreateUserWithEmailAndPassword(email.c_str(), kTestPassword);
WaitForCompletion(create_user, "CreateUserWithEmailAndPassword");
EXPECT_TRUE(auth_->current_user().is_valid());

// Set some user profile properties.
 firebase::auth::User user = create_user.result()->user;
constcharkDisplayName[] = "Hello World";
constcharkPhotoUrl[] = "http://example.com/image.jpg";
 firebase::auth::User::UserProfile user_profile;
 user_profile.display_name = kDisplayName;
 user_profile.photo_url = kPhotoUrl;
 firebase::Future<void> update_profile = user.UpdateUserProfile(user_profile);
WaitForCompletion(update_profile, "UpdateUserProfile");
 user = auth_->current_user();
EXPECT_EQ(user.display_name(), kDisplayName);
EXPECT_EQ(user.photo_url(), kPhotoUrl);

// Setting the fields to empty should clear it.
 firebase::auth::User::UserProfile user_profile_empty;
 user_profile_empty.display_name = "";
 user_profile_empty.photo_url = "";
 firebase::Future<void> update_profile_empty =
 user.UpdateUserProfile(user_profile_empty);
WaitForCompletion(update_profile_empty, "UpdateUserProfileEmpty");
 user = auth_->current_user();
EXPECT_EQ(user.display_name(), "");
EXPECT_EQ(user.photo_url(), "");

// Validate that the properties are cleared out after signing out and in.
SignOut();
WaitForCompletion(
 auth_->SignInWithEmailAndPassword(email.c_str(), kTestPassword),
"SignInWithEmailAndPassword");
 user = auth_->current_user();
EXPECT_EQ(user.display_name(), "");
EXPECT_EQ(user.photo_url(), "");
DeleteUser();
}

TEST_F(FirebaseAuthTest, TestUpdateEmailAndPassword) {
 std::string email = GenerateEmailAddress();
WaitForCompletion(
 auth_->CreateUserWithEmailAndPassword(email.c_str(), kTestPassword),
"CreateUserWithEmailAndPassword");
 firebase::auth::User user = auth_->current_user();
EXPECT_TRUE(user.is_valid());

// Update the user's email and password.
const std::string new_email = "new_" + email;
WaitForCompletion(user.UpdateEmail(new_email.c_str()), "UpdateEmail");
WaitForCompletion(user.UpdatePassword(kTestPasswordUpdated),
"UpdatePassword");

 firebase::auth::Credential new_email_cred =
firebase::auth::EmailAuthProvider::GetCredential(new_email.c_str(),
kTestPasswordUpdated);
WaitForCompletion(user.Reauthenticate(new_email_cred), "Reauthenticate");
EXPECT_TRUE(user.is_valid());

WaitForCompletion(user.SendEmailVerification(), "SendEmailVerification");
DeleteUser();
}

TEST_F(FirebaseAuthTest, TestVerifyBeforeUpdatingEmail) {
 std::string email = GenerateEmailAddress();
WaitForCompletion(
 auth_->CreateUserWithEmailAndPassword(email.c_str(), kTestPassword),
"CreateUserWithEmailAndPassword");
 firebase::auth::User user = auth_->current_user();
EXPECT_TRUE(user.is_valid());

// Update the user's email and password.
const std::string new_email = "new_" + email;
WaitForCompletion(
 user.SendEmailVerificationBeforeUpdatingEmail(new_email.c_str()),
"SendEmailVerificationBeforeUpdatingEmail");
EXPECT_TRUE(user.is_valid());
DeleteUser();
}

TEST_F(FirebaseAuthTest, TestLinkAnonymousUserWithEmailCredential) {
FLAKY_TEST_SECTION_BEGIN();

WaitForCompletion(auth_->SignInAnonymously(), "SignInAnonymously");

 firebase::auth::User user = auth_->current_user();
EXPECT_TRUE(user.is_valid());
 std::string email = GenerateEmailAddress();
 firebase::auth::Credential credential =
firebase::auth::EmailAuthProvider::GetCredential(email.c_str(),
kTestPassword);
WaitForCompletion(user.LinkWithCredential(credential), "LinkWithCredential");
WaitForCompletion(user.Unlink(credential.provider().c_str()), "Unlink");
SignOut();
WaitForCompletion(auth_->SignInAnonymously(), "SignInAnonymously");
 user = auth_->current_user();
EXPECT_TRUE(user.is_valid());
 std::string email1 = GenerateEmailAddress();
 firebase::auth::Credential credential1 =
firebase::auth::EmailAuthProvider::GetCredential(email1.c_str(),
kTestPassword);
WaitForCompletion(user.LinkWithCredential(credential1),
"LinkWithCredential 1");
 user = auth_->current_user();
EXPECT_TRUE(user.is_valid());

 std::string email2 = GenerateEmailAddress();
 firebase::auth::Credential credential2 =
firebase::auth::EmailAuthProvider::GetCredential(email2.c_str(),
kTestPassword);
WaitForCompletion(user.LinkWithCredential(credential2),
"LinkWithCredential 2",
 firebase::auth::kAuthErrorProviderAlreadyLinked);
WaitForCompletion(user.Unlink(credential.provider().c_str()), "Unlink 2");
DeleteUser();

// In case any operations failed, force signout before retrying the test.
SignOut();
FLAKY_TEST_SECTION_END();
}

TEST_F(FirebaseAuthTest, TestLinkAnonymousUserWithBadCredential) {
SignInAnonymously();
 firebase::auth::User pre_link_user = auth_->current_user();
EXPECT_TRUE(pre_link_user.is_valid());
 firebase::auth::Credential twitter_cred =
firebase::auth::TwitterAuthProvider::GetCredential(kTestIdTokenBad,
kTestAccessTokenBad);
WaitForCompletion(pre_link_user.LinkWithCredential(twitter_cred),
"LinkWithCredential",
 firebase::auth::kAuthErrorInvalidCredential);
// Ensure that user stays the same.
EXPECT_TRUE(pre_link_user.is_valid());
EXPECT_TRUE(auth_->current_user().is_valid());
EXPECT_EQ(auth_->current_user().uid(), pre_link_user.uid());
DeleteUser();
}

TEST_F(FirebaseAuthTest, TestSignInWithBadEmailFails) {
WaitForCompletion(
 auth_->SignInWithEmailAndPassword(kTestEmailBad, kTestPassword),
"SignInWithEmailAndPassword", firebase::auth::kAuthErrorUserNotFound);
EXPECT_FALSE(auth_->current_user().is_valid());
}

TEST_F(FirebaseAuthTest, TestSignInWithBadPasswordFails) {
 std::string email = GenerateEmailAddress();
WaitForCompletion(
 auth_->CreateUserWithEmailAndPassword(email.c_str(), kTestPassword),
"CreateUserWithEmailAndPassword");
EXPECT_TRUE(auth_->current_user().is_valid());
SignOut();
WaitForCompletion(
 auth_->SignInWithEmailAndPassword(email.c_str(), kTestPasswordBad),
"SignInWithEmailAndPassword", firebase::auth::kAuthErrorWrongPassword);
EXPECT_FALSE(auth_->current_user().is_valid());
SignOut();
// Sign back in and delete the user.
WaitForCompletion(
 auth_->SignInWithEmailAndPassword(email.c_str(), kTestPassword),
"SignInWithEmailAndPassword");
EXPECT_TRUE(auth_->current_user().is_valid());
DeleteUser();
}

TEST_F(FirebaseAuthTest, TestCreateUserWithExistingEmailFails) {
 std::string email = GenerateEmailAddress();
WaitForCompletion(
 auth_->CreateUserWithEmailAndPassword(email.c_str(), kTestPassword),
"CreateUserWithEmailAndPassword 1");
EXPECT_TRUE(auth_->current_user().is_valid());
SignOut();
WaitForCompletion(
 auth_->CreateUserWithEmailAndPassword(email.c_str(), kTestPassword),
"CreateUserWithEmailAndPassword 2",
 firebase::auth::kAuthErrorEmailAlreadyInUse);
EXPECT_FALSE(auth_->current_user().is_valid());
SignOut();
// Try again with a different password.
WaitForCompletion(
 auth_->CreateUserWithEmailAndPassword(email.c_str(), kTestPasswordBad),
"CreateUserWithEmailAndPassword 3",
 firebase::auth::kAuthErrorEmailAlreadyInUse);
EXPECT_FALSE(auth_->current_user().is_valid());
SignOut();
WaitForCompletion(
 auth_->SignInWithEmailAndPassword(email.c_str(), kTestPassword),
"SignInWithEmailAndPassword");
EXPECT_TRUE(auth_->current_user().is_valid());
DeleteUser();
}

TEST_F(FirebaseAuthTest, TestSignInWithBadCredentials) {
// Get an anonymous user first.
SignInAnonymously();
EXPECT_TRUE(auth_->current_user().is_valid());
// Hold on to the existing user, to make sure it is unchanged by bad signins.
 firebase::auth::User existing_user = auth_->current_user();
// Test signing in with a variety of bad credentials.
WaitForCompletion(auth_->SignInWithCredential(
firebase::auth::FacebookAuthProvider::GetCredential(
kTestAccessTokenBad)),
"SignInWithCredential (Facebook)",
 firebase::auth::kAuthErrorInvalidCredential);
// Ensure that failing to sign in with a credential doesn't modify the user.
EXPECT_TRUE(auth_->current_user().is_valid());
EXPECT_TRUE(existing_user.is_valid());
EXPECT_EQ(auth_->current_user().uid(), existing_user.uid());
WaitForCompletion(auth_->SignInWithCredential(
firebase::auth::TwitterAuthProvider::GetCredential(
kTestIdTokenBad, kTestAccessTokenBad)),
"SignInWithCredential (Twitter)",
 firebase::auth::kAuthErrorInvalidCredential);
EXPECT_TRUE(auth_->current_user().is_valid());
EXPECT_TRUE(existing_user.is_valid());
EXPECT_EQ(auth_->current_user().uid(), existing_user.uid());
WaitForCompletion(auth_->SignInWithCredential(
firebase::auth::GitHubAuthProvider::GetCredential(
kTestAccessTokenBad)),
"SignInWithCredential (GitHub)",
 firebase::auth::kAuthErrorInvalidCredential);
EXPECT_TRUE(auth_->current_user().is_valid());
EXPECT_TRUE(existing_user.is_valid());
EXPECT_EQ(auth_->current_user().uid(), existing_user.uid());
WaitForCompletion(auth_->SignInWithCredential(
firebase::auth::GoogleAuthProvider::GetCredential(
kTestIdTokenBad, kTestAccessTokenBad)),
"SignInWithCredential (Google 1)",
 firebase::auth::kAuthErrorInvalidCredential);
EXPECT_TRUE(auth_->current_user().is_valid());
EXPECT_TRUE(existing_user.is_valid());
EXPECT_EQ(auth_->current_user().uid(), existing_user.uid());
WaitForCompletion(auth_->SignInWithCredential(
firebase::auth::GoogleAuthProvider::GetCredential(
kTestIdTokenBad, nullptr)),
"SignInWithCredential (Google 2)",
 firebase::auth::kAuthErrorInvalidCredential);
EXPECT_TRUE(auth_->current_user().is_valid());
EXPECT_TRUE(existing_user.is_valid());
EXPECT_EQ(auth_->current_user().uid(), existing_user.uid());
WaitForCompletion(
 auth_->SignInWithCredential(firebase::auth::OAuthProvider::GetCredential(
kTestIdProviderIdBad, kTestIdTokenBad, kTestAccessTokenBad)),
"SignInWithCredential (OAuth)", firebase::auth::kAuthErrorFailure);
EXPECT_TRUE(auth_->current_user().is_valid());
EXPECT_TRUE(existing_user.is_valid());
EXPECT_EQ(auth_->current_user().uid(), existing_user.uid());

#if defined(__ANDROID__)
// Test Play Games sign-in on Android only.
WaitForCompletion(auth_->SignInWithCredential(
firebase::auth::PlayGamesAuthProvider::GetCredential(
kTestServerAuthCodeBad)),
"SignInWithCredential (Play Games)",
 firebase::auth::kAuthErrorInvalidCredential);
EXPECT_TRUE(auth_->current_user().is_valid());
EXPECT_TRUE(existing_user.is_valid());
EXPECT_EQ(auth_->current_user().uid(), existing_user.uid());
#endif// defined(__ANDROID__)
DeleteUser();
}

#if TARGET_OS_IPHONE
TEST_F(FirebaseAuthTest, TestGameCenterSignIn) {
// Test Game Center sign-in on iPhone only.
if (!firebase::auth::GameCenterAuthProvider::IsPlayerAuthenticated()) {
LogInfo("Not signed into Game Center, skipping test.");
GTEST_SKIP();
return;
 }
LogDebug("Signed in, testing Game Center authentication.");
 firebase::Future<firebase::auth::Credential> credential_future =
firebase::auth::GameCenterAuthProvider::GetCredential();
FirebaseTest::WaitForCompletion(credential_future,
"GameCenterAuthProvider::GetCredential()");

EXPECT_NE(credential_future.result(), nullptr);
if (credential_future.result()) {
WaitForCompletion(auth_->SignInWithCredential(*credential_future.result()),