chrome/browser/ui/safety_hub/menu_notification_unittest.cc - chromium/src.git - Git at Google

 // Copyright 2023 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/safety_hub/menu_notification.h"

 #include <memory>

 #include "base/json/values_util.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/ui/safety_hub/revoked_permissions_service.h"
 #include "chrome/browser/ui/safety_hub/safety_hub_constants.h"
 #include "chrome/browser/ui/safety_hub/safety_hub_service.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "components/content_settings/core/browser/content_settings_registry.h"
 #include "components/content_settings/core/common/content_settings_constraints.h"
 #include "content/public/test/browser_task_environment.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace {
 constexpr char kUrl1[] = "https://example1.com:443";
 const base::TimeDelta kLifetime = base::Days(60);
 const base::Time kPastTime = base::Time::Now() - kLifetime;

 // TODO(crbug.com/40267370): Use a mock result instead.
 std::unique_ptr<RevokedPermissionsResult> CreateRevokedPermissionsResult(
     base::Value::List urls) {
   auto result = std::make_unique<RevokedPermissionsResult>();
   PermissionsData permissions_data;
   for (base::Value& url_val : urls) {
     permissions_data.primary_pattern =
         ContentSettingsPattern::FromString(url_val.GetString());
     permissions_data.permission_types = {ContentSettingsType::GEOLOCATION};
     permissions_data.constraints =
         content_settings::ContentSettingConstraints(kPastTime);
     permissions_data.constraints.set_lifetime(kLifetime);
     result->AddRevokedPermission(permissions_data);
   }
   return result;
 }
 }  // namespace

 class SafetyHubMenuNotificationTest : public testing::Test {
  public:
   SafetyHubMenuNotificationTest() {
     testing_profile_manager_ = std::make_unique<TestingProfileManager>(
         TestingBrowserProcess::GetGlobal());
     EXPECT_TRUE(testing_profile_manager_->SetUp());
     profile_ =
         testing_profile_manager_->CreateTestingProfile("user@example.com");
     EXPECT_TRUE(profile_);
   }
   ~SafetyHubMenuNotificationTest() override = default;

   void SetUp() override {
     // Content settings registry needs to be reset to ensure that it has loaded
     // the correct permission types.
     auto* registry = content_settings::ContentSettingsRegistry::GetInstance();
     registry->ResetForTest();
     service_ = std::make_unique<RevokedPermissionsService>(
         profile(), profile()->GetPrefs());
   }

  protected:
   void FastForwardBy(base::TimeDelta delta) {
     task_environment_.FastForwardBy(delta);
   }

   RevokedPermissionsService* service() { return service_.get(); }
   TestingProfile* profile() { return profile_.get(); }

  private:
   content::BrowserTaskEnvironment task_environment_{
       base::test::TaskEnvironment::TimeSource::MOCK_TIME};
   std::unique_ptr<TestingProfileManager> testing_profile_manager_;
   raw_ptr<TestingProfile> profile_ = nullptr;
   std::unique_ptr<RevokedPermissionsService> service_;
 };

 // TODO(crbug.com/364523673): This test is flaking on android pie builder.
 TEST_F(SafetyHubMenuNotificationTest, DISABLED_ToFromDictValue) {
   // Creating a mock menu notification.
   base::Time last = kPastTime + base::Days(30);
   auto notification = std::make_unique<SafetyHubMenuNotification>(
       safety_hub::SafetyHubModuleType::UNUSED_SITE_PERMISSIONS);
   notification->is_currently_active_ = true;
   notification->impression_count_ = 42;
   notification->first_impression_time_ = kPastTime;
   notification->last_impression_time_ = last;
   notification->current_result_ =
       CreateRevokedPermissionsResult(base::Value::List().Append(kUrl1));

   // When transforming the notification to a Dict, the properties of the
   // notification should be correct.
   base::Value::Dict dict = notification->ToDictValue();
   EXPECT_TRUE(
       dict.FindBool(safety_hub::kSafetyHubMenuNotificationActiveKey).value());
   EXPECT_EQ(42, dict.FindInt(
                     safety_hub::kSafetyHubMenuNotificationImpressionCountKey));
   EXPECT_EQ(
       base::TimeToValue(kPastTime),
       *dict.Find(safety_hub::kSafetyHubMenuNotificationFirstImpressionKey));
   EXPECT_EQ(
       base::TimeToValue(last),
       *dict.Find(safety_hub::kSafetyHubMenuNotificationLastImpressionKey));
   EXPECT_TRUE(dict.contains(safety_hub::kSafetyHubMenuNotificationResultKey));
   // The properties of the contained result should also be correct.
   auto* result_dict =
       dict.FindDict(safety_hub::kSafetyHubMenuNotificationResultKey);
   EXPECT_TRUE(result_dict->contains(kRevokedPermissionsResultKey));
   EXPECT_EQ(1U, result_dict->FindList(kRevokedPermissionsResultKey)->size());
   base::Value::List& revoked_origins =
       *result_dict->FindList(kRevokedPermissionsResultKey);
   EXPECT_EQ(kUrl1, revoked_origins.front());

   // Using the dict from before, we can create another menu notification object
   // that should have the same properties as when it was initially created.
   auto new_notification = std::make_unique<SafetyHubMenuNotification>(
       std::move(dict),
       safety_hub::SafetyHubModuleType::UNUSED_SITE_PERMISSIONS);
   EXPECT_TRUE(new_notification->is_currently_active_);
   EXPECT_EQ(42, new_notification->impression_count_);
   EXPECT_EQ(kPastTime, new_notification->first_impression_time_);
   EXPECT_EQ(last, new_notification->last_impression_time_);
   EXPECT_FALSE(new_notification->prev_stored_result_.empty());
   EXPECT_EQ(kUrl1, new_notification->prev_stored_result_
                        .FindList(kRevokedPermissionsResultKey)
                        ->front()
                        .GetString());
 }

 // TODO(crbug.com/364523673): This test is flaking on android pie builder.
 TEST_F(SafetyHubMenuNotificationTest, DISABLED_ShouldBeShown) {
   base::TimeDelta interval = base::Days(30);
   auto notification = std::make_unique<SafetyHubMenuNotification>(
       safety_hub::SafetyHubModuleType::UNUSED_SITE_PERMISSIONS);

   // No result associated with notification, so should not be shown.
   ASSERT_FALSE(notification->ShouldBeShown(interval));

   // The notification is updated with a new result that is a trigger. The
   // notification has never been shown, so should be shown.
   std::unique_ptr<RevokedPermissionsResult> result =
       CreateRevokedPermissionsResult(base::Value::List().Append(kUrl1));
   notification->UpdateResult(std::move(result));
   ASSERT_TRUE(notification->ShouldBeShown(interval));

   // Showing the notification once should make it still be shown after.
   notification->Show();
   ASSERT_TRUE(notification->ShouldBeShown(interval));

   // Showing the notification the minimum number of times, but not the minimum
   // period of time, should make it still be shown.
   for (int i = 0; i < kSafetyHubMenuNotificationMinImpressionCount; ++i) {
     notification->Show();
     FastForwardBy(base::Hours(1));
   }
   ASSERT_TRUE(notification->ShouldBeShown(interval));

   // Moving past the minimum duration should now make the notification no longer
   // be shown.
   FastForwardBy(kSafetyHubMenuNotificationMinNotificationDuration);
   ASSERT_FALSE(notification->ShouldBeShown(interval));

   // The notification can be dismissed now, and it should still not be shown.
   notification->Dismiss();
   ASSERT_FALSE(notification->ShouldBeShown(interval));

   // If the result does not change, the notification should not be shown.
   FastForwardBy(interval);
   ASSERT_FALSE(notification->ShouldBeShown(interval));

   // When updating to a similar result, the notification should still not be
   // shown.
   std::unique_ptr<RevokedPermissionsResult> similar_result =
       CreateRevokedPermissionsResult(base::Value::List().Append(kUrl1));
   notification->UpdateResult(std::move(similar_result));
   ASSERT_FALSE(notification->ShouldBeShown(interval));

   // When updating to a new result, the notification should be shown.
   std::unique_ptr<RevokedPermissionsResult> new_result =
       CreateRevokedPermissionsResult(
           base::Value::List().Append("https://other.com:443"));
   notification->UpdateResult(std::move(new_result));
   ASSERT_TRUE(notification->ShouldBeShown(interval));

   // Notification should still be shown after showing once.
   notification->Show();
   ASSERT_TRUE(notification->ShouldBeShown(interval));

   // Dimissing an active notification should make it not be shown. Note: showing
   // notification once is a prerequisite for dismissing it.
   notification->Dismiss();
   ASSERT_FALSE(notification->ShouldBeShown(interval));

   // Create new notification and new associated result to test passing time but
   // not the count.
   result = CreateRevokedPermissionsResult(base::Value::List().Append(kUrl1));
   auto other_notification = std::make_unique<SafetyHubMenuNotification>(
       safety_hub::SafetyHubModuleType::UNUSED_SITE_PERMISSIONS);
   other_notification->UpdateResult(std::move(result));
   other_notification->Show();

   // Go past the minimum duration that the notification should be shown. It
   // should still be shown because it was only shown once.
   FastForwardBy(kSafetyHubMenuNotificationMinNotificationDuration +
                 base::Days(2));
   ASSERT_TRUE(other_notification->ShouldBeShown(interval));

   // The notification should no longer be shown if it has already been shown a
   // sufficient number of times.
   for (int i = 0; i < kSafetyHubMenuNotificationMinImpressionCount; ++i) {
     other_notification->Show();
     FastForwardBy(base::Hours(1));
   }
   ASSERT_FALSE(other_notification->ShouldBeShown(interval));
 }

 // TODO(crbug.com/364523673): This test is flaking on android pie builder.
 TEST_F(SafetyHubMenuNotificationTest, DISABLED_IsCurrentlyActive) {
   auto notification = std::make_unique<SafetyHubMenuNotification>(
       safety_hub::SafetyHubModuleType::UNUSED_SITE_PERMISSIONS);

   // A notification is not active when it new or when it has not been shown yet.
   ASSERT_FALSE(notification->IsCurrentlyActive());
   std::unique_ptr<RevokedPermissionsResult> result =
       CreateRevokedPermissionsResult(base::Value::List().Append(kUrl1));
   notification->UpdateResult(std::move(result));
   ASSERT_FALSE(notification->IsCurrentlyActive());

   // Showing a notification makes it active.
   notification->Show();
   ASSERT_TRUE(notification->IsCurrentlyActive());

   // Dismissing the nofication makes it not active any more.
   notification->Dismiss();
   ASSERT_FALSE(notification->IsCurrentlyActive());
 }

 // TODO(crbug.com/40267370): Add tests for other types of Safety Hub services
 // and Safety Hub results.
	// Copyright 2023 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/safety_hub/menu_notification.h"

	#include <memory>

	#include "base/json/values_util.h"
	#include "base/time/time.h"
	#include "base/values.h"
	#include "chrome/browser/content_settings/host_content_settings_map_factory.h"
	#include "chrome/browser/ui/safety_hub/revoked_permissions_service.h"
	#include "chrome/browser/ui/safety_hub/safety_hub_constants.h"
	#include "chrome/browser/ui/safety_hub/safety_hub_service.h"
	#include "chrome/test/base/testing_browser_process.h"
	#include "chrome/test/base/testing_profile.h"
	#include "chrome/test/base/testing_profile_manager.h"
	#include "components/content_settings/core/browser/content_settings_registry.h"
	#include "components/content_settings/core/common/content_settings_constraints.h"
	#include "content/public/test/browser_task_environment.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace {
	constexpr char kUrl1[] = "https://example1.com:443";
	const base::TimeDelta kLifetime = base::Days(60);
	const base::Time kPastTime = base::Time::Now() - kLifetime;

	// TODO(crbug.com/40267370): Use a mock result instead.
	std::unique_ptr<RevokedPermissionsResult> CreateRevokedPermissionsResult(
	base::Value::List urls) {
	auto result = std::make_unique<RevokedPermissionsResult>();
	PermissionsData permissions_data;
	for (base::Value& url_val : urls) {
	permissions_data.primary_pattern =
	ContentSettingsPattern::FromString(url_val.GetString());
	permissions_data.permission_types = {ContentSettingsType::GEOLOCATION};
	permissions_data.constraints =
	content_settings::ContentSettingConstraints(kPastTime);
	permissions_data.constraints.set_lifetime(kLifetime);
	result->AddRevokedPermission(permissions_data);
	}
	return result;
	}
	} // namespace

	class SafetyHubMenuNotificationTest : public testing::Test {
	public:
	SafetyHubMenuNotificationTest() {
	testing_profile_manager_ = std::make_unique<TestingProfileManager>(
	TestingBrowserProcess::GetGlobal());
	EXPECT_TRUE(testing_profile_manager_->SetUp());
	profile_ =
	testing_profile_manager_->CreateTestingProfile("user@example.com");
	EXPECT_TRUE(profile_);
	}
	~SafetyHubMenuNotificationTest() override = default;

	void SetUp() override {
	// Content settings registry needs to be reset to ensure that it has loaded
	// the correct permission types.
	auto* registry = content_settings::ContentSettingsRegistry::GetInstance();
	registry->ResetForTest();
	service_ = std::make_unique<RevokedPermissionsService>(
	profile(), profile()->GetPrefs());
	}

	protected:
	void FastForwardBy(base::TimeDelta delta) {
	task_environment_.FastForwardBy(delta);
	}

	RevokedPermissionsService* service() { return service_.get(); }
	TestingProfile* profile() { return profile_.get(); }

	private:
	content::BrowserTaskEnvironment task_environment_{
	base::test::TaskEnvironment::TimeSource::MOCK_TIME};
	std::unique_ptr<TestingProfileManager> testing_profile_manager_;
	raw_ptr<TestingProfile> profile_ = nullptr;
	std::unique_ptr<RevokedPermissionsService> service_;
	};

	// TODO(crbug.com/364523673): This test is flaking on android pie builder.
	TEST_F(SafetyHubMenuNotificationTest, DISABLED_ToFromDictValue) {
	// Creating a mock menu notification.
	base::Time last = kPastTime + base::Days(30);
	auto notification = std::make_unique<SafetyHubMenuNotification>(
	safety_hub::SafetyHubModuleType::UNUSED_SITE_PERMISSIONS);
	notification->is_currently_active_ = true;
	notification->impression_count_ = 42;
	notification->first_impression_time_ = kPastTime;
	notification->last_impression_time_ = last;
	notification->current_result_ =
	CreateRevokedPermissionsResult(base::Value::List().Append(kUrl1));

	// When transforming the notification to a Dict, the properties of the
	// notification should be correct.
	base::Value::Dict dict = notification->ToDictValue();
	EXPECT_TRUE(
	dict.FindBool(safety_hub::kSafetyHubMenuNotificationActiveKey).value());
	EXPECT_EQ(42, dict.FindInt(
	safety_hub::kSafetyHubMenuNotificationImpressionCountKey));
	EXPECT_EQ(
	base::TimeToValue(kPastTime),
	*dict.Find(safety_hub::kSafetyHubMenuNotificationFirstImpressionKey));
	EXPECT_EQ(
	base::TimeToValue(last),
	*dict.Find(safety_hub::kSafetyHubMenuNotificationLastImpressionKey));
	EXPECT_TRUE(dict.contains(safety_hub::kSafetyHubMenuNotificationResultKey));
	// The properties of the contained result should also be correct.
	auto* result_dict =
	dict.FindDict(safety_hub::kSafetyHubMenuNotificationResultKey);
	EXPECT_TRUE(result_dict->contains(kRevokedPermissionsResultKey));
	EXPECT_EQ(1U, result_dict->FindList(kRevokedPermissionsResultKey)->size());
	base::Value::List& revoked_origins =
	*result_dict->FindList(kRevokedPermissionsResultKey);
	EXPECT_EQ(kUrl1, revoked_origins.front());

	// Using the dict from before, we can create another menu notification object
	// that should have the same properties as when it was initially created.
	auto new_notification = std::make_unique<SafetyHubMenuNotification>(
	std::move(dict),
	safety_hub::SafetyHubModuleType::UNUSED_SITE_PERMISSIONS);
	EXPECT_TRUE(new_notification->is_currently_active_);
	EXPECT_EQ(42, new_notification->impression_count_);
	EXPECT_EQ(kPastTime, new_notification->first_impression_time_);
	EXPECT_EQ(last, new_notification->last_impression_time_);
	EXPECT_FALSE(new_notification->prev_stored_result_.empty());
	EXPECT_EQ(kUrl1, new_notification->prev_stored_result_
	.FindList(kRevokedPermissionsResultKey)
	->front()
	.GetString());
	}

	// TODO(crbug.com/364523673): This test is flaking on android pie builder.
	TEST_F(SafetyHubMenuNotificationTest, DISABLED_ShouldBeShown) {
	base::TimeDelta interval = base::Days(30);
	auto notification = std::make_unique<SafetyHubMenuNotification>(
	safety_hub::SafetyHubModuleType::UNUSED_SITE_PERMISSIONS);

	// No result associated with notification, so should not be shown.
	ASSERT_FALSE(notification->ShouldBeShown(interval));

	// The notification is updated with a new result that is a trigger. The
	// notification has never been shown, so should be shown.
	std::unique_ptr<RevokedPermissionsResult> result =
	CreateRevokedPermissionsResult(base::Value::List().Append(kUrl1));
	notification->UpdateResult(std::move(result));
	ASSERT_TRUE(notification->ShouldBeShown(interval));

	// Showing the notification once should make it still be shown after.
	notification->Show();
	ASSERT_TRUE(notification->ShouldBeShown(interval));

	// Showing the notification the minimum number of times, but not the minimum
	// period of time, should make it still be shown.
	for (int i = 0; i < kSafetyHubMenuNotificationMinImpressionCount; ++i) {
	notification->Show();
	FastForwardBy(base::Hours(1));
	}
	ASSERT_TRUE(notification->ShouldBeShown(interval));

	// Moving past the minimum duration should now make the notification no longer
	// be shown.
	FastForwardBy(kSafetyHubMenuNotificationMinNotificationDuration);
	ASSERT_FALSE(notification->ShouldBeShown(interval));

	// The notification can be dismissed now, and it should still not be shown.
	notification->Dismiss();
	ASSERT_FALSE(notification->ShouldBeShown(interval));

	// If the result does not change, the notification should not be shown.
	FastForwardBy(interval);
	ASSERT_FALSE(notification->ShouldBeShown(interval));

	// When updating to a similar result, the notification should still not be
	// shown.
	std::unique_ptr<RevokedPermissionsResult> similar_result =
	CreateRevokedPermissionsResult(base::Value::List().Append(kUrl1));
	notification->UpdateResult(std::move(similar_result));
	ASSERT_FALSE(notification->ShouldBeShown(interval));

	// When updating to a new result, the notification should be shown.
	std::unique_ptr<RevokedPermissionsResult> new_result =
	CreateRevokedPermissionsResult(
	base::Value::List().Append("https://other.com:443"));
	notification->UpdateResult(std::move(new_result));
	ASSERT_TRUE(notification->ShouldBeShown(interval));

	// Notification should still be shown after showing once.
	notification->Show();
	ASSERT_TRUE(notification->ShouldBeShown(interval));

	// Dimissing an active notification should make it not be shown. Note: showing
	// notification once is a prerequisite for dismissing it.
	notification->Dismiss();
	ASSERT_FALSE(notification->ShouldBeShown(interval));

	// Create new notification and new associated result to test passing time but
	// not the count.
	result = CreateRevokedPermissionsResult(base::Value::List().Append(kUrl1));
	auto other_notification = std::make_unique<SafetyHubMenuNotification>(
	safety_hub::SafetyHubModuleType::UNUSED_SITE_PERMISSIONS);
	other_notification->UpdateResult(std::move(result));
	other_notification->Show();

	// Go past the minimum duration that the notification should be shown. It
	// should still be shown because it was only shown once.
	FastForwardBy(kSafetyHubMenuNotificationMinNotificationDuration +
	base::Days(2));
	ASSERT_TRUE(other_notification->ShouldBeShown(interval));

	// The notification should no longer be shown if it has already been shown a
	// sufficient number of times.
	for (int i = 0; i < kSafetyHubMenuNotificationMinImpressionCount; ++i) {
	other_notification->Show();
	FastForwardBy(base::Hours(1));
	}
	ASSERT_FALSE(other_notification->ShouldBeShown(interval));
	}

	// TODO(crbug.com/364523673): This test is flaking on android pie builder.
	TEST_F(SafetyHubMenuNotificationTest, DISABLED_IsCurrentlyActive) {
	auto notification = std::make_unique<SafetyHubMenuNotification>(
	safety_hub::SafetyHubModuleType::UNUSED_SITE_PERMISSIONS);

	// A notification is not active when it new or when it has not been shown yet.
	ASSERT_FALSE(notification->IsCurrentlyActive());
	std::unique_ptr<RevokedPermissionsResult> result =
	CreateRevokedPermissionsResult(base::Value::List().Append(kUrl1));
	notification->UpdateResult(std::move(result));
	ASSERT_FALSE(notification->IsCurrentlyActive());

	// Showing a notification makes it active.
	notification->Show();
	ASSERT_TRUE(notification->IsCurrentlyActive());

	// Dismissing the nofication makes it not active any more.
	notification->Dismiss();
	ASSERT_FALSE(notification->IsCurrentlyActive());
	}

	// TODO(crbug.com/40267370): Add tests for other types of Safety Hub services
	// and Safety Hub results.