[Doodle] Replace the expiry_date in DoodleConfig by time_to_live

components/doodle/doodle_fetcher_impl_unittest.cc

 // Copyright 2016 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_fetcher_impl.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
-#include "base/test/simple_test_clock.h"
 #include "base/values.h"
 #include "components/google/core/browser/google_switches.h"
 #include "components/google/core/browser/google_url_tracker.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_status.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 44 matching lines @@
 
 class DoodleFetcherImplTest : public testing::Test {
  public:
   DoodleFetcherImplTest()
       : url_(GURL(GoogleURLTracker::kDefaultGoogleHomepage)),
         google_url_tracker_(base::MakeUnique<GoogleURLTrackerClientStub>(),
                             GoogleURLTracker::UNIT_TEST_MODE),
         doodle_fetcher_(
             new net::TestURLRequestContextGetter(message_loop_.task_runner()),
             &google_url_tracker_,
-            base::Bind(ParseJson)) {
-    // Random difference to ensure that expiry_dates are really relative.
-    auto clock = base::MakeUnique<base::SimpleTestClock>();
-    clock_ = clock.get();
-    clock_->Advance(base::TimeDelta::FromMilliseconds(1123581321));
-    doodle_fetcher_.SetClockForTesting(std::move(clock));
-  }
+            base::Bind(ParseJson)) {}
 
   void RespondWithData(const std::string& data) {
     RespondToFetcherWithData(GetRunningFetcher(), data);
   }
 
   void RespondToFetcherWithData(net::TestURLFetcher* url_fetcher,
                                 const std::string& data) {
     url_fetcher->set_status(net::URLRequestStatus());
     url_fetcher->set_response_code(net::HTTP_OK);
     url_fetcher->SetResponseString(data);
@@ skipping 29 matching lines @@
             *config_out = config;
           }
         },
         state_out, config_out);
   }
 
   DoodleFetcherImpl* doodle_fetcher() { return &doodle_fetcher_; }
 
   GURL GetGoogleBaseURL() { return google_url_tracker_.google_url(); }
 
-  base::Time TimeFromNow(uint64_t milliseconds) {
-    return clock_->Now() + base::TimeDelta::FromMilliseconds(milliseconds);
-  }
-
  private:
   base::MessageLoop message_loop_;
   GURL url_;
   net::TestURLFetcherFactory url_fetcher_factory_;
-  base::SimpleTestClock* clock_;  // Owned by the doodle_fetcher.
   GoogleURLTracker google_url_tracker_;
   DoodleFetcherImpl doodle_fetcher_;
 };
 
 TEST_F(DoodleFetcherImplTest, ReturnsFromFetchWithoutError) {
   DoodleState state(DoodleState::NO_DOODLE);
   base::Optional<DoodleConfig> response;
 
   doodle_fetcher()->FetchDoodle(
       CreateResponseSavingCallback(&state, &response));
@@ skipping 70 matching lines @@
   EXPECT_TRUE(config.fullpage_interactive_url.is_empty());
   EXPECT_TRUE(config.target_url.is_valid());
   EXPECT_THAT(config.target_url,
               Eq(Resolve("/search?q\u003dtest\u0026sa\u003dX\u0026ved\u003d"
                          "0ahUKEw")));
   EXPECT_THAT(config.doodle_type, Eq(DoodleType::SIMPLE));
   EXPECT_THAT(config.alt_text, Eq("Mouseover Text"));
   EXPECT_THAT(config.interactive_html,
               Eq("\u003cstyle\u003e\u003c/style\u003e"));
 
-  EXPECT_THAT(config.expiry_date, Eq(TimeFromNow(55000)));
+  EXPECT_THAT(config.time_to_live,
+              Eq(base::TimeDelta::FromMilliseconds(55000)));
 }
 
 TEST_F(DoodleFetcherImplTest, DoodleExpiresWithinThirtyDaysForTooLargeTTL) {
   DoodleState state(DoodleState::NO_DOODLE);
   base::Optional<DoodleConfig> response;
 
   doodle_fetcher()->FetchDoodle(
       CreateResponseSavingCallback(&state, &response));
   RespondWithData(R"json({"ddljson": {
       "time_to_live_ms":5184000000,
       "large_image": {"url":"/logos/doodles/2015/some.gif"}
     }})json");  // 60 days
 
   EXPECT_THAT(state, Eq(DoodleState::AVAILABLE));
   ASSERT_TRUE(response.has_value());
-  EXPECT_THAT(response.value().expiry_date,
-              Eq(TimeFromNow(30ul * 24 * 60 * 60 * 1000 /* ms */)));  // 30 days
+  EXPECT_THAT(response.value().time_to_live,
+              Eq(base::TimeDelta::FromMilliseconds(30ul * 24 * 60 * 60 *
+                                                   1000)));  // 30 days
 }
 
-TEST_F(DoodleFetcherImplTest, DoodleExpiresNowWithNegativeTTL) {
+TEST_F(DoodleFetcherImplTest, DoodleExpiresImmediatelyWithNegativeTTL) {
   DoodleState state(DoodleState::NO_DOODLE);
   base::Optional<DoodleConfig> response;
 
   doodle_fetcher()->FetchDoodle(
       CreateResponseSavingCallback(&state, &response));
   RespondWithData(R"json({"ddljson": {
       "time_to_live_ms":-1,
       "large_image": {"url":"/logos/doodles/2015/some.gif"}
     }})json");
 
   EXPECT_THAT(state, Eq(DoodleState::AVAILABLE));
   ASSERT_TRUE(response.has_value());
-  EXPECT_THAT(response.value().expiry_date, Eq(TimeFromNow(0)));
+  EXPECT_THAT(response.value().time_to_live,
+              Eq(base::TimeDelta::FromMilliseconds(0)));
 }
 
-TEST_F(DoodleFetcherImplTest, DoodleExpiresNowWithoutValidTTL) {
+TEST_F(DoodleFetcherImplTest, DoodleExpiresImmediatelyWithoutValidTTL) {
   DoodleState state(DoodleState::NO_DOODLE);
   base::Optional<DoodleConfig> response;
 
   doodle_fetcher()->FetchDoodle(
       CreateResponseSavingCallback(&state, &response));
   RespondWithData(R"json({"ddljson": {
         "large_image": {"url":"/logos/doodles/2015/some.gif"}
       }})json");
 
   EXPECT_THAT(state, Eq(DoodleState::AVAILABLE));
   ASSERT_TRUE(response.has_value());
-  EXPECT_THAT(response.value().expiry_date, Eq(TimeFromNow(0)));
+  EXPECT_THAT(response.value().time_to_live,
+              Eq(base::TimeDelta::FromMilliseconds(0)));
 }
 
 TEST_F(DoodleFetcherImplTest, ReturnsNoDoodleForMissingLargeImageUrl) {
   DoodleState state(DoodleState::AVAILABLE);
   base::Optional<DoodleConfig> response;
 
   doodle_fetcher()->FetchDoodle(
       CreateResponseSavingCallback(&state, &response));
   RespondWithData(R"json({"ddljson": {
         "time_to_live_ms":55000,
@@ skipping 122 matching lines @@
       switches::kGoogleBaseURL, "http://www.google.kz");
 
   doodle_fetcher()->FetchDoodle(
       CreateResponseSavingCallback(/*state=*/nullptr, /*response=*/nullptr));
 
   EXPECT_THAT(GetRunningFetcher()->GetOriginalURL(),
               Eq(GURL("http://www.google.kz").Resolve(kDoodleConfigPath)));
 }
 
 }  // namespace doodle