📰 The Status card reports disabled sync states

components/ntp_snippets/ntp_snippets_service_unittest.cc

 // Copyright 2015 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 "components/ntp_snippets/ntp_snippets_service.h"
 
 #include <memory>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/histogram_tester.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/image_fetcher/image_decoder.h"
 #include "components/image_fetcher/image_fetcher.h"
 #include "components/ntp_snippets/ntp_snippet.h"
 #include "components/ntp_snippets/ntp_snippets_database.h"
 #include "components/ntp_snippets/ntp_snippets_fetcher.h"
 #include "components/ntp_snippets/ntp_snippets_scheduler.h"
+#include "components/ntp_snippets/ntp_snippets_test_utils.h"
 #include "components/ntp_snippets/switches.h"
 #include "components/prefs/testing_pref_service.h"
-#include "components/signin/core/browser/account_tracker_service.h"
 #include "components/signin/core/browser/fake_profile_oauth2_token_service.h"
 #include "components/signin/core/browser/fake_signin_manager.h"
-#include "components/signin/core/browser/test_signin_client.h"
-#include "components/sync_driver/fake_sync_service.h"
 #include "google_apis/google_api_keys.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::ElementsAre;
 using testing::Eq;
 using testing::Return;
 using testing::IsEmpty;
@@ skipping 153 matching lines @@
     error_callback.Run(json_reader.GetErrorMessage());
   }
 }
 
 // Factory for FakeURLFetcher objects that always generate errors.
 class FailingFakeURLFetcherFactory : public net::URLFetcherFactory {
  public:
   std::unique_ptr<net::URLFetcher> CreateURLFetcher(
       int id, const GURL& url, net::URLFetcher::RequestType request_type,
       net::URLFetcherDelegate* d) override {
-    return base::WrapUnique(new net::FakeURLFetcher(
+    return base::MakeUnique<net::FakeURLFetcher>(
         url, d, /*response_data=*/std::string(), net::HTTP_NOT_FOUND,
-        net::URLRequestStatus::FAILED));
+        net::URLRequestStatus::FAILED);
   }
 };
 
 class MockScheduler : public NTPSnippetsScheduler {
  public:
   MOCK_METHOD4(Schedule,
                bool(base::TimeDelta period_wifi_charging,
                     base::TimeDelta period_wifi,
                     base::TimeDelta period_fallback,
                     base::Time reschedule_time));
   MOCK_METHOD0(Unschedule, bool());
 };
 
-class MockSyncService : public sync_driver::FakeSyncService {
- public:
-  MockSyncService() {}
-  virtual ~MockSyncService() {}
-  MOCK_CONST_METHOD0(CanSyncStart, bool());
-  MOCK_CONST_METHOD0(IsSyncActive, bool());
-  MOCK_CONST_METHOD0(ConfigurationDone, bool());
-  MOCK_CONST_METHOD0(GetActiveDataTypes, syncer::ModelTypeSet());
-};
-
 class MockServiceObserver : public NTPSnippetsServiceObserver {
  public:
   MOCK_METHOD0(NTPSnippetsServiceLoaded, void());
   MOCK_METHOD0(NTPSnippetsServiceShutdown, void());
-  MOCK_METHOD0(NTPSnippetsServiceDisabled, void());
+  MOCK_METHOD1(NTPSnippetsServiceDisabledReasonChanged,
+               void(DisabledReason disabled_reason));
 };
 
 class WaitForDBLoad : public NTPSnippetsServiceObserver {
  public:
   WaitForDBLoad(NTPSnippetsService* service) : service_(service) {
     service_->AddObserver(this);
     if (!service_->ready())
       run_loop_.Run();
   }
 
   ~WaitForDBLoad() override {
     service_->RemoveObserver(this);
   }
 
  private:
   void NTPSnippetsServiceLoaded() override {
     EXPECT_TRUE(service_->ready());
     run_loop_.Quit();
   }
 
   void NTPSnippetsServiceShutdown() override {}
-  void NTPSnippetsServiceDisabled() override {}
+  void NTPSnippetsServiceDisabledReasonChanged(
+      DisabledReason disabled_reason) override {}
 
   NTPSnippetsService* service_;
   base::RunLoop run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(WaitForDBLoad);
 };
 
 }  // namespace
 
-class NTPSnippetsServiceTest : public testing::Test {
+class NTPSnippetsServiceTest : public test::NTPSnippetsTestBase {
  public:
   NTPSnippetsServiceTest()
       : fake_url_fetcher_factory_(
             /*default_factory=*/&failing_url_fetcher_factory_),
         test_url_(base::StringPrintf(kTestContentSnippetsServerFormat,
-                                     google_apis::GetAPIKey().c_str())),
-        pref_service_(new TestingPrefServiceSimple()),
-        signin_client_(new TestSigninClient(nullptr)),
-        account_tracker_(new AccountTrackerService()),
-        fake_signin_manager_(new FakeSigninManagerBase(signin_client_.get(),
-                                                       account_tracker_.get())),
-        fake_token_service_(new FakeProfileOAuth2TokenService()) {
-    NTPSnippetsService::RegisterProfilePrefs(pref_service_->registry());
+                                     google_apis::GetAPIKey().c_str())) {
+    NTPSnippetsService::RegisterProfilePrefs(pref_service()->registry());
+
     // Since no SuggestionsService is injected in tests, we need to force the
     // service to fetch from all hosts.
     base::CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kDontRestrict);
     EXPECT_TRUE(database_dir_.CreateUniqueTempDir());
   }
 
   ~NTPSnippetsServiceTest() override {
     if (service_)
       service_->Shutdown();
 
     // We need to run the message loop after deleting the database, because
     // ProtoDatabaseImpl deletes the actual LevelDB asynchronously on the task
     // runner. Without this, we'd get reports of memory leaks.
     service_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
   void SetUp() override {
-    ResetSyncServiceMock();
+    test::NTPSnippetsTestBase::SetUp();
     EXPECT_CALL(mock_scheduler(), Schedule(_, _, _, _)).Times(1);
     CreateSnippetsService(/*enabled=*/true);
   }
 
   void CreateSnippetsService(bool enabled) {
     if (service_)
       service_->Shutdown();
 
     scoped_refptr<base::SingleThreadTaskRunner> task_runner(
         base::ThreadTaskRunnerHandle::Get());
     scoped_refptr<net::TestURLRequestContextGetter> request_context_getter =
         new net::TestURLRequestContextGetter(task_runner.get());
 
     // Delete the current service, so that the database is destroyed before we
     // create the new one, otherwise opening the new database will fail.
     service_.reset();
 
+    ResetSigninManager();
+    std::unique_ptr<NTPSnippetsFetcher> snippets_fetcher =
+        base::MakeUnique<NTPSnippetsFetcher>(
+            fake_signin_manager(), fake_token_service_.get(),
+            std::move(request_context_getter), base::Bind(&ParseJson),
+            /*is_stable_channel=*/true);
+
+    fake_signin_manager()->SignIn("foo@bar.com");
+    snippets_fetcher->SetPersonalizationForTesting(
+        NTPSnippetsFetcher::Personalization::kNonPersonal);
+
     service_.reset(new NTPSnippetsService(
-        enabled, pref_service_.get(), mock_sync_service_.get(), nullptr,
-        std::string("fr"), &scheduler_,
-        base::WrapUnique(new NTPSnippetsFetcher(
-            fake_signin_manager_.get(), fake_token_service_.get(),
-            std::move(request_context_getter), base::Bind(&ParseJson),
-            /*is_stable_channel=*/true)),
-        /*image_fetcher=*/nullptr, /*image_decoder=*/nullptr,
-        base::WrapUnique(new NTPSnippetsDatabase(database_dir_.path(),
-                                                 task_runner))));
+        enabled, pref_service(), nullptr, "fr", &scheduler_,
+        std::move(snippets_fetcher), /*image_fetcher=*/nullptr,
+        /*image_fetcher=*/nullptr, base::MakeUnique<NTPSnippetsDatabase>(
+                                       database_dir_.path(), task_runner),
+        base::MakeUnique<NTPSnippetsStatusService>(fake_signin_manager(),
+                                                   mock_sync_service())));
+
     if (enabled)
       WaitForDBLoad(service_.get());
   }
 
  protected:
   const GURL& test_url() { return test_url_; }
   NTPSnippetsService* service() { return service_.get(); }
   MockScheduler& mock_scheduler() {  return scheduler_; }
-  MockSyncService* mock_sync_service() { return mock_sync_service_.get(); }
 
   // Provide the json to be returned by the fake fetcher.
   void SetUpFetchResponse(const std::string& json) {
     fake_url_fetcher_factory_.SetFakeResponse(test_url_, json, net::HTTP_OK,
                                               net::URLRequestStatus::SUCCESS);
   }
 
   void LoadFromJSONString(const std::string& json) {
     SetUpFetchResponse(json);
     service()->FetchSnippets();
     base::RunLoop().RunUntilIdle();
   }
 
-  // Call before the service is set up to initialize a sync service.
-  // Subsequent calls reset the return values of the mocked methods.
-  void ResetSyncServiceMock() {
-    if (!mock_sync_service_) {
-      // Use a NiceMock to avoid the "uninteresting call" warnings.
-      mock_sync_service_.reset(new testing::NiceMock<MockSyncService>);
-    }
-
-    ON_CALL(*mock_sync_service_, CanSyncStart()).WillByDefault(Return(true));
-    ON_CALL(*mock_sync_service_, IsSyncActive()).WillByDefault(Return(true));
-    ON_CALL(*mock_sync_service_, ConfigurationDone())
-        .WillByDefault(Return(true));
-    ON_CALL(*mock_sync_service_, GetActiveDataTypes())
-        .WillByDefault(
-            Return(syncer::ModelTypeSet(syncer::HISTORY_DELETE_DIRECTIVES)));
-  }
-
  private:
   base::MessageLoop message_loop_;
   FailingFakeURLFetcherFactory failing_url_fetcher_factory_;
   // Instantiation of factory automatically sets itself as URLFetcher's factory.
   net::FakeURLFetcherFactory fake_url_fetcher_factory_;
   const GURL test_url_;
-  std::unique_ptr<TestingPrefServiceSimple> pref_service_;
-  std::unique_ptr<TestSigninClient> signin_client_;
-  std::unique_ptr<AccountTrackerService> account_tracker_;
-  std::unique_ptr<MockSyncService> mock_sync_service_;  // Null by default.
-  std::unique_ptr<SigninManagerBase> fake_signin_manager_;
   std::unique_ptr<OAuth2TokenService> fake_token_service_;
   MockScheduler scheduler_;
   // Last so that the dependencies are deleted after the service.
   std::unique_ptr<NTPSnippetsService> service_;
 
   base::ScopedTempDir database_dir_;
 
   DISALLOW_COPY_AND_ASSIGN(NTPSnippetsServiceTest);
 };
 
 class NTPSnippetsServiceDisabledTest : public NTPSnippetsServiceTest {
  public:
   void SetUp() override {
+    test::NTPSnippetsTestBase::SetUp();
     EXPECT_CALL(mock_scheduler(), Unschedule()).Times(1);
     CreateSnippetsService(/*enabled=*/false);
   }
 };
 
 TEST_F(NTPSnippetsServiceTest, ScheduleIfEnabled) {
   // SetUp() checks that Schedule is called.
 }
 
 TEST_F(NTPSnippetsServiceDisabledTest, Unschedule) {
@@ skipping 462 matching lines @@
   // Discard the snippet via the mashable source corpus ID.
   EXPECT_TRUE(service()->DiscardSnippet(source_urls[0]));
   EXPECT_THAT(service()->snippets(), IsEmpty());
 
   // The same article from the AOL domain should now be detected as discarded.
   LoadFromJSONString(GetTestJson({GetSnippetWithUrlAndTimesAndSources(
       source_urls[1], creation, expiry, source_urls, publishers, amp_urls)}));
   ASSERT_THAT(service()->snippets(), IsEmpty());
 }
 
-TEST_F(NTPSnippetsServiceTest, SyncStateCompatibility) {
-  // The default test setup has a compatible sync state.
-  EXPECT_EQ(DisabledReason::NONE, service()->GetDisabledReason());
-
-  // History sync disabled.
-  ON_CALL(*mock_sync_service(), GetActiveDataTypes())
-      .WillByDefault(Return(syncer::ModelTypeSet()));
-  EXPECT_EQ(DisabledReason::HISTORY_SYNC_DISABLED,
-            service()->GetDisabledReason());
-  ResetSyncServiceMock();
-
-  // Not done loading.
-  ON_CALL(*mock_sync_service(), ConfigurationDone())
-      .WillByDefault(Return(false));
-  ON_CALL(*mock_sync_service(), GetActiveDataTypes())
-      .WillByDefault(Return(syncer::ModelTypeSet()));
-  EXPECT_EQ(DisabledReason::HISTORY_SYNC_STATE_UNKNOWN,
-            service()->GetDisabledReason());
-  ResetSyncServiceMock();
-
-  // Sync disabled.
-  ON_CALL(*mock_sync_service(), CanSyncStart()).WillByDefault(Return(false));
-  EXPECT_EQ(DisabledReason::HISTORY_SYNC_DISABLED,
-            service()->GetDisabledReason());
-  ResetSyncServiceMock();
-
-  // No service.
-  service()->sync_service_ = nullptr;
-  EXPECT_EQ(DisabledReason::HISTORY_SYNC_DISABLED,
-            service()->GetDisabledReason());
-}
-
 TEST_F(NTPSnippetsServiceTest, HistorySyncStateChanges) {
   MockServiceObserver mock_observer;
   service()->AddObserver(&mock_observer);
 
-  // Simulate user disabled sync.
-  ON_CALL(*mock_sync_service(), CanSyncStart()).WillByDefault(Return(false));
-  // The service should notify observers it's been disabled and clear the
-  // snippets instead of pulling new ones.
-  EXPECT_CALL(mock_observer, NTPSnippetsServiceDisabled());
+  // Simulate user signed out
   SetUpFetchResponse(GetTestJson({GetSnippet()}));
-  service()->OnStateChanged();
+  EXPECT_CALL(mock_observer, NTPSnippetsServiceDisabledReasonChanged(
+                                 DisabledReason::SIGNED_OUT));
+  service()->UpdateStateForStatus(DisabledReason::SIGNED_OUT);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(NTPSnippetsService::State::DISABLED, service()->state_);
   EXPECT_THAT(service()->snippets(), IsEmpty()); // No fetch should be made.
 
-  // Simulate user sign in.
-  ResetSyncServiceMock();
-  // The service should be ready again and load snippets.
+  // Simulate user sign in. The service should be ready again and load snippets.
+  SetUpFetchResponse(GetTestJson({GetSnippet()}));
+  EXPECT_CALL(mock_observer,
+              NTPSnippetsServiceDisabledReasonChanged(DisabledReason::NONE));
   EXPECT_CALL(mock_scheduler(), Schedule(_, _, _, _)).Times(1);
-  SetUpFetchResponse(GetTestJson({GetSnippet()}));
-  service()->OnStateChanged();
+  service()->UpdateStateForStatus(DisabledReason::NONE);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(NTPSnippetsService::State::READY, service()->state_);
   EXPECT_FALSE(service()->snippets().empty());
 
   service()->RemoveObserver(&mock_observer);
 }
 
 }  // namespace ntp_snippets