// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "google_apis/gcm/engine/gcm_store_impl.h"

#include <stdint.h>

#include <memory>
#include <string>
#include <utility>
#include <vector>

#include "base/command_line.h"
#include "base/containers/contains.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/functional/bind.h"
#include "base/memory/ptr_util.h"
#include "base/strings/string_number_conversions.h"
#include "base/test/task_environment.h"
#include "google_apis/gaia/gaia_id.h"
#include "google_apis/gcm/base/fake_encryptor.h"
#include "google_apis/gcm/base/gcm_constants.h"
#include "google_apis/gcm/base/mcs_message.h"
#include "google_apis/gcm/base/mcs_util.h"
#include "google_apis/gcm/protocol/mcs.pb.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace gcm {

namespace {

// Number of persistent ids to use in tests.
const int kNumPersistentIds = 10;

// Number of per-app messages in tests.
const int kNumMessagesPerApp = 20;

// App name for testing.
const char kAppName[] = "my_app";
const char kAppName2[] = "my_app_2";

// Category name for testing.
const char kCategoryName[] = "my_category";

const uint64_t kDeviceId = 22;
const uint64_t kDeviceToken = 55;

class GCMStoreImplTest : public testing::Test {
 public:
  GCMStoreImplTest();
  ~GCMStoreImplTest() override;

  void TearDown() override;

  std::unique_ptr<GCMStoreImpl> BuildGCMStore();
  void LoadGCMStore(GCMStoreImpl* gcm_store,
                    std::unique_ptr<GCMStore::LoadResult>* result_dst);

  std::string GetNextPersistentId();

  void PumpLoop();

  void LoadCallback(std::unique_ptr<GCMStore::LoadResult>* result_dst,
                    std::unique_ptr<GCMStore::LoadResult> result);
  void LoadWithoutCheckCallback(
      std::unique_ptr<GCMStore::LoadResult>* result_dst,
      std::unique_ptr<GCMStore::LoadResult> result);
  void UpdateCallback(bool success);

 protected:
  base::test::TaskEnvironment task_environment_;
  base::ScopedTempDir temp_directory_;
  base::FilePath store_path_;
  bool expected_success_;
  uint64_t next_persistent_id_;
};

GCMStoreImplTest::GCMStoreImplTest()
    : task_environment_(base::test::TaskEnvironment::TimeSource::MOCK_TIME,
                        base::test::TaskEnvironment::MainThreadType::IO),
      expected_success_(true),
      next_persistent_id_(base::Time::Now().ToInternalValue()) {
  EXPECT_TRUE(temp_directory_.CreateUniqueTempDir());
}

GCMStoreImplTest::~GCMStoreImplTest() {}

void GCMStoreImplTest::TearDown() {
  PumpLoop();
}

std::unique_ptr<GCMStoreImpl> GCMStoreImplTest::BuildGCMStore() {
  // Pass an non-existent directory as store path to match the exact behavior in
  // the production code. Currently GCMStoreImpl checks if the directory exists
  // and contains a CURRENT file to determine the store existence.
  store_path_ =
      temp_directory_.GetPath().Append(FILE_PATH_LITERAL("GCM Store"));
  return std::make_unique<GCMStoreImpl>(
      store_path_, task_environment_.GetMainThreadTaskRunner(),
      std::make_unique<FakeEncryptor>());
}

void GCMStoreImplTest::LoadGCMStore(
    GCMStoreImpl* gcm_store,
    std::unique_ptr<GCMStore::LoadResult>* result_dst) {
  gcm_store->Load(GCMStore::CREATE_IF_MISSING,
                  base::BindOnce(&GCMStoreImplTest::LoadCallback,
                                 base::Unretained(this), result_dst));
  PumpLoop();
}

std::string GCMStoreImplTest::GetNextPersistentId() {
  return base::NumberToString(next_persistent_id_++);
}

void GCMStoreImplTest::PumpLoop() {
  task_environment_.RunUntilIdle();
}

void GCMStoreImplTest::LoadCallback(
    std::unique_ptr<GCMStore::LoadResult>* result_dst,
    std::unique_ptr<GCMStore::LoadResult> result) {
  ASSERT_TRUE(result->success);
  LoadWithoutCheckCallback(result_dst, std::move(result));
}

void GCMStoreImplTest::LoadWithoutCheckCallback(
    std::unique_ptr<GCMStore::LoadResult>* result_dst,
    std::unique_ptr<GCMStore::LoadResult> result) {
  *result_dst = std::move(result);
}

void GCMStoreImplTest::UpdateCallback(bool success) {
  ASSERT_EQ(expected_success_, success);
}

// Verify creating a new database and loading it.
TEST_F(GCMStoreImplTest, LoadNew) {
  std::unique_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());
  std::unique_ptr<GCMStore::LoadResult> load_result;
  LoadGCMStore(gcm_store.get(), &load_result);

  EXPECT_EQ(0U, load_result->device_android_id);
  EXPECT_EQ(0U, load_result->device_security_token);
  EXPECT_TRUE(load_result->incoming_messages.empty());
  EXPECT_TRUE(load_result->outgoing_messages.empty());
  EXPECT_TRUE(load_result->gservices_settings.empty());
  EXPECT_EQ(base::Time::FromInternalValue(0LL), load_result->last_checkin_time);
}

// Verify new database is not created when DO_NOT_CREATE is passed.
TEST_F(GCMStoreImplTest, LoadWithoutCreatingNewStore) {
  std::unique_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());
  std::unique_ptr<GCMStore::LoadResult> load_result;
  gcm_store->Load(GCMStore::DO_NOT_CREATE,
                  base::BindOnce(&GCMStoreImplTest::LoadWithoutCheckCallback,
                                 base::Unretained(this), &load_result));
  PumpLoop();

  EXPECT_FALSE(load_result->success);
  EXPECT_TRUE(load_result->store_does_not_exist);
}

// Verifies that loads with DO_NOT_CREATE set store_does_not_exist to true when
// an empty directory was left behind after destroying the database.
TEST_F(GCMStoreImplTest, LoadWithEmptyDirectory) {
  std::unique_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());

  // Create an empty directory at the store path, to simulate an empty directory
  // being left behind after destroying a previous store.
  ASSERT_TRUE(base::CreateDirectory(store_path_));

  std::unique_ptr<GCMStore::LoadResult> load_result;
  gcm_store->Load(GCMStore::DO_NOT_CREATE,
                  base::BindOnce(&GCMStoreImplTest::LoadWithoutCheckCallback,
                                 base::Unretained(this), &load_result));
  PumpLoop();

  EXPECT_FALSE(load_result->success);
  EXPECT_TRUE(load_result->store_does_not_exist);
}

TEST_F(GCMStoreImplTest, DeviceCredentials) {
  std::unique_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());
  std::unique_ptr<GCMStore::LoadResult> load_result;
  LoadGCMStore(gcm_store.get(), &load_result);

  gcm_store->SetDeviceCredentials(
      kDeviceId, kDeviceToken,
      base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                     base::Unretained(this)));
  PumpLoop();

  gcm_store = BuildGCMStore();
  LoadGCMStore(gcm_store.get(), &load_result);

  ASSERT_EQ(kDeviceId, load_result->device_android_id);
  ASSERT_EQ(kDeviceToken, load_result->device_security_token);
}

TEST_F(GCMStoreImplTest, LastCheckinInfo) {
  std::unique_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());
  std::unique_ptr<GCMStore::LoadResult> load_result;
  LoadGCMStore(gcm_store.get(), &load_result);

  base::Time last_checkin_time = base::Time::Now();

  gcm_store->SetLastCheckinInfo(
      last_checkin_time, base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                                        base::Unretained(this)));
  PumpLoop();

  gcm_store = BuildGCMStore();
  LoadGCMStore(gcm_store.get(), &load_result);
  ASSERT_EQ(last_checkin_time, load_result->last_checkin_time);

  // Negative cases, where the value read is gibberish.
  gcm_store->SetValueForTesting(
      "last_checkin_time", "gibberish",
      base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                     base::Unretained(this)));
  PumpLoop();

  gcm_store = BuildGCMStore();
  LoadGCMStore(gcm_store.get(), &load_result);
  EXPECT_EQ(base::Time(), load_result->last_checkin_time);
}

TEST_F(GCMStoreImplTest, GServicesSettings_ProtocolV2) {
  std::unique_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());
  std::unique_ptr<GCMStore::LoadResult> load_result;
  LoadGCMStore(gcm_store.get(), &load_result);

  std::map<std::string, std::string> settings;
  settings["checkin_interval"] = "12345";
  settings["mcs_port"] = "438";
  settings["checkin_url"] = "http://checkin.google.com";
  std::string digest = "digest1";

  gcm_store->SetGServicesSettings(
      settings, digest,
      base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                     base::Unretained(this)));
  PumpLoop();

  gcm_store = BuildGCMStore();
  LoadGCMStore(gcm_store.get(), &load_result);

  ASSERT_EQ(settings, load_result->gservices_settings);
  ASSERT_EQ(digest, load_result->gservices_digest);

  // Remove some, and add some.
  settings.clear();
  settings["checkin_interval"] = "54321";
  settings["registration_url"] = "http://registration.google.com";
  digest = "digest2";

  gcm_store->SetGServicesSettings(
      settings, digest,
      base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                     base::Unretained(this)));
  PumpLoop();

  gcm_store = BuildGCMStore();
  LoadGCMStore(gcm_store.get(), &load_result);

  ASSERT_EQ(settings, load_result->gservices_settings);
  ASSERT_EQ(digest, load_result->gservices_digest);
}

TEST_F(GCMStoreImplTest, Registrations) {
  std::unique_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());
  std::unique_ptr<GCMStore::LoadResult> load_result;
  LoadGCMStore(gcm_store.get(), &load_result);

  // Add one registration with one sender.
  std::string registration = "sender1=registration1";
  gcm_store->AddRegistration(kAppName, registration,
                             base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                                            base::Unretained(this)));
  PumpLoop();

  // Add one registration with multiple senders.
  std::string registration2 = "sender1,sender2=registration2";
  gcm_store->AddRegistration(kAppName2, registration2,
                             base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                                            base::Unretained(this)));
  PumpLoop();

  gcm_store = BuildGCMStore();
  LoadGCMStore(gcm_store.get(), &load_result);

  ASSERT_EQ(2u, load_result->registrations.size());
  EXPECT_TRUE(base::Contains(load_result->registrations, kAppName));
  EXPECT_EQ(registration, load_result->registrations[kAppName]);
  EXPECT_TRUE(base::Contains(load_result->registrations, kAppName2));
  EXPECT_EQ(registration2, load_result->registrations[kAppName2]);

  gcm_store->RemoveRegistration(
      kAppName2, base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                                base::Unretained(this)));
  PumpLoop();

  gcm_store = BuildGCMStore();
  LoadGCMStore(gcm_store.get(), &load_result);

  ASSERT_EQ(1u, load_result->registrations.size());
  EXPECT_TRUE(base::Contains(load_result->registrations, kAppName));
  EXPECT_EQ(registration, load_result->registrations[kAppName]);
}

// Verify saving some incoming messages, reopening the directory, and then
// removing those incoming messages.
TEST_F(GCMStoreImplTest, IncomingMessages) {
  std::unique_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());
  std::unique_ptr<GCMStore::LoadResult> load_result;
  LoadGCMStore(gcm_store.get(), &load_result);

  std::vector<std::string> persistent_ids;
  for (int i = 0; i < kNumPersistentIds; ++i) {
    persistent_ids.push_back(GetNextPersistentId());
    gcm_store->AddIncomingMessage(
        persistent_ids.back(), base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                                              base::Unretained(this)));
    PumpLoop();
  }

  gcm_store = BuildGCMStore();
  LoadGCMStore(gcm_store.get(), &load_result);

  ASSERT_EQ(persistent_ids, load_result->incoming_messages);
  ASSERT_TRUE(load_result->outgoing_messages.empty());

  gcm_store->RemoveIncomingMessages(
      persistent_ids, base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                                     base::Unretained(this)));
  PumpLoop();

  gcm_store = BuildGCMStore();
  load_result->incoming_messages.clear();
  LoadGCMStore(gcm_store.get(), &load_result);

  ASSERT_TRUE(load_result->incoming_messages.empty());
  ASSERT_TRUE(load_result->outgoing_messages.empty());
}

// Verify saving some incoming messages, reopening the directory after half of
// the TTL and TTL, and then verify expired incoming messages got removed.
TEST_F(GCMStoreImplTest, IncomingMessages_WithTTL) {
  auto gcm_store = BuildGCMStore();
  std::unique_ptr<GCMStore::LoadResult> load_result;
  LoadGCMStore(gcm_store.get(), &load_result);

  std::vector<std::string> persistent_ids;
  for (int i = 0; i < kNumPersistentIds; ++i) {
    persistent_ids.push_back(GetNextPersistentId());
    gcm_store->AddIncomingMessage(
        persistent_ids.back(), base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                                              base::Unretained(this)));
    PumpLoop();
  }

  task_environment_.FastForwardBy(kIncomingMessageTTL / 2);

  gcm_store = BuildGCMStore();
  LoadGCMStore(gcm_store.get(), &load_result);

  EXPECT_EQ(persistent_ids, load_result->incoming_messages);
  EXPECT_TRUE(load_result->outgoing_messages.empty());

  task_environment_.FastForwardBy(kIncomingMessageTTL / 2);

  gcm_store = BuildGCMStore();
  load_result->incoming_messages.clear();
  LoadGCMStore(gcm_store.get(), &load_result);

  ASSERT_TRUE(load_result->incoming_messages.empty());
  ASSERT_TRUE(load_result->outgoing_messages.empty());
}

// Verify saving some outgoing messages, reopening the directory, and then
// removing those outgoing messages.
TEST_F(GCMStoreImplTest, OutgoingMessages) {
  std::unique_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());
  std::unique_ptr<GCMStore::LoadResult> load_result;
  LoadGCMStore(gcm_store.get(), &load_result);

  std::vector<std::string> persistent_ids;
  for (int i = 0; i < kNumPersistentIds; ++i) {
    persistent_ids.push_back(GetNextPersistentId());
    mcs_proto::DataMessageStanza message;
    message.set_from(kAppName + persistent_ids.back());
    message.set_category(kCategoryName + persistent_ids.back());
    gcm_store->AddOutgoingMessage(
        persistent_ids.back(), MCSMessage(message),
        base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                       base::Unretained(this)));
    PumpLoop();
  }

  gcm_store = BuildGCMStore();
  LoadGCMStore(gcm_store.get(), &load_result);

  ASSERT_TRUE(load_result->incoming_messages.empty());
  ASSERT_EQ(load_result->outgoing_messages.size(), persistent_ids.size());
  for (int i = 0; i < kNumPersistentIds; ++i) {
    std::string id = persistent_ids[i];
    ASSERT_TRUE(load_result->outgoing_messages[id].get());
    const mcs_proto::DataMessageStanza* message =
        reinterpret_cast<mcs_proto::DataMessageStanza*>(
            load_result->outgoing_messages[id].get());
    ASSERT_EQ(message->from(), kAppName + id);
    ASSERT_EQ(message->category(), kCategoryName + id);
  }

  gcm_store->RemoveOutgoingMessages(
      persistent_ids, base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                                     base::Unretained(this)));
  PumpLoop();

  gcm_store = BuildGCMStore();
  load_result->outgoing_messages.clear();
  LoadGCMStore(gcm_store.get(), &load_result);

  ASSERT_TRUE(load_result->incoming_messages.empty());
  ASSERT_TRUE(load_result->outgoing_messages.empty());
}

// Verify incoming and outgoing messages don't conflict.
TEST_F(GCMStoreImplTest, IncomingAndOutgoingMessages) {
  std::unique_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());
  std::unique_ptr<GCMStore::LoadResult> load_result;
  LoadGCMStore(gcm_store.get(), &load_result);

  std::vector<std::string> persistent_ids;
  for (int i = 0; i < kNumPersistentIds; ++i) {
    persistent_ids.push_back(GetNextPersistentId());
    gcm_store->AddIncomingMessage(
        persistent_ids.back(), base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                                              base::Unretained(this)));
    PumpLoop();

    mcs_proto::DataMessageStanza message;
    message.set_from(kAppName + persistent_ids.back());
    message.set_category(kCategoryName + persistent_ids.back());
    gcm_store->AddOutgoingMessage(
        persistent_ids.back(), MCSMessage(message),
        base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                       base::Unretained(this)));
    PumpLoop();
  }

  gcm_store = BuildGCMStore();
  LoadGCMStore(gcm_store.get(), &load_result);

  ASSERT_EQ(persistent_ids, load_result->incoming_messages);
  ASSERT_EQ(load_result->outgoing_messages.size(), persistent_ids.size());
  for (int i = 0; i < kNumPersistentIds; ++i) {
    std::string id = persistent_ids[i];
    ASSERT_TRUE(load_result->outgoing_messages[id].get());
    const mcs_proto::DataMessageStanza* message =
        reinterpret_cast<mcs_proto::DataMessageStanza*>(
            load_result->outgoing_messages[id].get());
    ASSERT_EQ(message->from(), kAppName + id);
    ASSERT_EQ(message->category(), kCategoryName + id);
  }

  gcm_store->RemoveIncomingMessages(
      persistent_ids, base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                                     base::Unretained(this)));
  PumpLoop();
  gcm_store->RemoveOutgoingMessages(
      persistent_ids, base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                                     base::Unretained(this)));
  PumpLoop();

  gcm_store = BuildGCMStore();
  load_result->incoming_messages.clear();
  load_result->outgoing_messages.clear();
  LoadGCMStore(gcm_store.get(), &load_result);

  ASSERT_TRUE(load_result->incoming_messages.empty());
  ASSERT_TRUE(load_result->outgoing_messages.empty());
}

// Test that per-app message limits are enforced, persisted across restarts,
// and updated as messages are removed.
TEST_F(GCMStoreImplTest, PerAppMessageLimits) {
  std::unique_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());
  std::unique_ptr<GCMStore::LoadResult> load_result;
  LoadGCMStore(gcm_store.get(), &load_result);

  // Add the initial (below app limit) messages.
  for (int i = 0; i < kNumMessagesPerApp; ++i) {
    mcs_proto::DataMessageStanza message;
    message.set_from(kAppName);
    message.set_category(kCategoryName);
    EXPECT_TRUE(gcm_store->AddOutgoingMessage(
        base::NumberToString(i), MCSMessage(message),
        base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                       base::Unretained(this))));
    PumpLoop();
  }

  // Attempting to add some more should fail.
  for (int i = 0; i < kNumMessagesPerApp; ++i) {
    mcs_proto::DataMessageStanza message;
    message.set_from(kAppName);
    message.set_category(kCategoryName);
    EXPECT_FALSE(gcm_store->AddOutgoingMessage(
        base::NumberToString(i + kNumMessagesPerApp), MCSMessage(message),
        base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                       base::Unretained(this))));
    PumpLoop();
  }

  // Tear down and restore the database.
  gcm_store = BuildGCMStore();
  LoadGCMStore(gcm_store.get(), &load_result);

  // Adding more messages should still fail.
  for (int i = 0; i < kNumMessagesPerApp; ++i) {
    mcs_proto::DataMessageStanza message;
    message.set_from(kAppName);
    message.set_category(kCategoryName);
    EXPECT_FALSE(gcm_store->AddOutgoingMessage(
        base::NumberToString(i + kNumMessagesPerApp), MCSMessage(message),
        base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                       base::Unretained(this))));
    PumpLoop();
  }

  // Remove the existing messages.
  for (int i = 0; i < kNumMessagesPerApp; ++i) {
    gcm_store->RemoveOutgoingMessage(
        base::NumberToString(i),
        base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                       base::Unretained(this)));
    PumpLoop();
  }

  // Successfully add new messages.
  for (int i = 0; i < kNumMessagesPerApp; ++i) {
    mcs_proto::DataMessageStanza message;
    message.set_from(kAppName);
    message.set_category(kCategoryName);
    EXPECT_TRUE(gcm_store->AddOutgoingMessage(
        base::NumberToString(i + kNumMessagesPerApp), MCSMessage(message),
        base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                       base::Unretained(this))));
    PumpLoop();
  }
}

TEST_F(GCMStoreImplTest, AccountMapping) {
  std::unique_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());
  std::unique_ptr<GCMStore::LoadResult> load_result;
  LoadGCMStore(gcm_store.get(), &load_result);

  // Add account mappings.
  AccountMapping account_mapping1;
  account_mapping1.account_id =
      CoreAccountId::FromGaiaId(GaiaId("account_id_1"));
  account_mapping1.email = "account_id_1@gmail.com";
  account_mapping1.access_token = "account_token1";
  account_mapping1.status = AccountMapping::ADDING;
  account_mapping1.status_change_timestamp = base::Time();
  account_mapping1.last_message_id = "message_1";

  AccountMapping account_mapping2;
  account_mapping2.account_id =
      CoreAccountId::FromGaiaId(GaiaId("account_id_2"));
  account_mapping2.email = "account_id_2@gmail.com";
  account_mapping2.access_token = "account_token1";
  account_mapping2.status = AccountMapping::REMOVING;
  account_mapping2.status_change_timestamp =
      base::Time::FromInternalValue(1305734521259935LL);
  account_mapping2.last_message_id = "message_2";

  gcm_store->AddAccountMapping(account_mapping1,
                               base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                                              base::Unretained(this)));
  PumpLoop();
  gcm_store->AddAccountMapping(account_mapping2,
                               base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                                              base::Unretained(this)));
  PumpLoop();

  gcm_store = BuildGCMStore();
  LoadGCMStore(gcm_store.get(), &load_result);

  EXPECT_EQ(2UL, load_result->account_mappings.size());
  GCMStore::AccountMappings::iterator iter =
      load_result->account_mappings.begin();
  EXPECT_EQ(account_mapping1.account_id, iter->account_id);
  EXPECT_EQ(account_mapping1.email, iter->email);
  EXPECT_TRUE(iter->access_token.empty());
  EXPECT_EQ(AccountMapping::ADDING, iter->status);
  EXPECT_EQ(account_mapping1.status_change_timestamp,
            iter->status_change_timestamp);
  EXPECT_EQ(account_mapping1.last_message_id, iter->last_message_id);
  ++iter;
  EXPECT_EQ(account_mapping2.account_id, iter->account_id);
  EXPECT_EQ(account_mapping2.email, iter->email);
  EXPECT_TRUE(iter->access_token.empty());
  EXPECT_EQ(AccountMapping::REMOVING, iter->status);
  EXPECT_EQ(account_mapping2.status_change_timestamp,
            iter->status_change_timestamp);
  EXPECT_EQ(account_mapping2.last_message_id, iter->last_message_id);

  gcm_store->RemoveAccountMapping(
      account_mapping1.account_id,
      base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                     base::Unretained(this)));
  PumpLoop();

  gcm_store = BuildGCMStore();
  LoadGCMStore(gcm_store.get(), &load_result);

  EXPECT_EQ(1UL, load_result->account_mappings.size());
  iter = load_result->account_mappings.begin();
  EXPECT_EQ(account_mapping2.account_id, iter->account_id);
  EXPECT_EQ(account_mapping2.email, iter->email);
  EXPECT_TRUE(iter->access_token.empty());
  EXPECT_EQ(AccountMapping::REMOVING, iter->status);
  EXPECT_EQ(account_mapping2.status_change_timestamp,
            iter->status_change_timestamp);
  EXPECT_EQ(account_mapping2.last_message_id, iter->last_message_id);
}

TEST_F(GCMStoreImplTest, HeartbeatInterval) {
  std::unique_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());
  std::unique_ptr<GCMStore::LoadResult> load_result;
  LoadGCMStore(gcm_store.get(), &load_result);

  std::string scope1 = "scope1";
  std::string scope2 = "scope2";
  int heartbeat1 = 120 * 1000;
  int heartbeat2 = 360 * 1000;

  gcm_store->AddHeartbeatInterval(
      scope1, heartbeat1,
      base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                     base::Unretained(this)));
  PumpLoop();
  gcm_store->AddHeartbeatInterval(
      scope2, heartbeat2,
      base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                     base::Unretained(this)));
  PumpLoop();

  gcm_store = BuildGCMStore();
  LoadGCMStore(gcm_store.get(), &load_result);

  EXPECT_EQ(2UL, load_result->heartbeat_intervals.size());
  EXPECT_TRUE(base::Contains(load_result->heartbeat_intervals, scope1));
  EXPECT_EQ(heartbeat1, load_result->heartbeat_intervals[scope1]);
  EXPECT_TRUE(base::Contains(load_result->heartbeat_intervals, scope2));
  EXPECT_EQ(heartbeat2, load_result->heartbeat_intervals[scope2]);

  gcm_store->RemoveHeartbeatInterval(
      scope2, base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                             base::Unretained(this)));
  PumpLoop();

  gcm_store = BuildGCMStore();
  LoadGCMStore(gcm_store.get(), &load_result);

  EXPECT_EQ(1UL, load_result->heartbeat_intervals.size());
  EXPECT_TRUE(base::Contains(load_result->heartbeat_intervals, scope1));
  EXPECT_EQ(heartbeat1, load_result->heartbeat_intervals[scope1]);
}

// When the database is destroyed, all database updates should fail. At the
// same time, they per-app message counts should not go up, as failures should
// result in decrementing the counts.
TEST_F(GCMStoreImplTest, AddMessageAfterDestroy) {
  std::unique_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());
  std::unique_ptr<GCMStore::LoadResult> load_result;
  LoadGCMStore(gcm_store.get(), &load_result);
  gcm_store->Destroy(base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                                    base::Unretained(this)));
  PumpLoop();

  expected_success_ = false;
  for (int i = 0; i < kNumMessagesPerApp * 2; ++i) {
    mcs_proto::DataMessageStanza message;
    message.set_from(kAppName);
    message.set_category(kCategoryName);
    // Because all adds are failing, none should hit the per-app message limits.
    EXPECT_TRUE(gcm_store->AddOutgoingMessage(
        base::NumberToString(i), MCSMessage(message),
        base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                       base::Unretained(this))));
    PumpLoop();
  }
}

TEST_F(GCMStoreImplTest, ReloadAfterClose) {
  std::unique_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());
  std::unique_ptr<GCMStore::LoadResult> load_result;
  LoadGCMStore(gcm_store.get(), &load_result);

  gcm_store->Close();
  PumpLoop();

  LoadGCMStore(gcm_store.get(), &load_result);
}

TEST_F(GCMStoreImplTest, LastTokenFetchTime) {
  std::unique_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());
  std::unique_ptr<GCMStore::LoadResult> load_result;
  LoadGCMStore(gcm_store.get(), &load_result);
  EXPECT_EQ(base::Time(), load_result->last_token_fetch_time);

  base::Time last_token_fetch_time = base::Time::Now();
  gcm_store->SetLastTokenFetchTime(
      last_token_fetch_time, base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                                            base::Unretained(this)));
  PumpLoop();

  gcm_store = BuildGCMStore();
  LoadGCMStore(gcm_store.get(), &load_result);
  EXPECT_EQ(last_token_fetch_time, load_result->last_token_fetch_time);

  // Negative cases, where the value read is gibberish.
  gcm_store->SetValueForTesting(
      "last_token_fetch_time", "gibberish",
      base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                     base::Unretained(this)));
  PumpLoop();

  gcm_store = BuildGCMStore();
  LoadGCMStore(gcm_store.get(), &load_result);
  EXPECT_EQ(base::Time(), load_result->last_token_fetch_time);
}

TEST_F(GCMStoreImplTest, InstanceIDData) {
  std::unique_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());
  std::unique_ptr<GCMStore::LoadResult> load_result;
  LoadGCMStore(gcm_store.get(), &load_result);

  std::string instance_id_data("Foo");
  gcm_store->AddInstanceIDData(kAppName, instance_id_data,
                               base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                                              base::Unretained(this)));
  PumpLoop();

  std::string instance_id_data2("Hello Instance ID");
  gcm_store->AddInstanceIDData(kAppName2, instance_id_data2,
                               base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                                              base::Unretained(this)));
  PumpLoop();

  gcm_store = BuildGCMStore();
  LoadGCMStore(gcm_store.get(), &load_result);

  ASSERT_EQ(2u, load_result->instance_id_data.size());
  EXPECT_TRUE(base::Contains(load_result->instance_id_data, kAppName));
  EXPECT_TRUE(base::Contains(load_result->instance_id_data, kAppName2));
  EXPECT_EQ(instance_id_data, load_result->instance_id_data[kAppName]);
  EXPECT_EQ(instance_id_data2, load_result->instance_id_data[kAppName2]);

  gcm_store->RemoveInstanceIDData(
      kAppName, base::BindOnce(&GCMStoreImplTest::UpdateCallback,
                               base::Unretained(this)));
  PumpLoop();

  gcm_store = BuildGCMStore();
  LoadGCMStore(gcm_store.get(), &load_result);

  ASSERT_EQ(1u, load_result->instance_id_data.size());
  EXPECT_TRUE(base::Contains(load_result->instance_id_data, kAppName2));
  EXPECT_EQ(instance_id_data2, load_result->instance_id_data[kAppName2]);
}

}  // namespace

}  // namespace gcm