Adding a user list (to be consumed by GCM Client Implementation)

google_apis/gcm/engine/user_list_unittest.cc

Index: google_apis/gcm/engine/user_list_unittest.cc
diff --git a/google_apis/gcm/engine/user_list_unittest.cc b/google_apis/gcm/engine/user_list_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1f8faa0d41b91fca9f5c9eaab62252a4b175af73
--- /dev/null
+++ b/google_apis/gcm/engine/user_list_unittest.cc
@@ -0,0 +1,319 @@
+// 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/user_list.h"
+
+#include <string>
+#include <vector>
+
+#include "base/bind.h"
+#include "base/callback_forward.h"
+#include "base/files/file_path.h"
+#include "base/files/scoped_temp_dir.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "google_apis/gcm/engine/gcm_store_impl.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace gcm {
+
+class UserListTest : public testing::Test {
+ public:
+  UserListTest();
+  virtual ~UserListTest();
+
+  static unsigned long GetListSize(const UserList* user_list);
+
+  scoped_ptr<UserList> BuildUserList();
+
+  void PumpLoop();
+
+  void UpdateCallback(bool success);
+
+  scoped_ptr<GCMStore> gcm_store_;
+  base::ScopedTempDir temp_directory_;
+  base::MessageLoop message_loop_;
+};
+
+class GCMClientDelegate : public GCMClient::Delegate {
+ public:
+  explicit GCMClientDelegate(const std::string& username);
+  virtual ~GCMClientDelegate();
+
+  const std::string& GetUsername() const {
+    return username_;
+  }
+
+  // Overrides of GCMClientDelegate:
+  virtual void OnCheckInFinished(const GCMClient::CheckinInfo& checkin_info,
+                                 GCMClient::Result result) OVERRIDE {}
+  virtual void OnRegisterFinished(const std::string& app_id,
+                                  const std::string& registration_id,
+                                  GCMClient::Result result) OVERRIDE {}
+  virtual void OnSendFinished(const std::string& app_id,
+                              const std::string& message_id,
+                              GCMClient::Result result) OVERRIDE {}
+  virtual void OnMessageReceived(
+      const std::string& app_id,
+      const GCMClient::IncomingMessage& message) OVERRIDE {}
+  virtual void OnMessagesDeleted(const std::string& app_id) OVERRIDE {}
+  virtual void OnMessageSendError(const std::string& app_id,
+                                  const std::string& message_id,
+                                  GCMClient::Result result) OVERRIDE {}
+  virtual GCMClient::CheckinInfo GetCheckinInfo() const OVERRIDE {
+    return checkin_info_;
+  }
+  virtual void OnLoadingCompleted() OVERRIDE {}
+  virtual base::TaskRunner* GetFileTaskRunner() OVERRIDE {
+    return NULL;
+  }
+
+ private:
+  GCMClient::CheckinInfo checkin_info_;
+  std::string username_;
+};
+
+UserListTest::UserListTest() {
+  EXPECT_TRUE(temp_directory_.CreateUniqueTempDir());
+}
+
+UserListTest::~UserListTest() {
+}
+
+//static
+unsigned long UserListTest::GetListSize(const UserList* user_list) {
+  return user_list->delegates_.size();
+}
+
+scoped_ptr<UserList> UserListTest::BuildUserList() {
+  gcm_store_.reset(new GCMStoreImpl(
+      temp_directory_.path(),
+      message_loop_.message_loop_proxy()));
+  return scoped_ptr<UserList>(new UserList(gcm_store_.get()));
+}
+
+void UserListTest::PumpLoop() {
+  message_loop_.RunUntilIdle();
+}
+
+void UserListTest::UpdateCallback(bool success) {
+  ASSERT_TRUE(success);
+}
+
+GCMClientDelegate::GCMClientDelegate(const std::string& username)
+    : username_(username) {
+}
+
+GCMClientDelegate::~GCMClientDelegate() { }
+
+TEST_F(UserListTest, AddDelegateAddSerialNumber) {
+  scoped_ptr<UserList> user_list(BuildUserList());
+  gcm_store_->Load(base::Bind(&UserList::Initialize,
+                              base::Unretained(user_list.get())));
+  PumpLoop();
+
+  // First adding a delegate.
+  scoped_ptr<GCMClientDelegate> delegate(new GCMClientDelegate("test_user_1"));
+  user_list->AddDelegate(delegate->GetUsername(), delegate.get());
+
+  // Verify the record was created.
+  EXPECT_EQ(1u, GetListSize(user_list.get()));
+  int64 read_serial_number;
+  EXPECT_FALSE(user_list->GetSerialNumberForUsername(delegate->GetUsername(),
+                                                     &read_serial_number));
+  EXPECT_EQ(delegate.get(),
+            user_list->GetDelegateByUsername(delegate->GetUsername()));
+
+  // Add then a serial number.
+  int64 serial_number = user_list->GetNextSerialNumber();
+  user_list->AddSerialNumber(delegate->GetUsername(),
+                                 serial_number,
+                                 base::Bind(&UserListTest::UpdateCallback,
+                                            base::Unretained(this)));
+  PumpLoop();
+
+  // Ensuring that the record was updated in place.
+  EXPECT_EQ(1u, GetListSize(user_list.get()));
+  EXPECT_TRUE(user_list->GetSerialNumberForUsername(delegate->GetUsername(),
+                                                    &read_serial_number));
+  EXPECT_EQ(serial_number, read_serial_number);
+  EXPECT_EQ(delegate.get(),
+            user_list->GetDelegateByUsername(delegate->GetUsername()));
+  EXPECT_EQ(delegate.get(),
+            user_list->GetDelegateBySerialNumber(serial_number));
+}
+
+TEST_F(UserListTest, LoadUserEntryAddDelegate) {
+  scoped_ptr<UserList> user_list(BuildUserList());
+  gcm_store_->Load(base::Bind(&UserList::Initialize,
+                              base::Unretained(user_list.get())));
+  PumpLoop();
+
+  // Start by adding a delegate and a serial number.
+  int64 serial_number = user_list->GetNextSerialNumber();
+  scoped_ptr<GCMClientDelegate> delegate(new GCMClientDelegate("test_user_1"));
+  user_list->AddDelegate(delegate->GetUsername(), delegate.get());
+  user_list->AddSerialNumber(delegate->GetUsername(),
+                                 serial_number,
+                                 base::Bind(&UserListTest::UpdateCallback,
+                                            base::Unretained(this)));
+  PumpLoop();
+
+  // Reload the GCM User List.
+  user_list = BuildUserList().Pass();
+  gcm_store_->Load(base::Bind(&UserList::Initialize,
+                              base::Unretained(user_list.get())));
+  PumpLoop();
+
+  // Verify a single record was loaded, with matching username, but no delegate.
+  EXPECT_EQ(1u, GetListSize(user_list.get()));
+  int64 read_serial_number;
+  EXPECT_TRUE(user_list->GetSerialNumberForUsername(delegate->GetUsername(),
+                                                    &read_serial_number));
+  EXPECT_EQ(serial_number, read_serial_number);
+  EXPECT_EQ(NULL,
+            user_list->GetDelegateByUsername(delegate->GetUsername()));
+  EXPECT_EQ(NULL,
+            user_list->GetDelegateBySerialNumber(serial_number));
+
+  // After loading is complete, Delegates will start adding itself looking for
+  // their serial numbers. Check that correct matches are found and new records
+  // not created.
+  user_list->AddDelegate(delegate->GetUsername(), delegate.get());
+  EXPECT_EQ(1u, GetListSize(user_list.get()));
+  EXPECT_TRUE(user_list->GetSerialNumberForUsername(delegate->GetUsername(),
+                                                    &read_serial_number));
+  EXPECT_EQ(serial_number, read_serial_number);
+  EXPECT_EQ(delegate.get(),
+            user_list->GetDelegateByUsername(delegate->GetUsername()));
+  EXPECT_EQ(delegate.get(),
+            user_list->GetDelegateBySerialNumber(serial_number));
+}
+
+TEST_F(UserListTest, GetDelegate) {
+  scoped_ptr<UserList> user_list(BuildUserList());
+  gcm_store_->Load(base::Bind(&UserList::Initialize,
+                              base::Unretained(user_list.get())));
+  PumpLoop();
+
+  // Start by adding a delegate and a serial number.
+  int64 serial_number = user_list->GetNextSerialNumber();
+  scoped_ptr<GCMClientDelegate> delegate(new GCMClientDelegate("test_user_1"));
+  user_list->AddDelegate(delegate->GetUsername(), delegate.get());
+  user_list->AddSerialNumber(delegate->GetUsername(),
+                                 serial_number,
+                                 base::Bind(&UserListTest::UpdateCallback,
+                                            base::Unretained(this)));
+  PumpLoop();
+
+  EXPECT_EQ(delegate.get(),
+            user_list->GetDelegateBySerialNumber(serial_number));
+  EXPECT_EQ(delegate.get(),
+            user_list->GetDelegateByUsername(delegate->GetUsername()));
+}
+
+TEST_F(UserListTest, GetSerialNumberForUsername) {
+  scoped_ptr<UserList> user_list(BuildUserList());
+  gcm_store_->Load(base::Bind(&UserList::Initialize,
+                              base::Unretained(user_list.get())));
+  PumpLoop();
+
+  // Start by adding a delegate and a serial number.
+  int64 serial_number = user_list->GetNextSerialNumber();
+  scoped_ptr<GCMClientDelegate> delegate(new GCMClientDelegate("test_user_1"));
+  user_list->AddDelegate(delegate->GetUsername(), delegate.get());
+  user_list->AddSerialNumber(delegate->GetUsername(),
+                                 serial_number,
+                                 base::Bind(&UserListTest::UpdateCallback,
+                                            base::Unretained(this)));
+  PumpLoop();
+
+  int64 read_serial_number;
+  EXPECT_TRUE(user_list->GetSerialNumberForUsername(delegate->GetUsername(),
+                                                    &read_serial_number));
+  EXPECT_EQ(serial_number, read_serial_number);
+}
+
+TEST_F(UserListTest, AddMultipleDelegates) {
+  scoped_ptr<UserList> user_list(BuildUserList());
+  gcm_store_->Load(base::Bind(&UserList::Initialize,
+                              base::Unretained(user_list.get())));
+  PumpLoop();
+
+  // Start by adding a delegate and a serial number.
+  scoped_ptr<GCMClientDelegate> delegate1(new GCMClientDelegate("test_user_1"));
+  user_list->AddDelegate(delegate1->GetUsername(), delegate1.get());
+  int64 serial_number1 = user_list->GetNextSerialNumber();
+  user_list->AddSerialNumber(delegate1->GetUsername(),
+                                 serial_number1,
+                                 base::Bind(&UserListTest::UpdateCallback,
+                                            base::Unretained(this)));
+  scoped_ptr<GCMClientDelegate> delegate2(new GCMClientDelegate("test_user_2"));
+  user_list->AddDelegate(delegate2->GetUsername(), delegate2.get());
+  int64 serial_number2 = user_list->GetNextSerialNumber();
+  user_list->AddSerialNumber(delegate2->GetUsername(),
+                                 serial_number2,
+                                 base::Bind(&UserListTest::UpdateCallback,
+                                            base::Unretained(this)));
+  PumpLoop();
+
+  // Ensuring that serial numbers are different.
+  EXPECT_NE(serial_number1, serial_number2);
+
+  // Verifying that each entry has it's own serial numbers and delegates.
+  EXPECT_EQ(2u, GetListSize(user_list.get()));
+  EXPECT_EQ(delegate1.get(),
+            user_list->GetDelegateByUsername(delegate1->GetUsername()));
+  EXPECT_EQ(delegate1.get(),
+            user_list->GetDelegateBySerialNumber(serial_number1));
+  int64 read_serial_number;
+  EXPECT_TRUE(user_list->GetSerialNumberForUsername(delegate1->GetUsername(),
+                                                    &read_serial_number));
+  EXPECT_EQ(serial_number1, read_serial_number);
+  EXPECT_EQ(delegate2.get(),
+            user_list->GetDelegateByUsername(delegate2->GetUsername()));
+  EXPECT_EQ(delegate2.get(),
+            user_list->GetDelegateBySerialNumber(serial_number2));
+  EXPECT_TRUE(user_list->GetSerialNumberForUsername(delegate2->GetUsername(),
+                                                    &read_serial_number));
+  EXPECT_EQ(serial_number2, read_serial_number);
+
+  // Reading the user entries.
+  user_list = BuildUserList().Pass();
+  gcm_store_->Load(base::Bind(&UserList::Initialize,
+                              base::Unretained(user_list.get())));
+  PumpLoop();
+
+  // Serial numbers stay the same, but there are no delegates assigned.
+  EXPECT_EQ(2u, GetListSize(user_list.get()));
+  EXPECT_EQ(NULL,
+            user_list->GetDelegateByUsername(delegate1->GetUsername()));
+  EXPECT_EQ(NULL,
+            user_list->GetDelegateBySerialNumber(serial_number1));
+  EXPECT_TRUE(user_list->GetSerialNumberForUsername(delegate1->GetUsername(),
+                                                    &read_serial_number));
+  EXPECT_EQ(serial_number1, read_serial_number);
+  EXPECT_EQ(NULL,
+            user_list->GetDelegateByUsername(delegate2->GetUsername()));
+  EXPECT_EQ(NULL,
+            user_list->GetDelegateBySerialNumber(serial_number2));
+  EXPECT_TRUE(user_list->GetSerialNumberForUsername(delegate2->GetUsername(),
+                                                    &read_serial_number));
+  EXPECT_EQ(serial_number2, read_serial_number);
+
+  // Setting and checking a delegate on the second user.
+  user_list->AddDelegate(delegate2->GetUsername(), delegate2.get());
+  EXPECT_EQ(delegate2.get(),
+            user_list->GetDelegateByUsername(delegate2->GetUsername()));
+  EXPECT_EQ(delegate2.get(),
+            user_list->GetDelegateBySerialNumber(serial_number2));
+  // First user still does not have a delegate.
+  EXPECT_EQ(NULL,
+            user_list->GetDelegateByUsername(delegate1->GetUsername()));
+  EXPECT_EQ(NULL,
+            user_list->GetDelegateBySerialNumber(serial_number1));
+}
+
+}  // namespace gcm