[GCM] Persistence of account mappings.

google_apis/gcm/engine/gcm_store_impl_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // 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 <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 27 matching lines @@
 const char kCategoryName[] = "my_category";
 
 const uint64 kDeviceId = 22;
 const uint64 kDeviceToken = 55;
 
 class GCMStoreImplTest : public testing::Test {
  public:
   GCMStoreImplTest();
   virtual ~GCMStoreImplTest();
 
-  virtual void SetUp() OVERRIDE;
-
   scoped_ptr<GCMStore> BuildGCMStore();
 
   std::string GetNextPersistentId();
 
   void PumpLoop();
 
   void LoadCallback(scoped_ptr<GCMStore::LoadResult>* result_dst,
                     scoped_ptr<GCMStore::LoadResult> result);
   void UpdateCallback(bool success);
 
  protected:
   base::MessageLoop message_loop_;
   base::ScopedTempDir temp_directory_;
   bool expected_success_;
   uint64 next_persistent_id_;
   scoped_ptr<base::RunLoop> run_loop_;
 };
 
 GCMStoreImplTest::GCMStoreImplTest()
     : expected_success_(true),
       next_persistent_id_(base::Time::Now().ToInternalValue()) {
   EXPECT_TRUE(temp_directory_.CreateUniqueTempDir());
   run_loop_.reset(new base::RunLoop());
 }
 
 GCMStoreImplTest::~GCMStoreImplTest() {}
 
-void GCMStoreImplTest::SetUp() {
-  testing::Test::SetUp();
-}
-
 scoped_ptr<GCMStore> GCMStoreImplTest::BuildGCMStore() {
   return scoped_ptr<GCMStore>(new GCMStoreImpl(
       temp_directory_.path(),
       message_loop_.message_loop_proxy(),
       make_scoped_ptr<Encryptor>(new FakeEncryptor)));
 }
 
 std::string GCMStoreImplTest::GetNextPersistentId() {
   return base::Uint64ToString(next_persistent_id_++);
 }
@@ skipping 408 matching lines @@
     message.set_category(kCategoryName);
     EXPECT_TRUE(gcm_store->AddOutgoingMessage(
                     base::IntToString(i + kNumMessagesPerApp),
                     MCSMessage(message),
                     base::Bind(&GCMStoreImplTest::UpdateCallback,
                                base::Unretained(this))));
     PumpLoop();
   }
 }
 
+TEST_F(GCMStoreImplTest, AccountMapping) {
+  scoped_ptr<GCMStore> gcm_store(BuildGCMStore());
+  scoped_ptr<GCMStore::LoadResult> load_result;
+  gcm_store->Load(base::Bind(
+      &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
+
+  // Add account mappings.
+  AccountInfo account_info1;
+  account_info1.account_id = "account_id_1";
+  account_info1.email = "account_id_1@gmail.com";
+  account_info1.last_message_type = AccountInfo::MSG_ADD;
+  account_info1.last_message_id = "message_1";
+  account_info1.last_message_timestamp =
+      base::Time::FromInternalValue(1305797421259935LL);
+  AccountInfo account_info2;
+  account_info2.account_id = "account_id_2";
+  account_info2.email = "account_id_2@gmail.com";
+  account_info2.last_message_type = AccountInfo::MSG_REMOVE;
+  account_info2.last_message_id = "message_2";
+  account_info2.last_message_timestamp =
+      base::Time::FromInternalValue(1305734521259935LL);
+
+  gcm_store->AddAccountMapping(
+      account_info1,
+      base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this)));
+  PumpLoop();
+  gcm_store->AddAccountMapping(
+      account_info2,
+      base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this)));
+  PumpLoop();
+
+  gcm_store = BuildGCMStore().Pass();
+  gcm_store->Load(base::Bind(
+      &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
+  PumpLoop();
+
+  EXPECT_EQ(2UL, load_result->account_infos.size());
+  GCMStore::AccountInfoMap::iterator iter = load_result->account_infos.begin();
+  EXPECT_EQ("account_id_1", iter->first);
+  EXPECT_EQ(account_info1.account_id, iter->second.account_id);
+  EXPECT_EQ(account_info1.email, iter->second.email);
+  EXPECT_EQ(account_info1.last_message_type, iter->second.last_message_type);
+  EXPECT_EQ(account_info1.last_message_id, iter->second.last_message_id);
+  EXPECT_EQ(account_info1.last_message_timestamp,
+            iter->second.last_message_timestamp);
+  ++iter;
+  EXPECT_EQ("account_id_2", iter->first);
+  EXPECT_EQ(account_info2.account_id, iter->second.account_id);
+  EXPECT_EQ(account_info2.email, iter->second.email);
+  EXPECT_EQ(account_info2.last_message_type, iter->second.last_message_type);
+  EXPECT_EQ(account_info2.last_message_id, iter->second.last_message_id);
+  EXPECT_EQ(account_info2.last_message_timestamp,
+            iter->second.last_message_timestamp);
+
+  gcm_store->RemoveAccountMapping(
+      account_info1.account_id,
+      base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this)));
+  PumpLoop();
+
+  gcm_store = BuildGCMStore().Pass();
+  gcm_store->Load(base::Bind(
+      &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
+  PumpLoop();
+
+  EXPECT_EQ(1UL, load_result->account_infos.size());
+  iter = load_result->account_infos.begin();
+  EXPECT_EQ("account_id_2", iter->first);
+  EXPECT_EQ(account_info2.account_id, iter->second.account_id);
+  EXPECT_EQ(account_info2.email, iter->second.email);
+  EXPECT_EQ(account_info2.last_message_type, iter->second.last_message_type);
+  EXPECT_EQ(account_info2.last_message_id, iter->second.last_message_id);
+  EXPECT_EQ(account_info2.last_message_timestamp,
+            iter->second.last_message_timestamp);
+}
+
 // 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) {
   scoped_ptr<GCMStore> gcm_store(BuildGCMStore());
   scoped_ptr<GCMStore::LoadResult> load_result;
   gcm_store->Load(base::Bind(&GCMStoreImplTest::LoadCallback,
                              base::Unretained(this),
                              &load_result));
   PumpLoop();
@@ skipping 29 matching lines @@
 
   gcm_store->Load(base::Bind(&GCMStoreImplTest::LoadCallback,
                              base::Unretained(this),
                              &load_result));
   PumpLoop();
 }
 
 }  // namespace
 
 }  // namespace gcm