[NTP Snippets] Unschedule fetches when the service should be disabled

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/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"
@@ skipping 195 matching lines @@
   MOCK_CONST_METHOD0(GetActiveDataTypes, syncer::ModelTypeSet());
 };
 
 class MockServiceObserver : public NTPSnippetsServiceObserver {
  public:
   MOCK_METHOD0(NTPSnippetsServiceLoaded, void());
   MOCK_METHOD0(NTPSnippetsServiceShutdown, void());
   MOCK_METHOD0(NTPSnippetsServiceDisabled, void());
 };
 
+class WaitForDBLoad : public NTPSnippetsServiceObserver {
+ public:
+  WaitForDBLoad(NTPSnippetsService* service) : service_(service) {
+    EXPECT_TRUE(!service_->loaded());
+    service_->AddObserver(this);
+    run_loop_.Run();
+  }
+
+  ~WaitForDBLoad() override {
+    service_->RemoveObserver(this);
+  }
+
+ private:
+  void NTPSnippetsServiceLoaded() override {
+    EXPECT_TRUE(service_->loaded());
+    run_loop_.Quit();
+  }
+
+  void NTPSnippetsServiceShutdown() override {};
+  void NTPSnippetsServiceDisabled() override {};
+
+  NTPSnippetsService* service_;
+  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)),
         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());
     // 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();
   }
 
   void SetUp() override {
+    ResetSyncServiceMock();
     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();
+
     service_.reset(new NTPSnippetsService(
-        pref_service_.get(), mock_sync_service_.get(), nullptr, task_runner,
+        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_fetcher=*/nullptr,
+        base::WrapUnique(new NTPSnippetsDatabase(database_dir_.path(),
+                                                 task_runner))));
     service_->Init(enabled);
+    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) {
@@ skipping 33 matching lines @@
   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 NTPSnippetsServiceWithSyncTest : public NTPSnippetsServiceTest {
  public:
   void SetUp() override {
-    ResetSyncServiceMock();
+    // ResetSyncServiceMock();
     NTPSnippetsServiceTest::SetUp();
   }
 };
 
 class NTPSnippetsServiceDisabledTest : public NTPSnippetsServiceTest {
  public:
   void SetUp() override {
     EXPECT_CALL(mock_scheduler(), Unschedule()).Times(1);
     CreateSnippetsService(/*enabled=*/false);
   }
@@ skipping 471 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(NTPSnippetsServiceWithSyncTest, SyncStateCompatibility) {
   // The default test setup has a compatible sync state.
-  EXPECT_FALSE(service()->IsSyncStateIncompatible());
+  EXPECT_EQ(DisabledReason::NONE, service()->GetDisabledReason());
 
   // History sync disabled.
   ON_CALL(*mock_sync_service(), GetActiveDataTypes())
       .WillByDefault(Return(syncer::ModelTypeSet()));
-  EXPECT_TRUE(service()->IsSyncStateIncompatible());
+  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_FALSE(service()->IsSyncStateIncompatible());
+  EXPECT_EQ(DisabledReason::HISTORY_SYNC_DISABLED, service()->GetDisabledReason());
   ResetSyncServiceMock();
 
   // Sync disabled.
   ON_CALL(*mock_sync_service(), CanSyncStart()).WillByDefault(Return(false));
-  EXPECT_TRUE(service()->IsSyncStateIncompatible());
+  EXPECT_EQ(DisabledReason::HISTORY_SYNC_DISABLED, service()->GetDisabledReason());
   ResetSyncServiceMock();
 
   // No service.
   service()->sync_service_ = nullptr;
-  EXPECT_TRUE(service()->IsSyncStateIncompatible());
+  EXPECT_EQ(DisabledReason::HISTORY_SYNC_DISABLED, service()->GetDisabledReason());
 }
 
 TEST_F(NTPSnippetsServiceWithSyncTest, 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());
   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.
   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