Add SiteEngagementService::GetAllDetails(), to return detailed scores.

chrome/browser/engagement/site_engagement_score_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 "chrome/browser/engagement/site_engagement_score.h"
 
 #include <utility>
 
 #include "base/macros.h"
 #include "base/test/simple_test_clock.h"
@@ skipping 96 matching lines @@
 // Accumulate score many times on the same day. Ensure each time the score goes
 // up, but not more than the maximum per day.
 TEST_F(SiteEngagementScoreTest, AccumulateOnSameDay) {
   base::Time reference_time = GetReferenceTime();
 
   test_clock_.SetNow(reference_time);
   for (int i = 0; i < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++i) {
     score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
     EXPECT_EQ(std::min(SiteEngagementScore::GetMaxPointsPerDay(),
                        (i + 1) * SiteEngagementScore::GetNavigationPoints()),
-              score_.GetScore());
+              score_.GetTotal());
   }
 
-  EXPECT_EQ(SiteEngagementScore::GetMaxPointsPerDay(), score_.GetScore());
+  EXPECT_EQ(SiteEngagementScore::GetMaxPointsPerDay(), score_.GetTotal());
 }
 
 // Accumulate on the first day to max that day's engagement, then accumulate on
 // a different day.
 TEST_F(SiteEngagementScoreTest, AccumulateOnTwoDays) {
   base::Time reference_time = GetReferenceTime();
   base::Time later_date = reference_time + base::TimeDelta::FromDays(2);
 
   test_clock_.SetNow(reference_time);
   for (int i = 0; i < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++i)
     score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
 
-  EXPECT_EQ(SiteEngagementScore::GetMaxPointsPerDay(), score_.GetScore());
+  EXPECT_EQ(SiteEngagementScore::GetMaxPointsPerDay(), score_.GetTotal());
 
   test_clock_.SetNow(later_date);
   for (int i = 0; i < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++i) {
     score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
     double day_score =
         std::min(SiteEngagementScore::GetMaxPointsPerDay(),
                  (i + 1) * SiteEngagementScore::GetNavigationPoints());
     EXPECT_EQ(day_score + SiteEngagementScore::GetMaxPointsPerDay(),
-              score_.GetScore());
+              score_.GetTotal());
   }
 
-  EXPECT_EQ(2 * SiteEngagementScore::GetMaxPointsPerDay(), score_.GetScore());
+  EXPECT_EQ(2 * SiteEngagementScore::GetMaxPointsPerDay(), score_.GetTotal());
 }
 
 // Accumulate score on many consecutive days and ensure the score doesn't exceed
 // the maximum allowed.
 TEST_F(SiteEngagementScoreTest, AccumulateALotOnManyDays) {
   base::Time current_day = GetReferenceTime();
 
   for (int i = 0; i < kMoreDaysThanNeededToMaxTotalEngagement; ++i) {
     current_day += base::TimeDelta::FromDays(1);
     test_clock_.SetNow(current_day);
     for (int j = 0; j < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++j)
       score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
 
     EXPECT_EQ(std::min(SiteEngagementScore::kMaxPoints,
                        (i + 1) * SiteEngagementScore::GetMaxPointsPerDay()),
-              score_.GetScore());
+              score_.GetTotal());
   }
 
-  EXPECT_EQ(SiteEngagementScore::kMaxPoints, score_.GetScore());
+  EXPECT_EQ(SiteEngagementScore::kMaxPoints, score_.GetTotal());
 }
 
 // Accumulate a little on many consecutive days and ensure the score doesn't
 // exceed the maximum allowed.
 TEST_F(SiteEngagementScoreTest, AccumulateALittleOnManyDays) {
   base::Time current_day = GetReferenceTime();
 
   for (int i = 0; i < kMoreAccumulationsThanNeededToMaxTotalEngagement; ++i) {
     current_day += base::TimeDelta::FromDays(1);
     test_clock_.SetNow(current_day);
 
     for (int j = 0; j < kLessAccumulationsThanNeededToMaxDailyEngagement; ++j)
       score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
 
     EXPECT_EQ(
         std::min(SiteEngagementScore::kMaxPoints,
                  (i + 1) * kLessAccumulationsThanNeededToMaxDailyEngagement *
                      SiteEngagementScore::GetNavigationPoints()),
-        score_.GetScore());
+        score_.GetTotal());
   }
 
-  EXPECT_EQ(SiteEngagementScore::kMaxPoints, score_.GetScore());
+  EXPECT_EQ(SiteEngagementScore::kMaxPoints, score_.GetTotal());
 }
 
 // Accumulate a bit, then check the score decays properly for a range of times.
 TEST_F(SiteEngagementScoreTest, ScoresDecayOverTime) {
   base::Time current_day = GetReferenceTime();
 
   // First max the score.
   for (int i = 0; i < kMoreDaysThanNeededToMaxTotalEngagement; ++i) {
     current_day += base::TimeDelta::FromDays(1);
     test_clock_.SetNow(current_day);
 
     for (int j = 0; j < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++j)
       score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
   }
 
-  EXPECT_EQ(SiteEngagementScore::kMaxPoints, score_.GetScore());
+  EXPECT_EQ(SiteEngagementScore::kMaxPoints, score_.GetTotal());
 
   // The score should not have decayed before the first decay period has
   // elapsed.
   test_clock_.SetNow(current_day +
                      base::TimeDelta::FromHours(
                          SiteEngagementScore::GetDecayPeriodInHours() - 1));
-  EXPECT_EQ(SiteEngagementScore::kMaxPoints, score_.GetScore());
+  EXPECT_EQ(SiteEngagementScore::kMaxPoints, score_.GetTotal());
 
   // The score should have decayed by one chunk after one decay period has
   // elapsed.
   test_clock_.SetNow(
       current_day +
       base::TimeDelta::FromHours(SiteEngagementScore::GetDecayPeriodInHours()));
   EXPECT_EQ(
       SiteEngagementScore::kMaxPoints - SiteEngagementScore::GetDecayPoints(),
-      score_.GetScore());
+      score_.GetTotal());
 
   // The score should have decayed by the right number of chunks after a few
   // decay periods have elapsed.
   test_clock_.SetNow(
       current_day +
       base::TimeDelta::FromHours(kLessPeriodsThanNeededToDecayMaxScore *
                                  SiteEngagementScore::GetDecayPeriodInHours()));
   EXPECT_EQ(SiteEngagementScore::kMaxPoints -
                 kLessPeriodsThanNeededToDecayMaxScore *
                     SiteEngagementScore::GetDecayPoints(),
-            score_.GetScore());
+            score_.GetTotal());
 
   // The score should not decay below zero.
   test_clock_.SetNow(
       current_day +
       base::TimeDelta::FromHours(kMorePeriodsThanNeededToDecayMaxScore *
                                  SiteEngagementScore::GetDecayPeriodInHours()));
-  EXPECT_EQ(0, score_.GetScore());
+  EXPECT_EQ(0, score_.GetTotal());
 }
 
 // Test that any expected decays are applied before adding points.
 TEST_F(SiteEngagementScoreTest, DecaysAppliedBeforeAdd) {
   base::Time current_day = GetReferenceTime();
 
   // Get the score up to something that can handle a bit of decay before
   for (int i = 0; i < kLessDaysThanNeededToMaxTotalEngagement; ++i) {
     current_day += base::TimeDelta::FromDays(1);
     test_clock_.SetNow(current_day);
 
     for (int j = 0; j < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++j)
       score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
   }
 
   double initial_score = kLessDaysThanNeededToMaxTotalEngagement *
                          SiteEngagementScore::GetMaxPointsPerDay();
-  EXPECT_EQ(initial_score, score_.GetScore());
+  EXPECT_EQ(initial_score, score_.GetTotal());
 
   // Go forward a few decay periods.
   test_clock_.SetNow(
       current_day +
       base::TimeDelta::FromHours(kLessPeriodsThanNeededToDecayMaxScore *
                                  SiteEngagementScore::GetDecayPeriodInHours()));
 
   double decayed_score = initial_score -
                          kLessPeriodsThanNeededToDecayMaxScore *
                              SiteEngagementScore::GetDecayPoints();
-  EXPECT_EQ(decayed_score, score_.GetScore());
+  EXPECT_EQ(decayed_score, score_.GetTotal());
 
   // Now add some points.
   score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
   EXPECT_EQ(decayed_score + SiteEngagementScore::GetNavigationPoints(),
-            score_.GetScore());
+            score_.GetTotal());
 }
 
 // Test that going back in time is handled properly.
 TEST_F(SiteEngagementScoreTest, GoBackInTime) {
   base::Time current_day = GetReferenceTime();
 
   test_clock_.SetNow(current_day);
   for (int i = 0; i < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++i)
     score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
 
-  EXPECT_EQ(SiteEngagementScore::GetMaxPointsPerDay(), score_.GetScore());
+  EXPECT_EQ(SiteEngagementScore::GetMaxPointsPerDay(), score_.GetTotal());
 
   // Adding to the score on an earlier date should be treated like another day,
   // and should not cause any decay.
   test_clock_.SetNow(current_day - base::TimeDelta::FromDays(
                                        kMorePeriodsThanNeededToDecayMaxScore *
                                        SiteEngagementScore::GetDecayPoints()));
   for (int i = 0; i < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++i) {
     score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
     double day_score =
         std::min(SiteEngagementScore::GetMaxPointsPerDay(),
                  (i + 1) * SiteEngagementScore::GetNavigationPoints());
     EXPECT_EQ(day_score + SiteEngagementScore::GetMaxPointsPerDay(),
-              score_.GetScore());
+              score_.GetTotal());
   }
 
-  EXPECT_EQ(2 * SiteEngagementScore::GetMaxPointsPerDay(), score_.GetScore());
+  EXPECT_EQ(2 * SiteEngagementScore::GetMaxPointsPerDay(), score_.GetTotal());
 }
 
 // Test that scores are read / written correctly from / to empty score
 // dictionaries.
 TEST_F(SiteEngagementScoreTest, EmptyDictionary) {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   TestScoreInitializesAndUpdates(std::move(dict), 0, 0, base::Time());
 }
 
 // Test that scores are read / written correctly from / to partially empty
@@ skipping 24 matching lines @@
   SiteEngagementScore score1(&test_clock_, GURL(),
                              std::unique_ptr<base::DictionaryValue>());
   SiteEngagementScore score2(&test_clock_, GURL(),
                              std::unique_ptr<base::DictionaryValue>());
   base::Time current_day = GetReferenceTime();
 
   test_clock_.SetNow(current_day);
 
   // The first engagement event gets the bonus.
   score1.AddPoints(0.5);
-  EXPECT_EQ(1.0, score1.GetScore());
+  EXPECT_EQ(1.0, score1.GetTotal());
 
   // Subsequent events do not.
   score1.AddPoints(0.5);
-  EXPECT_EQ(1.5, score1.GetScore());
+  EXPECT_EQ(1.5, score1.GetTotal());
 
   // Bonuses are awarded independently between scores.
   score2.AddPoints(1.0);
-  EXPECT_EQ(1.5, score2.GetScore());
+  EXPECT_EQ(1.5, score2.GetTotal());
   score2.AddPoints(1.0);
-  EXPECT_EQ(2.5, score2.GetScore());
+  EXPECT_EQ(2.5, score2.GetTotal());
 
   test_clock_.SetNow(current_day + base::TimeDelta::FromDays(1));
 
   // The first event for the next day gets the bonus.
   score1.AddPoints(0.5);
-  EXPECT_EQ(2.5, score1.GetScore());
+  EXPECT_EQ(2.5, score1.GetTotal());
 
   // Subsequent events do not.
   score1.AddPoints(0.5);
-  EXPECT_EQ(3.0, score1.GetScore());
+  EXPECT_EQ(3.0, score1.GetTotal());
 
   score2.AddPoints(1.0);
-  EXPECT_EQ(4.0, score2.GetScore());
+  EXPECT_EQ(4.0, score2.GetTotal());
   score2.AddPoints(1.0);
-  EXPECT_EQ(5.0, score2.GetScore());
+  EXPECT_EQ(5.0, score2.GetTotal());
 }
 
 // Test that resetting a score has the correct properties.
 TEST_F(SiteEngagementScoreTest, Reset) {
   base::Time current_day = GetReferenceTime();
 
   test_clock_.SetNow(current_day);
   score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
-  EXPECT_EQ(SiteEngagementScore::GetNavigationPoints(), score_.GetScore());
+  EXPECT_EQ(SiteEngagementScore::GetNavigationPoints(), score_.GetTotal());
 
   current_day += base::TimeDelta::FromDays(7);
   test_clock_.SetNow(current_day);
 
   score_.Reset(20.0, current_day);
-  EXPECT_DOUBLE_EQ(20.0, score_.GetScore());
+  EXPECT_DOUBLE_EQ(20.0, score_.GetTotal());
   EXPECT_DOUBLE_EQ(0, score_.points_added_today_);
   EXPECT_EQ(current_day, score_.last_engagement_time_);
   EXPECT_TRUE(score_.last_shortcut_launch_time_.is_null());
 
   // Adding points after the reset should work as normal.
   score_.AddPoints(5);
-  EXPECT_EQ(25.0, score_.GetScore());
+  EXPECT_EQ(25.0, score_.GetTotal());
 
   // The decay should happen one decay period from the current time.
   test_clock_.SetNow(current_day +
                      base::TimeDelta::FromHours(
                          SiteEngagementScore::GetDecayPeriodInHours() + 1));
-  EXPECT_EQ(25.0 - SiteEngagementScore::GetDecayPoints(), score_.GetScore());
+  EXPECT_EQ(25.0 - SiteEngagementScore::GetDecayPoints(), score_.GetTotal());
 
   // Ensure that manually setting a time works as expected.
   score_.AddPoints(5);
   test_clock_.SetNow(GetReferenceTime());
   base::Time now = test_clock_.Now();
   score_.Reset(10.0, now);
 
-  EXPECT_DOUBLE_EQ(10.0, score_.GetScore());
+  EXPECT_DOUBLE_EQ(10.0, score_.GetTotal());
   EXPECT_DOUBLE_EQ(0, score_.points_added_today_);
   EXPECT_EQ(now, score_.last_engagement_time_);
   EXPECT_TRUE(score_.last_shortcut_launch_time_.is_null());
 
   base::Time old_now = test_clock_.Now();
 
   score_.set_last_shortcut_launch_time(test_clock_.Now());
   test_clock_.SetNow(GetReferenceTime() + base::TimeDelta::FromDays(3));
   now = test_clock_.Now();
   score_.Reset(15.0, now);
 
   // 5 bonus from the last shortcut launch.
-  EXPECT_DOUBLE_EQ(20.0, score_.GetScore());
+  EXPECT_DOUBLE_EQ(20.0, score_.GetTotal());
   EXPECT_DOUBLE_EQ(0, score_.points_added_today_);
   EXPECT_EQ(now, score_.last_engagement_time_);
   EXPECT_EQ(old_now, score_.last_shortcut_launch_time_);
 }
 
 // Test proportional decay.
 TEST_F(SiteEngagementScoreTest, ProportionalDecay) {
   SetParamValue(SiteEngagementScore::DECAY_PROPORTION, 0.5);
   SetParamValue(SiteEngagementScore::DECAY_POINTS, 0);
   SetParamValue(SiteEngagementScore::MAX_POINTS_PER_DAY, 20);
   base::Time current_day = GetReferenceTime();
   test_clock_.SetNow(current_day);
 
   // Single decay period, expect the score to be halved once.
   score_.AddPoints(2.0);
   current_day += base::TimeDelta::FromDays(7);
   test_clock_.SetNow(current_day);
-  EXPECT_DOUBLE_EQ(1.0, score_.GetScore());
+  EXPECT_DOUBLE_EQ(1.0, score_.GetTotal());
 
   // 3 decay periods, expect the score to be halved 3 times.
   score_.AddPoints(15.0);
   current_day += base::TimeDelta::FromDays(21);
   test_clock_.SetNow(current_day);
-  EXPECT_DOUBLE_EQ(2.0, score_.GetScore());
+  EXPECT_DOUBLE_EQ(2.0, score_.GetTotal());
 
   // Ensure point removal happens after proportional decay.
   score_.AddPoints(4.0);
-  EXPECT_DOUBLE_EQ(6.0, score_.GetScore());
+  EXPECT_DOUBLE_EQ(6.0, score_.GetTotal());
   SetParamValue(SiteEngagementScore::DECAY_POINTS, 2.0);
   current_day += base::TimeDelta::FromDays(7);
   test_clock_.SetNow(current_day);
-  EXPECT_NEAR(1.0, score_.GetScore(), kMaxRoundingDeviation);
+  EXPECT_NEAR(1.0, score_.GetTotal(), kMaxRoundingDeviation);
 }