| // 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/previews/core/previews_logger.h" |
| |
| #include <memory> |
| #include <string> |
| #include <unordered_map> |
| #include <vector> |
| |
| #include "base/command_line.h" |
| #include "base/macros.h" |
| #include "base/strings/string_split.h" |
| #include "base/test/scoped_command_line.h" |
| #include "base/time/time.h" |
| #include "components/previews/core/previews_black_list.h" |
| #include "components/previews/core/previews_logger_observer.h" |
| #include "components/previews/core/previews_switches.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace previews { |
| |
| namespace { |
| |
| const char kPreviewsDecisionMadeEventType[] = "Decision"; |
| const char kPreviewsNavigationEventType[] = "Navigation"; |
| const size_t kMaximumNavigationLogs = 10; |
| const size_t kMaximumDecisionLogs = 25; |
| |
| // Mock class to test correct MessageLog is passed back to the |
| // mojo::InterventionsInternalsPagePtr. |
| class TestPreviewsLoggerObserver : public PreviewsLoggerObserver { |
| public: |
| TestPreviewsLoggerObserver() |
| : host_blacklisted_called_(false), |
| user_status_change_calls_(0), |
| blacklist_cleared_called_(false), |
| blacklist_ignored_(false), |
| last_removed_notified_(false) {} |
| |
| ~TestPreviewsLoggerObserver() override {} |
| |
| // PreviewsLoggerObserver: |
| void OnNewMessageLogAdded( |
| const PreviewsLogger::MessageLog& message) override { |
| message_ = std::make_unique<PreviewsLogger::MessageLog>(message); |
| messages_.push_back(*message_); |
| } |
| void OnNewBlacklistedHost(const std::string& host, base::Time time) override { |
| host_blacklisted_called_ = true; |
| blacklisted_hosts_[host] = time; |
| } |
| void OnUserBlacklistedStatusChange(bool blacklisted) override { |
| ++user_status_change_calls_; |
| user_blacklisted_ = blacklisted; |
| } |
| void OnBlacklistCleared(base::Time time) override { |
| blacklist_cleared_called_ = true; |
| blacklist_cleared_time_ = time; |
| } |
| void OnIgnoreBlacklistDecisionStatusChanged(bool ignored) override { |
| blacklist_ignored_ = ignored; |
| } |
| void OnLastObserverRemove() override { last_removed_notified_ = true; } |
| |
| // Expose the passed in MessageLog for testing. |
| PreviewsLogger::MessageLog* message() const { return message_.get(); } |
| |
| // Expose the received MessageLogs for testing. |
| const std::vector<PreviewsLogger::MessageLog>& messages() const { |
| return messages_; |
| }; |
| |
| // Expose blacklist events info for testing. |
| const std::unordered_map<std::string, base::Time>& blacklisted_hosts() { |
| return blacklisted_hosts_; |
| } |
| bool host_blacklisted_called() const { return host_blacklisted_called_; } |
| size_t user_status_change_calls() const { return user_status_change_calls_; } |
| bool blacklist_cleared_called() const { return blacklist_cleared_called_; } |
| bool user_blacklisted() const { return user_blacklisted_; } |
| base::Time blacklist_cleared_time() const { return blacklist_cleared_time_; } |
| |
| // Expose whether PreviewsBlackList decisions are ignored or not. |
| bool blacklist_ignored() const { return blacklist_ignored_; } |
| |
| // Expose whether observer is notified that it is the last observer to be |
| // removed for testing. |
| bool last_removed_notified() { return last_removed_notified_; } |
| |
| private: |
| // Received messages. |
| std::vector<PreviewsLogger::MessageLog> messages_; |
| |
| // The passed in MessageLog in OnNewMessageLogAdded. |
| std::unique_ptr<PreviewsLogger::MessageLog> message_; |
| |
| // Received blacklisted event info. |
| std::unordered_map<std::string, base::Time> blacklisted_hosts_; |
| bool user_blacklisted_; |
| base::Time blacklist_cleared_time_; |
| bool host_blacklisted_called_; |
| size_t user_status_change_calls_; |
| bool blacklist_cleared_called_; |
| |
| // BlacklistPreviews decision is ignored or not. |
| bool blacklist_ignored_; |
| |
| // Whether |this| is the last observer to be removed. |
| bool last_removed_notified_; |
| }; |
| |
| class PreviewsLoggerTest : public testing::Test { |
| public: |
| PreviewsLoggerTest() {} |
| |
| ~PreviewsLoggerTest() override {} |
| |
| void SetUp() override { logger_ = std::make_unique<PreviewsLogger>(); } |
| |
| std::string LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason reason, |
| bool final_reason) { |
| const base::Time time = base::Time::Now(); |
| PreviewsType type = PreviewsType::OFFLINE; |
| const GURL url("http://www.url_a.com/url"); |
| const uint64_t page_id = 1234; |
| TestPreviewsLoggerObserver observer; |
| logger_->AddAndNotifyObserver(&observer); |
| if (final_reason) { |
| std::vector<PreviewsEligibilityReason> passed_reasons = {}; |
| logger_->LogPreviewDecisionMade(reason, url, time, type, |
| std::move(passed_reasons), page_id); |
| } else { |
| std::vector<PreviewsEligibilityReason> passed_reasons = {reason}; |
| logger_->LogPreviewDecisionMade(PreviewsEligibilityReason::ALLOWED, url, |
| time, type, std::move(passed_reasons), |
| page_id); |
| } |
| |
| auto actual = observer.messages(); |
| |
| const size_t expected_size = final_reason ? 1 : 2; |
| EXPECT_EQ(expected_size, actual.size()); |
| |
| std::vector<std::string> description_parts = base::SplitStringUsingSubstr( |
| actual[0].event_description, "preview - ", base::TRIM_WHITESPACE, |
| base::SPLIT_WANT_NONEMPTY); |
| return description_parts[1]; |
| } |
| |
| protected: |
| std::unique_ptr<PreviewsLogger> logger_; |
| }; |
| |
| TEST_F(PreviewsLoggerTest, LogPreviewDecisionMadeLogMessage) { |
| const base::Time time = base::Time::Now(); |
| |
| PreviewsType type_a = PreviewsType::OFFLINE; |
| PreviewsType type_b = PreviewsType::LOFI; |
| PreviewsEligibilityReason reason_a = |
| PreviewsEligibilityReason::BLACKLIST_UNAVAILABLE; |
| std::vector<PreviewsEligibilityReason> passed_reasons_a = {}; |
| PreviewsEligibilityReason reason_b = |
| PreviewsEligibilityReason::NETWORK_NOT_SLOW; |
| std::vector<PreviewsEligibilityReason> passed_reasons_b = { |
| PreviewsEligibilityReason::NETWORK_QUALITY_UNAVAILABLE, |
| PreviewsEligibilityReason::RELOAD_DISALLOWED, |
| }; |
| const GURL url_a("http://www.url_a.com/url_a"); |
| const GURL url_b("http://www.url_b.com/url_b"); |
| const uint64_t page_id_a = 1234; |
| const uint64_t page_id_b = 4321; |
| |
| TestPreviewsLoggerObserver observer; |
| logger_->AddAndNotifyObserver(&observer); |
| |
| logger_->LogPreviewDecisionMade(reason_a, url_a, time, type_a, |
| std::move(passed_reasons_a), page_id_a); |
| logger_->LogPreviewDecisionMade(reason_b, url_b, time, type_b, |
| std::move(passed_reasons_b), page_id_b); |
| |
| auto actual = observer.messages(); |
| const size_t expected_size = 4; // reason_a, reason_b, and passed_reasons_b |
| EXPECT_EQ(expected_size, actual.size()); |
| |
| std::string expected_description_a = |
| "Offline preview - Blacklist failed to be created"; |
| EXPECT_EQ(kPreviewsDecisionMadeEventType, actual[0].event_type); |
| EXPECT_EQ(expected_description_a, actual[0].event_description); |
| EXPECT_EQ(url_a, actual[0].url); |
| EXPECT_EQ(time, actual[0].time); |
| EXPECT_EQ(page_id_a, actual[0].page_id); |
| |
| std::string expected_passed_0 = "LoFi preview - Network quality available"; |
| EXPECT_EQ(kPreviewsDecisionMadeEventType, actual[1].event_type); |
| EXPECT_EQ(expected_passed_0, actual[1].event_description); |
| EXPECT_EQ(url_b, actual[1].url); |
| EXPECT_EQ(time, actual[1].time); |
| EXPECT_EQ(page_id_b, actual[1].page_id); |
| |
| std::string expected_passed_1 = "LoFi preview - Page reloads allowed"; |
| EXPECT_EQ(kPreviewsDecisionMadeEventType, actual[2].event_type); |
| EXPECT_EQ(expected_passed_1, actual[2].event_description); |
| EXPECT_EQ(url_b, actual[2].url); |
| EXPECT_EQ(time, actual[2].time); |
| EXPECT_EQ(page_id_b, actual[2].page_id); |
| |
| std::string expected_description_b = "LoFi preview - Network not slow"; |
| EXPECT_EQ(kPreviewsDecisionMadeEventType, actual[3].event_type); |
| EXPECT_EQ(expected_description_b, actual[3].event_description); |
| EXPECT_EQ(url_b, actual[3].url); |
| EXPECT_EQ(time, actual[3].time); |
| EXPECT_EQ(page_id_b, actual[3].page_id); |
| } |
| |
| TEST_F(PreviewsLoggerTest, LogPreviewNavigationLogMessage) { |
| const base::Time time = base::Time::Now(); |
| |
| PreviewsType type_a = PreviewsType::OFFLINE; |
| PreviewsType type_b = PreviewsType::LOFI; |
| const GURL url_a("http://www.url_a.com/url_a"); |
| const GURL url_b("http://www.url_b.com/url_b"); |
| const uint64_t page_id_a = 1234; |
| const uint64_t page_id_b = 1234; |
| |
| TestPreviewsLoggerObserver observer; |
| logger_->AddAndNotifyObserver(&observer); |
| |
| logger_->LogPreviewNavigation(url_a, type_a, true /* opt_out */, time, |
| page_id_a); |
| logger_->LogPreviewNavigation(url_b, type_b, false /* opt_out */, time, |
| page_id_b); |
| |
| auto actual = observer.messages(); |
| |
| const size_t expected_size = 2; |
| EXPECT_EQ(expected_size, actual.size()); |
| |
| std::string expected_description_a = "Offline preview - user opt-out: True"; |
| EXPECT_EQ(kPreviewsNavigationEventType, actual[0].event_type); |
| EXPECT_EQ(expected_description_a, actual[0].event_description); |
| EXPECT_EQ(url_a, actual[0].url); |
| EXPECT_EQ(time, actual[0].time); |
| EXPECT_EQ(page_id_a, actual[0].page_id); |
| |
| std::string expected_description_b = "LoFi preview - user opt-out: False"; |
| EXPECT_EQ(kPreviewsNavigationEventType, actual[1].event_type); |
| EXPECT_EQ(expected_description_b, actual[1].event_description); |
| EXPECT_EQ(url_b, actual[1].url); |
| EXPECT_EQ(time, actual[1].time); |
| EXPECT_EQ(page_id_b, actual[1].page_id); |
| } |
| |
| TEST_F(PreviewsLoggerTest, PreviewsLoggerOnlyKeepsCertainNumberOfDecisionLogs) { |
| PreviewsType type = PreviewsType::OFFLINE; |
| PreviewsEligibilityReason reason = |
| PreviewsEligibilityReason::BLACKLIST_UNAVAILABLE; |
| const base::Time time = base::Time::Now(); |
| const GURL url("http://www.url_.com/url_"); |
| const uint64_t page_id = 1234; |
| |
| for (size_t i = 0; i < 2 * kMaximumDecisionLogs; i++) { |
| std::vector<PreviewsEligibilityReason> passed_reasons = {}; |
| logger_->LogPreviewDecisionMade(reason, url, time, type, |
| std::move(passed_reasons), page_id); |
| } |
| |
| TestPreviewsLoggerObserver observer; |
| logger_->AddAndNotifyObserver(&observer); |
| EXPECT_EQ(kMaximumDecisionLogs, observer.messages().size()); |
| } |
| |
| TEST_F(PreviewsLoggerTest, |
| PreviewsLoggerOnlyKeepsCertainNumberOfNavigationLogs) { |
| PreviewsType type = PreviewsType::OFFLINE; |
| const GURL url("http://www.url_.com/url_"); |
| const base::Time time = base::Time::Now(); |
| const uint64_t page_id = 1234; |
| |
| for (size_t i = 0; i < 2 * kMaximumNavigationLogs; ++i) { |
| logger_->LogPreviewNavigation(url, type, true /* opt_out */, time, page_id); |
| } |
| |
| TestPreviewsLoggerObserver observer; |
| logger_->AddAndNotifyObserver(&observer); |
| EXPECT_EQ(kMaximumNavigationLogs, observer.messages().size()); |
| } |
| |
| TEST_F(PreviewsLoggerTest, |
| ObserverIsNotifiedOfHistoricalNavigationsAndDecisionsWhenAdded) { |
| // Non historical log event. |
| logger_->LogMessage("Event_", "Some description_", |
| GURL("http://www.url_.com/url_"), base::Time::Now(), |
| 1234 /* page_id */); |
| |
| PreviewsType type = PreviewsType::LOFI; |
| PreviewsEligibilityReason final_reason = |
| PreviewsEligibilityReason::BLACKLIST_UNAVAILABLE; |
| std::vector<PreviewsEligibilityReason> passed_reasons = { |
| PreviewsEligibilityReason::NETWORK_NOT_SLOW}; |
| const GURL urls[] = { |
| GURL("http://www.url_0.com/url_0"), // Decision event. |
| GURL("http://www.url_0.com/url_0"), // Decision event. |
| GURL("http://www.url_1.com/url_1"), // Navigation event. |
| }; |
| const base::Time times[] = { |
| base::Time::FromJsTime(-413696806000), // Nov 21 1956 20:13:14 UTC |
| base::Time::FromJsTime(-413696806000), // Same as above. |
| base::Time::FromJsTime(758620800000), // Jan 15 1994 08:00:00 UTC |
| }; |
| const uint64_t page_ids[] = {1233, 1233, 5678 /* Navigation page_id */}; |
| |
| // Logging decisions and navigations events. |
| logger_->LogPreviewDecisionMade(final_reason, urls[0], times[0], type, |
| std::move(passed_reasons), page_ids[0]); |
| logger_->LogPreviewNavigation(urls[2], type, true /* opt_out */, times[2], |
| page_ids[2]); |
| |
| TestPreviewsLoggerObserver observer; |
| logger_->AddAndNotifyObserver(&observer); |
| |
| // Check correct ordering of the historical log messages. |
| auto received_messages = observer.messages(); |
| |
| const size_t expected_size = 3; |
| EXPECT_EQ(expected_size, received_messages.size()); |
| |
| const std::string expected_types[] = { |
| kPreviewsDecisionMadeEventType, kPreviewsDecisionMadeEventType, |
| kPreviewsNavigationEventType, |
| }; |
| |
| for (size_t i = 0; i < expected_size; i++) { |
| EXPECT_EQ(expected_types[i], received_messages[i].event_type); |
| EXPECT_EQ(urls[i], received_messages[i].url); |
| EXPECT_EQ(times[i], received_messages[i].time); |
| EXPECT_EQ(page_ids[i], received_messages[i].page_id); |
| } |
| } |
| |
| TEST_F(PreviewsLoggerTest, ObserversOnNewMessageIsCalledWithCorrectParams) { |
| TestPreviewsLoggerObserver observers[3]; |
| |
| const size_t number_of_obs = 3; |
| for (size_t i = 0; i < number_of_obs; i++) { |
| logger_->AddAndNotifyObserver(&observers[i]); |
| } |
| |
| const std::string type = "Event_"; |
| const std::string description = "Some description"; |
| const GURL url("http://www.url_.com/url_"); |
| const base::Time now = base::Time::Now(); |
| const uint64_t page_id = 1234; |
| logger_->LogMessage(type, description, url, now, page_id); |
| |
| const size_t expected_size = 1; |
| for (size_t i = 0; i < number_of_obs; i++) { |
| EXPECT_EQ(expected_size, observers[i].messages().size()); |
| EXPECT_EQ(type, observers[i].message()->event_type); |
| EXPECT_EQ(description, observers[i].message()->event_description); |
| EXPECT_EQ(url, observers[i].message()->url); |
| EXPECT_EQ(now, observers[i].message()->time); |
| EXPECT_EQ(page_id, observers[i].message()->page_id); |
| } |
| } |
| |
| TEST_F(PreviewsLoggerTest, RemovedObserverIsNotNotified) { |
| TestPreviewsLoggerObserver observers[3]; |
| |
| const size_t number_of_obs = 3; |
| for (size_t i = 0; i < number_of_obs; i++) { |
| logger_->AddAndNotifyObserver(&observers[i]); |
| } |
| |
| const size_t removed_observer = 1; |
| logger_->RemoveObserver(&observers[removed_observer]); |
| |
| const std::string type = "Event_"; |
| const std::string description = "Some description"; |
| const GURL url("http://www.url_.com/url_"); |
| const base::Time now = base::Time::Now(); |
| const uint64_t page_id = 1234; |
| logger_->LogMessage(type, description, url, now, page_id); |
| |
| const size_t expected_size = 0; |
| EXPECT_EQ(expected_size, observers[removed_observer].messages().size()); |
| |
| for (size_t i = 0; i < number_of_obs; i++) { |
| if (i != removed_observer) { |
| EXPECT_EQ(type, observers[i].message()->event_type); |
| EXPECT_EQ(description, observers[i].message()->event_description); |
| EXPECT_EQ(url, observers[i].message()->url); |
| EXPECT_EQ(now, observers[i].message()->time); |
| EXPECT_EQ(page_id, observers[i].message()->page_id); |
| } |
| } |
| } |
| |
| TEST_F(PreviewsLoggerTest, LogPreviewDecisionDescriptionAllowedChecked) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::ALLOWED, true /* final_reason */); |
| std::string expected_description = "Allowed"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, LogPreviewDecisionDescriptionUnavailabeFailed) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::BLACKLIST_UNAVAILABLE, |
| true /* final_reason */); |
| std::string expected_description = "Blacklist failed to be created"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, LogPreviewDecisionDescriptionUnavailabeChecked) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::BLACKLIST_UNAVAILABLE, |
| false /* final_reason */); |
| std::string expected_description = "Blacklist not null"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, LogPreviewDecisionDescriptionNotLoadedFailed) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::BLACKLIST_DATA_NOT_LOADED, |
| true /* final_reason */); |
| std::string expected_description = "Blacklist not loaded from disk yet"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, LogPreviewDecisionDescriptionNotLoadedChecked) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::BLACKLIST_DATA_NOT_LOADED, |
| false /* final_reason */); |
| std::string expected_description = "Blacklist loaded from disk"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, |
| LogPreviewDecisionDescriptionRecentlyOptedOutFailed) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::USER_RECENTLY_OPTED_OUT, |
| true /* final_reason */); |
| std::string expected_description = "User recently opted out"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, |
| LogPreviewDecisionDescriptionRecentlyOptedOutChecked) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::USER_RECENTLY_OPTED_OUT, |
| false /* final_reason */); |
| std::string expected_description = "User did not opt out recently"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, LogPreviewDecisionDescriptionBlacklistedFailed) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::USER_BLACKLISTED, true /* final_reason */); |
| std::string expected_description = "All previews are blacklisted"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, LogPreviewDecisionDescriptionBlacklistedChecked) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::USER_BLACKLISTED, false /* final_reason */); |
| std::string expected_description = "Not all previews are blacklisted"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, LogPreviewDecisionDescriptionHostBlacklistedFailed) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::HOST_BLACKLISTED, true /* final_reason */); |
| std::string expected_description = |
| "All previews on this host are blacklisted"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, |
| LogPreviewDecisionDescriptionHostBlacklistedChecked) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::HOST_BLACKLISTED, false /* final_reason */); |
| std::string expected_description = "Host is not blacklisted on all previews"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, |
| LogPreviewDecisionDescriptionNetworkUnavailableFailed) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::NETWORK_QUALITY_UNAVAILABLE, |
| true /* final_reason */); |
| std::string expected_description = "Network quality unavailable"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, |
| LogPreviewDecisionDescriptionNetworkUnavailableChecked) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::NETWORK_QUALITY_UNAVAILABLE, |
| false /* final_reason */); |
| std::string expected_description = "Network quality available"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, LogPreviewDecisionDescriptionNetworkNotSlowFailed) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::NETWORK_NOT_SLOW, true /* final_reason */); |
| std::string expected_description = "Network not slow"; |
| |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, LogPreviewDecisionDescriptionNetworkNotSlowChecked) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::NETWORK_NOT_SLOW, false /* final_reason */); |
| std::string expected_description = "Network is slow"; |
| |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, |
| LogPreviewDecisionDescriptionReloadDisallowedFailed) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::RELOAD_DISALLOWED, true /* final_reason */); |
| std::string expected_description = |
| "Page reloads do not show previews for this preview type"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, |
| LogPreviewDecisionDescriptionReloadDisallowedChecked) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::RELOAD_DISALLOWED, false /* final_reason */); |
| std::string expected_description = "Page reloads allowed"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, LogPreviewDecisionDescriptionServerRulesFailed) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::HOST_BLACKLISTED_BY_SERVER, |
| true /* final_reason */); |
| std::string expected_description = "Host blacklisted by server rules"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, LogPreviewDecisionDescriptionServerRulesChecked) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::HOST_BLACKLISTED_BY_SERVER, |
| false /* final_reason */); |
| std::string expected_description = "Host not blacklisted by server rules"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, |
| LogPreviewDecisionDescriptionNotWhitelisedByServerFailed) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::HOST_NOT_WHITELISTED_BY_SERVER, |
| true /* final_reason */); |
| std::string expected_description = "Host not whitelisted by server rules"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, |
| LogPreviewDecisionDescriptionNotWhitelisedByServerChecked) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::HOST_NOT_WHITELISTED_BY_SERVER, |
| false /* final_reason */); |
| std::string expected_description = "Host whitelisted by server rules"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F( |
| PreviewsLoggerTest, |
| LogPreviewDecisionDescriptionAllowedWithoutServerOptimizationHintsFailed) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::ALLOWED_WITHOUT_OPTIMIZATION_HINTS, |
| true /* final_reason */); |
| std::string expected_description = "Allowed (but without server rule check)"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F( |
| PreviewsLoggerTest, |
| LogPreviewDecisionDescriptionAllowedWithoutServerOptimizationHintsChecked) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::ALLOWED_WITHOUT_OPTIMIZATION_HINTS, |
| false /* final_reason */); |
| std::string expected_description = "Not allowed (without server rule check)"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, LogPreviewDecisionDescriptionCommitted) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::COMMITTED, true /* final_reason */); |
| std::string expected_description = "Committed"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, |
| LogPreviewDecisionDescriptionCacheControlNoTransform) { |
| std::string actual_description = LogPreviewDecisionAndGetReasonDescription( |
| PreviewsEligibilityReason::CACHE_CONTROL_NO_TRANSFORM, |
| true /* final_reason */); |
| std::string expected_description = "Cache-control no-transform received"; |
| EXPECT_EQ(expected_description, actual_description); |
| } |
| |
| TEST_F(PreviewsLoggerTest, NotifyObserversOfNewBlacklistedHost) { |
| TestPreviewsLoggerObserver observers[3]; |
| |
| const size_t number_of_obs = 3; |
| for (size_t i = 0; i < number_of_obs; i++) { |
| logger_->AddAndNotifyObserver(&observers[i]); |
| } |
| |
| const size_t removed_observer = 1; |
| logger_->RemoveObserver(&observers[removed_observer]); |
| |
| const std::string expected_host = "example.com"; |
| const base::Time expected_time = base::Time::Now(); |
| const size_t expected_size = 1; |
| logger_->OnNewBlacklistedHost(expected_host, expected_time); |
| |
| for (size_t i = 0; i < number_of_obs; i++) { |
| if (i != removed_observer) { |
| EXPECT_TRUE(observers[i].host_blacklisted_called()); |
| EXPECT_EQ(expected_size, observers[i].blacklisted_hosts().size()); |
| EXPECT_EQ(expected_time, |
| observers[i].blacklisted_hosts().find(expected_host)->second); |
| } |
| } |
| EXPECT_FALSE(observers[removed_observer].host_blacklisted_called()); |
| } |
| |
| TEST_F(PreviewsLoggerTest, NotifyObserversWhenUserBlacklisted) { |
| TestPreviewsLoggerObserver observers[3]; |
| |
| const size_t number_of_obs = 3; |
| for (size_t i = 0; i < number_of_obs; i++) { |
| logger_->AddAndNotifyObserver(&observers[i]); |
| } |
| |
| const size_t removed_observer = 1; |
| logger_->RemoveObserver(&observers[removed_observer]); |
| logger_->OnUserBlacklistedStatusChange(true /* blacklisted */); |
| const size_t expected_times = 2; |
| |
| for (size_t i = 0; i < number_of_obs; i++) { |
| if (i != removed_observer) { |
| EXPECT_EQ(expected_times, observers[i].user_status_change_calls()); |
| EXPECT_TRUE(observers[i].user_blacklisted()); |
| } |
| } |
| EXPECT_EQ(expected_times - 1, |
| observers[removed_observer].user_status_change_calls()); |
| } |
| |
| TEST_F(PreviewsLoggerTest, NotifyObserversWhenUserNotBlacklisted) { |
| TestPreviewsLoggerObserver observers[3]; |
| |
| const size_t number_of_obs = 3; |
| for (size_t i = 0; i < number_of_obs; i++) { |
| logger_->AddAndNotifyObserver(&observers[i]); |
| } |
| |
| const size_t removed_observer = 1; |
| logger_->RemoveObserver(&observers[removed_observer]); |
| logger_->OnUserBlacklistedStatusChange(false /* blacklisted */); |
| const size_t expected_times = 2; |
| |
| for (size_t i = 0; i < number_of_obs; i++) { |
| if (i != removed_observer) { |
| EXPECT_EQ(expected_times, observers[i].user_status_change_calls()); |
| EXPECT_FALSE(observers[i].user_blacklisted()); |
| } |
| } |
| EXPECT_EQ(expected_times - 1, |
| observers[removed_observer].user_status_change_calls()); |
| } |
| |
| TEST_F(PreviewsLoggerTest, NotifyObserversWhenBlacklistCleared) { |
| TestPreviewsLoggerObserver observers[3]; |
| |
| const size_t number_of_obs = 3; |
| for (size_t i = 0; i < number_of_obs; i++) { |
| logger_->AddAndNotifyObserver(&observers[i]); |
| } |
| |
| const size_t removed_observer = 1; |
| logger_->RemoveObserver(&observers[removed_observer]); |
| |
| const base::Time expected_time = base::Time::Now(); |
| logger_->OnBlacklistCleared(expected_time); |
| |
| for (size_t i = 0; i < number_of_obs; i++) { |
| if (i != removed_observer) { |
| EXPECT_TRUE(observers[i].blacklist_cleared_called()); |
| EXPECT_EQ(expected_time, observers[i].blacklist_cleared_time()); |
| } |
| } |
| EXPECT_FALSE(observers[removed_observer].blacklist_cleared_called()); |
| } |
| |
| TEST_F(PreviewsLoggerTest, ObserverNotifiedOfUserBlacklistedStateWhenAdded) { |
| TestPreviewsLoggerObserver observer; |
| |
| const std::string host0 = "example0.com"; |
| const std::string host1 = "example1.com"; |
| const base::Time time0 = base::Time::Now(); |
| const base::Time time1 = base::Time::Now(); |
| |
| logger_->OnUserBlacklistedStatusChange(true /* blacklisted */); |
| logger_->OnNewBlacklistedHost(host0, time0); |
| logger_->OnNewBlacklistedHost(host1, time1); |
| logger_->AddAndNotifyObserver(&observer); |
| |
| const size_t expected_times = 1; |
| EXPECT_EQ(expected_times, observer.user_status_change_calls()); |
| const size_t expected_size = 2; |
| EXPECT_EQ(expected_size, observer.blacklisted_hosts().size()); |
| EXPECT_EQ(time0, observer.blacklisted_hosts().find(host0)->second); |
| EXPECT_EQ(time1, observer.blacklisted_hosts().find(host1)->second); |
| } |
| |
| TEST_F(PreviewsLoggerTest, NotifyObserversBlacklistIgnoredUpdate) { |
| TestPreviewsLoggerObserver observers[3]; |
| const size_t number_of_obs = 3; |
| for (size_t i = 0; i < number_of_obs; i++) { |
| logger_->AddAndNotifyObserver(&observers[i]); |
| } |
| |
| for (size_t i = 0; i < number_of_obs; i++) { |
| EXPECT_FALSE(observers[i].blacklist_ignored()); |
| } |
| |
| const size_t removed_observer = 1; |
| logger_->RemoveObserver(&observers[removed_observer]); |
| logger_->OnIgnoreBlacklistDecisionStatusChanged(true /* ignored */); |
| for (size_t i = 0; i < number_of_obs; i++) { |
| if (i != removed_observer) { |
| EXPECT_TRUE(observers[i].blacklist_ignored()); |
| } |
| } |
| EXPECT_FALSE(observers[removed_observer].blacklist_ignored()); |
| } |
| |
| TEST_F(PreviewsLoggerTest, ObserverNotifiedOfBlacklistIgnoreStatusOnAdd) { |
| logger_->OnIgnoreBlacklistDecisionStatusChanged(true /* ignored */); |
| TestPreviewsLoggerObserver observer; |
| EXPECT_FALSE(observer.blacklist_ignored()); |
| logger_->AddAndNotifyObserver(&observer); |
| EXPECT_TRUE(observer.blacklist_ignored()); |
| } |
| |
| TEST_F(PreviewsLoggerTest, |
| ObserverNotifiedOfBlacklistIgnoreStatusDisabledViaFlag) { |
| ASSERT_FALSE(base::CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kIgnorePreviewsBlacklist)); |
| |
| TestPreviewsLoggerObserver observer; |
| PreviewsLogger logger; |
| logger.AddAndNotifyObserver(&observer); |
| EXPECT_FALSE(observer.blacklist_ignored()); |
| } |
| |
| TEST_F(PreviewsLoggerTest, |
| ObserverNotifiedOfBlacklistIgnoreStatusEnabledViaFlag) { |
| base::test::ScopedCommandLine scoped_command_line; |
| base::CommandLine* command_line = scoped_command_line.GetProcessCommandLine(); |
| command_line->AppendSwitch(switches::kIgnorePreviewsBlacklist); |
| ASSERT_TRUE(base::CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kIgnorePreviewsBlacklist)); |
| |
| TestPreviewsLoggerObserver observer; |
| PreviewsLogger logger; |
| logger.AddAndNotifyObserver(&observer); |
| EXPECT_TRUE(observer.blacklist_ignored()); |
| } |
| |
| TEST_F(PreviewsLoggerTest, LastObserverRemovedIsNotified) { |
| TestPreviewsLoggerObserver observers[3]; |
| const size_t number_of_obs = 3; |
| for (size_t i = 0; i < number_of_obs; i++) { |
| logger_->AddAndNotifyObserver(&observers[i]); |
| } |
| for (size_t i = 0; i < number_of_obs; i++) { |
| logger_->RemoveObserver(&observers[i]); |
| } |
| EXPECT_TRUE(observers[number_of_obs - 1].last_removed_notified()); |
| } |
| |
| TEST_F(PreviewsLoggerTest, ClearBufferLogsWhenBlacklistCleared) { |
| const std::string type = "Event_"; |
| const std::string description = "Some description"; |
| const GURL url("http://www.url_.com/url_"); |
| const base::Time now = base::Time::Now(); |
| const uint64_t page_id = 1234; |
| |
| logger_->LogMessage(type, description, url, now, page_id); |
| |
| logger_->OnBlacklistCleared(base::Time::Now()); |
| |
| TestPreviewsLoggerObserver observer; |
| logger_->AddAndNotifyObserver(&observer); |
| EXPECT_EQ(0UL, observer.messages().size()); |
| } |
| |
| } // namespace |
| |
| } // namespace previews |