[NTP Snippets] Add tests for scheduling/unscheduling

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 "base/json/json_reader.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/ntp_snippets/ntp_snippet.h"
 #include "components/ntp_snippets/ntp_snippets_fetcher.h"
+#include "components/ntp_snippets/ntp_snippets_scheduler.h"
 #include "components/prefs/testing_pref_service.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::_;
+
 namespace ntp_snippets {
 
 namespace {
 
 const base::Time::Exploded kDefaultCreationTime = {2015, 11, 4, 25, 13, 46, 45};
 
 base::Time GetDefaultCreationTime() {
   return base::Time::FromUTCExploded(kDefaultCreationTime);
 }
 
@@ skipping 63 matching lines @@
   scoped_ptr<base::Value> value = json_reader.ReadToValue(json);
   bool success = !!value;
   EXPECT_EQ(expect_success, success);
   if (value) {
     success_callback.Run(std::move(value));
   } else {
     error_callback.Run(json_reader.GetErrorMessage());
   }
 }
 
+class MockScheduler : public NTPSnippetsScheduler {
+ public:
+  MockScheduler() {}

[Bernhard Bauer, 2016/04/20 11:25:57]

Nit: I would just remove the default constructor and destructor -- the compiler
is going to generate them anyway, right?

[Marc Treib, 2016/04/20 12:03:04]

Done.

+  ~MockScheduler() {}
+
+  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());
+};
+
 }  // namespace
 
 class NTPSnippetsServiceTest : public testing::Test {
  public:
   NTPSnippetsServiceTest()
       : pref_service_(new TestingPrefServiceSimple()) {}
   ~NTPSnippetsServiceTest() override {}
 
   void SetUp() override {
     NTPSnippetsService::RegisterProfilePrefs(pref_service_->registry());
 
     CreateSnippetsService();
   }
 
-  void CreateSnippetsService() {
+  virtual void CreateSnippetsService() {
+    CreateSnippetsServiceEnabled(true);
+  }
+
+  void CreateSnippetsServiceEnabled(bool enabled) {
+    scheduler_.reset(new MockScheduler);
     scoped_refptr<base::SingleThreadTaskRunner> task_runner(
         base::ThreadTaskRunnerHandle::Get());
     scoped_refptr<net::TestURLRequestContextGetter> request_context_getter =
         new net::TestURLRequestContextGetter(task_runner.get());
 
     service_.reset(new NTPSnippetsService(
-        pref_service_.get(), nullptr, task_runner, std::string("fr"), nullptr,
+        pref_service_.get(), nullptr, task_runner, std::string("fr"),
+        scheduler_.get(),
         make_scoped_ptr(new NTPSnippetsFetcher(
             task_runner, std::move(request_context_getter), true)),
         base::Bind(&ParseJson, true)));
-    service_->Init(true);
+    if (enabled)
+      EXPECT_CALL(*scheduler_, Schedule(_, _, _, _));
+    else
+      EXPECT_CALL(*scheduler_, Unschedule());
+    service_->Init(enabled);
   }
 
  protected:
-  NTPSnippetsService* service() {
-    return service_.get();
-  }
+  NTPSnippetsService* service() { return service_.get(); }
 
   void LoadFromJSONString(const std::string& json) {
     service_->OnSnippetsDownloaded(json);
   }
 
   void SetExpectJsonParseSuccess(bool expect_success) {
     service_->parse_json_callback_ = base::Bind(&ParseJson, expect_success);
   }
 
  private:
   base::MessageLoop message_loop_;
   scoped_ptr<TestingPrefServiceSimple> pref_service_;
   scoped_ptr<NTPSnippetsService> service_;
+  scoped_ptr<MockScheduler> scheduler_;
 
   DISALLOW_COPY_AND_ASSIGN(NTPSnippetsServiceTest);
 };
 
+class NTPSnippetsServiceDisabledTest : public NTPSnippetsServiceTest {
+ public:
+  void CreateSnippetsService() override {
+    CreateSnippetsServiceEnabled(false);
+  }
+};
+
+TEST_F(NTPSnippetsServiceTest, Schedule) {
+  // CreateSnippetsServiceEnabled checks that Schedule is called.

[Bernhard Bauer, 2016/04/20 11:25:57]

This is a bit strange, but I guess it works...

[Marc Treib, 2016/04/20 12:03:04]

Well, suggestions for improvement welcome :)

+}
+
+TEST_F(NTPSnippetsServiceDisabledTest, Unschedule) {
+  // CreateSnippetsServiceEnabled checks that Unschedule is called.
+}
+
 TEST_F(NTPSnippetsServiceTest, Loop) {
   std::string json_str(
       "{ \"recos\": [ "
       "{ \"contentInfo\": { \"url\" : \"http://localhost/foobar\" }}"
       "]}");
   LoadFromJSONString(json_str);
 
   // The same for loop without the '&' should not compile.
   for (auto& snippet : *service()) {
     // Snippet here is a const.
@@ skipping 133 matching lines @@
 }
 
 TEST_F(NTPSnippetsServiceTest, RemoveExpiredContent) {
   std::string json_str(GetTestExpiredJson());
 
   LoadFromJSONString(json_str);
   EXPECT_EQ(service()->size(), 0u);
 }
 
 }  // namespace ntp_snippets