📰 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_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/switches.h"
+#include "components/prefs/pref_registry_simple.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/signin/core/common/signin_pref_names.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;
@@ skipping 177 matching lines @@
   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(IsEncryptEverythingEnabled, 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) {
+  WaitForDBLoad(NTPSnippetsService* service, bool check_state)
+      : service_(service), check_state_(check_state) {
     service_->AddObserver(this);
     if (!service_->ready())
       run_loop_.Run();
   }
 
   ~WaitForDBLoad() override {
     service_->RemoveObserver(this);
   }
 
  private:
   void NTPSnippetsServiceLoaded() override {
-    EXPECT_TRUE(service_->ready());
+    if (check_state_)
+      EXPECT_TRUE(service_->ready());
     run_loop_.Quit();
   }
 
   void NTPSnippetsServiceShutdown() override {}
-  void NTPSnippetsServiceDisabled() override {}
+  void NTPSnippetsServiceDisabledReasonChanged(
+      DisabledReason disabled_reason) override {}
 
   NTPSnippetsService* service_;
+  bool check_state_;
   base::RunLoop run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(WaitForDBLoad);
 };
 
 }  // namespace
 
 class NTPSnippetsServiceTest : public testing::Test {
  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)),
+        signin_client_(new TestSigninClient(pref_service_.get())),
         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());
+    RegisterSigninManagerPrefs();
+
     // 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();
     EXPECT_CALL(mock_scheduler(), Schedule(_, _, _, _)).Times(1);
-    CreateSnippetsService(/*enabled=*/true);
+    CreateSnippetsService(/*enabled=*/true, /*sign_in=*/true);
   }
 
-  void CreateSnippetsService(bool enabled) {
+  void CreateSnippetsService(bool enabled, bool sign_in) {
     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();
 
+    fake_signin_manager_.reset(new FakeSigninManagerBase(

[Bernhard Bauer, 2016/06/16 14:03:35]

I would store this in a raw FakeSigninManagerBase* so you can access it below
without the static cast.

[dgn, 2016/06/16 14:34:10]

Done.

+        signin_client_.get(), account_tracker_.get()));
+
+    NTPSnippetsFetcher* snippets_fetcher = new NTPSnippetsFetcher(
+        fake_signin_manager_.get(), fake_token_service_.get(),
+        std::move(request_context_getter), base::Bind(&ParseJson),
+        /*is_stable_channel=*/true);
+
+    if (sign_in) {
+      static_cast<FakeSigninManagerBase*>(fake_signin_manager_.get())
+          ->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,
-        base::WrapUnique(new NTPSnippetsDatabase(database_dir_.path(),
-                                                 task_runner))));
+        enabled, pref_service_.get(), fake_signin_manager_.get(),
+        mock_sync_service_.get(), nullptr, std::string("fr"), &scheduler_,
+        base::WrapUnique(snippets_fetcher), /*image_fetcher=*/nullptr,
+        base::WrapUnique(
+            new NTPSnippetsDatabase(database_dir_.path(), task_runner))));
+
     if (enabled)
-      WaitForDBLoad(service_.get());
+      WaitForDBLoad(service_.get(), sign_in);
   }
 
  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) {
@@ skipping 10 matching lines @@
   // 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_, IsEncryptEverythingEnabled())
+        .WillByDefault(Return(false));
     ON_CALL(*mock_sync_service_, ConfigurationDone())
         .WillByDefault(Return(true));
     ON_CALL(*mock_sync_service_, GetActiveDataTypes())
         .WillByDefault(
             Return(syncer::ModelTypeSet(syncer::HISTORY_DELETE_DIRECTIVES)));
   }
 
+  void RegisterSigninManagerPrefs() {
+    pref_service_->registry()->RegisterStringPref(
+        prefs::kGoogleServicesAccountId, std::string());
+    pref_service_->registry()->RegisterStringPref(
+        prefs::kGoogleServicesLastAccountId, std::string());
+    pref_service_->registry()->RegisterStringPref(
+        prefs::kGoogleServicesLastUsername, std::string());
+  }
+
  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 {
     EXPECT_CALL(mock_scheduler(), Unschedule()).Times(1);
-    CreateSnippetsService(/*enabled=*/false);
+    CreateSnippetsService(/*enabled=*/false, /*sign_in=*/true);
   }
 };
 
 TEST_F(NTPSnippetsServiceTest, ScheduleIfEnabled) {
   // SetUp() checks that Schedule is called.
 }
 
 TEST_F(NTPSnippetsServiceDisabledTest, Unschedule) {
   // SetUp() checks that Unschedule is called.
 }
@@ skipping 111 matching lines @@
   // Discard the snippet.
   EXPECT_TRUE(service()->DiscardSnippet(kSnippetUrl));
   EXPECT_THAT(service()->snippets(), IsEmpty());
 
   // Make sure that fetching the same snippet again does not re-add it.
   LoadFromJSONString(json_str);
   EXPECT_THAT(service()->snippets(), IsEmpty());
 
   // The snippet should stay discarded even after re-creating the service.
   EXPECT_CALL(mock_scheduler(), Schedule(_, _, _, _)).Times(1);
-  CreateSnippetsService(/*enabled=*/true);
+  CreateSnippetsService(/*enabled=*/true, /*sign_in=*/true);
   LoadFromJSONString(json_str);
   EXPECT_THAT(service()->snippets(), IsEmpty());
 
   // The snippet can be added again after clearing discarded snippets.
   service()->ClearDiscardedSnippets();
   EXPECT_THAT(service()->snippets(), IsEmpty());
   LoadFromJSONString(json_str);
   EXPECT_THAT(service()->snippets(), SizeIs(1));
 }
 
@@ skipping 295 matching lines @@
   // Discarded snippets shouldn't influence NumArticlesFetched.
   EXPECT_THAT(tester.GetAllSamples("NewTabPage.Snippets.NumArticlesFetched"),
               ElementsAre(base::Bucket(/*min=*/0, /*count=*/1),
                           base::Bucket(/*min=*/1, /*count=*/3)));
   EXPECT_THAT(
       tester.GetAllSamples("NewTabPage.Snippets.NumArticlesZeroDueToDiscarded"),
       ElementsAre(base::Bucket(/*min=*/1, /*count=*/1)));
   // Recreating the service and loading from prefs shouldn't count as fetched
   // articles.
   EXPECT_CALL(mock_scheduler(), Schedule(_, _, _, _)).Times(1);
-  CreateSnippetsService(/*enabled=*/true);
+  CreateSnippetsService(/*enabled=*/true, /*sign_in=*/true);
   tester.ExpectTotalCount("NewTabPage.Snippets.NumArticlesFetched", 4);
 }
 
 TEST_F(NTPSnippetsServiceTest, DiscardShouldRespectAllKnownUrls) {
   const std::string creation =
       NTPSnippet::TimeToJsonString(GetDefaultCreationTime());
   const std::string expiry =
       NTPSnippet::TimeToJsonString(GetDefaultExpirationTime());
   const std::vector<std::string> source_urls = {
       "http://mashable.com/2016/05/11/stolen",
@@ skipping 14 matching lines @@
   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());
+  EXPECT_EQ(DisabledReason::NONE, service()->GetNewDisabledReason());
 
   // History sync disabled.
   ON_CALL(*mock_sync_service(), GetActiveDataTypes())
       .WillByDefault(Return(syncer::ModelTypeSet()));
   EXPECT_EQ(DisabledReason::HISTORY_SYNC_DISABLED,
-            service()->GetDisabledReason());
-  ResetSyncServiceMock();
+            service()->GetNewDisabledReason());
+
+  // Encryption enabled.
+  ON_CALL(*mock_sync_service(), IsEncryptEverythingEnabled())
+      .WillByDefault(Return(true));
+  EXPECT_EQ(DisabledReason::PASSPHRASE_ENCRYPTION_ENABLED,
+            service()->GetNewDisabledReason());
 
   // 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();
+            service()->GetNewDisabledReason());
 
   // Sync disabled.
   ON_CALL(*mock_sync_service(), CanSyncStart()).WillByDefault(Return(false));
-  EXPECT_EQ(DisabledReason::HISTORY_SYNC_DISABLED,
-            service()->GetDisabledReason());
-  ResetSyncServiceMock();
+  EXPECT_EQ(DisabledReason::SYNC_DISABLED, service()->GetNewDisabledReason());
 
-  // No service.
+  // No sync service.
   service()->sync_service_ = nullptr;
-  EXPECT_EQ(DisabledReason::HISTORY_SYNC_DISABLED,
-            service()->GetDisabledReason());
+  EXPECT_EQ(DisabledReason::SYNC_DISABLED, service()->GetNewDisabledReason());
+
+  // Signed out.
+  CreateSnippetsService(/*enabled=*/true, /*sign_in=*/false);
+  EXPECT_EQ(DisabledReason::SIGNED_OUT, service()->GetNewDisabledReason());
+
+  CreateSnippetsService(/*enabled=*/false, /*sign_in=*/true);
+  EXPECT_EQ(DisabledReason::EXPLICITLY_DISABLED,
+            service()->GetNewDisabledReason());
 }
 
 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());
+  EXPECT_CALL(mock_observer, NTPSnippetsServiceDisabledReasonChanged(
+                                 DisabledReason::SYNC_DISABLED));
   SetUpFetchResponse(GetTestJson({GetSnippet()}));
   service()->OnStateChanged();
   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.
   EXPECT_CALL(mock_scheduler(), Schedule(_, _, _, _)).Times(1);
+  EXPECT_CALL(mock_observer,
+              NTPSnippetsServiceDisabledReasonChanged(DisabledReason::NONE));
   SetUpFetchResponse(GetTestJson({GetSnippet()}));
   service()->OnStateChanged();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(NTPSnippetsService::State::READY, service()->state_);
   EXPECT_FALSE(service()->snippets().empty());
 
   service()->RemoveObserver(&mock_observer);
 }
 
 }  // namespace ntp_snippets