Fix grouped history query range for months.

chrome/browser/ui/webui/browsing_history_handler_unittest.cc

 // Copyright (c) 2013 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 "chrome/browser/ui/webui/browsing_history_handler.h"
 
 #include <stdint.h>
 #include <memory>
 #include <set>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/test/simple_test_clock.h"
 #include "base/values.h"
 #include "chrome/browser/history/web_history_service_factory.h"
 #include "chrome/browser/signin/fake_profile_oauth2_token_service_builder.h"
 #include "chrome/browser/signin/fake_signin_manager_builder.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync/profile_sync_test_util.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/browser_sync/test_profile_sync_service.h"
@@ skipping 17 matching lines @@
 
 struct TestResult {
   std::string url;
   int64_t hour_offset;  // Visit time in hours past the baseline time.
 };
 
 // Duplicates on the same day in the local timezone are removed, so set a
 // baseline time in local time.
 const base::Time baseline_time = base::Time::UnixEpoch().LocalMidnight();
 
+base::Time GetReferenceTime() {

[Dan Beam, 2016/11/10 19:06:37]

nit: PretendNow?

[calamity, 2016/11/17 02:24:34]

Done.

+  base::Time::Exploded exploded_reference_time;
+  exploded_reference_time.year = 2015;
+  exploded_reference_time.month = 1;
+  exploded_reference_time.day_of_month = 2;
+  exploded_reference_time.day_of_week = 5;
+  exploded_reference_time.hour = 11;
+  exploded_reference_time.minute = 0;
+  exploded_reference_time.second = 0;
+  exploded_reference_time.millisecond = 0;
+
+  base::Time out_time;
+  EXPECT_TRUE(
+      base::Time::FromLocalExploded(exploded_reference_time, &out_time));
+  return out_time;
+}
+
 // For each item in |results|, create a new Value representing the visit, and
 // insert it into |list_value|.
 void AddQueryResults(
     TestResult* test_results,
     int test_results_size,
     std::vector<BrowsingHistoryHandler::HistoryEntry>* results) {
   for (int i = 0; i < test_results_size; ++i) {
     BrowsingHistoryHandler::HistoryEntry entry;
     entry.time = baseline_time +
                  base::TimeDelta::FromHours(test_results[i].hour_offset);
@@ skipping 34 matching lines @@
     NotifyObservers();
   }
 
  private:
   bool sync_active_;
 };
 
 class BrowsingHistoryHandlerWithWebUIForTesting
     : public BrowsingHistoryHandler {
  public:
-  explicit BrowsingHistoryHandlerWithWebUIForTesting(content::WebUI* web_ui) {
+  explicit BrowsingHistoryHandlerWithWebUIForTesting(content::WebUI* web_ui)
+      : test_clock_(new base::SimpleTestClock()) {
+    set_clock(base::WrapUnique(test_clock_));
     set_web_ui(web_ui);
   }
   using BrowsingHistoryHandler::QueryComplete;
+
+  base::SimpleTestClock* test_clock() { return test_clock_; }
+
+ private:
+  base::SimpleTestClock* test_clock_;
 };
 
 }  // namespace
 
 class BrowsingHistoryHandlerTest : public ::testing::Test {
  public:
   void SetUp() override {
     TestingProfile::Builder builder;
     builder.AddTestingFactory(ProfileOAuth2TokenServiceFactory::GetInstance(),
                               &BuildFakeProfileOAuth2TokenService);
@@ skipping 139 matching lines @@
     BrowsingHistoryHandler::MergeDuplicateResults(&results);
 
     ASSERT_EQ(2U, results.size());
     EXPECT_TRUE(ResultEquals(results[0], test_data[3]));
     EXPECT_TRUE(ResultEquals(results[1], test_data[1]));
     EXPECT_EQ(3u, results[0].all_timestamps.size());
     EXPECT_EQ(1u, results[1].all_timestamps.size());
   }
 }
 
+TEST_F(BrowsingHistoryHandlerTest, SetQueryTimeInWeeks) {
+  BrowsingHistoryHandlerWithWebUIForTesting handler(web_ui());
+  handler.test_clock()->SetNow(GetReferenceTime());
+
+  history::QueryOptions options;
+  base::Time expected_time = GetReferenceTime();

[Dan Beam, 2016/11/10 19:06:36]

I think the reader loses a bit of information / has to attempt to follow more
state when you re-use the same |expected_time| local while modifying it.  What I
meant was more along the lines of:

base::Time pretend_now = GetPretendNow();
handler.test_clock()->SetNow(pretend_now);

handler.SetQueryTimeInWeeks(0, &options);
base::Time midnight_tonight = pretend_now.LocalMidnight();
base::Time midnight_tomorrow = midnight_tonight + base::TimeDelta::FromDays(1);
EXPECT_EQ(midnight_tomorrow, options.end_time);

base::Time midnight_a_week_ago =
    midnight_tomorrow - base::TimeDelta::FromDays(7);
EXPECT_EQ(mignight_a_week_ago, options.begin_time);

this reads more naturally because it's way more descriptive and i don't have to
look through all the -= to attempt to mentally map from the start of the local
to the end

[calamity, 2016/11/17 02:24:34]

Done.

+
+  // Querying this week should result in end time being midnight tonight and
+  // begin time being midnight a week ago.
+  handler.SetQueryTimeInWeeks(0, &options);
+  expected_time = expected_time.LocalMidnight() + base::TimeDelta::FromDays(1);
+  EXPECT_EQ(expected_time, options.end_time);
+  expected_time -= base::TimeDelta::FromDays(7);
+  EXPECT_EQ(expected_time, options.begin_time);
+
+  // Querying 4 weeks ago should result in end time being midnight 4 weeks ago
+  // and begin time being midnight 5 weeks ago.
+  handler.SetQueryTimeInWeeks(4, &options);
+  expected_time = GetReferenceTime() - base::TimeDelta::FromDays(28);
+  EXPECT_EQ(expected_time, options.end_time);
+  expected_time -= base::TimeDelta::FromDays(7);
+  EXPECT_EQ(expected_time, options.begin_time);
+}
+
+TEST_F(BrowsingHistoryHandlerTest, SetQueryTimeInMonths) {
+  BrowsingHistoryHandlerWithWebUIForTesting handler(web_ui());
+  handler.test_clock()->SetNow(GetReferenceTime());
+  history::QueryOptions options;
+
+  base::Time::Exploded exploded_expected_time;
+  GetReferenceTime().LocalExplode(&exploded_expected_time);
+
+  base::Time expected_time;
+
+  // Querying this month should result in end time being unset and begin time
+  // being midnight of the 1st.
+  handler.SetQueryTimeInMonths(0, &options);
+  EXPECT_EQ(base::Time(), options.end_time);
+
+  exploded_expected_time.day_of_month = 1;
+  exploded_expected_time.hour = 0;
+  EXPECT_TRUE(
+      base::Time::FromLocalExploded(exploded_expected_time, &expected_time));
+  EXPECT_EQ(expected_time, options.begin_time);
+
+  // Querying 6 months ago should result in end time being 2014-08-01 and begin
+  // time being 2014-07-01.
+  handler.SetQueryTimeInMonths(6, &options);
+
+  exploded_expected_time.year = 2014;
+  exploded_expected_time.month = 8;
+  EXPECT_TRUE(
+      base::Time::FromLocalExploded(exploded_expected_time, &expected_time));
+  EXPECT_EQ(expected_time, options.end_time);
+  exploded_expected_time.month = 7;
+  EXPECT_TRUE(
+      base::Time::FromLocalExploded(exploded_expected_time, &expected_time));
+  EXPECT_EQ(expected_time, options.begin_time);
+}
+
 // Tests that BrowsingHistoryHandler observes WebHistoryService deletions.
 TEST_F(BrowsingHistoryHandlerTest, ObservingWebHistoryDeletions) {
   base::Callback<void(bool)> callback = base::Bind(&IgnoreBoolAndDoNothing);
 
   // BrowsingHistoryHandler listens to WebHistoryService history deletions.
   {
     sync_service()->SetSyncActive(true);
     BrowsingHistoryHandlerWithWebUIForTesting handler(web_ui());
     handler.RegisterMessages();
 
@@ skipping 83 matching lines @@
   const base::DictionaryValue* first_entry;
   ASSERT_TRUE(arg2->GetDictionary(0, &first_entry));
 
   base::string16 title;
   ASSERT_TRUE(first_entry->GetString("title", &title));
 
   ASSERT_EQ(0u, title.find(base::ASCIIToUTF16("http://loooo")));
   EXPECT_EQ(300u, title.size());
 }
 #endif