[Doodle] Automatically expire Doodles after their TTL

components/doodle/doodle_service_unittest.cc

 // Copyright 2017 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/doodle/doodle_service.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
+#include "base/memory/ref_counted.h"
+#include "base/test/simple_test_tick_clock.h"
+#include "base/test/test_simple_task_runner.h"
 #include "base/time/time.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::Eq;
 using testing::StrictMock;
 
 namespace doodle {
 
 namespace {
@@ skipping 25 matching lines @@
 class MockDoodleObserver : public DoodleService::Observer {
  public:
   MOCK_METHOD1(OnDoodleConfigUpdated,
                void(const base::Optional<DoodleConfig>&));
 };
 
 }  // namespace
 
 class DoodleServiceTest : public testing::Test {
  public:
   DoodleServiceTest() : fetcher_(nullptr) {

[fhorschig, 2017/03/02 20:12:59]

expiry_timer_(nullptr)?

[Marc Treib, 2017/03/03 10:06:58]

Indeed, thanks!

+    tick_clock_.SetNowTicks(base::TimeTicks::UnixEpoch() +
+                            base::TimeDelta::FromDays(5000));
+    task_runner_ = new base::TestSimpleTaskRunner();

[fhorschig, 2017/03/02 20:12:59]

any reason you don't initialize this earlier?
(initializer-list)

[Marc Treib, 2017/03/03 10:06:57]

Nope. Done.

+
+    auto expiry_timer = base::MakeUnique<base::OneShotTimer>(&tick_clock_);
+    expiry_timer->SetTaskRunner(task_runner_);
+    expiry_timer_ = expiry_timer.get();
+
     auto fetcher = base::MakeUnique<FakeDoodleFetcher>();
     fetcher_ = fetcher.get();
-    service_ = base::MakeUnique<DoodleService>(std::move(fetcher));
+
+    service_ = base::MakeUnique<DoodleService>(std::move(fetcher),
+                                               std::move(expiry_timer));
   }
 
   DoodleService* service() { return service_.get(); }
   FakeDoodleFetcher* fetcher() { return fetcher_; }
 
-  base::TimeDelta some_time() const { return base::TimeDelta::FromHours(1); }
+  base::TestSimpleTaskRunner* task_runner() { return task_runner_.get(); }
+
+  base::TimeDelta SomeTime() const { return base::TimeDelta::FromHours(1); }

[fhorschig, 2017/03/02 20:12:59]

When it was lower_case, it used to be pretty clear that it's only a get.
Maybe call it |AnHour()| so it's clearer it's const.
... can we make it an implementation detail?

[Marc Treib, 2017/03/03 10:06:58]

I don't know what you mean by "implementation detail". Anyway, it's gone now.

 
  private:
+  // Weak, owned by the service.
+  FakeDoodleFetcher* fetcher_;
+
+  base::SimpleTestTickClock tick_clock_;
+  scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
+  // Weak, owned by the service.
+  base::OneShotTimer* expiry_timer_;

[fhorschig, 2017/03/02 20:12:59]

nitty nit: Would be nice to visually group the weak references.
(moving up or down)

[Marc Treib, 2017/03/03 10:06:58]

To me, the "logical" grouping (clock + task_runner + timer belong together) is
more important than the "weak" property.

+
   std::unique_ptr<DoodleService> service_;
-  FakeDoodleFetcher* fetcher_;
 };
 
 TEST_F(DoodleServiceTest, FetchesConfigOnRefresh) {
   ASSERT_THAT(service()->config(), Eq(base::nullopt));
 
   // Request a refresh of the doodle config.
   service()->Refresh();
   // The request should have arrived at the fetcher.
   EXPECT_THAT(fetcher()->num_pending_callbacks(), Eq(1u));
 
   // Serve it (with an arbitrary config).
   DoodleConfig config;
   config.doodle_type = DoodleType::SIMPLE;
-  fetcher()->ServeAllCallbacks(DoodleState::AVAILABLE, some_time(), config);
+  fetcher()->ServeAllCallbacks(DoodleState::AVAILABLE, SomeTime(), config);
 
   // The config should be available.
   EXPECT_THAT(service()->config(), Eq(config));
 
   // Request a refresh again.
   service()->Refresh();
   // The request should have arrived at the fetcher again.
   EXPECT_THAT(fetcher()->num_pending_callbacks(), Eq(1u));
 
   // Serve it with a different config.
   DoodleConfig other_config;
   other_config.doodle_type = DoodleType::SLIDESHOW;
   DCHECK(config != other_config);
-  fetcher()->ServeAllCallbacks(DoodleState::AVAILABLE, some_time(),
+  fetcher()->ServeAllCallbacks(DoodleState::AVAILABLE, SomeTime(),
                                other_config);
 
   // The config should have been updated.
   EXPECT_THAT(service()->config(), Eq(other_config));
 }
 
 TEST_F(DoodleServiceTest, CallsObserverOnConfigReceived) {
   StrictMock<MockDoodleObserver> observer;
   service()->AddObserver(&observer);
 
   ASSERT_THAT(service()->config(), Eq(base::nullopt));
 
   // Request a refresh of the doodle config.
   service()->Refresh();
   // The request should have arrived at the fetcher.
   ASSERT_THAT(fetcher()->num_pending_callbacks(), Eq(1u));
 
   // Serve it (with an arbitrary config). The observer should get notified.
   DoodleConfig config;
   config.doodle_type = DoodleType::SIMPLE;
   EXPECT_CALL(observer, OnDoodleConfigUpdated(Eq(config)));
-  fetcher()->ServeAllCallbacks(DoodleState::AVAILABLE, some_time(), config);
+  fetcher()->ServeAllCallbacks(DoodleState::AVAILABLE, SomeTime(), config);
 
   // Remove the observer before the service gets destroyed.
   service()->RemoveObserver(&observer);
 }
 
 TEST_F(DoodleServiceTest, CallsObserverOnConfigRemoved) {
   // Load some doodle config.
   service()->Refresh();
   DoodleConfig config;
   config.doodle_type = DoodleType::SIMPLE;
-  fetcher()->ServeAllCallbacks(DoodleState::AVAILABLE, some_time(), config);
+  fetcher()->ServeAllCallbacks(DoodleState::AVAILABLE, SomeTime(), config);
   ASSERT_THAT(service()->config(), Eq(config));
 
   // Register an observer and request a refresh.
   StrictMock<MockDoodleObserver> observer;
   service()->AddObserver(&observer);
   service()->Refresh();
   ASSERT_THAT(fetcher()->num_pending_callbacks(), Eq(1u));
 
   // Serve the request with an empty doodle config. The observer should get
   // notified.
   EXPECT_CALL(observer, OnDoodleConfigUpdated(Eq(base::nullopt)));
   fetcher()->ServeAllCallbacks(DoodleState::NO_DOODLE, base::TimeDelta(),
                                base::nullopt);
 
   // Remove the observer before the service gets destroyed.
   service()->RemoveObserver(&observer);
 }
 
 TEST_F(DoodleServiceTest, CallsObserverOnConfigUpdated) {
   // Load some doodle config.
   service()->Refresh();
   DoodleConfig config;
   config.doodle_type = DoodleType::SIMPLE;
-  fetcher()->ServeAllCallbacks(DoodleState::AVAILABLE, some_time(), config);
+  fetcher()->ServeAllCallbacks(DoodleState::AVAILABLE, SomeTime(), config);
   ASSERT_THAT(service()->config(), Eq(config));
 
   // Register an observer and request a refresh.
   StrictMock<MockDoodleObserver> observer;
   service()->AddObserver(&observer);
   service()->Refresh();
   ASSERT_THAT(fetcher()->num_pending_callbacks(), Eq(1u));
 
   // Serve the request with a different doodle config. The observer should get
   // notified.
   DoodleConfig other_config;
   other_config.doodle_type = DoodleType::SLIDESHOW;
   DCHECK(config != other_config);
   EXPECT_CALL(observer, OnDoodleConfigUpdated(Eq(other_config)));
-  fetcher()->ServeAllCallbacks(DoodleState::AVAILABLE, some_time(),
+  fetcher()->ServeAllCallbacks(DoodleState::AVAILABLE, SomeTime(),
                                other_config);
 
   // Remove the observer before the service gets destroyed.
   service()->RemoveObserver(&observer);
 }
 
-TEST_F(DoodleServiceTest, DoesNotCallObserverWhenConfigEquivalent) {
+TEST_F(DoodleServiceTest, DoesNotCallObserverIfConfigEquivalent) {
   // Load some doodle config.
   service()->Refresh();
   DoodleConfig config;
   config.doodle_type = DoodleType::SIMPLE;
-  fetcher()->ServeAllCallbacks(DoodleState::AVAILABLE, some_time(), config);
+  fetcher()->ServeAllCallbacks(DoodleState::AVAILABLE, SomeTime(), config);
   ASSERT_THAT(service()->config(), Eq(config));
 
   // Register an observer and request a refresh.
   StrictMock<MockDoodleObserver> observer;
   service()->AddObserver(&observer);
   service()->Refresh();
   ASSERT_THAT(fetcher()->num_pending_callbacks(), Eq(1u));
 
   // Serve the request with an equivalent doodle config. The observer should
   // *not* get notified.
   DoodleConfig equivalent_config;
   equivalent_config.doodle_type = DoodleType::SIMPLE;
   DCHECK(config == equivalent_config);
-  fetcher()->ServeAllCallbacks(DoodleState::AVAILABLE, some_time(),
+  fetcher()->ServeAllCallbacks(DoodleState::AVAILABLE, SomeTime(),
                                equivalent_config);
 
   // Remove the observer before the service gets destroyed.
   service()->RemoveObserver(&observer);
 }
 
+TEST_F(DoodleServiceTest, CallsObserverWhenConfigExpires) {
+  // Load some doodle config.
+  service()->Refresh();
+  DoodleConfig config;
+  config.doodle_type = DoodleType::SIMPLE;
+  fetcher()->ServeAllCallbacks(DoodleState::AVAILABLE, SomeTime(), config);
+  ASSERT_THAT(service()->config(), Eq(config));
+
+  // Make sure the task arrived at the timer's task runner.
+  ASSERT_THAT(task_runner()->NumPendingTasks(), Eq(1u));
+  EXPECT_THAT(task_runner()->NextPendingTaskDelay(), Eq(SomeTime()));
+
+  // Register an observer.
+  StrictMock<MockDoodleObserver> observer;
+  service()->AddObserver(&observer);
+
+  // Run the expiry task. The observer should get notified that there's no
+  // config anymore.
+  EXPECT_CALL(observer, OnDoodleConfigUpdated(Eq(base::nullopt)));
+  task_runner()->RunPendingTasks();

[Marc Treib, 2017/03/02 18:51:02]

So, this is the famous and amazing TestSimpleTaskRunner in action. Admittedly
it's less than optimal; it ignores time completely. But the only alternative I
can see would be using a full MessageLoop with its MessageLoopTaskRunner. But
that seems messy and hard to control, e.g. there's no way to inject a Clock as
far as I can tell.

[fhorschig, 2017/03/02 20:12:59]

What about TestMockTimeTaskRunner. As far as I know, it's the same but it
allows to fast forward:
https://cs.chromium.org/chromium/src/base/test/test_mock_time_task_runner.h?t...

This even comes with a free Mock{Tick,}Clock.
We used it once already:
https://cs.chromium.org/chromium/src/components/ntp_snippets/remote/remote_su...

[Marc Treib, 2017/03/03 10:06:58]

D'oh, forgot about that one again. Thanks for the pointer!
Done.

+
+  // Remove the observer before the service gets destroyed.
+  service()->RemoveObserver(&observer);
+}
+
+TEST_F(DoodleServiceTest, DisregardsAlreadyExpiredConfigs) {
+  StrictMock<MockDoodleObserver> observer;
+  service()->AddObserver(&observer);
+
+  ASSERT_THAT(service()->config(), Eq(base::nullopt));
+
+  // Load an already-expired config. This should have no effect; in particular
+  // no call to the observer.
+  service()->Refresh();
+  DoodleConfig config;
+  config.doodle_type = DoodleType::SIMPLE;
+  fetcher()->ServeAllCallbacks(DoodleState::AVAILABLE,
+                               base::TimeDelta::FromSeconds(0), config);
+  EXPECT_THAT(service()->config(), Eq(base::nullopt));
+
+  // Load a doodle config as usual. Nothing to see here.
+  service()->Refresh();
+  EXPECT_CALL(observer, OnDoodleConfigUpdated(Eq(config)));
+  fetcher()->ServeAllCallbacks(DoodleState::AVAILABLE, SomeTime(), config);
+  ASSERT_THAT(service()->config(), Eq(config));
+
+  // Now load an expired config again. The cached one should go away.
+  service()->Refresh();
+  EXPECT_CALL(observer, OnDoodleConfigUpdated(Eq(base::nullopt)));
+  fetcher()->ServeAllCallbacks(DoodleState::AVAILABLE,
+                               base::TimeDelta::FromSeconds(0), config);
+
+  // Remove the observer before the service gets destroyed.
+  service()->RemoveObserver(&observer);
+}
+
 }  // namespace doodle