ash / system / privacy_hub / privacy_hub_geolocation_activity_unittest.cc [blame]

// 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 "ash/system/privacy_hub/geolocation_privacy_switch_controller.h"

#include <utility>
#include <vector>

#include "ash/constants/ash_features.h"
#include "ash/constants/ash_pref_names.h"
#include "ash/constants/ash_switches.h"
#include "ash/constants/geolocation_access_level.h"
#include "ash/session/session_controller_impl.h"
#include "ash/shell.h"
#include "ash/strings/grit/ash_strings.h"
#include "ash/system/privacy_hub/privacy_hub_controller.h"
#include "ash/system/privacy_hub/privacy_hub_metrics.h"
#include "ash/system/privacy_hub/privacy_hub_notification.h"
#include "ash/system/privacy_hub/privacy_hub_notification_controller.h"
#include "ash/system/privacy_hub/sensor_disabled_notification_delegate.h"
#include "ash/test/ash_test_base.h"
#include "base/command_line.h"
#include "base/memory/raw_ptr.h"
#include "base/run_loop.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_feature_list.h"
#include "components/prefs/pref_change_registrar.h"
#include "components/prefs/pref_service.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/message_center/message_center.h"
#include "ui/message_center/public/cpp/notification.h"

using testing::_;

namespace ash {

namespace {

message_center::Notification* FindNotification() {
  return message_center::MessageCenter::Get()->FindNotificationById(
      PrivacyHubNotificationController::kGeolocationSwitchNotificationId);
}

}  // namespace

class PrivacyHubGeolocationTestBase : public AshTestBase {
public:
  PrivacyHubGeolocationTestBase()
      : AshTestBase(base::test::TaskEnvironment::TimeSource::MOCK_TIME) {
    scoped_feature_list_.InitWithFeatures(
        { features::kCrosPrivacyHub}, {});
  }

  ~PrivacyHubGeolocationTestBase() override = default;

  // AshTest:
  void SetUp() override {
    AshTestBase::SetUp();
    controller_ = GeolocationPrivacySwitchController::Get();
  }

  void SetAccessLevel(GeolocationAccessLevel access_level) {
    Shell::Get()->session_controller()->GetActivePrefService()->SetInteger(
        prefs::kUserGeolocationAccessLevel, static_cast<int>(access_level));
  }

  GeolocationAccessLevel GetAccessLevel() {
    return static_cast<GeolocationAccessLevel>(
        Shell::Get()->session_controller()->GetActivePrefService()->GetInteger(
            prefs::kUserGeolocationAccessLevel));
  }

 protected:
  raw_ptr<GeolocationPrivacySwitchController, DanglingUntriaged> controller_;

 private:
  base::test::ScopedFeatureList scoped_feature_list_;
};

class PrivacyHubGeolocationActivityTest : public PrivacyHubGeolocationTestBase,
      public testing::WithParamInterface<GeolocationAccessLevel> {
 public:
  // TODO(b/323169598): Review all uses of this function and rewrite the tests
  // to check all access levels using GetAccessLevel().
  void SetUserPref(bool allowed) {
    GeolocationAccessLevel access_level;
    if (allowed) {
      access_level = GeolocationAccessLevel::kAllowed;
    } else {
      access_level = static_cast<GeolocationAccessLevel>(GetParam());
      ASSERT_NE(access_level, GeolocationAccessLevel::kAllowed);
    }
    SetAccessLevel(access_level);
  }

  const base::HistogramTester histogram_tester_;
};

TEST_P(PrivacyHubGeolocationActivityTest, GetActiveAppsTest) {
  EXPECT_TRUE(features::IsCrosPrivacyHubLocationEnabled());
  const std::vector<std::string> app_names{"App1", "App2", "App3"};
  const std::vector<std::u16string> app_names_u16{u"App1", u"App2", u"App3"};
  EXPECT_EQ(controller_->GetActiveApps(3), (std::vector<std::u16string>{}));
  controller_->TrackGeolocationAttempted(app_names[0]);
  EXPECT_EQ(controller_->GetActiveApps(3),
            (std::vector<std::u16string>{app_names_u16[0]}));
  controller_->TrackGeolocationAttempted(app_names[1]);
  EXPECT_EQ(controller_->GetActiveApps(3),
            (std::vector<std::u16string>{app_names_u16[0], app_names_u16[1]}));
  controller_->TrackGeolocationAttempted(app_names[1]);
  EXPECT_EQ(controller_->GetActiveApps(3),
            (std::vector<std::u16string>{app_names_u16[0], app_names_u16[1]}));
  controller_->TrackGeolocationAttempted(app_names[2]);
  EXPECT_EQ(controller_->GetActiveApps(3), app_names_u16);
  controller_->TrackGeolocationRelinquished(app_names[2]);
  EXPECT_EQ(controller_->GetActiveApps(3),
            (std::vector<std::u16string>{app_names_u16[0], app_names_u16[1]}));
  controller_->TrackGeolocationRelinquished(app_names[1]);
  EXPECT_EQ(controller_->GetActiveApps(3),
            (std::vector<std::u16string>{app_names_u16[0], app_names_u16[1]}));
  controller_->TrackGeolocationRelinquished(app_names[1]);
  EXPECT_EQ(controller_->GetActiveApps(3),
            (std::vector<std::u16string>{app_names_u16[0]}));
  controller_->TrackGeolocationRelinquished(app_names[0]);
  EXPECT_EQ(controller_->GetActiveApps(3), (std::vector<std::u16string>{}));
}

TEST_P(PrivacyHubGeolocationActivityTest, NotificationOnActivityChangeTest) {
  const std::string app_name = "app";
  SetUserPref(false);
  EXPECT_FALSE(FindNotification());
  controller_->TrackGeolocationAttempted(app_name);
  EXPECT_TRUE(FindNotification());
  controller_->TrackGeolocationRelinquished(app_name);
  EXPECT_FALSE(FindNotification());
}

TEST_P(PrivacyHubGeolocationActivityTest,
       NotificationOnPreferenceChangeTest) {
  const std::string app_name = "app";
  SetUserPref(true);
  controller_->TrackGeolocationAttempted(app_name);
  EXPECT_FALSE(FindNotification());
  SetUserPref(false);
  EXPECT_TRUE(FindNotification());
  SetUserPref(true);
  EXPECT_FALSE(FindNotification());
}

TEST_P(PrivacyHubGeolocationActivityTest, ClickOnNotificationTest) {
  const std::string app_name = "app";
  SetUserPref(false);
  EXPECT_TRUE(features::IsCrosPrivacyHubLocationEnabled());
  EXPECT_TRUE(controller_);
  controller_->TrackGeolocationAttempted(app_name);

  const auto kGeolocationAccessLevels = {
      GeolocationAccessLevel::kDisallowed, GeolocationAccessLevel::kAllowed,
      GeolocationAccessLevel::kOnlyAllowedForSystem};
  ASSERT_EQ(static_cast<unsigned long>(GeolocationAccessLevel::kMaxValue) + 1,
            kGeolocationAccessLevels.size());

  // We didn't log any notification clicks so far.
  for (auto access_level : kGeolocationAccessLevels) {
    EXPECT_EQ(0,
              histogram_tester_.GetBucketCount(
                  privacy_hub_metrics::
                      kPrivacyHubGeolocationAccessLevelChangedFromNotification,
                  access_level));
  }
  EXPECT_TRUE(FindNotification());
  EXPECT_NE(GetAccessLevel(), GeolocationAccessLevel::kAllowed);

  // Click on the notification button.
  message_center::MessageCenter::Get()->ClickOnNotificationButton(
      PrivacyHubNotificationController::kGeolocationSwitchNotificationId, 0);
  // This must change the user pref.
  EXPECT_EQ(GetAccessLevel(), GeolocationAccessLevel::kAllowed);
  // The notification should be cleared after it has been clicked on.
  EXPECT_FALSE(FindNotification());

  // The histograms were updated.
  EXPECT_EQ(1, histogram_tester_.GetBucketCount(
                   privacy_hub_metrics::
                       kPrivacyHubGeolocationAccessLevelChangedFromNotification,
                   GeolocationAccessLevel::kAllowed));
  EXPECT_EQ(0, histogram_tester_.GetBucketCount(
                   privacy_hub_metrics::
                       kPrivacyHubGeolocationAccessLevelChangedFromNotification,
                   GeolocationAccessLevel::kDisallowed));
  EXPECT_EQ(0, histogram_tester_.GetBucketCount(
                   privacy_hub_metrics::
                       kPrivacyHubGeolocationAccessLevelChangedFromNotification,
                   GeolocationAccessLevel::kOnlyAllowedForSystem));
}

INSTANTIATE_TEST_SUITE_P(All,
                         PrivacyHubGeolocationActivityTest,
                         testing::Values( GeolocationAccessLevel::kDisallowed, GeolocationAccessLevel::kOnlyAllowedForSystem));

using BooleanSyncTransitionTableRow = std::tuple<GeolocationAccessLevel,
                                                 GeolocationAccessLevel,
                                                 bool,
                                                 GeolocationAccessLevel,
                                                 GeolocationAccessLevel>;

class PrivacyHubGeolocationApplyArcLocationUpdatesTest
    : public PrivacyHubGeolocationTestBase,
      public testing::WithParamInterface<BooleanSyncTransitionTableRow> {
 public:
  GeolocationAccessLevel PreviousAccessLevel() const {
    return std::get<0>(GetParam());
  }
  GeolocationAccessLevel CurrentAccessLevel() const {
    return std::get<1>(GetParam());
  }
  bool IncomingValueToBeSynced() const { return std::get<2>(GetParam()); }
  GeolocationAccessLevel ExpectedNewPreviousAccessLevel() const {
    return std::get<3>(GetParam());
  }
  GeolocationAccessLevel ExpectedNewAccessLevel() const {
    return std::get<4>(GetParam());
  }
};

TEST_P(PrivacyHubGeolocationApplyArcLocationUpdatesTest, UpdateTest) {
  ASSERT_NE(CurrentAccessLevel(), PreviousAccessLevel());
  // Test initial values
  EXPECT_EQ(GeolocationAccessLevel::kAllowed, controller_->AccessLevel());
  EXPECT_EQ(GeolocationAccessLevel::kDisallowed,
            controller_->PreviousAccessLevel());

  SetAccessLevel(PreviousAccessLevel());
  SetAccessLevel(CurrentAccessLevel());
  EXPECT_EQ(CurrentAccessLevel(), controller_->AccessLevel());
  EXPECT_EQ(PreviousAccessLevel(), controller_->PreviousAccessLevel());

  controller_->ApplyArcLocationUpdate(IncomingValueToBeSynced());
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(ExpectedNewAccessLevel(), controller_->AccessLevel());
  EXPECT_EQ(ExpectedNewPreviousAccessLevel(),
            controller_->PreviousAccessLevel());
}

using BooleanSyncTransitionTable = std::vector<BooleanSyncTransitionTableRow>;
// Utility function to generate all possible perameter combinations for the
// PrivacyHubGeolocationApplyArcLocationUpdatesTest test suite.
BooleanSyncTransitionTable GenerateTransitionTable() {
  BooleanSyncTransitionTable table;
  const std::array<GeolocationAccessLevel, 3> all_levels{
      GeolocationAccessLevel::kAllowed, GeolocationAccessLevel::kDisallowed,
      GeolocationAccessLevel::kOnlyAllowedForSystem};
  const auto is_blocking = [](GeolocationAccessLevel level) {
    return (level != GeolocationAccessLevel::kAllowed);
  };
  for (const GeolocationAccessLevel previous_level : all_levels) {
    for (const GeolocationAccessLevel current_level : all_levels) {
      if (previous_level == current_level) {
        // The GeolocationPrivacySwitch ensures that the previous and current
        // levels are different
        continue;
      }
      for (const bool incoming_enable : {true, false}) {
        const bool is_noop = (incoming_enable && !is_blocking(current_level)) ||
                             (!incoming_enable && is_blocking(current_level));
        const GeolocationAccessLevel expected_new_current_level =
            is_noop ? current_level
                    : (incoming_enable ? GeolocationAccessLevel::kAllowed
                                       : previous_level);
        const GeolocationAccessLevel expected_new_previous_level =
            is_noop ? previous_level : current_level;
        table.push_back(std::make_tuple(
            previous_level, current_level, incoming_enable,
            expected_new_previous_level, expected_new_current_level));
      }
    }
  }
  return table;
}

INSTANTIATE_TEST_SUITE_P(AllCombinations,
                         PrivacyHubGeolocationApplyArcLocationUpdatesTest,
                         testing::ValuesIn(GenerateTransitionTable()));

}  // namespace ash