Remote service state handling

chrome/browser/sync_file_system/drive_file_sync_service_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/sync_file_system/drive_file_sync_service.h"
 
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "chrome/browser/google_apis/gdata_errorcode.h"
 #include "chrome/browser/google_apis/mock_drive_service.h"
 #include "chrome/browser/google_apis/mock_drive_uploader.h"
 #include "chrome/browser/google_apis/test_util.h"
 #include "chrome/browser/sync_file_system/drive_file_sync_client.h"
 #include "chrome/browser/sync_file_system/drive_metadata_store.h"
 #include "chrome/test/base/testing_profile.h"
 #include "net/base/escape.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/fileapi/syncable/syncable_file_system_util.h"
 
 using ::testing::StrictMock;
 using ::testing::InSequence;
+using ::testing::AtLeast;

[tzik, 2012/11/16 05:21:51]

sort?

[kinuko, 2012/11/16 05:45:02]

Done.

 using ::testing::_;
 
 using google_apis::DriveServiceInterface;
 using google_apis::DriveUploaderInterface;
 using google_apis::test_util::LoadJSONFile;
 
 namespace sync_file_system {
 
 namespace {
 
@@ skipping 13 matching lines @@
 void ExpectEqStatus(bool* done,
                     fileapi::SyncStatusCode expected,
                     fileapi::SyncStatusCode actual) {
   EXPECT_FALSE(*done);
   *done = true;
   EXPECT_EQ(expected, actual);
 }
 
 }  // namespace
 
+class MockRemoteServiceObserver : public RemoteFileSyncService::Observer {
+ public:
+  MockRemoteServiceObserver() {}
+  virtual ~MockRemoteServiceObserver() {}
+
+  // LocalChangeProcessor override.
+  MOCK_METHOD1(OnRemoteChangeAvailable,
+               void(int64 pending_changes));
+  MOCK_METHOD2(OnRemoteServiceStateUpdated,
+               void(RemoteServiceState state,
+                    const std::string& description));
+};
+
 class DriveFileSyncServiceTest : public testing::Test {
  public:
   DriveFileSyncServiceTest()
       : mock_drive_service_(NULL),
         mock_drive_uploader_(NULL) {
   }
 
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(fileapi::RegisterSyncableFileSystem(
         DriveFileSyncService::kServiceName));
@@ skipping 14 matching lines @@
 
     bool done = false;
     metadata_store_->Initialize(base::Bind(&DidInitialize, &done));
     message_loop_.RunUntilIdle();
     EXPECT_TRUE(done);
   }
 
   void SetUpDriveSyncService() {
     sync_service_ = DriveFileSyncService::CreateForTesting(
         sync_client_.Pass(), metadata_store_.Pass()).Pass();
+    sync_service_->AddObserver(&mock_remote_observer_);
   }
 
   virtual void TearDown() OVERRIDE {
     if (sync_service_) {
       sync_service_.reset();
     }
 
     metadata_store_.reset();
     sync_client_.reset();
     mock_drive_uploader_ = NULL;
@@ skipping 18 matching lines @@
   }
 
   StrictMock<google_apis::MockDriveService>* mock_drive_service() {
     return mock_drive_service_;
   }
 
   StrictMock<google_apis::MockDriveUploader>* mock_drive_uploader() {
     return mock_drive_uploader_;
   }
 
+  StrictMock<MockRemoteServiceObserver>* mock_remote_observer() {
+    return &mock_remote_observer_;
+  }
+
   MessageLoop* message_loop() { return &message_loop_; }
   DriveFileSyncService* sync_service() { return sync_service_.get(); }
 
   std::string FormatTitleQuery(const std::string& title) {
     return DriveFileSyncClient::FormatTitleQuery(title);
   }
 
   const DriveFileSyncService::ChangeQueue& pending_changes() const {
     return sync_service_->pending_changes_;
   }
 
  private:
   MessageLoop message_loop_;
 
   ScopedTempDir base_dir_;
   TestingProfile profile_;
 
   scoped_ptr<DriveFileSyncService> sync_service_;
 
   // Owned by |sync_client_|.
   StrictMock<google_apis::MockDriveService>* mock_drive_service_;
   StrictMock<google_apis::MockDriveUploader>* mock_drive_uploader_;
+  StrictMock<MockRemoteServiceObserver> mock_remote_observer_;
 
   scoped_ptr<DriveFileSyncClient> sync_client_;
   scoped_ptr<DriveMetadataStore> metadata_store_;
 
   DISALLOW_COPY_AND_ASSIGN(DriveFileSyncServiceTest);
 };
 
 // Invokes |arg0| as a GetDataCallback.
 ACTION_P2(InvokeGetDataCallback0, error, result) {
   scoped_ptr<base::Value> value(result.Pass());
@@ skipping 31 matching lines @@
 TEST_F(DriveFileSyncServiceTest, GetSyncRoot) {
   scoped_ptr<Value> sync_root_found(LoadJSONFile(
       "sync_file_system/sync_root_found.json"));
   std::string query = FormatTitleQuery(kSyncRootDirectoryName);
   EXPECT_CALL(*mock_drive_service(),
               GetDocuments(GURL(), 0, query, std::string(), _))
       .WillOnce(InvokeGetDataCallback4(
           google_apis::HTTP_SUCCESS,
           base::Passed(&sync_root_found)));
 
+  EXPECT_CALL(*mock_remote_observer(),
+              OnRemoteServiceStateUpdated(REMOTE_SERVICE_OK, _))
+      .Times(1);
+
   SetUpDriveSyncService();
   message_loop()->RunUntilIdle();
 
   EXPECT_EQ("folder:sync_root_resource_id",
             metadata_store()->sync_root_directory());
 
   EXPECT_EQ(0u, metadata_store()->batch_sync_origins().size());
   EXPECT_EQ(0u, metadata_store()->incremental_sync_origins().size());
   EXPECT_EQ(0u, pending_changes().size());
 }
@@ skipping 18 matching lines @@
       "gdata/account_metadata.json"));
   EXPECT_CALL(*mock_drive_service(),
               GetAccountMetadata(_))
       .WillOnce(InvokeGetDataCallback0(
           google_apis::HTTP_SUCCESS,
           base::Passed(&account_metadata)));
 
   scoped_ptr<Value> listing_files_in_directory(LoadJSONFile(
       "sync_file_system/listing_files_in_directory.json"));
   EXPECT_CALL(*mock_drive_service(),
-              GetDocuments(GURL(), 0, std::string(), kDirectoryResourceId1, _))
+              GetDocuments(GURL(), 0, std::string(),
+                           kDirectoryResourceId1, _))
       .WillOnce(InvokeGetDataCallback4(
           google_apis::HTTP_SUCCESS,
           base::Passed(&listing_files_in_directory)));
 
+  EXPECT_CALL(*mock_remote_observer(),
+              OnRemoteServiceStateUpdated(REMOTE_SERVICE_OK, _))
+      .Times(1);
+
   SetUpDriveSyncService();
   message_loop()->RunUntilIdle();
 
   // kOrigin1 should be a batch sync origin and kOrigin2 should be an
   // incremental sync origin.
   // 4 pending remote changes are from listing_files_in_directory as batch sync
   // changes.
   EXPECT_EQ(1u, metadata_store()->batch_sync_origins().size());
   EXPECT_EQ(1u, metadata_store()->incremental_sync_origins().size());
   EXPECT_EQ(4u, pending_changes().size());
 }
 
 TEST_F(DriveFileSyncServiceTest, RegisterNewOrigin) {
   const GURL kOrigin("http://example.com");
   const std::string kDirectoryResourceId("folder:origin_directory_resource_id");
   const std::string kSyncRootResourceId("folder:sync_root_resource_id");
   const GURL kSyncRootContentURL("https://sync_root_content_url/");
 
   metadata_store()->SetSyncRootDirectory(kSyncRootResourceId);
 
+  EXPECT_CALL(*mock_remote_observer(),
+              OnRemoteServiceStateUpdated(REMOTE_SERVICE_OK, _))
+      .Times(AtLeast(1));
+
   InSequence sequence;
 
   scoped_ptr<Value> origin_directory_not_found(LoadJSONFile(
       "sync_file_system/origin_directory_not_found.json"));
   std::string query = FormatTitleQuery(kOrigin.spec());
 
   EXPECT_CALL(*mock_drive_service(),
               GetDocuments(GURL(), 0, query, kSyncRootResourceId, _))
       .WillOnce(InvokeGetDataCallback4(
           google_apis::HTTP_SUCCESS,
@@ skipping 53 matching lines @@
   EXPECT_TRUE(pending_changes().empty());
 }
 
 TEST_F(DriveFileSyncServiceTest, RegisterExistingOrigin) {
   const GURL kOrigin("http://example.com");
   const std::string kDirectoryResourceId("folder:origin_directory_resource_id");
   const std::string kSyncRootResourceId("folder:sync_root_resource_id");
 
   metadata_store()->SetSyncRootDirectory(kSyncRootResourceId);
 
+  EXPECT_CALL(*mock_remote_observer(),
+              OnRemoteServiceStateUpdated(REMOTE_SERVICE_OK, _))
+      .Times(AtLeast(1));
+
   InSequence sequence;
 
   scoped_ptr<Value> origin_directory_found(LoadJSONFile(
       "sync_file_system/origin_directory_found.json"));
   std::string query = FormatTitleQuery("http://example.com/");
   EXPECT_CALL(*mock_drive_service(),
               GetDocuments(GURL(), 0, query, kSyncRootResourceId, _))
       .WillOnce(InvokeGetDataCallback4(
           google_apis::HTTP_SUCCESS,
           base::Passed(&origin_directory_found)))
@@ skipping 38 matching lines @@
       "folder:origin_directory_resource_id");
   const std::string kDirectoryResourceId2(
       "folder:origin_directory_resource_id2");
   const std::string kSyncRootResourceId("folder:sync_root_resource_id");
 
   metadata_store()->SetSyncRootDirectory(kSyncRootResourceId);
   metadata_store()->AddBatchSyncOrigin(kOrigin1, kDirectoryResourceId1);
   metadata_store()->AddBatchSyncOrigin(kOrigin2, kDirectoryResourceId2);
   metadata_store()->MoveBatchSyncOriginToIncremental(kOrigin2);
 
+  EXPECT_CALL(*mock_remote_observer(),
+              OnRemoteServiceStateUpdated(REMOTE_SERVICE_OK, _))
+      .Times(AtLeast(1));
+
   InSequence sequence;
 
   scoped_ptr<Value> account_metadata(LoadJSONFile(
       "gdata/account_metadata.json"));
   EXPECT_CALL(*mock_drive_service(),
               GetAccountMetadata(_))
       .WillOnce(InvokeGetDataCallback0(
           google_apis::HTTP_SUCCESS,
           base::Passed(&account_metadata)));
 
@@ skipping 19 matching lines @@
   EXPECT_TRUE(done);
 
   EXPECT_TRUE(metadata_store()->batch_sync_origins().empty());
   EXPECT_EQ(1u, metadata_store()->incremental_sync_origins().size());
   EXPECT_TRUE(pending_changes().empty());
 }
 
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace sync_file_system