| // Copyright 2021 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chrome/browser/ui/hats/trust_safety_sentiment_service.h" |
| |
| #include "base/memory/raw_ptr.h" |
| #include "base/test/metrics/histogram_tester.h" |
| #include "chrome/browser/content_settings/host_content_settings_map_factory.h" |
| #include "chrome/browser/extensions/api/settings_private/generated_pref.h" |
| #include "chrome/browser/ui/hats/hats_service.h" |
| #include "chrome/browser/ui/hats/hats_service_factory.h" |
| #include "chrome/browser/ui/hats/mock_hats_service.h" |
| #include "chrome/browser/ui/hats/trust_safety_sentiment_service_factory.h" |
| #include "chrome/common/chrome_features.h" |
| #include "chrome/common/webui_url_constants.h" |
| #include "chrome/test/base/testing_profile.h" |
| #include "components/browsing_data/core/browsing_data_utils.h" |
| #include "components/content_settings/core/test/content_settings_mock_provider.h" |
| #include "components/content_settings/core/test/content_settings_test_utils.h" |
| #include "components/privacy_sandbox/tracking_protection_prefs.h" |
| #include "components/signin/public/base/signin_pref_names.h" |
| #include "components/sync_preferences/testing_pref_service_syncable.h" |
| #include "components/unified_consent/pref_names.h" |
| #include "content/public/test/browser_task_environment.h" |
| #include "content/public/test/test_renderer_host.h" |
| #include "content/public/test/web_contents_tester.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "url/gurl.h" |
| |
| using ::testing::_; |
| |
| class TrustSafetySentimentServiceTest : public testing::Test { |
| public: |
| TrustSafetySentimentServiceTest() { |
| mock_hats_service_ = static_cast<MockHatsService*>( |
| HatsServiceFactory::GetInstance()->SetTestingFactoryAndUse( |
| profile(), base::BindRepeating(&BuildMockHatsService))); |
| EXPECT_CALL(*mock_hats_service(), CanShowAnySurvey(_)) |
| .WillRepeatedly(testing::Return(true)); |
| } |
| |
| void SetUp() override { |
| metrics::DesktopSessionDurationTracker::Initialize(); |
| } |
| |
| void TearDown() override { |
| TrustSafetySentimentServiceFactory::GetInstance()->ShutDownForTesting( |
| profile()); |
| metrics::DesktopSessionDurationTracker::CleanupForTesting(); |
| } |
| |
| protected: |
| struct FeatureParams { |
| std::string privacy_settings_time = "20s"; |
| std::string min_time_to_prompt = "2m"; |
| std::string max_time_to_prompt = "60m"; |
| std::string ntp_visits_min_range = "2"; |
| std::string ntp_visits_max_range = "4"; |
| std::string privacy_settings_probability = "0.6"; |
| std::string trusted_surface_probability = "0.4"; |
| std::string transactions_probability = "0.05"; |
| std::string privacy_sandbox_4_consent_accept_probability = "0.01"; |
| std::string privacy_sandbox_4_consent_decline_probability = "0.1"; |
| std::string privacy_sandbox_4_notice_ok_probability = "0.1"; |
| std::string privacy_sandbox_4_notice_settings_probability = "0.1"; |
| std::string privacy_settings_trigger_id = "privacy-settings-test"; |
| std::string trusted_surface_trigger_id = "trusted-surface-test"; |
| std::string transactions_trigger_id = "transactions-test"; |
| std::string transactions_password_manager_time = "20s"; |
| }; |
| |
| // Skip deprecated PrivacySandbox3 and 4 values. |
| bool IsDeprecatedFeatureArea(int enum_value) { |
| return ((enum_value >= 4 && enum_value <= 9) || |
| (enum_value >= 15 && enum_value <= 18)); |
| } |
| |
| void SetupFeatureParameters(FeatureParams params) { |
| feature_list()->InitWithFeaturesAndParameters( |
| /*enabled_features=*/ |
| {base::test::FeatureRefAndParams( |
| features::kTrustSafetySentimentSurvey, |
| { |
| {"privacy-settings-time", params.privacy_settings_time}, |
| {"min-time-to-prompt", params.min_time_to_prompt}, |
| {"max-time-to-prompt", params.max_time_to_prompt}, |
| {"ntp-visits-min-range", params.ntp_visits_min_range}, |
| {"ntp-visits-max-range", params.ntp_visits_max_range}, |
| {"privacy-settings-probability", |
| params.privacy_settings_probability}, |
| {"trusted-surface-probability", |
| params.trusted_surface_probability}, |
| {"transactions-probability", params.transactions_probability}, |
| {"privacy-settings-trigger-id", |
| params.privacy_settings_trigger_id}, |
| {"trusted-surface-trigger-id", |
| params.trusted_surface_trigger_id}, |
| {"transactions-trigger-id", params.transactions_trigger_id}, |
| {"transactions-password-manager-time", |
| params.transactions_password_manager_time}, |
| })}, |
| /*disabled_features=*/ |
| {features::kTrustSafetySentimentSurveyV2}); |
| } |
| |
| struct FeatureParamsV2 { |
| std::string min_time_to_prompt = "2m"; |
| std::string max_time_to_prompt = "60m"; |
| std::string ntp_visits_min_range = "2"; |
| std::string ntp_visits_max_range = "4"; |
| std::string min_session_time = "30s"; |
| std::string trusted_surface_time = "5s"; |
| std::string browsing_data_probability = "0.4"; |
| std::string control_group_probability = "0.4"; |
| std::string download_warning_ui_probability = "0.0"; |
| std::string password_check_probability = "0.4"; |
| std::string password_protection_ui_probability = "0.0"; |
| std::string safety_check_probability = "0.4"; |
| std::string safety_hub_notification_probability = "0.4"; |
| std::string safety_hub_interaction_probability = "0.4"; |
| std::string trusted_surface_probability = "0.4"; |
| std::string privacy_guide_probability = "0.4"; |
| std::string privacy_sandbox_4_consent_accept_probability = "0.01"; |
| std::string privacy_sandbox_4_consent_decline_probability = "0.1"; |
| std::string privacy_sandbox_4_notice_ok_probability = "0.1"; |
| std::string privacy_sandbox_4_notice_settings_probability = "0.1"; |
| std::string safe_browsing_interstitial_probability = "0.4"; |
| std::string browsing_data_trigger_id = "browsing-data-test"; |
| std::string control_group_trigger_id = "control-group-test"; |
| std::string download_warning_ui_trigger_id = "download-warning-ui-test"; |
| std::string password_check_trigger_id = "password-check-test"; |
| std::string password_protection_ui_trigger_id = |
| "password-protection-ui-test"; |
| std::string safety_check_trigger_id = "safety-check-test"; |
| std::string trusted_surface_trigger_id = "trusted-surface-test"; |
| std::string privacy_guide_trigger_id = "privacy-guide-test"; |
| std::string safe_browsing_interstitial_trigger_id = |
| "safe-browsing-interstitial"; |
| }; |
| |
| void SetupFeatureParametersV2(FeatureParamsV2 params) { |
| feature_list()->InitAndEnableFeatureWithParameters( |
| features::kTrustSafetySentimentSurveyV2, |
| { |
| {"min-time-to-prompt", params.min_time_to_prompt}, |
| {"max-time-to-prompt", params.max_time_to_prompt}, |
| {"ntp-visits-min-range", params.ntp_visits_min_range}, |
| {"ntp-visits-max-range", params.ntp_visits_max_range}, |
| {"min-session-time", params.min_session_time}, |
| {"trusted-surface-time", params.trusted_surface_time}, |
| {"browsing-data-probability", params.browsing_data_probability}, |
| {"control-group-probability", params.control_group_probability}, |
| {"download-warning-ui-probability", |
| params.download_warning_ui_probability}, |
| {"password-check-probability", params.password_check_probability}, |
| {"password-protection-ui-probability", |
| params.password_protection_ui_probability}, |
| {"safety-check-probability", params.safety_check_probability}, |
| {"safety-hub-notification-probability", |
| params.safety_hub_notification_probability}, |
| {"safety-hub-interaction-probability", |
| params.safety_hub_interaction_probability}, |
| {"trusted-surface-probability", params.trusted_surface_probability}, |
| {"privacy-guide-probability", params.privacy_guide_probability}, |
| {"safe-browsing-interstitial-probability", |
| params.safe_browsing_interstitial_probability}, |
| {"browsing-data-trigger-id", params.browsing_data_trigger_id}, |
| {"control-group-trigger-id", params.control_group_trigger_id}, |
| {"download-warning-ui-trigger-id", |
| params.download_warning_ui_trigger_id}, |
| {"password-check-trigger-id", params.password_check_trigger_id}, |
| {"password-protection-ui-trigger-id", |
| params.password_protection_ui_trigger_id}, |
| {"safety-check-trigger-id", params.safety_check_trigger_id}, |
| {"trusted-surface-trigger-id", params.trusted_surface_trigger_id}, |
| {"privacy-guide-trigger-id", params.privacy_guide_trigger_id}, |
| {"safe-browsing-interstitial-trigger-id", |
| params.safe_browsing_interstitial_trigger_id}, |
| }); |
| } |
| |
| void CheckHistograms( |
| const std::set<TrustSafetySentimentService::FeatureArea>& triggered_areas, |
| const std::set<TrustSafetySentimentService::FeatureArea>& |
| surveyed_areas) { |
| std::map<std::string, std::set<TrustSafetySentimentService::FeatureArea>> |
| histogram_to_expected = { |
| {"Feedback.TrustSafetySentiment.TriggerOccurred", triggered_areas}, |
| {"Feedback.TrustSafetySentiment.SurveyRequested", surveyed_areas}}; |
| |
| for (const auto& histogram_expected : histogram_to_expected) { |
| const auto& histogram_name = histogram_expected.first; |
| const auto& expected = histogram_expected.second; |
| histogram_tester()->ExpectTotalCount(histogram_name, expected.size()); |
| for (auto area : expected) { |
| histogram_tester()->ExpectBucketCount(histogram_name, area, 1); |
| } |
| } |
| } |
| |
| void CheckCallTriggerOccurredHistogram( |
| const std::map<TrustSafetySentimentService::FeatureArea, int>& |
| triggered_area_counts) { |
| int total_count = 0; |
| const std::string histogram_name = |
| "Feedback.TrustSafetySentiment.CallTriggerOccurred"; |
| for (const auto& histogram_expected : triggered_area_counts) { |
| const auto& feature_area = histogram_expected.first; |
| int expected_count = histogram_expected.second; |
| histogram_tester()->ExpectBucketCount(histogram_name, feature_area, |
| expected_count); |
| total_count += expected_count; |
| } |
| histogram_tester()->ExpectTotalCount(histogram_name, total_count); |
| } |
| |
| TrustSafetySentimentService* service() { |
| return TrustSafetySentimentServiceFactory::GetForProfile(profile()); |
| } |
| content::BrowserTaskEnvironment* task_environment() { |
| return &task_environment_; |
| } |
| base::test::ScopedFeatureList* feature_list() { return &feature_list_; } |
| base::HistogramTester* histogram_tester() { return &histogram_tester_; } |
| MockHatsService* mock_hats_service() { return mock_hats_service_; } |
| TestingProfile* profile() { return &profile_; } |
| |
| private: |
| content::BrowserTaskEnvironment task_environment_{ |
| base::test::TaskEnvironment::TimeSource::MOCK_TIME}; |
| content::RenderViewHostTestEnabler render_view_host_test_enabler_; |
| TestingProfile profile_; |
| base::test::ScopedFeatureList feature_list_; |
| base::HistogramTester histogram_tester_; |
| raw_ptr<MockHatsService> mock_hats_service_; |
| }; |
| |
| TEST_F(TrustSafetySentimentServiceTest, Eligibility_NtpOpens) { |
| // A survey should not be shown if not enough NTPs have been opened since |
| // the most recent trigger action. |
| FeatureParams params; |
| params.privacy_settings_probability = "1.0"; |
| params.trusted_surface_probability = "1.0"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "2"; |
| params.ntp_visits_max_range = "2"; |
| SetupFeatureParameters(params); |
| |
| EXPECT_CALL(*mock_hats_service(), LaunchSurvey).Times(0); |
| |
| service()->TriggerOccurred( |
| TrustSafetySentimentService::FeatureArea::kPrivacySettings, {}); |
| service()->OpenedNewTabPage(); |
| service()->TriggerOccurred( |
| TrustSafetySentimentService::FeatureArea::kTrustedSurface, {}); |
| |
| // The Trusted Surface trigger should prevent a survey from being shown, as |
| // it still has 1 NTP to open. |
| service()->OpenedNewTabPage(); |
| testing::Mock::VerifyAndClearExpectations(mock_hats_service()); |
| |
| CheckHistograms({TrustSafetySentimentService::FeatureArea::kPrivacySettings, |
| TrustSafetySentimentService::FeatureArea::kTrustedSurface}, |
| {}); |
| CheckCallTriggerOccurredHistogram( |
| {{TrustSafetySentimentService::FeatureArea::kPrivacySettings, 1}, |
| {TrustSafetySentimentService::FeatureArea::kTrustedSurface, 1}}); |
| |
| // The next NTP should be eligible for a survey. |
| EXPECT_CALL(*mock_hats_service(), LaunchSurvey); |
| service()->OpenedNewTabPage(); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, Eligibility_Time) { |
| // A survey should not be shown if any trigger action occurred to recently, or |
| // if all trigger actions occurred too long ago. |
| FeatureParams params; |
| params.privacy_settings_probability = "1.0"; |
| params.trusted_surface_probability = "1.0"; |
| params.min_time_to_prompt = "1m"; |
| params.max_time_to_prompt = "10m"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| SetupFeatureParameters(params); |
| |
| EXPECT_CALL(*mock_hats_service(), LaunchSurvey).Times(0); |
| service()->TriggerOccurred( |
| TrustSafetySentimentService::FeatureArea::kPrivacySettings, {}); |
| service()->OpenedNewTabPage(); |
| |
| task_environment()->AdvanceClock(base::Minutes(2)); |
| service()->TriggerOccurred( |
| TrustSafetySentimentService::FeatureArea::kTrustedSurface, {}); |
| service()->OpenedNewTabPage(); |
| testing::Mock::VerifyAndClearExpectations(mock_hats_service()); |
| |
| // Moving the clock forward such that only the trusted surface trigger is |
| // within the window should guarantee it is the survey shown. |
| task_environment()->AdvanceClock(base::Minutes(9)); |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyTrustedSurface, _, _, _, |
| _, _, _)); |
| service()->OpenedNewTabPage(); |
| |
| CheckHistograms({TrustSafetySentimentService::FeatureArea::kPrivacySettings, |
| TrustSafetySentimentService::FeatureArea::kTrustedSurface}, |
| {TrustSafetySentimentService::FeatureArea::kTrustedSurface}); |
| CheckCallTriggerOccurredHistogram( |
| {{TrustSafetySentimentService::FeatureArea::kPrivacySettings, 1}, |
| {TrustSafetySentimentService::FeatureArea::kTrustedSurface, 1}}); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, TriggerProbability) { |
| // Triggers which fail the probability check should not be considered. |
| EXPECT_CALL(*mock_hats_service(), LaunchSurvey).Times(0); |
| FeatureParams params; |
| params.trusted_surface_probability = "0.0"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| SetupFeatureParameters(params); |
| |
| service()->TriggerOccurred( |
| TrustSafetySentimentService::FeatureArea::kTrustedSurface, {}); |
| service()->OpenedNewTabPage(); |
| CheckHistograms({}, {}); |
| CheckCallTriggerOccurredHistogram( |
| {{TrustSafetySentimentService::FeatureArea::kTrustedSurface, 1}}); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, TriggersClearOnLaunch) { |
| // Check that all active triggers are cleared when a survey is launched. |
| FeatureParams params; |
| params.trusted_surface_probability = "1.0"; |
| params.privacy_settings_probability = "1.0"; |
| params.transactions_probability = "1.0"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| SetupFeatureParameters(params); |
| |
| service()->TriggerOccurred( |
| TrustSafetySentimentService::FeatureArea::kPrivacySettings, {}); |
| service()->TriggerOccurred( |
| TrustSafetySentimentService::FeatureArea::kTrustedSurface, {}); |
| |
| CheckHistograms({TrustSafetySentimentService::FeatureArea::kPrivacySettings, |
| TrustSafetySentimentService::FeatureArea::kTrustedSurface}, |
| {}); |
| |
| // The launched survey will be randomly selected from the two triggers. |
| std::string requested_survey_trigger; |
| EXPECT_CALL(*mock_hats_service(), LaunchSurvey) |
| .WillOnce(testing::SaveArg<0>(&requested_survey_trigger)); |
| service()->OpenedNewTabPage(); |
| testing::Mock::VerifyAndClearExpectations(mock_hats_service()); |
| auto surveyed_feature_area = |
| requested_survey_trigger == kHatsSurveyTriggerTrustSafetyPrivacySettings |
| ? TrustSafetySentimentService::FeatureArea::kPrivacySettings |
| : TrustSafetySentimentService::FeatureArea::kTrustedSurface; |
| |
| // The trigger which did not result in a survey should no longer be |
| // considered. |
| EXPECT_CALL(*mock_hats_service(), LaunchSurvey).Times(0); |
| service()->OpenedNewTabPage(); |
| testing::Mock::VerifyAndClearExpectations(mock_hats_service()); |
| |
| // Repeated triggers post survey launch should however be considered. |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyTransactions, _, _, _, |
| _, _, _)); |
| service()->TriggerOccurred( |
| TrustSafetySentimentService::FeatureArea::kTransactions, {}); |
| service()->OpenedNewTabPage(); |
| |
| CheckHistograms({TrustSafetySentimentService::FeatureArea::kPrivacySettings, |
| TrustSafetySentimentService::FeatureArea::kTrustedSurface, |
| TrustSafetySentimentService::FeatureArea::kTransactions}, |
| {surveyed_feature_area, |
| TrustSafetySentimentService::FeatureArea::kTransactions}); |
| CheckCallTriggerOccurredHistogram( |
| {{TrustSafetySentimentService::FeatureArea::kPrivacySettings, 1}, |
| {TrustSafetySentimentService::FeatureArea::kTrustedSurface, 1}, |
| {TrustSafetySentimentService::FeatureArea::kTransactions, 1}}); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, SettingsWatcher_PrivacySettings) { |
| FeatureParams params; |
| params.privacy_settings_probability = "1.0"; |
| params.privacy_settings_time = "10s"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| SetupFeatureParameters(params); |
| |
| // Create and navigate a test web contents to settings. |
| auto web_contents = |
| content::WebContentsTester::CreateTestWebContents(profile(), nullptr); |
| content::WebContentsTester::For(web_contents.get()) |
| ->SetLastCommittedURL(GURL(chrome::kChromeUISettingsURL)); |
| |
| // Interacting with setting shouldn't causes a survey to be immediately |
| // displayed, but should require the user to stay on settings for some time. |
| EXPECT_CALL(*mock_hats_service(), LaunchSurvey).Times(0); |
| service()->InteractedWithPrivacySettings(web_contents.get()); |
| service()->OpenedNewTabPage(); |
| testing::Mock::VerifyAndClearExpectations(mock_hats_service()); |
| |
| // Once the user has spent the appropriate amount of time on settings, they |
| // should be eligible for a survey. |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyPrivacySettings, _, _, |
| _, _, _, _)); |
| task_environment()->AdvanceClock(base::Seconds(20)); |
| task_environment()->RunUntilIdle(); |
| service()->OpenedNewTabPage(); |
| testing::Mock::VerifyAndClearExpectations(mock_hats_service()); |
| |
| // Leaving settings before the required time should disqualify the user from |
| // receiving a survey. |
| EXPECT_CALL(*mock_hats_service(), LaunchSurvey).Times(0); |
| service()->InteractedWithPrivacySettings(web_contents.get()); |
| task_environment()->AdvanceClock(base::Seconds(5)); |
| task_environment()->RunUntilIdle(); |
| service()->OpenedNewTabPage(); |
| |
| content::WebContentsTester::For(web_contents.get()) |
| ->SetLastCommittedURL(GURL("http://unrelated.com")); |
| task_environment()->AdvanceClock(base::Seconds(15)); |
| task_environment()->RunUntilIdle(); |
| service()->OpenedNewTabPage(); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, SettingsWatcher_PasswordManager) { |
| FeatureParams params; |
| params.transactions_probability = "1.0"; |
| params.transactions_password_manager_time = "10s"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| SetupFeatureParameters(params); |
| |
| // Check that after being informed of a visit to the password manager page, |
| // the service correctly watches the provided WebContents to check if the |
| // user stays on settings. |
| auto web_contents = |
| content::WebContentsTester::CreateTestWebContents(profile(), nullptr); |
| content::WebContentsTester::For(web_contents.get()) |
| ->SetLastCommittedURL(GURL(chrome::kChromeUISettingsURL)); |
| |
| // A survey should not be shown unless the user spends at least the required |
| // time on settings after opening password manager. |
| EXPECT_CALL(*mock_hats_service(), LaunchSurvey).Times(0); |
| service()->OpenedPasswordManager(web_contents.get()); |
| service()->OpenedNewTabPage(); |
| testing::Mock::VerifyAndClearExpectations(mock_hats_service()); |
| |
| // Once the user has spent sufficient time on settings after visiting the |
| // password manager, they should be eligible for the Transactions copy of the |
| // survey. |
| SurveyBitsData expected_psd = {{"Saved password", false}}; |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyTransactions, _, _, |
| expected_psd, _, _, _)); |
| |
| task_environment()->AdvanceClock(base::Seconds(20)); |
| task_environment()->RunUntilIdle(); |
| service()->OpenedNewTabPage(); |
| testing::Mock::VerifyAndClearExpectations(mock_hats_service()); |
| |
| // Leaving settings before the required time should not make the user |
| // eligible. |
| EXPECT_CALL(*mock_hats_service(), LaunchSurvey).Times(0); |
| service()->OpenedPasswordManager(web_contents.get()); |
| task_environment()->AdvanceClock(base::Seconds(5)); |
| task_environment()->RunUntilIdle(); |
| service()->OpenedNewTabPage(); |
| |
| content::WebContentsTester::For(web_contents.get()) |
| ->SetLastCommittedURL(GURL("http://unrelated.com")); |
| task_environment()->AdvanceClock(base::Seconds(15)); |
| task_environment()->RunUntilIdle(); |
| service()->OpenedNewTabPage(); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, RanSafetyCheck) { |
| // Running the safety check is considered a trigger, and should make a user |
| // eligible to receive a survey. |
| FeatureParams params; |
| params.privacy_settings_probability = "1.0"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| SetupFeatureParameters(params); |
| |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyPrivacySettings, _, _, |
| _, _, _, _)); |
| service()->RanSafetyCheck(); |
| service()->OpenedNewTabPage(); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, SavedPassword) { |
| // Saving a password is considered a trigger, and should make a user eligible |
| // to receive a survey. |
| FeatureParams params; |
| params.transactions_probability = "1.0"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| SetupFeatureParameters(params); |
| |
| SurveyBitsData expected_psd = {{"Saved password", true}}; |
| |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyTransactions, _, _, |
| expected_psd, _, _, _)); |
| service()->SavedPassword(); |
| service()->OpenedNewTabPage(); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, SavedCard) { |
| // Saving a card is considered a trigger, and should make a user eligible |
| // to receive a survey. |
| FeatureParams params; |
| params.transactions_probability = "1.0"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| SetupFeatureParameters(params); |
| |
| SurveyBitsData expected_psd = {{"Saved password", false}}; |
| |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyTransactions, _, _, |
| expected_psd, _, _, _)); |
| service()->SavedCard(); |
| service()->OpenedNewTabPage(); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, PrivacySettingsProductSpecificData) { |
| // Check the product specific data accompanying surveys for the Privacy |
| // Settings feature area correctly records whether the user has a non default |
| // privacy setting. |
| FeatureParams params; |
| params.privacy_settings_probability = "1.0"; |
| params.privacy_settings_time = "0s"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| SetupFeatureParameters(params); |
| |
| auto web_contents = |
| content::WebContentsTester::CreateTestWebContents(profile(), nullptr); |
| content::WebContentsTester::For(web_contents.get()) |
| ->SetLastCommittedURL(GURL(chrome::kChromeUISettingsURL)); |
| |
| SurveyBitsData expected_psd = {{"Non default setting", false}, |
| {"Ran safety check", false}}; |
| |
| // By default, a user should have no non-default settings. |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyPrivacySettings, _, _, |
| expected_psd, _, _, _)); |
| service()->InteractedWithPrivacySettings(web_contents.get()); |
| task_environment()->RunUntilIdle(); |
| service()->OpenedNewTabPage(); |
| testing::Mock::VerifyAndClearExpectations(mock_hats_service()); |
| |
| expected_psd["Ran safety check"] = true; |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyPrivacySettings, _, _, |
| expected_psd, _, _, _)); |
| service()->RanSafetyCheck(); |
| service()->OpenedNewTabPage(); |
| testing::Mock::VerifyAndClearExpectations(mock_hats_service()); |
| |
| // Check that default content settings are considered. |
| expected_psd["Non default setting"] = true; |
| auto* content_settings = |
| HostContentSettingsMapFactory::GetForProfile(profile()); |
| content_settings->SetDefaultContentSetting( |
| ContentSettingsType::SOUND, ContentSetting::CONTENT_SETTING_BLOCK); |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyPrivacySettings, _, _, |
| expected_psd, _, _, _)); |
| service()->RanSafetyCheck(); |
| service()->OpenedNewTabPage(); |
| testing::Mock::VerifyAndClearExpectations(mock_hats_service()); |
| content_settings->SetDefaultContentSetting( |
| ContentSettingsType::SOUND, ContentSetting::CONTENT_SETTING_DEFAULT); |
| |
| // Check that preferences are considered. |
| expected_psd["Ran safety check"] = false; |
| profile()->GetTestingPrefService()->SetUserPref( |
| prefs::kEnableDoNotTrack, std::make_unique<base::Value>(true)); |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyPrivacySettings, _, _, |
| expected_psd, _, _, _)); |
| service()->InteractedWithPrivacySettings(web_contents.get()); |
| task_environment()->RunUntilIdle(); |
| service()->OpenedNewTabPage(); |
| testing::Mock::VerifyAndClearExpectations(mock_hats_service()); |
| profile()->GetPrefs()->ClearPref(prefs::kEnableDoNotTrack); |
| |
| // Check that sync state defaults are handled correctly. |
| profile()->GetTestingPrefService()->SetUserPref( |
| unified_consent::prefs::kUrlKeyedAnonymizedDataCollectionEnabled, |
| std::make_unique<base::Value>(true)); |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyPrivacySettings, _, _, |
| expected_psd, _, _, _)); |
| service()->InteractedWithPrivacySettings(web_contents.get()); |
| task_environment()->RunUntilIdle(); |
| service()->OpenedNewTabPage(); |
| testing::Mock::VerifyAndClearExpectations(mock_hats_service()); |
| |
| // UKM is only non default while no sync consent is present. |
| expected_psd["Non default setting"] = false; |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyPrivacySettings, _, _, |
| expected_psd, _, _, _)); |
| profile()->GetTestingPrefService()->SetUserPref( |
| prefs::kGoogleServicesConsentedToSync, |
| std::make_unique<base::Value>(true)); |
| service()->InteractedWithPrivacySettings(web_contents.get()); |
| task_environment()->RunUntilIdle(); |
| service()->OpenedNewTabPage(); |
| |
| // A preference or content setting changed via policy should not be considered |
| // as non-default. |
| profile()->GetTestingPrefService()->SetManagedPref( |
| prefs::kEnableDoNotTrack, std::make_unique<base::Value>(true)); |
| auto managed_provider = std::make_unique<content_settings::MockProvider>(); |
| managed_provider->SetWebsiteSetting( |
| ContentSettingsPattern::Wildcard(), ContentSettingsPattern::Wildcard(), |
| ContentSettingsType::COOKIES, |
| base::Value(ContentSetting::CONTENT_SETTING_BLOCK), /*constraints=*/{}); |
| content_settings::TestUtils::OverrideProvider( |
| content_settings, std::move(managed_provider), |
| content_settings::ProviderType::kPolicyProvider); |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyPrivacySettings, _, _, |
| expected_psd, _, _, _)); |
| service()->InteractedWithPrivacySettings(web_contents.get()); |
| task_environment()->RunUntilIdle(); |
| service()->OpenedNewTabPage(); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, ActiveIncognitoPreventsSurvey) { |
| // Check that when an incognito profile exists that a survey is not shown. |
| FeatureParams params; |
| params.privacy_settings_probability = "1.0"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| SetupFeatureParameters(params); |
| |
| auto* otr_profile = |
| profile()->GetPrimaryOTRProfile(/*create_if_needed=*/true); |
| |
| EXPECT_CALL(*mock_hats_service(), LaunchSurvey).Times(0); |
| service()->RanSafetyCheck(); |
| service()->OpenedNewTabPage(); |
| testing::Mock::VerifyAndClearExpectations(mock_hats_service()); |
| |
| profile()->DestroyOffTheRecordProfile(otr_profile); |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyPrivacySettings, _, _, |
| _, _, _, _)); |
| service()->OpenedNewTabPage(); |
| CheckHistograms({TrustSafetySentimentService::FeatureArea::kPrivacySettings, |
| TrustSafetySentimentService::FeatureArea::kIneligible}, |
| {TrustSafetySentimentService::FeatureArea::kPrivacySettings}); |
| CheckCallTriggerOccurredHistogram( |
| {{TrustSafetySentimentService::FeatureArea::kSafetyCheck, 1}, |
| {TrustSafetySentimentService::FeatureArea::kPrivacySettings, 1}}); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, ClosingIncognitoDelaysSurvey) { |
| // Check that closing an incognito session delays when a survey is shown |
| // by the minimum time to prompt, and the maximum of the range of NTP visits. |
| FeatureParams params; |
| params.privacy_settings_probability = "1.0"; |
| params.min_time_to_prompt = "1m"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "2"; |
| SetupFeatureParameters(params); |
| |
| auto* otr_profile = |
| profile()->GetPrimaryOTRProfile(/*create_if_needed=*/true); |
| EXPECT_CALL(*mock_hats_service(), LaunchSurvey).Times(0); |
| service()->RanSafetyCheck(); |
| |
| // Record 2 visits to the NTP so regardless of the random NTP count chosen, |
| // the Privacy Settings trigger will be eligible, but currently blocked by |
| // the presence of an incognito profile. |
| for (int i = 0; i < 2; i++) { |
| service()->OpenedNewTabPage(); |
| } |
| |
| profile()->DestroyOffTheRecordProfile(otr_profile); |
| |
| // The first NTP opened after closing the incognito session should never |
| // result in a survey, as the maximum of the range is 2. |
| service()->OpenedNewTabPage(); |
| |
| CheckHistograms({TrustSafetySentimentService::FeatureArea::kPrivacySettings, |
| TrustSafetySentimentService::FeatureArea::kIneligible}, |
| {}); |
| |
| // The second visit to the NTP should not trigger a survey if it takes place |
| // less than the minimum time to prompt after closing an incognito session. |
| task_environment()->AdvanceClock(base::Seconds(30)); |
| service()->OpenedNewTabPage(); |
| |
| // Up to this point no attempt to show any survey should have been made. |
| testing::Mock::VerifyAndClearExpectations(mock_hats_service()); |
| |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyPrivacySettings, _, _, |
| _, _, _, _)); |
| |
| // The next tab open which occurs after the required number of opens, and the |
| // minimum time has passed, should trigger a survey. |
| task_environment()->AdvanceClock(base::Minutes(1)); |
| service()->OpenedNewTabPage(); |
| |
| CheckHistograms({TrustSafetySentimentService::FeatureArea::kPrivacySettings, |
| TrustSafetySentimentService::FeatureArea::kIneligible}, |
| {TrustSafetySentimentService::FeatureArea::kPrivacySettings}); |
| CheckCallTriggerOccurredHistogram( |
| {{TrustSafetySentimentService::FeatureArea::kSafetyCheck, 1}, |
| {TrustSafetySentimentService::FeatureArea::kPrivacySettings, 1}}); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, AllFeatureAreasHaveTriggers) { |
| // Assert that for every feature area there is the correct version(s) and |
| // survey trigger id. |
| FeatureParams paramsv1; |
| SetupFeatureParameters(paramsv1); |
| for (int enum_value = 0; |
| enum_value <= |
| static_cast<int>(TrustSafetySentimentService::FeatureArea::kMaxValue); |
| ++enum_value) { |
| if (IsDeprecatedFeatureArea(enum_value)) { |
| continue; |
| } |
| auto feature_area = |
| static_cast<TrustSafetySentimentService::FeatureArea>(enum_value); |
| if (TrustSafetySentimentService::VersionCheck(feature_area)) { |
| EXPECT_NE("", TrustSafetySentimentService::GetHatsTriggerForFeatureArea( |
| feature_area)); |
| } |
| } |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, V2_AllFeatureAreasHaveTriggers) { |
| // Assert that for every feature area there is the correct version(s) and |
| // survey trigger id. |
| FeatureParamsV2 paramsv2; |
| SetupFeatureParametersV2(paramsv2); |
| for (int enum_value = 0; |
| enum_value <= |
| static_cast<int>(TrustSafetySentimentService::FeatureArea::kMaxValue); |
| ++enum_value) { |
| if (IsDeprecatedFeatureArea(enum_value)) { |
| continue; |
| } |
| auto feature_area = |
| static_cast<TrustSafetySentimentService::FeatureArea>(enum_value); |
| if (TrustSafetySentimentService::VersionCheck(feature_area)) { |
| EXPECT_NE("", TrustSafetySentimentService::GetHatsTriggerForFeatureArea( |
| feature_area)); |
| } |
| } |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, AllFeatureAreasHaveProbabilities) { |
| // Check that for every feature with a probability of 1 and the correct |
| // version, the dice roll always succeeds. |
| FeatureParams params; |
| params.privacy_settings_probability = "1.0"; |
| params.trusted_surface_probability = "1.0"; |
| params.transactions_probability = "1.0"; |
| params.privacy_sandbox_4_consent_accept_probability = "1.0"; |
| params.privacy_sandbox_4_consent_decline_probability = "1.0"; |
| params.privacy_sandbox_4_notice_ok_probability = "1.0"; |
| params.privacy_sandbox_4_notice_settings_probability = "1.0"; |
| |
| SetupFeatureParameters(params); |
| for (int enum_value = 0; |
| enum_value <= |
| static_cast<int>(TrustSafetySentimentService::FeatureArea::kMaxValue); |
| ++enum_value) { |
| if (IsDeprecatedFeatureArea(enum_value)) { |
| continue; |
| } |
| auto feature_area = |
| static_cast<TrustSafetySentimentService::FeatureArea>(enum_value); |
| if (TrustSafetySentimentService::VersionCheck(feature_area)) { |
| EXPECT_TRUE(TrustSafetySentimentService::ProbabilityCheck(feature_area)) |
| << "Feature area: " << static_cast<int>(feature_area); |
| } |
| } |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, V2_AllFeatureAreasHaveProbabilities) { |
| // Check that for every feature with a probability of 1 and the correct |
| // version, the dice roll always succeeds. |
| FeatureParamsV2 params; |
| params.browsing_data_probability = "1.0"; |
| params.control_group_probability = "1.0"; |
| params.download_warning_ui_probability = "1.0"; |
| params.password_check_probability = "1.0"; |
| params.password_protection_ui_probability = "1.0"; |
| params.safety_check_probability = "1.0"; |
| params.trusted_surface_probability = "1.0"; |
| params.privacy_guide_probability = "1.0"; |
| params.privacy_sandbox_4_consent_accept_probability = "1.0"; |
| params.privacy_sandbox_4_consent_decline_probability = "1.0"; |
| params.privacy_sandbox_4_notice_ok_probability = "1.0"; |
| params.privacy_sandbox_4_notice_settings_probability = "1.0"; |
| params.safe_browsing_interstitial_probability = "1.0"; |
| params.safety_hub_notification_probability = "1.0"; |
| params.safety_hub_interaction_probability = "1.0"; |
| |
| SetupFeatureParametersV2(params); |
| for (int enum_value = 0; |
| enum_value <= |
| static_cast<int>(TrustSafetySentimentService::FeatureArea::kMaxValue); |
| ++enum_value) { |
| if (IsDeprecatedFeatureArea(enum_value)) { |
| continue; |
| } |
| auto feature_area = |
| static_cast<TrustSafetySentimentService::FeatureArea>(enum_value); |
| if (TrustSafetySentimentService::VersionCheck(feature_area)) { |
| EXPECT_TRUE(TrustSafetySentimentService::ProbabilityCheck(feature_area)) |
| << "Feature area: " << static_cast<int>(feature_area); |
| } |
| } |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, Eligibility_V1FeatureWhileV2Enabled) { |
| // A survey from V1 only is not shown because V2 is enabled. |
| FeatureParams params; |
| params.privacy_settings_probability = "1.0"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| feature_list()->InitWithFeaturesAndParameters( |
| {{features::kTrustSafetySentimentSurvey, |
| { |
| {"min-time-to-prompt", params.min_time_to_prompt}, |
| {"max-time-to-prompt", params.max_time_to_prompt}, |
| {"ntp-visits-min-range", params.ntp_visits_min_range}, |
| {"ntp-visits-max-range", params.ntp_visits_max_range}, |
| {"trusted-surface-probability", params.trusted_surface_probability}, |
| {"trusted-surface-trigger-id", params.trusted_surface_trigger_id}, |
| }}, |
| {features::kTrustSafetySentimentSurveyV2, {}}}, |
| {}); |
| |
| EXPECT_CALL(*mock_hats_service(), LaunchSurvey).Times(0); |
| service()->TriggerOccurred( |
| TrustSafetySentimentService::FeatureArea::kPrivacySettings, {}); |
| |
| service()->OpenedNewTabPage(); |
| |
| // Survey should not shown be shown as triggered because v2 enabled. |
| CheckHistograms({}, {}); |
| testing::Mock::VerifyAndClearExpectations(mock_hats_service()); |
| |
| // Disable V2 and now the same trigger should work. |
| feature_list()->Reset(); |
| SetupFeatureParameters(params); |
| |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyPrivacySettings, _, _, |
| _, _, _, _)); |
| service()->TriggerOccurred( |
| TrustSafetySentimentService::FeatureArea::kPrivacySettings, {}); |
| service()->OpenedNewTabPage(); |
| CheckHistograms({TrustSafetySentimentService::FeatureArea::kPrivacySettings}, |
| {TrustSafetySentimentService::FeatureArea::kPrivacySettings}); |
| CheckCallTriggerOccurredHistogram( |
| {{TrustSafetySentimentService::FeatureArea::kPrivacySettings, 2}}); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, V2_TrustedSurface) { |
| // A survey from version 2 is only shown if the right conditions are met. |
| FeatureParamsV2 params; |
| params.trusted_surface_probability = "1.0"; |
| params.min_time_to_prompt = "2m"; |
| params.max_time_to_prompt = "4m"; |
| params.ntp_visits_min_range = "2"; |
| params.ntp_visits_max_range = "2"; |
| SetupFeatureParametersV2(params); |
| |
| EXPECT_CALL(*mock_hats_service(), LaunchSurvey).Times(0); |
| service()->TriggerOccurred( |
| TrustSafetySentimentService::FeatureArea::kTrustedSurface, {}); |
| |
| service()->OpenedNewTabPage(); |
| service()->OpenedNewTabPage(); |
| |
| // Survey should not shown because although the ntp visits condition is met, |
| // the time is not. |
| CheckHistograms({TrustSafetySentimentService::FeatureArea::kTrustedSurface}, |
| {}); |
| testing::Mock::VerifyAndClearExpectations(mock_hats_service()); |
| |
| task_environment()->AdvanceClock(base::Minutes(3)); |
| // Assert the V2 survey is called and not the V1. |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyTrustedSurface, _, _, _, |
| _, _, _)) |
| .Times(0); |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyV2TrustedSurface, _, _, |
| _, _, _, _)); |
| |
| // A survey should be shown because we are now within the right time. |
| service()->OpenedNewTabPage(); |
| CheckHistograms({TrustSafetySentimentService::FeatureArea::kTrustedSurface}, |
| {TrustSafetySentimentService::FeatureArea::kTrustedSurface}); |
| CheckCallTriggerOccurredHistogram( |
| {{TrustSafetySentimentService::FeatureArea::kTrustedSurface, 1}}); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, V2_SafetyCheck) { |
| // Running the safety check is considered a trigger, and should make a user |
| // eligible to receive a survey. |
| FeatureParamsV2 params; |
| params.safety_check_probability = "1.0"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| SetupFeatureParametersV2(params); |
| |
| // Running safety check was previously part of PrivacySettings, so assure only |
| // the correct histograms and survey are triggered for V2. |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyPrivacySettings, _, _, |
| _, _, _, _)) |
| .Times(0); |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyV2SafetyCheck, _, _, _, |
| _, _, _)); |
| service()->RanSafetyCheck(); |
| service()->OpenedNewTabPage(); |
| CheckHistograms({TrustSafetySentimentService::FeatureArea::kSafetyCheck}, |
| {TrustSafetySentimentService::FeatureArea::kSafetyCheck}); |
| CheckCallTriggerOccurredHistogram( |
| {{TrustSafetySentimentService::FeatureArea::kSafetyCheck, 1}, |
| {TrustSafetySentimentService::FeatureArea::kPrivacySettings, 1}}); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, V2_PasswordCheck) { |
| // Running password check should make a user eligible to receive a survey. |
| FeatureParamsV2 params; |
| params.password_check_probability = "1.0"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| SetupFeatureParametersV2(params); |
| |
| // The correct survey should be launched. |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyV2PasswordCheck, _, _, |
| _, _, _, _)); |
| service()->RanPasswordCheck(); |
| service()->OpenedNewTabPage(); |
| CheckHistograms({TrustSafetySentimentService::FeatureArea::kPasswordCheck}, |
| {TrustSafetySentimentService::FeatureArea::kPasswordCheck}); |
| CheckCallTriggerOccurredHistogram( |
| {{TrustSafetySentimentService::FeatureArea::kPasswordCheck, 1}}); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, V2_BrowsingData) { |
| // Clearing history through CBD should make user eligible to receive a survey. |
| FeatureParamsV2 params; |
| params.browsing_data_probability = "1.0"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| SetupFeatureParametersV2(params); |
| |
| std::vector<std::pair<browsing_data::BrowsingDataType, SurveyBitsData>> |
| datatypes = {{browsing_data::BrowsingDataType::HISTORY, |
| {{"Deleted history", true}, |
| {"Deleted downloads", false}, |
| {"Deleted autofill form data", false}}}, |
| {browsing_data::BrowsingDataType::DOWNLOADS, |
| {{"Deleted history", false}, |
| {"Deleted downloads", true}, |
| {"Deleted autofill form data", false}}}, |
| {browsing_data::BrowsingDataType::FORM_DATA, |
| {{"Deleted history", false}, |
| {"Deleted downloads", false}, |
| {"Deleted autofill form data", true}}}}; |
| |
| for (const auto& datatype : datatypes) { |
| // The correct survey should be launched. |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyV2BrowsingData, _, _, |
| datatype.second, _, _, _)); |
| service()->ClearedBrowsingData(datatype.first); |
| service()->OpenedNewTabPage(); |
| testing::Mock::VerifyAndClearExpectations(mock_hats_service()); |
| } |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, V2_BrowsingData_NotInterested) { |
| // Clearing a BrowsingDataType that we are not interested in should not |
| // trigger a survey. |
| FeatureParamsV2 params; |
| params.browsing_data_probability = "1.0"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| SetupFeatureParametersV2(params); |
| |
| // No browsing data survey should be launched. |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyV2BrowsingData, _, _, _, |
| _, _, _)) |
| .Times(0); |
| service()->ClearedBrowsingData(browsing_data::BrowsingDataType::SITE_DATA); |
| service()->OpenedNewTabPage(); |
| CheckHistograms({}, {}); |
| CheckCallTriggerOccurredHistogram({}); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, V2_PrivacyGuide) { |
| // Finishing the privacy guide is considered a trigger, and should make a user |
| // eligible to receive a survey. |
| FeatureParamsV2 params; |
| params.privacy_guide_probability = "1.0"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| SetupFeatureParametersV2(params); |
| |
| // The correct survey should be launched. |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyV2PrivacyGuide, _, _, _, |
| _, _, _)); |
| service()->FinishedPrivacyGuide(); |
| service()->OpenedNewTabPage(); |
| CheckHistograms({TrustSafetySentimentService::FeatureArea::kPrivacyGuide}, |
| {TrustSafetySentimentService::FeatureArea::kPrivacyGuide}); |
| CheckCallTriggerOccurredHistogram( |
| {{TrustSafetySentimentService::FeatureArea::kPrivacyGuide, 1}}); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, V2_ControlGroup) { |
| // If a user is in the control group, they should be eligible to see a survey |
| // if they reached a certain threshold of session length, and only once. |
| FeatureParamsV2 params; |
| params.control_group_probability = "1.0"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| params.min_session_time = "30s"; |
| SetupFeatureParametersV2(params); |
| |
| // A survey should not be launched because the session threshold was not |
| // surpassed. |
| EXPECT_CALL(*mock_hats_service(), LaunchSurvey).Times(0); |
| base::TimeTicks session_start = base::TimeTicks::Now(); |
| service()->OnSessionStarted(session_start); |
| task_environment()->AdvanceClock(base::Seconds(10)); |
| base::TimeTicks session_end = base::TimeTicks::Now(); |
| service()->OnSessionEnded(session_end - session_start, session_end); |
| service()->OpenedNewTabPage(); |
| CheckHistograms({}, {}); |
| testing::Mock::VerifyAndClearExpectations(mock_hats_service()); |
| |
| // A survey should be launched because the session threshold was surpassed. |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyV2ControlGroup, _, _, _, |
| _, _, _)); |
| session_start = base::TimeTicks::Now(); |
| service()->OnSessionStarted(session_start); |
| task_environment()->AdvanceClock(base::Seconds(40)); |
| session_end = base::TimeTicks::Now(); |
| service()->OnSessionEnded(session_end - session_start, session_end); |
| service()->OpenedNewTabPage(); |
| CheckHistograms({TrustSafetySentimentService::FeatureArea::kControlGroup}, |
| {TrustSafetySentimentService::FeatureArea::kControlGroup}); |
| CheckCallTriggerOccurredHistogram( |
| {{TrustSafetySentimentService::FeatureArea::kControlGroup, 1}}); |
| testing::Mock::VerifyAndClearExpectations(mock_hats_service()); |
| |
| // A second valid trigger should not launch a survey because we have already |
| // performed one dice roll for this user. |
| EXPECT_CALL(*mock_hats_service(), LaunchSurvey).Times(0); |
| session_start = base::TimeTicks::Now(); |
| service()->OnSessionStarted(session_start); |
| task_environment()->AdvanceClock(base::Seconds(40)); |
| session_end = base::TimeTicks::Now(); |
| service()->OnSessionEnded(session_end - session_start, session_end); |
| service()->OpenedNewTabPage(); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, V2_SafeBrowsingInterstitial) { |
| // Making a final decision on a safe browsing interstitial is considered a |
| // trigger, and should make a user eligible to receive a survey. |
| FeatureParamsV2 params; |
| params.safe_browsing_interstitial_probability = "1.0"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| SetupFeatureParametersV2(params); |
| |
| // The correct survey should be launched. |
| EXPECT_CALL( |
| *mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyV2SafeBrowsingInterstitial, _, |
| _, _, _, _, _)); |
| service()->InteractedWithSafeBrowsingInterstitial( |
| true, safe_browsing::SBThreatType::SB_THREAT_TYPE_URL_PHISHING); |
| service()->OpenedNewTabPage(); |
| CheckHistograms( |
| {TrustSafetySentimentService::FeatureArea::kSafeBrowsingInterstitial}, |
| {TrustSafetySentimentService::FeatureArea::kSafeBrowsingInterstitial}); |
| CheckCallTriggerOccurredHistogram( |
| {{TrustSafetySentimentService::FeatureArea::kSafeBrowsingInterstitial, |
| 1}}); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, V2_DownloadWarningUI) { |
| // Making a final decision on a download warning is considered a |
| // trigger, and should make a user eligible to receive a survey. |
| FeatureParamsV2 params; |
| params.download_warning_ui_probability = "1.0"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| SetupFeatureParametersV2(params); |
| |
| // The correct survey should be launched. |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyV2DownloadWarningUI, _, |
| _, _, _, _, _)); |
| service()->InteractedWithDownloadWarningUI( |
| DownloadItemWarningData::WarningSurface::BUBBLE_MAINPAGE, |
| DownloadItemWarningData::WarningAction::PROCEED); |
| service()->OpenedNewTabPage(); |
| CheckHistograms( |
| {TrustSafetySentimentService::FeatureArea::kDownloadWarningUI}, |
| {TrustSafetySentimentService::FeatureArea::kDownloadWarningUI}); |
| CheckCallTriggerOccurredHistogram( |
| {{TrustSafetySentimentService::FeatureArea::kDownloadWarningUI, 1}}); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, PasswordProtectionUINonPasswordChange) { |
| // Making a final decision on a password protection UI is considered a |
| // trigger, and should make a user eligible to receive a survey. |
| FeatureParamsV2 params; |
| params.password_protection_ui_probability = "1.0"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| SetupFeatureParametersV2(params); |
| |
| // The correct survey should be launched. |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyV2PasswordProtectionUI, |
| _, _, _, _, _, _)); |
| service()->PhishedPasswordUpdateNotClicked( |
| PasswordProtectionUIType::PAGE_INFO, |
| PasswordProtectionUIAction::IGNORE_WARNING); |
| service()->OpenedNewTabPage(); |
| CheckHistograms( |
| {TrustSafetySentimentService::FeatureArea::kPasswordProtectionUI}, |
| {TrustSafetySentimentService::FeatureArea::kPasswordProtectionUI}); |
| CheckCallTriggerOccurredHistogram( |
| {{TrustSafetySentimentService::FeatureArea::kPasswordProtectionUI, 1}}); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, |
| PasswordProtectionUIPasswordChangeClickedNotCompleted) { |
| // Making a final decision on a password protection UI is considered a |
| // trigger, and should make a user eligible to receive a survey. |
| FeatureParamsV2 params; |
| params.password_protection_ui_probability = "1.0"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| SetupFeatureParametersV2(params); |
| |
| // The correct survey should be launched. |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyV2PasswordProtectionUI, |
| _, _, _, _, _, _)); |
| service()->ProtectResetOrCheckPasswordClicked( |
| PasswordProtectionUIType::PAGE_INFO); |
| task_environment()->AdvanceClock(kPasswordChangeInactivity); |
| task_environment()->RunUntilIdle(); |
| service()->OpenedNewTabPage(); |
| |
| CheckHistograms( |
| {TrustSafetySentimentService::FeatureArea::kPasswordProtectionUI}, |
| {TrustSafetySentimentService::FeatureArea::kPasswordProtectionUI}); |
| CheckCallTriggerOccurredHistogram( |
| {{TrustSafetySentimentService::FeatureArea::kPasswordProtectionUI, 1}}); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, |
| PasswordProtectionUIPasswordChangeClickedAndCompleted) { |
| // Making a final decision on a password protection UI is considered a |
| // trigger, and should make a user eligible to receive a survey. |
| FeatureParamsV2 params; |
| params.password_protection_ui_probability = "1.0"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| SetupFeatureParametersV2(params); |
| |
| // The correct survey should be launched. |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyV2PasswordProtectionUI, |
| _, _, _, _, _, _)); |
| service()->ProtectResetOrCheckPasswordClicked( |
| PasswordProtectionUIType::PAGE_INFO); |
| service()->PhishedPasswordUpdateFinished(); |
| service()->OpenedNewTabPage(); |
| CheckHistograms( |
| {TrustSafetySentimentService::FeatureArea::kPasswordProtectionUI}, |
| {TrustSafetySentimentService::FeatureArea::kPasswordProtectionUI}); |
| CheckCallTriggerOccurredHistogram( |
| {{TrustSafetySentimentService::FeatureArea::kPasswordProtectionUI, 1}}); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, |
| PasswordProtectionUIPasswordChangeThenNonPasswordChange) { |
| // Making a final decision on a password protection UI is considered a |
| // trigger, and should make a user eligible to receive a survey. |
| FeatureParamsV2 params; |
| params.password_protection_ui_probability = "1.0"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| SetupFeatureParametersV2(params); |
| |
| // The correct survey should be launched. |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyV2PasswordProtectionUI, |
| _, _, _, _, _, _)); |
| service()->ProtectResetOrCheckPasswordClicked( |
| PasswordProtectionUIType::PAGE_INFO); |
| service()->PhishedPasswordUpdateNotClicked( |
| PasswordProtectionUIType::PAGE_INFO, PasswordProtectionUIAction::CLOSE); |
| service()->PhishedPasswordUpdateFinished(); |
| service()->OpenedNewTabPage(); |
| CheckCallTriggerOccurredHistogram( |
| {{TrustSafetySentimentService::FeatureArea::kPasswordProtectionUI, 2}}); |
| } |
| |
| TEST_F(TrustSafetySentimentServiceTest, |
| PasswordProtectionUIPasswordChangeThenNonPasswordChange2) { |
| // Making a final decision on a password protection UI is considered a |
| // trigger, and should make a user eligible to receive a survey. |
| FeatureParamsV2 params; |
| params.password_protection_ui_probability = "1.0"; |
| params.min_time_to_prompt = "0s"; |
| params.ntp_visits_min_range = "0"; |
| params.ntp_visits_max_range = "0"; |
| SetupFeatureParametersV2(params); |
| |
| // The correct survey should be launched. |
| EXPECT_CALL(*mock_hats_service(), |
| LaunchSurvey(kHatsSurveyTriggerTrustSafetyV2PasswordProtectionUI, |
| _, _, _, _, _, _)); |
| service()->ProtectResetOrCheckPasswordClicked( |
| PasswordProtectionUIType::PAGE_INFO); |
| service()->PhishedPasswordUpdateNotClicked( |
| PasswordProtectionUIType::PAGE_INFO, PasswordProtectionUIAction::CLOSE); |
| service()->PhishedPasswordUpdateFinished(); |
| task_environment()->AdvanceClock(kPasswordChangeInactivity); |
| service()->OpenedNewTabPage(); |
| CheckCallTriggerOccurredHistogram( |
| {{TrustSafetySentimentService::FeatureArea::kPasswordProtectionUI, 2}}); |
| } |
