| // Copyright 2022 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "components/browsing_topics/browsing_topics_state.h" |
| |
| #include <algorithm> |
| |
| #include "base/files/file_util.h" |
| #include "base/files/scoped_temp_dir.h" |
| #include "base/functional/callback_helpers.h" |
| #include "base/json/json_file_value_serializer.h" |
| #include "base/json/values_util.h" |
| #include "base/strings/strcat.h" |
| #include "base/test/metrics/histogram_tester.h" |
| #include "base/test/scoped_feature_list.h" |
| #include "base/test/task_environment.h" |
| #include "components/browsing_topics/util.h" |
| #include "services/network/public/cpp/features.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "third_party/blink/public/common/features.h" |
| |
| namespace browsing_topics { |
| |
| namespace { |
| |
| constexpr base::Time kTime1 = |
| base::Time::FromDeltaSinceWindowsEpoch(base::Days(1)); |
| constexpr base::Time kTime2 = |
| base::Time::FromDeltaSinceWindowsEpoch(base::Days(2)); |
| constexpr base::Time kTime3 = |
| base::Time::FromDeltaSinceWindowsEpoch(base::Days(3)); |
| constexpr base::Time kTime4 = |
| base::Time::FromDeltaSinceWindowsEpoch(base::Days(4)); |
| constexpr base::Time kTime5 = |
| base::Time::FromDeltaSinceWindowsEpoch(base::Days(5)); |
| |
| constexpr browsing_topics::HmacKey kZeroKey = {}; |
| constexpr browsing_topics::HmacKey kTestKey = {1}; |
| constexpr browsing_topics::HmacKey kTestKey2 = {2}; |
| |
| constexpr int kConfigVersion = 1; |
| constexpr int kTaxonomyVersion = 1; |
| constexpr int64_t kModelVersion = 2; |
| constexpr size_t kPaddedTopTopicsStartIndex = 3; |
| constexpr base::TimeDelta kNextScheduledCalculationDelay = base::Days(7); |
| |
| EpochTopics CreateTestEpochTopics(base::Time calculation_time, |
| bool from_manually_triggered_calculation, |
| int config_version = kConfigVersion) { |
| std::vector<TopicAndDomains> top_topics_and_observing_domains; |
| top_topics_and_observing_domains.emplace_back( |
| TopicAndDomains(Topic(1), {HashedDomain(1)})); |
| top_topics_and_observing_domains.emplace_back( |
| TopicAndDomains(Topic(2), {HashedDomain(1), HashedDomain(2)})); |
| top_topics_and_observing_domains.emplace_back( |
| TopicAndDomains(Topic(3), {HashedDomain(1), HashedDomain(3)})); |
| top_topics_and_observing_domains.emplace_back( |
| TopicAndDomains(Topic(4), {HashedDomain(2), HashedDomain(3)})); |
| top_topics_and_observing_domains.emplace_back( |
| TopicAndDomains(Topic(5), {HashedDomain(1)})); |
| |
| EpochTopics epoch_topics(std::move(top_topics_and_observing_domains), |
| kPaddedTopTopicsStartIndex, config_version, |
| kTaxonomyVersion, kModelVersion, calculation_time, |
| from_manually_triggered_calculation); |
| |
| return epoch_topics; |
| } |
| |
| } // namespace |
| |
| class BrowsingTopicsStateTest : public testing::Test { |
| public: |
| BrowsingTopicsStateTest() |
| : task_environment_(new base::test::TaskEnvironment( |
| base::test::TaskEnvironment::TimeSource::MOCK_TIME)) { |
| // Configure a long epoch_retention_duration to prevent epochs from expiring |
| // during tests where expiration is irrelevant. |
| feature_list_.InitWithFeaturesAndParameters( |
| /*enabled_features=*/ |
| {{network::features::kBrowsingTopics, {}}, |
| {blink::features::kBrowsingTopicsParameters, |
| {{"epoch_retention_duration", "3650000d"}}}}, |
| /*disabled_features=*/{}); |
| |
| OverrideHmacKeyForTesting(kTestKey); |
| |
| EXPECT_TRUE(temp_dir_.CreateUniqueTempDir()); |
| } |
| |
| base::FilePath TestFilePath() { |
| return temp_dir_.GetPath().Append(FILE_PATH_LITERAL("BrowsingTopicsState")); |
| } |
| |
| std::string GetTestFileContent() { |
| JSONFileValueDeserializer deserializer(TestFilePath()); |
| std::unique_ptr<base::Value> value = deserializer.Deserialize( |
| /*error_code=*/nullptr, |
| /*error_message=*/nullptr); |
| |
| EXPECT_TRUE(value); |
| return base::CollapseWhitespaceASCII(value->DebugString(), true); |
| } |
| |
| void CreateOrOverrideTestFile(std::vector<EpochTopics> epochs, |
| base::Time next_scheduled_calculation_time, |
| std::string hex_encoded_hmac_key) { |
| base::Value::List epochs_list; |
| for (const EpochTopics& epoch : epochs) { |
| epochs_list.Append(epoch.ToDictValue()); |
| } |
| |
| base::Value::Dict dict; |
| dict.Set("epochs", std::move(epochs_list)); |
| dict.Set("next_scheduled_calculation_time", |
| base::TimeToValue(next_scheduled_calculation_time)); |
| dict.Set("hex_encoded_hmac_key", std::move(hex_encoded_hmac_key)); |
| |
| JSONFileValueSerializer(TestFilePath()).Serialize(dict); |
| } |
| |
| void OnBrowsingTopicsStateLoaded() { observed_state_loaded_ = true; } |
| |
| bool observed_state_loaded() const { return observed_state_loaded_; } |
| |
| protected: |
| base::test::ScopedFeatureList feature_list_; |
| |
| std::unique_ptr<base::test::TaskEnvironment> task_environment_; |
| |
| base::ScopedTempDir temp_dir_; |
| |
| bool observed_state_loaded_ = false; |
| }; |
| |
| TEST_F(BrowsingTopicsStateTest, InitFromNoFile_SaveToDiskAfterDelay) { |
| base::HistogramTester histograms; |
| |
| BrowsingTopicsState state( |
| temp_dir_.GetPath(), |
| base::BindOnce(&BrowsingTopicsStateTest::OnBrowsingTopicsStateLoaded, |
| base::Unretained(this))); |
| |
| EXPECT_FALSE(state.HasScheduledSaveForTesting()); |
| EXPECT_FALSE(observed_state_loaded()); |
| |
| // UMA should not be recorded yet. |
| histograms.ExpectTotalCount( |
| "BrowsingTopics.BrowsingTopicsState.LoadFinishStatus", 0); |
| |
| // Let the backend file read task finish. |
| task_environment_->RunUntilIdle(); |
| |
| histograms.ExpectUniqueSample( |
| "BrowsingTopics.BrowsingTopicsState.LoadFinishStatus", true, |
| /*expected_bucket_count=*/1); |
| |
| EXPECT_TRUE(state.epochs().empty()); |
| EXPECT_TRUE(state.next_scheduled_calculation_time().is_null()); |
| EXPECT_TRUE(std::ranges::equal(state.hmac_key(), kTestKey)); |
| |
| EXPECT_TRUE(state.HasScheduledSaveForTesting()); |
| EXPECT_TRUE(observed_state_loaded()); |
| |
| // Advance clock until immediately before saving takes place. |
| task_environment_->FastForwardBy(base::Milliseconds(2499)); |
| EXPECT_TRUE(state.HasScheduledSaveForTesting()); |
| EXPECT_FALSE(base::PathExists(TestFilePath())); |
| |
| // Advance clock past the saving moment. |
| task_environment_->FastForwardBy(base::Milliseconds(1)); |
| EXPECT_FALSE(state.HasScheduledSaveForTesting()); |
| EXPECT_TRUE(base::PathExists(TestFilePath())); |
| EXPECT_EQ( |
| GetTestFileContent(), |
| "{\"epochs\": [ ],\"hex_encoded_hmac_key\": " |
| "\"0100000000000000000000000000000000000000000000000000000000000000\"," |
| "\"next_scheduled_calculation_time\": \"0\"}"); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, |
| UpdateNextScheduledCalculationTime_SaveToDiskAfterDelay) { |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| |
| task_environment_->FastForwardBy(base::Milliseconds(3000)); |
| EXPECT_FALSE(state.HasScheduledSaveForTesting()); |
| |
| state.UpdateNextScheduledCalculationTime(kNextScheduledCalculationDelay); |
| |
| EXPECT_TRUE(state.epochs().empty()); |
| EXPECT_EQ(state.next_scheduled_calculation_time(), |
| base::Time::Now() + kNextScheduledCalculationDelay); |
| EXPECT_TRUE(std::ranges::equal(state.hmac_key(), kTestKey)); |
| |
| EXPECT_TRUE(state.HasScheduledSaveForTesting()); |
| |
| task_environment_->FastForwardBy(base::Milliseconds(2499)); |
| EXPECT_TRUE(state.HasScheduledSaveForTesting()); |
| |
| task_environment_->FastForwardBy(base::Milliseconds(1)); |
| EXPECT_FALSE(state.HasScheduledSaveForTesting()); |
| |
| std::string expected_content = base::StrCat( |
| {"{\"epochs\": [ ],\"hex_encoded_hmac_key\": " |
| "\"0100000000000000000000000000000000000000000000000000000000000000" |
| "\",\"next_scheduled_calculation_time\": \"", |
| base::NumberToString(state.next_scheduled_calculation_time() |
| .ToDeltaSinceWindowsEpoch() |
| .InMicroseconds()), |
| "\"}"}); |
| |
| EXPECT_EQ(GetTestFileContent(), expected_content); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, AddEpoch) { |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| // Successful topics calculation at `kTime1`. |
| std::optional<EpochTopics> maybe_removed_epoch_1 = |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime1, /*from_manually_triggered_calculation=*/false)); |
| |
| EXPECT_EQ(state.epochs().size(), 1u); |
| EXPECT_FALSE(state.epochs()[0].empty()); |
| EXPECT_EQ(state.epochs()[0].calculation_time(), kTime1); |
| EXPECT_FALSE(maybe_removed_epoch_1.has_value()); |
| |
| // Successful topics calculation at `kTime2`. |
| std::optional<EpochTopics> maybe_removed_epoch_2 = |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime2, /*from_manually_triggered_calculation=*/false)); |
| EXPECT_EQ(state.epochs().size(), 2u); |
| EXPECT_FALSE(state.epochs()[0].empty()); |
| EXPECT_EQ(state.epochs()[0].calculation_time(), kTime1); |
| EXPECT_FALSE(state.epochs()[1].empty()); |
| EXPECT_EQ(state.epochs()[1].calculation_time(), kTime2); |
| EXPECT_FALSE(maybe_removed_epoch_2.has_value()); |
| |
| // Failed topics calculation. |
| std::optional<EpochTopics> maybe_removed_epoch_3 = |
| state.AddEpoch(EpochTopics(kTime3)); |
| EXPECT_EQ(state.epochs().size(), 3u); |
| EXPECT_FALSE(state.epochs()[0].empty()); |
| EXPECT_EQ(state.epochs()[0].calculation_time(), kTime1); |
| EXPECT_FALSE(state.epochs()[1].empty()); |
| EXPECT_EQ(state.epochs()[1].calculation_time(), kTime2); |
| EXPECT_TRUE(state.epochs()[2].empty()); |
| EXPECT_EQ(state.epochs()[2].calculation_time(), kTime3); |
| EXPECT_FALSE(maybe_removed_epoch_3.has_value()); |
| |
| // Successful topics calculation at `kTime4`. |
| std::optional<EpochTopics> maybe_removed_epoch_4 = |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime4, /*from_manually_triggered_calculation=*/false)); |
| EXPECT_EQ(state.epochs().size(), 4u); |
| EXPECT_FALSE(state.epochs()[0].empty()); |
| EXPECT_EQ(state.epochs()[0].calculation_time(), kTime1); |
| EXPECT_FALSE(state.epochs()[1].empty()); |
| EXPECT_EQ(state.epochs()[1].calculation_time(), kTime2); |
| EXPECT_TRUE(state.epochs()[2].empty()); |
| EXPECT_FALSE(state.epochs()[3].empty()); |
| EXPECT_EQ(state.epochs()[3].calculation_time(), kTime4); |
| EXPECT_FALSE(maybe_removed_epoch_4.has_value()); |
| |
| // Successful topics calculation at `kTime5`. When this epoch is added, the |
| // first one should be evicted. |
| std::optional<EpochTopics> maybe_removed_epoch_5 = |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime5, /*from_manually_triggered_calculation=*/false)); |
| EXPECT_EQ(state.epochs().size(), 4u); |
| EXPECT_FALSE(state.epochs()[0].empty()); |
| EXPECT_EQ(state.epochs()[0].calculation_time(), kTime2); |
| EXPECT_TRUE(state.epochs()[1].empty()); |
| EXPECT_FALSE(state.epochs()[2].empty()); |
| EXPECT_EQ(state.epochs()[2].calculation_time(), kTime4); |
| EXPECT_FALSE(state.epochs()[3].empty()); |
| EXPECT_EQ(state.epochs()[3].calculation_time(), kTime5); |
| EXPECT_TRUE(maybe_removed_epoch_5.has_value()); |
| EXPECT_EQ(maybe_removed_epoch_5.value().calculation_time(), kTime1); |
| |
| // The `next_scheduled_calculation_time` and `hmac_key` are unaffected. |
| EXPECT_EQ(state.next_scheduled_calculation_time(), base::Time()); |
| EXPECT_TRUE(std::ranges::equal(state.hmac_key(), kTestKey)); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, EpochsForSite_Empty) { |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| EXPECT_TRUE(state.EpochsForSite(/*top_domain=*/"foo.com").empty()); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, EpochsForSite_OneEpoch_IntroductionTime) { |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime1, /*from_manually_triggered_calculation=*/false)); |
| state.UpdateNextScheduledCalculationTime(kNextScheduledCalculationDelay); |
| |
| ASSERT_EQ(state.CalculateSiteStickyIntroductionDelay("foo.com"), |
| base::Seconds(96673)); |
| |
| // Advance time to just before the epoch introduction. |
| task_environment_->FastForwardBy(base::Seconds(96673)); |
| EXPECT_TRUE(state.EpochsForSite(/*top_domain=*/"foo.com").empty()); |
| |
| // Advance time to the epoch introduction time. |
| task_environment_->FastForwardBy(base::Seconds(1)); |
| std::vector<const EpochTopics*> epochs_for_site = |
| state.EpochsForSite(/*top_domain=*/"foo.com"); |
| EXPECT_EQ(epochs_for_site.size(), 1u); |
| EXPECT_EQ(epochs_for_site[0], &state.epochs()[0]); |
| } |
| |
| // Together with EpochsForSite_OneEpoch_IntroductionTime, this shows that the |
| // epoch introduction time is influenced by the specific epoch. |
| TEST_F(BrowsingTopicsStateTest, EpochsForSite_OneEpoch_IntroductionTime2) { |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime2, /*from_manually_triggered_calculation=*/false)); |
| state.UpdateNextScheduledCalculationTime(kNextScheduledCalculationDelay); |
| |
| ASSERT_EQ(state.CalculateSiteStickyIntroductionDelay("foo.com"), |
| base::Seconds(151685)); |
| |
| // Advance time to just before the epoch introduction. |
| task_environment_->FastForwardBy(base::Seconds(151685)); |
| EXPECT_TRUE(state.EpochsForSite(/*top_domain=*/"foo.com").empty()); |
| |
| // Advance time to the epoch introduction time. |
| task_environment_->FastForwardBy(base::Seconds(1)); |
| std::vector<const EpochTopics*> epochs_for_site = |
| state.EpochsForSite(/*top_domain=*/"foo.com"); |
| EXPECT_EQ(epochs_for_site.size(), 1u); |
| EXPECT_EQ(epochs_for_site[0], &state.epochs()[0]); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, EpochsForSite_OneEpoch_ManuallyTriggered) { |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime1, /*from_manually_triggered_calculation=*/true)); |
| state.UpdateNextScheduledCalculationTime(kNextScheduledCalculationDelay); |
| |
| // There shouldn't be a delay when the latest epoch is manually triggered. |
| ASSERT_EQ(state.CalculateSiteStickyIntroductionDelay("foo.com"), |
| base::Microseconds(0)); |
| task_environment_->FastForwardBy(base::Microseconds(10)); |
| |
| std::vector<const EpochTopics*> epochs_for_site = |
| state.EpochsForSite(/*top_domain=*/"foo.com"); |
| EXPECT_EQ(epochs_for_site.size(), 1u); |
| EXPECT_EQ(epochs_for_site[0], &state.epochs()[0]); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, EpochsForSite_ThreeEpochs_IntroductionTime) { |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime1, /*from_manually_triggered_calculation=*/false)); |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime2, /*from_manually_triggered_calculation=*/false)); |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime3, /*from_manually_triggered_calculation=*/false)); |
| state.UpdateNextScheduledCalculationTime(kNextScheduledCalculationDelay); |
| |
| ASSERT_EQ(state.CalculateSiteStickyIntroductionDelay("foo.com"), |
| base::Seconds(136778)); |
| |
| // Advance time to just before the epoch introduction. |
| task_environment_->FastForwardBy(base::Seconds(136778)); |
| std::vector<const EpochTopics*> epochs_for_site = |
| state.EpochsForSite(/*top_domain=*/"foo.com"); |
| EXPECT_EQ(epochs_for_site.size(), 2u); |
| EXPECT_EQ(epochs_for_site[0], &state.epochs()[0]); |
| EXPECT_EQ(epochs_for_site[1], &state.epochs()[1]); |
| |
| // Advance time to the epoch introduction time. |
| task_environment_->FastForwardBy(base::Seconds(1)); |
| |
| epochs_for_site = state.EpochsForSite(/*top_domain=*/"foo.com"); |
| EXPECT_EQ(epochs_for_site.size(), 3u); |
| EXPECT_EQ(epochs_for_site[0], &state.epochs()[0]); |
| EXPECT_EQ(epochs_for_site[1], &state.epochs()[1]); |
| EXPECT_EQ(epochs_for_site[2], &state.epochs()[2]); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, EpochsForSite_PhaseOutTime) { |
| feature_list_.Reset(); |
| feature_list_.InitWithFeaturesAndParameters( |
| /*enabled_features=*/ |
| {{network::features::kBrowsingTopics, {}}, |
| {blink::features::kBrowsingTopicsParameters, |
| {{"epoch_retention_duration", "28d"}}}}, |
| /*disabled_features=*/{}); |
| |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| base::Time now = base::Time::Now(); |
| |
| state.AddEpoch(CreateTestEpochTopics( |
| now, /*from_manually_triggered_calculation=*/false)); |
| state.UpdateNextScheduledCalculationTime(kNextScheduledCalculationDelay); |
| |
| base::TimeDelta phase_out_time_offset = |
| state.CalculateSiteStickyPhaseOutTimeOffset("foo.com", state.epochs()[0]); |
| |
| ASSERT_GT(phase_out_time_offset, base::Seconds(0)); |
| ASSERT_LT(phase_out_time_offset, base::Days(2)); |
| |
| // Advance time to just before the epoch phase out. |
| task_environment_->FastForwardBy(base::Days(28) - phase_out_time_offset - |
| base::Seconds(1)); |
| |
| std::vector<const EpochTopics*> epochs_for_site = |
| state.EpochsForSite(/*top_domain=*/"foo.com"); |
| EXPECT_EQ(epochs_for_site.size(), 1u); |
| EXPECT_EQ(epochs_for_site[0], &state.epochs()[0]); |
| |
| // Advance time to the epoch phase out time. |
| task_environment_->FastForwardBy(base::Seconds(1)); |
| |
| epochs_for_site = state.EpochsForSite(/*top_domain=*/"foo.com"); |
| EXPECT_EQ(epochs_for_site.size(), 0u); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, |
| EpochsForSite_ThreeEpochs_LatestManuallyTriggered) { |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime1, /*from_manually_triggered_calculation=*/false)); |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime2, /*from_manually_triggered_calculation=*/false)); |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime3, /*from_manually_triggered_calculation=*/true)); |
| state.UpdateNextScheduledCalculationTime(kNextScheduledCalculationDelay); |
| |
| task_environment_->FastForwardBy(base::Microseconds(10)); |
| |
| std::vector<const EpochTopics*> epochs_for_site = |
| state.EpochsForSite(/*top_domain=*/"foo.com"); |
| EXPECT_EQ(epochs_for_site.size(), 3u); |
| EXPECT_EQ(epochs_for_site[0], &state.epochs()[0]); |
| EXPECT_EQ(epochs_for_site[1], &state.epochs()[1]); |
| EXPECT_EQ(epochs_for_site[2], &state.epochs()[2]); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, |
| EpochsForSite_ThreeEpochs_EarlierEpochManuallyTriggered) { |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime1, /*from_manually_triggered_calculation=*/false)); |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime2, /*from_manually_triggered_calculation=*/true)); |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime3, /*from_manually_triggered_calculation=*/false)); |
| state.UpdateNextScheduledCalculationTime(kNextScheduledCalculationDelay); |
| |
| task_environment_->FastForwardBy(base::Microseconds(10)); |
| |
| std::vector<const EpochTopics*> epochs_for_site = |
| state.EpochsForSite(/*top_domain=*/"foo.com"); |
| // The latest epoch shouldn't be included because it wasn't manually |
| // triggered. |
| EXPECT_EQ(epochs_for_site.size(), 2u); |
| EXPECT_EQ(epochs_for_site[0], &state.epochs()[0]); |
| EXPECT_EQ(epochs_for_site[1], &state.epochs()[1]); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, |
| EpochsForSite_FourEpochs_IntroductionTimeNotArrived) { |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime1, /*from_manually_triggered_calculation=*/false)); |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime2, /*from_manually_triggered_calculation=*/false)); |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime3, /*from_manually_triggered_calculation=*/false)); |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime4, /*from_manually_triggered_calculation=*/false)); |
| state.UpdateNextScheduledCalculationTime(kNextScheduledCalculationDelay); |
| |
| task_environment_->FastForwardBy(base::Hours(1)); |
| |
| std::vector<const EpochTopics*> epochs_for_site = |
| state.EpochsForSite(/*top_domain=*/"foo.com"); |
| EXPECT_EQ(epochs_for_site.size(), 3u); |
| EXPECT_EQ(epochs_for_site[0], &state.epochs()[0]); |
| EXPECT_EQ(epochs_for_site[1], &state.epochs()[1]); |
| EXPECT_EQ(epochs_for_site[2], &state.epochs()[2]); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, |
| EpochsForSite_FourEpochs_IntroductionTimeArrived) { |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime1, /*from_manually_triggered_calculation=*/false)); |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime2, /*from_manually_triggered_calculation=*/false)); |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime3, /*from_manually_triggered_calculation=*/false)); |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime4, /*from_manually_triggered_calculation=*/false)); |
| state.UpdateNextScheduledCalculationTime(kNextScheduledCalculationDelay); |
| |
| task_environment_->FastForwardBy(base::Days(1)); |
| |
| std::vector<const EpochTopics*> epochs_for_site = |
| state.EpochsForSite(/*top_domain=*/"foo.com"); |
| EXPECT_EQ(epochs_for_site.size(), 3u); |
| EXPECT_EQ(epochs_for_site[0], &state.epochs()[1]); |
| EXPECT_EQ(epochs_for_site[1], &state.epochs()[2]); |
| EXPECT_EQ(epochs_for_site[2], &state.epochs()[3]); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, |
| EpochsForSite_FourEpochs_LatestManuallyTriggered) { |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime1, /*from_manually_triggered_calculation=*/false)); |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime2, /*from_manually_triggered_calculation=*/false)); |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime3, /*from_manually_triggered_calculation=*/false)); |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime4, /*from_manually_triggered_calculation=*/true)); |
| |
| state.UpdateNextScheduledCalculationTime(kNextScheduledCalculationDelay); |
| |
| task_environment_->FastForwardBy(base::Microseconds(10)); |
| |
| std::vector<const EpochTopics*> epochs_for_site = |
| state.EpochsForSite(/*top_domain=*/"foo.com"); |
| EXPECT_EQ(epochs_for_site.size(), 3u); |
| EXPECT_EQ(epochs_for_site[0], &state.epochs()[1]); |
| EXPECT_EQ(epochs_for_site[1], &state.epochs()[2]); |
| EXPECT_EQ(epochs_for_site[2], &state.epochs()[3]); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, |
| EpochsForSite_FourEpochs_EarlierEpochManuallyTriggered) { |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime1, /*from_manually_triggered_calculation=*/false)); |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime2, /*from_manually_triggered_calculation=*/true)); |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime3, /*from_manually_triggered_calculation=*/false)); |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime4, /*from_manually_triggered_calculation=*/false)); |
| state.UpdateNextScheduledCalculationTime(kNextScheduledCalculationDelay); |
| |
| task_environment_->FastForwardBy(base::Microseconds(10)); |
| |
| std::vector<const EpochTopics*> epochs_for_site = |
| state.EpochsForSite(/*top_domain=*/"foo.com"); |
| // The latest epoch shouldn't be included because it wasn't manually |
| // triggered. |
| EXPECT_EQ(epochs_for_site.size(), 3u); |
| EXPECT_EQ(epochs_for_site[0], &state.epochs()[0]); |
| EXPECT_EQ(epochs_for_site[1], &state.epochs()[1]); |
| EXPECT_EQ(epochs_for_site[2], &state.epochs()[2]); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, InitFromPreexistingFile_CorruptedHmacKey) { |
| base::HistogramTester histograms; |
| |
| std::vector<EpochTopics> epochs; |
| epochs.emplace_back(CreateTestEpochTopics( |
| kTime1, /*from_manually_triggered_calculation=*/false)); |
| |
| CreateOrOverrideTestFile(std::move(epochs), |
| /*next_scheduled_calculation_time=*/kTime2, |
| /*hex_encoded_hmac_key=*/"123"); |
| |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| EXPECT_EQ(state.epochs().size(), 0u); |
| EXPECT_TRUE(state.next_scheduled_calculation_time().is_null()); |
| EXPECT_TRUE(std::ranges::equal(state.hmac_key(), kZeroKey)); |
| |
| histograms.ExpectUniqueSample( |
| "BrowsingTopics.BrowsingTopicsState.LoadFinishStatus", false, |
| /*expected_bucket_count=*/1); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, InitFromPreexistingFile_SameConfigVersion) { |
| base::HistogramTester histograms; |
| |
| std::vector<EpochTopics> epochs; |
| epochs.emplace_back(CreateTestEpochTopics( |
| kTime1, /*from_manually_triggered_calculation=*/false)); |
| |
| CreateOrOverrideTestFile(std::move(epochs), |
| /*next_scheduled_calculation_time=*/kTime2, |
| /*hex_encoded_hmac_key=*/base::HexEncode(kTestKey2)); |
| |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| EXPECT_EQ(state.epochs().size(), 1u); |
| EXPECT_FALSE(state.epochs()[0].empty()); |
| EXPECT_EQ(state.epochs()[0].model_version(), kModelVersion); |
| EXPECT_EQ(state.next_scheduled_calculation_time(), kTime2); |
| EXPECT_TRUE(std::ranges::equal(state.hmac_key(), kTestKey2)); |
| |
| histograms.ExpectUniqueSample( |
| "BrowsingTopics.BrowsingTopicsState.LoadFinishStatus", true, |
| /*expected_bucket_count=*/1); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, |
| InitFromPreexistingFile_ForwardCompatibleConfigVersion) { |
| base::HistogramTester histograms; |
| |
| std::vector<EpochTopics> epochs; |
| // Current version is 1 but it's forward compatible with 2. |
| base::test::ScopedFeatureList feature_list; |
| feature_list.InitAndEnableFeatureWithParameters( |
| blink::features::kBrowsingTopicsParameters, |
| {{"prioritized_topics_list", ""}}); |
| EXPECT_EQ(CurrentConfigVersion(), 1); |
| epochs.emplace_back(CreateTestEpochTopics( |
| kTime1, /*from_manually_triggered_calculation=*/false, |
| /*config_version=*/2)); |
| |
| CreateOrOverrideTestFile(std::move(epochs), |
| /*next_scheduled_calculation_time=*/kTime2, |
| /*hex_encoded_hmac_key=*/base::HexEncode(kTestKey2)); |
| |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| EXPECT_EQ(state.epochs().size(), 1u); |
| EXPECT_FALSE(state.epochs()[0].empty()); |
| EXPECT_EQ(state.epochs()[0].model_version(), kModelVersion); |
| EXPECT_EQ(state.next_scheduled_calculation_time(), kTime2); |
| EXPECT_TRUE(std::ranges::equal(state.hmac_key(), kTestKey2)); |
| |
| histograms.ExpectUniqueSample( |
| "BrowsingTopics.BrowsingTopicsState.LoadFinishStatus", true, |
| /*expected_bucket_count=*/1); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, |
| InitFromPreexistingFile_BackwardCompatibleConfigVersion) { |
| base::HistogramTester histograms; |
| |
| std::vector<EpochTopics> epochs; |
| // Current version is 2 but it's backward compatible with 1. |
| base::test::ScopedFeatureList feature_list; |
| feature_list.InitAndEnableFeatureWithParameters( |
| blink::features::kBrowsingTopicsParameters, |
| {{"prioritized_topics_list", "4,57"}}); |
| EXPECT_EQ(CurrentConfigVersion(), 2); |
| epochs.emplace_back(CreateTestEpochTopics( |
| kTime1, /*from_manually_triggered_calculation=*/false, |
| /*config_version=*/1)); |
| |
| CreateOrOverrideTestFile(std::move(epochs), |
| /*next_scheduled_calculation_time=*/kTime2, |
| /*hex_encoded_hmac_key=*/base::HexEncode(kTestKey2)); |
| |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| EXPECT_EQ(state.epochs().size(), 1u); |
| EXPECT_FALSE(state.epochs()[0].empty()); |
| EXPECT_EQ(state.epochs()[0].model_version(), kModelVersion); |
| EXPECT_EQ(state.next_scheduled_calculation_time(), kTime2); |
| EXPECT_TRUE(std::ranges::equal(state.hmac_key(), kTestKey2)); |
| |
| histograms.ExpectUniqueSample( |
| "BrowsingTopics.BrowsingTopicsState.LoadFinishStatus", true, |
| /*expected_bucket_count=*/1); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, |
| InitFromPreexistingFile_IncompatibleConfigVersion) { |
| base::HistogramTester histograms; |
| |
| std::vector<EpochTopics> epochs; |
| epochs.emplace_back(CreateTestEpochTopics( |
| kTime1, /*from_manually_triggered_calculation=*/false, |
| /*config_version=*/100)); |
| |
| CreateOrOverrideTestFile(std::move(epochs), |
| /*next_scheduled_calculation_time=*/kTime2, |
| /*hex_encoded_hmac_key=*/base::HexEncode(kTestKey2)); |
| |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| EXPECT_TRUE(state.epochs().empty()); |
| EXPECT_TRUE(state.next_scheduled_calculation_time().is_null()); |
| EXPECT_TRUE(std::ranges::equal(state.hmac_key(), kTestKey2)); |
| |
| histograms.ExpectUniqueSample( |
| "BrowsingTopics.BrowsingTopicsState.LoadFinishStatus", true, |
| /*expected_bucket_count=*/1); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, ClearOneEpoch) { |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime1, /*from_manually_triggered_calculation=*/false)); |
| |
| EXPECT_EQ(state.epochs().size(), 1u); |
| EXPECT_FALSE(state.epochs()[0].empty()); |
| EXPECT_EQ(state.epochs()[0].calculation_time(), kTime1); |
| |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime2, /*from_manually_triggered_calculation=*/false)); |
| EXPECT_EQ(state.epochs().size(), 2u); |
| EXPECT_FALSE(state.epochs()[0].empty()); |
| EXPECT_EQ(state.epochs()[0].calculation_time(), kTime1); |
| EXPECT_FALSE(state.epochs()[1].empty()); |
| EXPECT_EQ(state.epochs()[1].calculation_time(), kTime2); |
| |
| state.ClearOneEpoch(/*epoch_index=*/0); |
| EXPECT_EQ(state.epochs().size(), 2u); |
| EXPECT_TRUE(state.epochs()[0].empty()); |
| EXPECT_FALSE(state.epochs()[1].empty()); |
| EXPECT_EQ(state.epochs()[1].calculation_time(), kTime2); |
| |
| state.UpdateNextScheduledCalculationTime(kNextScheduledCalculationDelay); |
| |
| EXPECT_EQ(state.next_scheduled_calculation_time(), |
| base::Time::Now() + kNextScheduledCalculationDelay); |
| EXPECT_TRUE(std::ranges::equal(state.hmac_key(), kTestKey)); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, ClearAllTopics) { |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime1, /*from_manually_triggered_calculation=*/false)); |
| |
| EXPECT_EQ(state.epochs().size(), 1u); |
| EXPECT_FALSE(state.epochs()[0].empty()); |
| EXPECT_EQ(state.epochs()[0].calculation_time(), kTime1); |
| |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime2, /*from_manually_triggered_calculation=*/false)); |
| EXPECT_EQ(state.epochs().size(), 2u); |
| EXPECT_FALSE(state.epochs()[0].empty()); |
| EXPECT_EQ(state.epochs()[0].calculation_time(), kTime1); |
| EXPECT_FALSE(state.epochs()[1].empty()); |
| EXPECT_EQ(state.epochs()[1].calculation_time(), kTime2); |
| |
| state.UpdateNextScheduledCalculationTime(kNextScheduledCalculationDelay); |
| |
| state.ClearAllTopics(); |
| EXPECT_EQ(state.epochs().size(), 0u); |
| |
| EXPECT_EQ(state.next_scheduled_calculation_time(), |
| base::Time::Now() + kNextScheduledCalculationDelay); |
| EXPECT_TRUE(std::ranges::equal(state.hmac_key(), kTestKey)); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, ClearTopic) { |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime1, /*from_manually_triggered_calculation=*/false)); |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime2, /*from_manually_triggered_calculation=*/false)); |
| state.UpdateNextScheduledCalculationTime(kNextScheduledCalculationDelay); |
| |
| state.ClearTopic(Topic(3)); |
| |
| EXPECT_EQ(state.epochs().size(), 2u); |
| EXPECT_EQ(state.epochs()[0].top_topics_and_observing_domains()[0].topic(), |
| Topic(1)); |
| EXPECT_EQ(state.epochs()[0].top_topics_and_observing_domains()[1].topic(), |
| Topic(2)); |
| EXPECT_FALSE( |
| state.epochs()[0].top_topics_and_observing_domains()[2].IsValid()); |
| EXPECT_EQ(state.epochs()[0].top_topics_and_observing_domains()[3].topic(), |
| Topic(4)); |
| EXPECT_EQ(state.epochs()[0].top_topics_and_observing_domains()[4].topic(), |
| Topic(5)); |
| |
| EXPECT_EQ(state.epochs()[1].top_topics_and_observing_domains()[0].topic(), |
| Topic(1)); |
| EXPECT_EQ(state.epochs()[1].top_topics_and_observing_domains()[1].topic(), |
| Topic(2)); |
| EXPECT_FALSE( |
| state.epochs()[1].top_topics_and_observing_domains()[2].IsValid()); |
| EXPECT_EQ(state.epochs()[1].top_topics_and_observing_domains()[3].topic(), |
| Topic(4)); |
| EXPECT_EQ(state.epochs()[1].top_topics_and_observing_domains()[4].topic(), |
| Topic(5)); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, ClearContextDomain) { |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime1, /*from_manually_triggered_calculation=*/false)); |
| state.AddEpoch(CreateTestEpochTopics( |
| kTime2, /*from_manually_triggered_calculation=*/false)); |
| state.UpdateNextScheduledCalculationTime(kNextScheduledCalculationDelay); |
| |
| state.ClearContextDomain(HashedDomain(1)); |
| |
| EXPECT_EQ( |
| state.epochs()[0].top_topics_and_observing_domains()[0].hashed_domains(), |
| std::set<HashedDomain>{}); |
| EXPECT_EQ( |
| state.epochs()[0].top_topics_and_observing_domains()[1].hashed_domains(), |
| std::set<HashedDomain>({HashedDomain(2)})); |
| EXPECT_EQ( |
| state.epochs()[0].top_topics_and_observing_domains()[2].hashed_domains(), |
| std::set<HashedDomain>({HashedDomain(3)})); |
| EXPECT_EQ( |
| state.epochs()[0].top_topics_and_observing_domains()[3].hashed_domains(), |
| std::set<HashedDomain>({HashedDomain(2), HashedDomain(3)})); |
| EXPECT_EQ( |
| state.epochs()[0].top_topics_and_observing_domains()[4].hashed_domains(), |
| std::set<HashedDomain>{}); |
| |
| EXPECT_EQ( |
| state.epochs()[1].top_topics_and_observing_domains()[0].hashed_domains(), |
| std::set<HashedDomain>{}); |
| EXPECT_EQ( |
| state.epochs()[1].top_topics_and_observing_domains()[1].hashed_domains(), |
| std::set<HashedDomain>({HashedDomain(2)})); |
| EXPECT_EQ( |
| state.epochs()[1].top_topics_and_observing_domains()[2].hashed_domains(), |
| std::set<HashedDomain>({HashedDomain(3)})); |
| EXPECT_EQ( |
| state.epochs()[1].top_topics_and_observing_domains()[3].hashed_domains(), |
| std::set<HashedDomain>({HashedDomain(2), HashedDomain(3)})); |
| EXPECT_EQ( |
| state.epochs()[1].top_topics_and_observing_domains()[4].hashed_domains(), |
| std::set<HashedDomain>{}); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, ShouldSaveFileDespiteShutdownWhileScheduled) { |
| auto state = std::make_unique<BrowsingTopicsState>(temp_dir_.GetPath(), |
| base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| ASSERT_TRUE(state->HasScheduledSaveForTesting()); |
| EXPECT_FALSE(base::PathExists(TestFilePath())); |
| |
| state.reset(); |
| task_environment_.reset(); |
| |
| // TaskEnvironment and BrowsingTopicsState both have been destroyed, mimic-ing |
| // a browser shutdown. |
| |
| EXPECT_TRUE(base::PathExists(TestFilePath())); |
| EXPECT_EQ( |
| GetTestFileContent(), |
| "{\"epochs\": [ ],\"hex_encoded_hmac_key\": " |
| "\"0100000000000000000000000000000000000000000000000000000000000000\"," |
| "\"next_scheduled_calculation_time\": \"0\"}"); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, ScheduleEpochsExpiration) { |
| feature_list_.Reset(); |
| feature_list_.InitWithFeaturesAndParameters( |
| /*enabled_features=*/ |
| {{network::features::kBrowsingTopics, {}}, |
| {blink::features::kBrowsingTopicsParameters, |
| {{"epoch_retention_duration", "28s"}}}}, |
| /*disabled_features=*/{}); |
| |
| base::Time start_time = base::Time::Now(); |
| |
| std::vector<EpochTopics> epochs; |
| epochs.emplace_back( |
| CreateTestEpochTopics(start_time - base::Seconds(29), |
| /*from_manually_triggered_calculation=*/false)); |
| epochs.emplace_back( |
| CreateTestEpochTopics(start_time - base::Seconds(28), |
| /*from_manually_triggered_calculation=*/false)); |
| epochs.emplace_back( |
| CreateTestEpochTopics(start_time - base::Seconds(27), |
| /*from_manually_triggered_calculation=*/false)); |
| epochs.emplace_back( |
| CreateTestEpochTopics(start_time - base::Seconds(26), |
| /*from_manually_triggered_calculation=*/false)); |
| |
| CreateOrOverrideTestFile(std::move(epochs), |
| /*next_scheduled_calculation_time=*/kTime2, |
| /*hex_encoded_hmac_key=*/base::HexEncode(kTestKey)); |
| |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| EXPECT_EQ(state.epochs().size(), 4u); |
| |
| state.ScheduleEpochsExpiration(); |
| |
| // Verify that two epochs have been removed immediately due to expiration. |
| EXPECT_EQ(state.epochs().size(), 2u); |
| EXPECT_EQ(state.epochs()[0].calculation_time(), |
| start_time - base::Seconds(27)); |
| EXPECT_EQ(state.epochs()[1].calculation_time(), |
| start_time - base::Seconds(26)); |
| |
| // Process any pending tasks to ensure any asynchronous expirations are |
| // handled. |
| task_environment_->RunUntilIdle(); |
| EXPECT_EQ(state.epochs().size(), 2u); |
| |
| // Trigger another epoch expiration. |
| task_environment_->FastForwardBy(base::Seconds(1)); |
| EXPECT_EQ(state.epochs().size(), 1u); |
| EXPECT_EQ(state.epochs()[0].calculation_time(), |
| start_time - base::Seconds(26)); |
| |
| // Trigger the final epoch expiration. |
| task_environment_->FastForwardBy(base::Seconds(1)); |
| EXPECT_EQ(state.epochs().size(), 0u); |
| } |
| |
| TEST_F(BrowsingTopicsStateTest, AddEpochAndVerifyExpiration) { |
| feature_list_.Reset(); |
| feature_list_.InitWithFeaturesAndParameters( |
| /*enabled_features=*/ |
| {{network::features::kBrowsingTopics, {}}, |
| {blink::features::kBrowsingTopicsParameters, |
| {{"epoch_retention_duration", "28s"}}}}, |
| /*disabled_features=*/{}); |
| |
| base::Time start_time = base::Time::Now(); |
| |
| BrowsingTopicsState state(temp_dir_.GetPath(), base::DoNothing()); |
| task_environment_->RunUntilIdle(); |
| |
| state.AddEpoch(CreateTestEpochTopics( |
| base::Time::Now(), /*from_manually_triggered_calculation=*/false)); |
| |
| task_environment_->FastForwardBy(base::Seconds(1)); |
| state.AddEpoch(CreateTestEpochTopics( |
| base::Time::Now(), /*from_manually_triggered_calculation=*/false)); |
| |
| EXPECT_EQ(state.epochs().size(), 2u); |
| |
| // Verify epochs haven't expired prematurely. |
| task_environment_->FastForwardBy(base::Seconds(26)); |
| EXPECT_EQ(state.epochs().size(), 2u); |
| |
| // Verify the first epoch expired at the expected expiration time. |
| task_environment_->FastForwardBy(base::Seconds(1)); |
| EXPECT_EQ(state.epochs().size(), 1u); |
| EXPECT_EQ(state.epochs()[0].calculation_time(), |
| start_time + base::Seconds(1)); |
| |
| // Verify the second epoch has also expired at the expected expiration time. |
| task_environment_->FastForwardBy(base::Seconds(1)); |
| EXPECT_EQ(state.epochs().size(), 0u); |
| } |
| |
| } // namespace browsing_topics |
