// 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 <cmath>
#include <limits>
#include <memory>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#include "ash/constants/ash_features.h"
#include "ash/constants/ash_pref_names.h"
#include "ash/public/cpp/ash_prefs.h"
#include "ash/public/cpp/schedule_enums.h"
#include "ash/public/cpp/session/session_types.h"
#include "ash/session/session_controller_impl.h"
#include "ash/session/test_session_controller_client.h"
#include "ash/shell.h"
#include "ash/style/dark_light_mode_controller_impl.h"
#include "ash/system/geolocation/geolocation_controller.h"
#include "ash/system/geolocation/geolocation_controller_test_util.h"
#include "ash/system/geolocation/test_geolocation_url_loader_factory.h"
#include "ash/system/scheduled_feature/scheduled_feature.h"
#include "ash/system/time/time_of_day.h"
#include "ash/test/ash_test_base.h"
#include "ash/test/ash_test_helper.h"
#include "ash/test/failing_local_time_converter.h"
#include "ash/test/time_of_day_test_util.h"
#include "ash/test_shell_delegate.h"
#include "base/command_line.h"
#include "base/memory/ptr_util.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/scoped_refptr.h"
#include "base/numerics/ranges.h"
#include "base/numerics/safe_conversions.h"
#include "base/scoped_observation.h"
#include "base/strings/pattern.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/test_mock_time_task_runner.h"
#include "base/time/time.h"
#include "base/types/expected.h"
#include "components/prefs/pref_change_registrar.h"
#include "components/prefs/pref_registry_simple.h"
#include "components/prefs/pref_service.h"
#include "components/prefs/testing_pref_service.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "ui/compositor/layer.h"
#include "ui/gfx/geometry/vector3d_f.h"
namespace ash {
namespace {
using ::testing::_;
using ::testing::AtLeast;
using ::testing::ElementsAre;
using ::testing::IsEmpty;
using ::testing::Mock;
using ::testing::Pair;
using RefreshReason = ScheduledFeature::RefreshReason;
constexpr char kUser1Email[] = "user1@featuredschedule";
constexpr char kUser2Email[] = "user2@featuredschedule";
constexpr char kTestEnabledPref[] = "ash.test.scheduled_feature.enabled";
constexpr char kTestScheduleTypePref[] =
"ash.test.scheduled_feature.schedule_type";
constexpr char kTestCustomStartTimePref[] =
"ash.test.scheduled_feature.custom_start_time";
constexpr char kTestCustomEndTimePref[] =
"ash.test.scheduled_feature.custom_end_time";
// 6:00 PM
constexpr int kTestCustomStartTimeOffsetMinutes = 18 * 60;
// 6:00 AM
constexpr int kTestCustomEndTimeOffsetMinutes = 6 * 60;
// Maximum backoff time for refreshing the schedule when failures are
// encountered.
constexpr base::TimeDelta kMaxRefreshBackoff = base::Minutes(1);
enum AmPm { kAM, kPM };
// Returns the `ScheduleCheckpoint` that is expected to come next after
// `current_checkpoint` (sunrise, morning, late afternoon, sunset, sunrise,
// etc).
ScheduleCheckpoint GetNextExpectedCheckpoint(
ScheduleCheckpoint current_checkpoint) {
switch (current_checkpoint) {
// Sunset to sunrise schedule type:
case ScheduleCheckpoint::kSunset:
return ScheduleCheckpoint::kSunrise;
case ScheduleCheckpoint::kSunrise:
return ScheduleCheckpoint::kMorning;
case ScheduleCheckpoint::kMorning:
return ScheduleCheckpoint::kLateAfternoon;
case ScheduleCheckpoint::kLateAfternoon:
return ScheduleCheckpoint::kSunset;
// Custom schedule type:
case ScheduleCheckpoint::kEnabled:
return ScheduleCheckpoint::kEnabled;
case ScheduleCheckpoint::kDisabled:
return ScheduleCheckpoint::kDisabled;
}
}
// Records all changes made to the feature state from the time that
// PrefChangeObserver is constructed (turned on at 2 PM, turned off at 5 PM,
// turned back on at 11 PM, etc). Allows tests to not only verify that the
// feature changed status at the appropriate times, but also that it did not
// change at an unintended time. For example, if the feature is expected to turn
// on at 2 PM and it's now 12 PM, we want to make sure that it did not turn off
// then back on again at some point in the middle (say 1 PM).
class PrefChangeObserver {
public:
PrefChangeObserver(PrefService* pref_service, const base::Clock* clock)
: clock_(clock) {
pref_registrar_.Init(pref_service);
pref_registrar_.Add(
kTestEnabledPref,
base::BindRepeating(&PrefChangeObserver::OnEnabledPrefChanged,
base::Unretained(this)));
}
~PrefChangeObserver() = default;
// Elements appear in chronological order:
// <Time of the status change, the status of the feature at the time>
const std::vector<std::pair<TimeOfDay, bool>>& changes() const {
return changes_;
}
void ClearHistory() { changes_.clear(); }
private:
void OnEnabledPrefChanged() {
changes_.emplace_back(
TimeOfDay::FromTime(clock_->Now()),
pref_registrar_.prefs()->GetBoolean(kTestEnabledPref));
}
PrefChangeRegistrar pref_registrar_;
const raw_ptr<const base::Clock> clock_;
std::vector<std::pair<TimeOfDay, bool>> changes_;
};
class CheckpointObserver : public ScheduledFeature::CheckpointObserver {
public:
CheckpointObserver(ScheduledFeature* feature, const base::Clock* clock)
: clock_(clock) {
observation_.Observe(feature);
}
CheckpointObserver(const CheckpointObserver&) = delete;
CheckpointObserver& operator=(const CheckpointObserver&) = delete;
~CheckpointObserver() override = default;
// ScheduledFeature::CheckpointObserver:
void OnCheckpointChanged(const ScheduledFeature* src,
ScheduleCheckpoint new_checkpoint) override {
changes_.emplace_back(TimeOfDay::FromTime(clock_->Now()), new_checkpoint);
}
// Elements appear in chronological order:
// <Time of the checkpoint change, the checkpoint received>
const std::vector<std::pair<TimeOfDay, ScheduleCheckpoint>>& changes() const {
return changes_;
}
private:
base::ScopedObservation<ScheduledFeature,
ScheduledFeature::CheckpointObserver>
observation_{this};
const raw_ptr<const base::Clock> clock_;
std::vector<std::pair<TimeOfDay, ScheduleCheckpoint>> changes_;
};
class TestScheduledFeature : public ScheduledFeature {
public:
TestScheduledFeature(const std::string prefs_path_enabled,
const std::string prefs_path_schedule_type,
const std::string prefs_path_custom_start_time,
const std::string prefs_path_custom_end_time)
: ScheduledFeature(prefs_path_enabled,
prefs_path_schedule_type,
prefs_path_custom_start_time,
prefs_path_custom_end_time) {}
TestScheduledFeature(const TestScheduledFeature& other) = delete;
TestScheduledFeature& operator=(const TestScheduledFeature& rhs) = delete;
~TestScheduledFeature() override {}
// ScheduledFeature:
const char* GetFeatureName() const override { return "TestFeature"; }
const char* GetScheduleTypeHistogramName() const override {
return schedule_type_histogram_name_.c_str();
}
MOCK_METHOD(void, RefreshFeatureState, (RefreshReason reason), (override));
void set_schedule_type_histogram_name(
std::string schedule_type_histogram_name) {
schedule_type_histogram_name_ = std::move(schedule_type_histogram_name);
}
private:
std::string schedule_type_histogram_name_;
};
class ScheduledFeatureTest : public NoSessionAshTestBase,
public ScheduledFeature::Clock {
public:
ScheduledFeatureTest()
: task_runner_(base::MakeRefCounted<base::TestMockTimeTaskRunner>()),
task_runner_origin_ticks_(task_runner_->NowTicks()) {}
ScheduledFeatureTest(const ScheduledFeatureTest& other) = delete;
ScheduledFeatureTest& operator=(const ScheduledFeatureTest& rhs) = delete;
~ScheduledFeatureTest() override = default;
PrefService* user1_pref_service() {
return Shell::Get()->session_controller()->GetUserPrefServiceForUser(
AccountId::FromUserEmail(kUser1Email));
}
PrefService* user2_pref_service() {
return Shell::Get()->session_controller()->GetUserPrefServiceForUser(
AccountId::FromUserEmail(kUser2Email));
}
TestScheduledFeature* feature() const { return feature_.get(); }
GeolocationController* geolocation_controller() {
return geolocation_controller_;
}
const base::OneShotTimer* timer_ptr() const { return timer_ptr_; }
TestGeolocationUrlLoaderFactory* factory() const {
CHECK(SimpleGeolocationProvider::GetInstance());
return static_cast<TestGeolocationUrlLoaderFactory*>(
SimpleGeolocationProvider::GetInstance()
->GetSharedURLLoaderFactoryForTesting());
}
// AshTestBase:
void SetUp() override {
NoSessionAshTestBase::SetUp();
SetWallClockOrigin("23 Dec 2021 12:00:00");
// Set the clock of geolocation controller to our test clock to control the
// time now.
geolocation_controller_ = ash::Shell::Get()->geolocation_controller();
geolocation_controller()->SetClockForTesting(this);
// Every feature that is auto scheduled by default needs to set test clock.
// Otherwise the tests will fails `DCHECK_GE(start_time, now)` in
// `ScheduledFeature::RefreshScheduleTimer()` when the new user session
// is entered and `InitFromUserPrefs()` triggers `RefreshScheduleTimer()`.
ash::Shell::Get()->dark_light_mode_controller()->SetClockForTesting(this);
CreateTestUserSessions();
// Simulate user 1 login.
SimulateNewUserFirstLogin(kUser1Email);
feature_ = std::make_unique<TestScheduledFeature>(
kTestEnabledPref, kTestScheduleTypePref, kTestCustomStartTimePref,
kTestCustomEndTimePref);
ASSERT_FALSE(feature_->GetEnabled());
feature_->SetClockForTesting(this);
feature_->SetTaskRunnerForTesting(task_runner_);
feature_->OnActiveUserPrefServiceChanged(
Shell::Get()->session_controller()->GetActivePrefService());
timer_ptr_ = geolocation_controller()->GetTimerForTesting();
}
void TearDown() override {
feature_.reset();
NoSessionAshTestBase::TearDown();
}
// ScheduledFeature::Clock:
base::Time Now() const override {
// Some tests may want to control the UTC wall clock time around which the
// test is centered. `wall_clock_origin_` allows for this, and the value
// returned here still reflects the advancement of `task_runner_`'s mock
// time.
const base::TimeDelta mock_time_elapsed =
NowTicks() - task_runner_origin_ticks_;
return wall_clock_origin_ + wall_clock_artificial_advancement_ +
mock_time_elapsed;
}
base::TimeTicks NowTicks() const override { return task_runner_->NowTicks(); }
void CreateTestUserSessions() {
GetSessionControllerClient()->Reset();
AddUserSession(kUser1Email);
AddUserSession(kUser2Email);
}
void AddUserSession(const std::string& user_email) {
auto prefs = std::make_unique<TestingPrefServiceSimple>();
prefs->registry()->RegisterBooleanPref(kTestEnabledPref, false);
prefs->registry()->RegisterIntegerPref(
kTestScheduleTypePref, static_cast<int>(ScheduleType::kNone));
prefs->registry()->RegisterIntegerPref(kTestCustomStartTimePref,
kTestCustomStartTimeOffsetMinutes);
prefs->registry()->RegisterIntegerPref(kTestCustomEndTimePref,
kTestCustomEndTimeOffsetMinutes);
RegisterUserProfilePrefs(prefs->registry(), /*country=*/"",
/*for_test=*/true);
auto* const session_controller_client = GetSessionControllerClient();
session_controller_client->AddUserSession(user_email,
user_manager::UserType::kRegular,
/*provide_pref_service=*/false);
session_controller_client->SetUserPrefService(
AccountId::FromUserEmail(user_email), std::move(prefs));
}
void SwitchActiveUser(const std::string& email) {
GetSessionControllerClient()->SwitchActiveUser(
AccountId::FromUserEmail(email));
}
bool GetEnabled() { return feature_->GetEnabled(); }
ScheduleType GetScheduleType() { return feature_->GetScheduleType(); }
void SetFeatureEnabled(bool enabled) { feature_->SetEnabled(enabled); }
void SetScheduleType(ScheduleType type) { feature_->SetScheduleType(type); }
// Convenience function for constructing a TimeOfDay object for exact hours
// during the day. |hour| is between 1 and 12.
TimeOfDay MakeTimeOfDay(int hour, AmPm am_pm) {
DCHECK_GE(hour, 1);
DCHECK_LE(hour, 12);
if (am_pm == kAM) {
hour %= 12;
} else {
if (hour != 12)
hour += 12;
hour %= 24;
}
return TimeOfDay(hour * 60).SetClock(this);
}
void FastForwardBy(base::TimeDelta amount) {
task_runner_->FastForwardBy(amount);
}
// Fast forwards to the next point in time that the specified `time_of_day`
// is hit. Examples:
// 1) now = 2 PM time_of_day = 5 PM, advances 3 hours
// 2) now = 7 PM time_of_day = 5 PM, advances 22 hours (the next day)
void FastForwardTo(TimeOfDay time_of_day) {
base::Time target_time = ToTimeToday(time_of_day.SetClock(this));
const base::Time now = Now();
if (target_time < now) {
target_time += base::Days(1);
ASSERT_GT(target_time, now);
}
FastForwardBy(target_time - now);
}
// To simulate events like the device suspending (wall clock advances, but
// clock "ticks" don't).
void AdvanceTimeBy(base::TimeDelta amount) {
wall_clock_artificial_advancement_ += amount;
}
// Fires the timer of the scheduler to request geoposition and wait for all
// observers to receive the latest geoposition from the server.
void FireTimerToFetchGeoposition() {
GeopositionResponsesWaiter waiter(geolocation_controller_);
EXPECT_TRUE(timer_ptr()->IsRunning());
// Fast forward the scheduler to reach the time when the controller
// requests for geoposition from the server in
// `GeolocationController::RequestGeoposition`.
timer_ptr_->FireNow();
// Waits for the observers to receive the geoposition from the server.
waiter.Wait();
}
// Checks if the feature is observing geoposition changes.
bool IsFeatureObservingGeoposition() {
return geolocation_controller()->HasObserver(feature());
}
// Sets the wall clock time at which the test case starts. After calling this,
// future calls to Now() will return `utc_time_str` plus the amount of mock
// time that has elapsed thus far in the test. See
// `base::Time::FromUTCString()` for format of `utc_time_str`.
void SetWallClockOrigin(const char* const utc_time_str) {
ASSERT_TRUE(base::Time::FromUTCString(utc_time_str, &wall_clock_origin_));
}
// Simulates scenarios where the code is receiving valid `base::Time` values
// from the clock, but converting them to/from local time is failing.
void SetLocalTimeConverter(const LocalTimeConverter* local_time_converter) {
geolocation_controller()->SetLocalTimeConverterForTesting(
local_time_converter);
ash::Shell::Get()
->dark_light_mode_controller()
->SetLocalTimeConverterForTesting(local_time_converter);
feature_->SetLocalTimeConverterForTesting(local_time_converter);
}
private:
// It is infeasible to initialize AshTestBase with "mock" time and fast
// forward the mock TaskEnvironment in these test cases. Why: The
// AshTestBase harness also instantiates a large portion of the UI stack
// (even though it's irrelevant to these tests), which causes
// TaskEnvironment::FastForwardBy() to block for long periods of time. The
// test cases ultimately take too long.
//
// To solve, create a dedicated `base::TestMockTimeTaskRunner` just for
// `ScheduledFeature` and its dependencies. The `task_runner_` is still
// run on the main test thread.
const scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
// The time at which `task_runner_`'s internal mock tick clock starts.
const base::TimeTicks task_runner_origin_ticks_;
// Wall clock time at which the test case starts. Individual test cases may
// adjust this with the `SetWallClockOrigin()` method. This is reflected in
// the return value of `Now()`.
base::Time wall_clock_origin_;
// Used to support `AdvanceTimeBy()`, where the wall clock is advanced but
// the tick clock is not (simulates a device suspending). This is reflected
// in the return value of `Now()` and defaults to 0.
base::TimeDelta wall_clock_artificial_advancement_;
std::unique_ptr<TestScheduledFeature> feature_;
raw_ptr<GeolocationController, DanglingUntriaged> geolocation_controller_;
raw_ptr<base::OneShotTimer, DanglingUntriaged> timer_ptr_;
Geoposition position_;
};
struct TestTimestamp {
// Passed to `base::Time::FromUTCString()`.
const char* utc_value = nullptr;
// Human-readable label printed in test output.
const char* label = nullptr;
};
struct TimeAndLocation {
TestTimestamp timestamp;
SimpleGeoposition geoposition;
};
// Iterates through all possible geopositions using the `kSunsetToSunrise`
// schedule type. Gives comprehensive test coverage for all seasons and for all
// parts of the globe.
class ScheduledFeatureGeopositionTest
: public ScheduledFeatureTest,
public testing::WithParamInterface<TimeAndLocation> {
public:
static constexpr TestTimestamp kAllTimestamps[] = {
{"07 Jan 2023 20:30:00.000", "Winter"},
{"07 Apr 2023 20:30:00.000", "Spring"},
{"07 Jun 2023 20:30:00.000", "Summer"},
{"07 Oct 2023 20:30:00.000", "Fall"},
};
// Generates coordinates in range ([-90, +90], [-180, +180]) with 15 degree
// step size in latitude and 30 degree step size in longitude.
static std::vector<TimeAndLocation> GenerateTestParams() {
static constexpr double kMinLatitude = -90.f;
static constexpr double kMaxLatitude = 90.f;
static constexpr double kMinLongitude = -180.f;
static constexpr double kMaxLongitude = 180.f;
static constexpr double kLatitudeStepSize = 15.f;
static constexpr double kLongitudeStepSize = 30.f;
// Accounts for precision lost when incrementing latitudes/longitudes. Ex:
// 150.f + 30.f may not necessarily equal 180.f exactly. If it evaluates to
// something slightly greater than 180.f, the geoposition code will consider
// this an invalid longitude and skip it. This ensures we are testing the
// max values of the lat/long ranges.
const auto increment_coordinate =
[](const double max_value, const double step_size, double& coordinate) {
constexpr double kCoordinateEpsilon = 0.001;
coordinate += step_size;
if (base::IsApproximatelyEqual(coordinate, max_value,
kCoordinateEpsilon)) {
coordinate = max_value;
}
};
std::vector<TimeAndLocation> test_params;
for (const TestTimestamp& timestamp : kAllTimestamps) {
TimeAndLocation time_and_location;
time_and_location.timestamp = timestamp;
for (double latitude = kMinLatitude; latitude <= kMaxLatitude;
increment_coordinate(kMaxLatitude, kLatitudeStepSize, latitude)) {
for (double longitude = kMinLongitude; longitude <= kMaxLongitude;
increment_coordinate(kMaxLongitude, kLongitudeStepSize,
longitude)) {
time_and_location.geoposition = {latitude, longitude};
test_params.push_back(time_and_location);
}
}
}
return test_params;
}
void SetUp() override {
ScheduledFeatureTest::SetUp();
SetWallClockOrigin(GetParam().timestamp.utc_value);
factory()->SetValidPosition(GetParam().geoposition.latitude,
GetParam().geoposition.longitude, Now());
FireTimerToFetchGeoposition();
feature()->SetScheduleType(ScheduleType::kSunsetToSunrise);
}
};
INSTANTIATE_TEST_SUITE_P(
AllGeopositions,
ScheduledFeatureGeopositionTest,
testing::ValuesIn(ScheduledFeatureGeopositionTest::GenerateTestParams()),
[](const testing::TestParamInfo<ScheduledFeatureGeopositionTest::ParamType>&
info) {
// gtest only permits alphanumeric characters in the generated name.
const auto coordinate_to_string = [](double coordinate) {
std::string coordinate_str =
base::NumberToString(base::ClampRound(coordinate));
base::ReplaceChars(coordinate_str, "-", "Negative", &coordinate_str);
return coordinate_str;
};
return base::StringPrintf(
"%sLat%sLong%s", info.param.timestamp.label,
coordinate_to_string(info.param.geoposition.latitude).c_str(),
coordinate_to_string(info.param.geoposition.longitude).c_str());
});
// Tests that switching users retrieves the feature settings for the active
// user's prefs.
TEST_F(ScheduledFeatureTest, UserSwitchAndSettingsPersistence) {
// Start with user1 logged in and update to sunset-to-sunrise schedule type.
const std::string kScheduleTypePrefString = kTestScheduleTypePref;
constexpr ScheduleType kUser1ScheduleType = ScheduleType::kSunsetToSunrise;
constexpr bool kUser1EnabledState = false;
constexpr ScheduleCheckpoint kUser1Checkpoint = ScheduleCheckpoint::kMorning;
EXPECT_CALL(*feature(), RefreshFeatureState(RefreshReason::kSettingsChanged));
feature()->SetScheduleType(kUser1ScheduleType);
Mock::VerifyAndClearExpectations(feature());
FastForwardTo(MakeTimeOfDay(10, AmPm::kAM));
EXPECT_EQ(GetScheduleType(), kUser1ScheduleType);
EXPECT_EQ(user1_pref_service()->GetInteger(kScheduleTypePrefString),
static_cast<int>(kUser1ScheduleType));
EXPECT_EQ(GetEnabled(), kUser1EnabledState);
EXPECT_EQ(feature()->current_checkpoint(), kUser1Checkpoint);
// Switch to user 2, and set to custom schedule type.
EXPECT_CALL(*feature(), RefreshFeatureState(RefreshReason::kSettingsChanged));
SwitchActiveUser(kUser2Email);
Mock::VerifyAndClearExpectations(feature());
const ScheduleType user2_schedule_type = ScheduleType::kCustom;
EXPECT_CALL(*feature(), RefreshFeatureState(RefreshReason::kSettingsChanged));
user2_pref_service()->SetInteger(kScheduleTypePrefString,
static_cast<int>(user2_schedule_type));
Mock::VerifyAndClearExpectations(feature());
EXPECT_EQ(GetScheduleType(), user2_schedule_type);
EXPECT_EQ(user2_pref_service()->GetInteger(kScheduleTypePrefString),
static_cast<int>(user2_schedule_type));
// Switch back to user 1, to find feature schedule type is restored to
// sunset-to-sunrise with the correct enabled state and checkpoint.
EXPECT_CALL(*feature(), RefreshFeatureState(RefreshReason::kSettingsChanged));
SwitchActiveUser(kUser1Email);
Mock::VerifyAndClearExpectations(feature());
EXPECT_EQ(GetScheduleType(), kUser1ScheduleType);
EXPECT_EQ(GetEnabled(), kUser1EnabledState);
EXPECT_EQ(feature()->current_checkpoint(), kUser1Checkpoint);
}
// Tests that the scheduler type is initiallized from user prefs and observes
// geoposition when the scheduler is enabled.
TEST_F(ScheduledFeatureTest, InitScheduleTypeFromUserPrefs) {
// Start with user1 logged in with the default disabled scheduler, `kNone`.
const std::string kScheduleTypePrefString = kTestScheduleTypePref;
const ScheduleType user1_schedule_type = ScheduleType::kNone;
EXPECT_EQ(user1_schedule_type, GetScheduleType());
// Check that the feature does not observe the geoposition when the schedule
// type is `kNone`.
EXPECT_FALSE(IsFeatureObservingGeoposition());
// Update user2's schedule type pref to sunset-to-sunrise.
const ScheduleType user2_schedule_type = ScheduleType::kSunsetToSunrise;
user2_pref_service()->SetInteger(kScheduleTypePrefString,
static_cast<int>(user2_schedule_type));
// Switching to user2 should update the schedule type to sunset-to-sunrise.
SwitchActiveUser(kUser2Email);
EXPECT_EQ(user2_schedule_type, GetScheduleType());
// Check that the feature starts observing geoposition when the schedule
// type is changed to `kSunsetToSunrise`.
EXPECT_TRUE(IsFeatureObservingGeoposition());
// Set custom schedule to test that once we switch to the user1 with `kNone`
// schedule type, the feature should remove itself from a geolocation
// observer.
feature()->SetScheduleType(ScheduleType::kCustom);
EXPECT_TRUE(IsFeatureObservingGeoposition());
// Make sure that switching back to user1 makes it remove itself from the
// geoposition observer.
SwitchActiveUser(kUser1Email);
EXPECT_EQ(user1_schedule_type, GetScheduleType());
EXPECT_FALSE(IsFeatureObservingGeoposition());
}
// Tests transitioning from kNone to kCustom and back to kNone schedule
// types.
TEST_F(ScheduledFeatureTest, ScheduleNoneToCustomTransition) {
// Now is 6:00 PM.
FastForwardTo(MakeTimeOfDay(6, AmPm::kPM));
SetFeatureEnabled(false);
feature()->SetScheduleType(ScheduleType::kNone);
// Start time is at 3:00 PM and end time is at 8:00 PM.
feature()->SetCustomStartTime(MakeTimeOfDay(3, AmPm::kPM));
feature()->SetCustomEndTime(MakeTimeOfDay(8, AmPm::kPM));
// 15:00 18:00 20:00
// <----- + ----------- + ----------- + ----->
// | | |
// start now end
//
// Even though "Now" is inside the feature interval, nothing should
// change, since the schedule type is "none".
EXPECT_FALSE(GetEnabled());
// Now change the schedule type to custom, the feature should turn on
// immediately, and the timer should be running with a delay of exactly 2
// hours scheduling the end.
feature()->SetScheduleType(ScheduleType::kCustom);
EXPECT_TRUE(GetEnabled());
PrefChangeObserver change_log(user1_pref_service(), this);
FastForwardTo(MakeTimeOfDay(8, AmPm::kPM));
EXPECT_FALSE(GetEnabled());
EXPECT_THAT(change_log.changes(),
ElementsAre(Pair(MakeTimeOfDay(8, AmPm::kPM), false)));
// First reset back to 6 p.m. the next day:
FastForwardTo(MakeTimeOfDay(6, AmPm::kPM));
ASSERT_TRUE(GetEnabled());
// If the user changes the schedule type to "none", the feature status
// should not change.
feature()->SetScheduleType(ScheduleType::kNone);
EXPECT_TRUE(GetEnabled());
// Since schedule type is none, the feature should not switch off at the
// scheduled end.
FastForwardTo(MakeTimeOfDay(8, AmPm::kPM));
EXPECT_TRUE(GetEnabled());
}
// Tests what happens when the time now reaches the end of the feature
// interval when the feature mode is on.
TEST_F(ScheduledFeatureTest, TestCustomScheduleReachingEndTime) {
FastForwardTo(MakeTimeOfDay(6, AmPm::kPM));
feature()->SetCustomStartTime(MakeTimeOfDay(3, AmPm::kPM));
feature()->SetCustomEndTime(MakeTimeOfDay(8, AmPm::kPM));
feature()->SetScheduleType(ScheduleType::kCustom);
EXPECT_TRUE(GetEnabled());
PrefChangeObserver change_log(user1_pref_service(), this);
// Simulate reaching the end time by triggering the timer's user task. Make
// sure that the feature ended.
//
// 15:00 20:00
// <----- + ------------------------ + ----->
// | |
// start end & now
//
// Now is 8:00 PM.
EXPECT_CALL(*feature(), RefreshFeatureState(RefreshReason::kScheduled));
FastForwardTo(MakeTimeOfDay(8, AmPm::kPM));
Mock::VerifyAndClearExpectations(feature());
EXPECT_FALSE(GetEnabled());
// The feature should be scheduled to start again at 3:00 PM tomorrow.
EXPECT_CALL(*feature(), RefreshFeatureState(RefreshReason::kScheduled));
FastForwardTo(MakeTimeOfDay(3, AmPm::kPM));
Mock::VerifyAndClearExpectations(feature());
EXPECT_THAT(change_log.changes(),
ElementsAre(Pair(MakeTimeOfDay(8, AmPm::kPM), false),
Pair(MakeTimeOfDay(3, AmPm::kPM), true)));
}
// Tests that user toggles from the system menu or system settings override any
// status set by an automatic schedule.
TEST_F(ScheduledFeatureTest, ExplicitUserTogglesWhileScheduleIsActive) {
// Start with the below custom schedule, where the feature is off.
//
// 15:00 20:00 23:00
// <----- + ----------------- + ------------ + ---->
// | | |
// start end now
//
FastForwardTo(MakeTimeOfDay(11, AmPm::kPM));
feature()->SetCustomStartTime(MakeTimeOfDay(3, AmPm::kPM));
feature()->SetCustomEndTime(MakeTimeOfDay(8, AmPm::kPM));
feature()->SetScheduleType(ScheduleType::kCustom);
EXPECT_FALSE(GetEnabled());
// What happens if the user manually turns the feature on while the schedule
// type says it should be off?
// User toggles either from the system menu or the System Settings toggle
// button must override any automatic schedule.
EXPECT_CALL(*feature(), RefreshFeatureState(RefreshReason::kExternal));
SetFeatureEnabled(true);
Mock::VerifyAndClearExpectations(feature());
EXPECT_TRUE(GetEnabled());
PrefChangeObserver change_log(user1_pref_service(), this);
// The feature should automatically turn off at 8:00 PM tomorrow. May refresh
// at 3:00 PM with no change in status.
EXPECT_CALL(*feature(), RefreshFeatureState(RefreshReason::kScheduled))
.Times(AtLeast(1));
FastForwardTo(MakeTimeOfDay(8, AmPm::kPM));
Mock::VerifyAndClearExpectations(feature());
EXPECT_FALSE(GetEnabled());
// Manually reset the feature back to on.
EXPECT_CALL(*feature(), RefreshFeatureState(RefreshReason::kExternal));
SetFeatureEnabled(true);
Mock::VerifyAndClearExpectations(feature());
EXPECT_TRUE(GetEnabled());
// Manually turning it back off should also be respected, and this time the
// start is scheduled at 3:00 PM tomorrow after 19 hours from "now" (8:00
// PM).
EXPECT_CALL(*feature(), RefreshFeatureState(RefreshReason::kExternal));
SetFeatureEnabled(false);
Mock::VerifyAndClearExpectations(feature());
EXPECT_FALSE(GetEnabled());
EXPECT_CALL(*feature(), RefreshFeatureState(RefreshReason::kScheduled));
FastForwardTo(MakeTimeOfDay(3, AmPm::kPM));
Mock::VerifyAndClearExpectations(feature());
EXPECT_TRUE(GetEnabled());
EXPECT_THAT(
change_log.changes(),
ElementsAre(
Pair(MakeTimeOfDay(8, AmPm::kPM), false),
Pair(MakeTimeOfDay(8, AmPm::kPM), true), // Manual toggle on
Pair(MakeTimeOfDay(8, AmPm::kPM), false), // Manual toggle off
Pair(MakeTimeOfDay(3, AmPm::kPM), true)));
}
// Tests that changing the custom start and end times, in such a way that
// shouldn't change the current status, only updates the timer but doesn't
// change the status.
// TODO(crbug.com/40889492): Fix test failure and re-enable on ChromeOS.
#if BUILDFLAG(IS_CHROMEOS)
#define MAYBE_ChangingStartTimesThatDontChangeTheStatus \
DISABLED_ChangingStartTimesThatDontChangeTheStatus
#else
#define MAYBE_ChangingStartTimesThatDontChangeTheStatus \
ChangingStartTimesThatDontChangeTheStatus
#endif
TEST_F(ScheduledFeatureTest, MAYBE_ChangingStartTimesThatDontChangeTheStatus) {
// 16:00 18:00 22:00
// <----- + ----------- + ----------- + ----->
// | | |
// now start end
//
FastForwardTo(MakeTimeOfDay(4, AmPm::kPM)); // 4:00 PM.
SetFeatureEnabled(false);
feature()->SetScheduleType(ScheduleType::kNone);
feature()->SetCustomStartTime(MakeTimeOfDay(6, AmPm::kPM)); // 6:00 PM.
feature()->SetCustomEndTime(MakeTimeOfDay(10, AmPm::kPM)); // 10:00 PM.
// Since now is outside the feature interval, changing the schedule type
// to kCustom, shouldn't affect the status. Validate the feature turns on then
// off at the scheduled times.
feature()->SetScheduleType(ScheduleType::kCustom);
EXPECT_FALSE(GetEnabled());
PrefChangeObserver change_log(user1_pref_service(), this);
FastForwardBy(base::Days(1));
EXPECT_THAT(change_log.changes(),
ElementsAre(Pair(MakeTimeOfDay(6, AmPm::kPM), true),
Pair(MakeTimeOfDay(10, AmPm::kPM), false)));
change_log.ClearHistory();
// Change the start time in such a way that doesn't change the status, but
// despite that, confirm that schedule has been updated.
ASSERT_FALSE(GetEnabled());
EXPECT_CALL(*feature(), RefreshFeatureState(RefreshReason::kSettingsChanged));
feature()->SetCustomStartTime(MakeTimeOfDay(7, AmPm::kPM)); // 7:00 PM.
Mock::VerifyAndClearExpectations(feature());
EXPECT_FALSE(GetEnabled());
// Changing the end time in a similar fashion to the above and expect no
// change.
EXPECT_CALL(*feature(), RefreshFeatureState(RefreshReason::kSettingsChanged));
feature()->SetCustomEndTime(MakeTimeOfDay(11, AmPm::kPM)); // 11:00 PM.
Mock::VerifyAndClearExpectations(feature());
EXPECT_FALSE(GetEnabled());
FastForwardBy(base::Days(1));
EXPECT_THAT(change_log.changes(),
ElementsAre(Pair(MakeTimeOfDay(7, AmPm::kPM), true),
Pair(MakeTimeOfDay(11, AmPm::kPM), false)));
}
// Tests that the feature should turn on at sunset time and turn off at sunrise
// time.
TEST_F(ScheduledFeatureTest, SunsetSunrise) {
EXPECT_FALSE(GetEnabled());
EXPECT_EQ(feature()->current_checkpoint(), ScheduleCheckpoint::kDisabled);
// Set time now to 10:00 AM.
FastForwardTo(MakeTimeOfDay(10, AmPm::kAM));
const CheckpointObserver checkpoint_observer(feature(), this);
feature()->SetScheduleType(ScheduleType::kSunsetToSunrise);
EXPECT_FALSE(GetEnabled());
const PrefChangeObserver change_log(user1_pref_service(), this);
// Set time now to 4:00 PM.
EXPECT_CALL(*feature(), RefreshFeatureState(RefreshReason::kScheduled));
FastForwardTo(MakeTimeOfDay(4, AmPm::kPM));
Mock::VerifyAndClearExpectations(feature());
EXPECT_FALSE(GetEnabled());
// Firing a timer should to advance the time to sunset and automatically turn
// on the feature.
const auto sunset = geolocation_controller()->GetSunsetTime();
ASSERT_TRUE(sunset.has_value());
const TimeOfDay sunset_time = TimeOfDay::FromTime(sunset.value());
EXPECT_CALL(*feature(), RefreshFeatureState(RefreshReason::kScheduled));
FastForwardTo(sunset_time);
Mock::VerifyAndClearExpectations(feature());
EXPECT_TRUE(GetEnabled());
// Firing a timer should advance the time to sunrise and automatically turn
// off the feature.
const auto sunrise = geolocation_controller()->GetSunriseTime();
ASSERT_TRUE(sunrise.has_value());
const TimeOfDay sunrise_time = TimeOfDay::FromTime(sunrise.value());
EXPECT_CALL(*feature(), RefreshFeatureState(RefreshReason::kScheduled));
FastForwardTo(sunrise_time);
Mock::VerifyAndClearExpectations(feature());
EXPECT_FALSE(GetEnabled());
EXPECT_THAT(change_log.changes(),
ElementsAre(Pair(sunset_time, true), Pair(sunrise_time, false)));
EXPECT_THAT(
checkpoint_observer.changes(),
ElementsAre(
Pair(MakeTimeOfDay(10, AmPm::kAM), ScheduleCheckpoint::kMorning),
Pair(MakeTimeOfDay(4, AmPm::kPM), ScheduleCheckpoint::kLateAfternoon),
Pair(sunset_time, ScheduleCheckpoint::kSunset),
Pair(sunrise_time, ScheduleCheckpoint::kSunrise)));
}
// Tests that scheduled start time and end time of sunset-to-sunrise feature
// are updated correctly if the geoposition changes.
TEST_F(ScheduledFeatureTest, SunsetSunriseGeoposition) {
constexpr double kFakePosition1_Latitude = 23.5;
constexpr double kFakePosition1_Longitude = 55.88;
constexpr double kFakePosition2_Latitude = 23.5;
constexpr double kFakePosition2_Longitude = 10.9;
// Position 1 sunset and sunrise times.
//
// sunset-4
// <----- + --------- + ---------------- + ------->
// | | |
// now sunset sunrise
//
GeolocationControllerObserver observer1;
geolocation_controller()->AddObserver(&observer1);
EXPECT_TRUE(timer_ptr()->IsRunning());
EXPECT_FALSE(observer1.possible_change_in_timezone());
// Set and fetch position update.
factory()->SetValidPosition(kFakePosition1_Latitude, kFakePosition1_Longitude,
Now());
FireTimerToFetchGeoposition();
EXPECT_TRUE(observer1.possible_change_in_timezone());
const auto sunset_time1 = geolocation_controller()->GetSunsetTime();
const auto sunrise_time1 = geolocation_controller()->GetSunriseTime();
ASSERT_TRUE(sunset_time1.has_value());
ASSERT_TRUE(sunrise_time1.has_value());
// Our assumption is that GeolocationController gives us sunrise time
// earlier in the same day before sunset.
ASSERT_GT(sunset_time1.value(), sunrise_time1.value());
ASSERT_LT(sunset_time1.value() - base::Days(1), sunrise_time1.value());
// Set time now to be 4 hours before sunset.
FastForwardTo(TimeOfDay::FromTime(sunset_time1.value() - base::Hours(4)));
// Expect that timer is running and the start is scheduled after 4 hours.
EXPECT_FALSE(feature()->GetEnabled());
feature()->SetScheduleType(ScheduleType::kSunsetToSunrise);
EXPECT_FALSE(feature()->GetEnabled());
EXPECT_TRUE(IsFeatureObservingGeoposition());
// A small delta used to help forwarding the time to be a little bit behind
// the target time. Used to avoid test flaky because of the time issue.
const base::TimeDelta delta = base::Minutes(5);
// Simulate reaching sunset.
FastForwardBy(base::Hours(4) +
delta); // Now is sunset time of the position1.
EXPECT_TRUE(feature()->GetEnabled());
// Simulate reaching sunrise.
FastForwardTo(TimeOfDay::FromTime(
sunrise_time1.value() + delta)); // Now is sunrise time of the position1
EXPECT_FALSE(feature()->GetEnabled());
// Now simulate user changing position.
// Position 2 sunset and sunrise times.
//
// <----- + --------- + ---------------- + ------->
// | | |
// sunset2 now (sunrise1) sunrise2
//
// Replace a response `position` with `position2`.
factory()->ClearResponses();
factory()->SetValidPosition(kFakePosition2_Latitude, kFakePosition2_Longitude,
Now());
EXPECT_CALL(*feature(), RefreshFeatureState(RefreshReason::kReset));
FireTimerToFetchGeoposition();
Mock::VerifyAndClearExpectations(feature());
EXPECT_TRUE(observer1.possible_change_in_timezone());
EXPECT_TRUE(IsFeatureObservingGeoposition());
const auto sunset_time2 = geolocation_controller()->GetSunsetTime();
const auto sunrise_time2 = geolocation_controller()->GetSunriseTime();
ASSERT_TRUE(sunset_time2.has_value());
ASSERT_TRUE(sunrise_time2.has_value());
// Expect that the scheduled end delay has been updated to sunrise of location
// 2, and the status has changed to enabled even though time has not advanced.
EXPECT_TRUE(feature()->GetEnabled());
// Simulate reaching sunrise.
FastForwardTo(TimeOfDay::FromTime(
sunrise_time2.value() + delta)); // Now is sunrise time of the position2.
EXPECT_FALSE(feature()->GetEnabled());
// Timer is running scheduling the start at the sunset of the next day.
FastForwardTo(TimeOfDay::FromTime(sunset_time2.value() + delta));
EXPECT_TRUE(feature()->GetEnabled());
}
// Tests that the feature is disabled and there are no crashes/unpredictable
// behavior if there is 24 hours of daylight.
TEST_F(ScheduledFeatureTest, SunsetSunriseAllDaylight) {
// 24 hours of daylight (Kiruna, Sweden)
constexpr double kTestLatitude = 67.855800;
constexpr double kTestLongitude = 20.225282;
SetWallClockOrigin("07 Jun 2023 20:30:00.000");
// Set and fetch position update.
factory()->SetValidPosition(kTestLatitude, kTestLongitude, Now());
FireTimerToFetchGeoposition();
feature()->SetScheduleType(ScheduleType::kSunsetToSunrise);
EXPECT_FALSE(feature()->GetEnabled());
FastForwardBy(base::Days(1));
EXPECT_FALSE(feature()->GetEnabled());
}
// Tests that on device resume from sleep, the feature status is updated
// correctly if the time has changed meanwhile.
TEST_F(ScheduledFeatureTest, CustomScheduleOnResume) {
// Now is 4:00 PM.
FastForwardTo(MakeTimeOfDay(4, AmPm::kPM));
feature()->SetEnabled(false);
// Start time is at 6:00 PM and end time is at 10:00 PM. The feature should be
// off.
// 16:00 18:00 22:00
// <----- + ----------- + ----------- + ----->
// | | |
// now start end
//
feature()->SetCustomStartTime(MakeTimeOfDay(6, AmPm::kPM));
feature()->SetCustomEndTime(MakeTimeOfDay(10, AmPm::kPM));
feature()->SetScheduleType(ScheduleType::kCustom);
ASSERT_FALSE(feature()->GetEnabled());
PrefChangeObserver change_log(user1_pref_service(), this);
// Now simulate that the device was suspended for 3 hours, and the time now
// is 7:00 PM when the devices was resumed. Expect that the feature turns on.
AdvanceTimeBy(base::Hours(3)); // 7:00 PM
EXPECT_CALL(*feature(), RefreshFeatureState(RefreshReason::kReset));
feature()->SuspendDone(base::TimeDelta::Max());
Mock::VerifyAndClearExpectations(feature());
EXPECT_TRUE(feature()->GetEnabled());
// The feature should be disabled at originally scheduled time.
FastForwardTo(MakeTimeOfDay(10, AmPm::kPM));
EXPECT_FALSE(feature()->GetEnabled());
EXPECT_THAT(change_log.changes(),
ElementsAre(Pair(MakeTimeOfDay(7, AmPm::kPM), true),
Pair(MakeTimeOfDay(10, AmPm::kPM), false)));
}
// The following tests ensure that the feature schedule is correctly
// refreshed when the start and end times are inverted (i.e. the "start time" as
// a time of day today is in the future with respect to the "end time" also as a
// time of day today).
//
// Case 1: "Now" is less than both "end" and "start".
TEST_F(ScheduledFeatureTest, CustomScheduleInvertedStartAndEndTimesCase1) {
// Now is 4:00 AM.
FastForwardTo(MakeTimeOfDay(4, AmPm::kAM));
SetFeatureEnabled(false);
// Start time is at 9:00 PM and end time is at 6:00 AM. "Now" is less than
// both. The feature should be on.
// 4:00 6:00 21:00
// <----- + ----------- + ----------- + ----->
// | | |
// now end start
//
feature()->SetCustomStartTime(MakeTimeOfDay(9, AmPm::kPM));
feature()->SetCustomEndTime(MakeTimeOfDay(6, AmPm::kAM));
feature()->SetScheduleType(ScheduleType::kCustom);
EXPECT_TRUE(GetEnabled());
PrefChangeObserver change_log(user1_pref_service(), this);
FastForwardBy(base::Days(1));
EXPECT_THAT(change_log.changes(),
ElementsAre(Pair(MakeTimeOfDay(6, AmPm::kAM), false),
Pair(MakeTimeOfDay(9, AmPm::kPM), true)));
}
// Case 2: "Now" is between "end" and "start".
TEST_F(ScheduledFeatureTest, CustomScheduleInvertedStartAndEndTimesCase2) {
// Now is 6:00 AM.
FastForwardTo(MakeTimeOfDay(6, AmPm::kAM));
SetFeatureEnabled(false);
// Start time is at 9:00 PM and end time is at 4:00 AM. "Now" is between both.
// The feature should be off.
// 4:00 6:00 21:00
// <----- + ----------- + ----------- + ----->
// | | |
// end now start
//
feature()->SetCustomStartTime(MakeTimeOfDay(9, AmPm::kPM));
feature()->SetCustomEndTime(MakeTimeOfDay(4, AmPm::kAM));
feature()->SetScheduleType(ScheduleType::kCustom);
EXPECT_FALSE(GetEnabled());
PrefChangeObserver change_log(user1_pref_service(), this);
FastForwardBy(base::Days(1));
EXPECT_THAT(change_log.changes(),
ElementsAre(Pair(MakeTimeOfDay(9, AmPm::kPM), true),
Pair(MakeTimeOfDay(4, AmPm::kAM), false)));
}
// Case 3: "Now" is greater than both "start" and "end".
TEST_F(ScheduledFeatureTest, CustomScheduleInvertedStartAndEndTimesCase3) {
// Now is 11:00 PM.
FastForwardTo(MakeTimeOfDay(11, AmPm::kPM));
SetFeatureEnabled(false);
// Start time is at 9:00 PM and end time is at 4:00 AM. "Now" is greater than
// both. the feature should be on.
// 4:00 21:00 23:00
// <----- + ----------- + ----------- + ----->
// | | |
// end start now
//
feature()->SetCustomStartTime(MakeTimeOfDay(9, AmPm::kPM));
feature()->SetCustomEndTime(MakeTimeOfDay(4, AmPm::kAM));
feature()->SetScheduleType(ScheduleType::kCustom);
EXPECT_TRUE(GetEnabled());
PrefChangeObserver change_log(user1_pref_service(), this);
FastForwardBy(base::Days(1));
EXPECT_THAT(change_log.changes(),
ElementsAre(Pair(MakeTimeOfDay(4, AmPm::kAM), false),
Pair(MakeTimeOfDay(9, AmPm::kPM), true)));
}
// Tests that manual changes to the feature status while a schedule is being
// used will be remembered and reapplied across user switches.
TEST_F(ScheduledFeatureTest, MultiUserManualStatusToggleWithSchedules) {
// Setup user 1 to use a custom schedule from 3pm till 8pm, and user 2 to use
// a sunset-to-sunrise schedule from 6pm till 6am.
//
//
// |<--- User 1 NL on --->|
// | |
// <--------+-------------+--------+----------------------------+----------->
// 3pm 6pm 8pm 6am
// | |
// |<----------- User 2 NL on ---------->|
//
// Test cases at:
//
// <---+---------+------------+------------+----------------------------+--->
// 2pm 4pm 7pm 10pm 9am
//
FastForwardTo(MakeTimeOfDay(2, kPM));
feature()->SetCustomStartTime(MakeTimeOfDay(3, kPM));
feature()->SetCustomEndTime(MakeTimeOfDay(8, kPM));
feature()->SetScheduleType(ScheduleType::kCustom);
SwitchActiveUser(kUser2Email);
feature()->SetScheduleType(ScheduleType::kSunsetToSunrise);
SwitchActiveUser(kUser1Email);
struct {
TimeOfDay fake_now;
bool user_1_expected_status;
bool user_2_expected_status;
} kTestCases[] = {
{MakeTimeOfDay(2, kPM), false, false},
{MakeTimeOfDay(4, kPM), true, false},
{MakeTimeOfDay(7, kPM), true, true},
{MakeTimeOfDay(10, kPM), false, true},
{MakeTimeOfDay(9, kAM), // 9:00 AM tomorrow.
false, false},
};
for (const auto& test_case : kTestCases) {
// Each test case begins when user_1 is active.
const bool user_1_toggled_status = !test_case.user_1_expected_status;
const bool user_2_toggled_status = !test_case.user_2_expected_status;
// Apply the test's case fake time, and fire the timer if there's a change
// expected in the feature's status.
FastForwardTo(test_case.fake_now);
// The untoggled states for both users should match the expected ones
// according to their schedules.
EXPECT_EQ(test_case.user_1_expected_status, feature()->GetEnabled());
SwitchActiveUser(kUser2Email);
EXPECT_EQ(test_case.user_2_expected_status, feature()->GetEnabled());
// Manually toggle the feature for user_2 and expect that it will be
// remembered when we switch to user_1 and back.
feature()->SetEnabled(user_2_toggled_status);
EXPECT_EQ(user_2_toggled_status, feature()->GetEnabled());
SwitchActiveUser(kUser1Email);
EXPECT_EQ(test_case.user_1_expected_status, feature()->GetEnabled());
SwitchActiveUser(kUser2Email);
EXPECT_EQ(user_2_toggled_status, feature()->GetEnabled());
// Toggle it for user_1 as well, and expect it will be remembered and won't
// affect the already toggled state for user_2.
SwitchActiveUser(kUser1Email);
EXPECT_EQ(test_case.user_1_expected_status, feature()->GetEnabled());
feature()->SetEnabled(user_1_toggled_status);
EXPECT_EQ(user_1_toggled_status, feature()->GetEnabled());
SwitchActiveUser(kUser2Email);
EXPECT_EQ(user_2_toggled_status, feature()->GetEnabled());
// Toggle both users back to their original states in preparation for the
// next test case.
feature()->SetEnabled(test_case.user_2_expected_status);
EXPECT_EQ(test_case.user_2_expected_status, feature()->GetEnabled());
SwitchActiveUser(kUser1Email);
EXPECT_EQ(user_1_toggled_status, feature()->GetEnabled());
feature()->SetEnabled(test_case.user_1_expected_status);
EXPECT_EQ(test_case.user_1_expected_status, feature()->GetEnabled());
}
}
TEST_F(ScheduledFeatureTest,
ManualStatusToggleCanPersistAfterResumeFromSuspend) {
FastForwardTo(MakeTimeOfDay(11, kAM));
feature()->SetCustomStartTime(MakeTimeOfDay(3, kPM));
feature()->SetCustomEndTime(MakeTimeOfDay(8, kPM));
feature()->SetScheduleType(ScheduleType::kCustom);
EXPECT_FALSE(feature()->GetEnabled());
// Toggle the status manually and expect that the feature is scheduled to
// turn back off at 8:00 PM.
feature()->SetEnabled(true);
EXPECT_TRUE(feature()->GetEnabled());
PrefChangeObserver change_log(user1_pref_service(), this);
// Simulate suspend and then resume at 2:00 PM (which is outside the user's
// custom schedule). However, the manual toggle to on should be kept.
AdvanceTimeBy(base::Hours(3));
feature()->SuspendDone(base::TimeDelta{});
EXPECT_TRUE(feature()->GetEnabled());
// Suspend again and resume at 5:00 PM (which is within the user's custom
// schedule). The schedule should be applied normally.
AdvanceTimeBy(base::Hours(3));
feature()->SuspendDone(base::TimeDelta{});
EXPECT_TRUE(feature()->GetEnabled());
// Suspend and resume at 9:00 PM and expect the feature to be off.
AdvanceTimeBy(base::Hours(4));
feature()->SuspendDone(base::TimeDelta{});
EXPECT_FALSE(feature()->GetEnabled());
EXPECT_THAT(change_log.changes(),
ElementsAre(Pair(MakeTimeOfDay(9, AmPm::kPM), false)));
}
TEST_F(ScheduledFeatureTest, CurrentCheckpointForNoneSchedule) {
ASSERT_EQ(feature()->current_checkpoint(), ScheduleCheckpoint::kDisabled);
const CheckpointObserver checkpoint_observer(feature(), this);
feature()->SetEnabled(true);
feature()->SetEnabled(true);
feature()->SetEnabled(false);
feature()->SetEnabled(false);
EXPECT_THAT(checkpoint_observer.changes(),
ElementsAre(Pair(_, ScheduleCheckpoint::kEnabled),
Pair(_, ScheduleCheckpoint::kDisabled)));
}
TEST_F(ScheduledFeatureTest, CurrentCheckpointForCustomSchedule) {
FastForwardTo(MakeTimeOfDay(12, kAM));
ASSERT_EQ(feature()->current_checkpoint(), ScheduleCheckpoint::kDisabled);
const CheckpointObserver checkpoint_observer(feature(), this);
// Checkpoint 0:
// Custom schedule is enabled from 6 PM to 6 AM, so it should immediately
// flip to enabled.
feature()->SetScheduleType(ScheduleType::kCustom);
// Checkpoint 1:
// Fast forward to sunrise
FastForwardTo(MakeTimeOfDay(6, kAM));
// Checkpoint 2:
// Fast forward to sunset.
FastForwardTo(MakeTimeOfDay(6, kPM));
EXPECT_THAT(
checkpoint_observer.changes(),
ElementsAre(Pair(MakeTimeOfDay(12, kAM), ScheduleCheckpoint::kEnabled),
Pair(MakeTimeOfDay(6, kAM), ScheduleCheckpoint::kDisabled),
Pair(MakeTimeOfDay(6, kPM), ScheduleCheckpoint::kEnabled)));
}
// These reflect real-world combinations of schedule type + feature enabled pref
// changes that can happen with D/L mode.
TEST_F(ScheduledFeatureTest, CurrentCheckpointForSwitchingScheduleTypes) {
FastForwardTo(MakeTimeOfDay(12, kAM));
ASSERT_EQ(feature()->current_checkpoint(), ScheduleCheckpoint::kDisabled);
const CheckpointObserver checkpoint_observer(feature(), this);
// Checkpoint 0:
// Sunset is 6 PM and sunrise is 6 AM, so it should immediately flip to
// enabled.
feature()->SetScheduleType(ScheduleType::kSunsetToSunrise);
// Checkpoint 1:
// Flip back to no schedule type. It should stay enabled.
feature()->SetScheduleType(ScheduleType::kNone);
// Checkpoint 2:
// Fast forward to 10 AM and flip back to sunset to sunrise schedule type.
// It should automatically flip to disabled, but at the morning checkpoint.
FastForwardTo(MakeTimeOfDay(10, kAM));
feature()->SetScheduleType(ScheduleType::kSunsetToSunrise);
// Checkpoint 2:
// Flip back to no schedule type. It should stay disabled, but the default
// checkpoint for disabled is sunrise, not morning, so the checkpoint should
// change again.
feature()->SetScheduleType(ScheduleType::kNone);
// Checkpoint 3:
// Fast forward to 12 AM again and switch to sunset to sunrise. Feature should
// automatically flip to enabled.
FastForwardTo(MakeTimeOfDay(12, kAM));
feature()->SetScheduleType(ScheduleType::kSunsetToSunrise);
// Checkpoint 4:
// Now manually toggle the feature to disabled (opposite of what the schedule
// says). The current checkpoint should reflect the feature being disabled.
feature()->SetEnabled(false);
EXPECT_THAT(
checkpoint_observer.changes(),
ElementsAre(Pair(MakeTimeOfDay(12, kAM), ScheduleCheckpoint::kSunset),
Pair(MakeTimeOfDay(12, kAM), ScheduleCheckpoint::kEnabled),
Pair(MakeTimeOfDay(10, kAM), ScheduleCheckpoint::kMorning),
Pair(MakeTimeOfDay(10, kAM), ScheduleCheckpoint::kDisabled),
Pair(MakeTimeOfDay(12, kAM), ScheduleCheckpoint::kSunset),
Pair(MakeTimeOfDay(12, kAM), ScheduleCheckpoint::kSunrise)));
}
// Tests that the feature gracefully handles failures to get local time:
// b/285187343
TEST_F(ScheduledFeatureTest, HandlesLocalTimeFailuresSunsetToSunrise) {
// Give test initial start time of 9:00 AM.
FastForwardTo(MakeTimeOfDay(9, AmPm::kAM));
const CheckpointObserver checkpoint_observer(feature(), this);
const PrefChangeObserver pref_change_log(user1_pref_service(), this);
const FailingLocalTimeConverter failing_local_time_converter;
SetLocalTimeConverter(&failing_local_time_converter);
ASSERT_EQ(
geolocation_controller()->GetSunsetTime(),
base::unexpected(GeolocationController::SunRiseSetError::kUnavailable));
ASSERT_EQ(
geolocation_controller()->GetSunriseTime(),
base::unexpected(GeolocationController::SunRiseSetError::kUnavailable));
// Normally, this would retrieve a default sunrise/sunset of 6 AM/PM. But
// due to local time failure, this should keep the current state (disabled)
// and started scheduling retries with backoff.
ASSERT_FALSE(GetEnabled());
feature()->SetScheduleType(ScheduleType::kSunsetToSunrise);
EXPECT_FALSE(GetEnabled());
// Fast forward to 8:00 PM. Normally, sunset is 6:00 PM, so the feature should
// be enabled now, but since local time is still failing, current state
// should still be maintained.
FastForwardTo(MakeTimeOfDay(8, AmPm::kPM));
EXPECT_FALSE(GetEnabled());
// Now local time comes back and starts working again.
SetLocalTimeConverter(nullptr);
// At the next refresh retry, the schedule should resume normally.
FastForwardBy(kMaxRefreshBackoff);
EXPECT_TRUE(GetEnabled());
// Test a full day of the schedule (24 hours)to make sure schedule resumed
// normally.
FastForwardBy(base::Days(1));
EXPECT_THAT(pref_change_log.changes(),
// When local time starts working again, we know that it is
// somewhere between 8:00 PM and 8:00 PM + `kMaxRefreshBackoff`.
// Due to backoff jitter and other variables, it is difficult to
// pinpoint the exact timestamp for a test expectation, but that's
// not critical here. The important thing is that it ultimately
// updates to the correct state gracefully.
ElementsAre(Pair(_, true), Pair(MakeTimeOfDay(6, kAM), false),
Pair(MakeTimeOfDay(6, kPM), true)));
EXPECT_THAT(
checkpoint_observer.changes(),
// 9 AM: Change to `kSunsetToSunrise` schedule type. Feature is disabled,
// which defaults to sunrise.
ElementsAre(
Pair(MakeTimeOfDay(9, kAM), ScheduleCheckpoint::kSunrise),
// Timestamp of initial change (when local time starts working
// again) is not precise. See comment above.
Pair(_, ScheduleCheckpoint::kSunset),
Pair(MakeTimeOfDay(6, kAM), ScheduleCheckpoint::kSunrise),
Pair(MakeTimeOfDay(10, kAM), ScheduleCheckpoint::kMorning),
Pair(MakeTimeOfDay(4, kPM), ScheduleCheckpoint::kLateAfternoon),
Pair(MakeTimeOfDay(6, kPM), ScheduleCheckpoint::kSunset)));
}
// Tests that the feature gracefully handles failures to get local time:
// b/285187343
TEST_F(ScheduledFeatureTest, HandlesLocalTimeFailuresCustom) {
// Start time is at 9:00 AM and end time is at 9:00 PM.
feature()->SetCustomStartTime(MakeTimeOfDay(9, AmPm::kAM));
feature()->SetCustomEndTime(MakeTimeOfDay(9, AmPm::kPM));
// Give test initial start time of 9:00 AM.
FastForwardTo(MakeTimeOfDay(9, AmPm::kAM));
const CheckpointObserver checkpoint_observer(feature(), this);
const PrefChangeObserver pref_change_log(user1_pref_service(), this);
// Feature should be enabled immediately since it's 9:00 AM.
feature()->SetScheduleType(ScheduleType::kCustom);
EXPECT_TRUE(GetEnabled());
const FailingLocalTimeConverter failing_local_time_converter;
SetLocalTimeConverter(&failing_local_time_converter);
// At 9 PM, we switch the feature off as previously scheduled, but local time
// has started failing. Thus, the feature switches state correctly, but the
// next refresh (which should come at 9 AM tomorrow) is not scheduled
// correctly. Retries start.
FastForwardTo(MakeTimeOfDay(9, AmPm::kPM));
EXPECT_FALSE(GetEnabled());
// 9 AM tomorrow. Feature is still disabled due to local time failure.
FastForwardTo(MakeTimeOfDay(9, AmPm::kAM));
EXPECT_FALSE(GetEnabled());
// Local time starts working again. Next refresh should return the schedule to
// normal.
SetLocalTimeConverter(nullptr);
FastForwardBy(kMaxRefreshBackoff);
EXPECT_TRUE(GetEnabled());
// Test a full day of the schedule (24 hours) to make sure schedule resumed
// normally.
FastForwardBy(base::Days(1));
EXPECT_THAT(pref_change_log.changes(),
ElementsAre(Pair(MakeTimeOfDay(9, kAM), true),
Pair(MakeTimeOfDay(9, kPM), false),
// Local time starts working slightly after 9 AM. See
// comments in
// `HandlesLocalTimeFailuresSunsetToSunrise` for why
// an exact timestamp is not specified.
Pair(_, true),
// Schedule resumes like normal:
Pair(MakeTimeOfDay(9, kPM), false),
Pair(MakeTimeOfDay(9, kAM), true)));
EXPECT_THAT(
checkpoint_observer.changes(),
ElementsAre(Pair(MakeTimeOfDay(9, kAM), ScheduleCheckpoint::kEnabled),
Pair(MakeTimeOfDay(9, kPM), ScheduleCheckpoint::kDisabled),
// Local time starts working slightly after 9 AM. See
// comments in
// `HandlesLocalTimeFailuresSunsetToSunrise` for why
// an exact timestamp is not specified.
Pair(_, ScheduleCheckpoint::kEnabled),
// Schedule resumes like normal:
Pair(MakeTimeOfDay(9, kPM), ScheduleCheckpoint::kDisabled),
Pair(MakeTimeOfDay(9, kAM), ScheduleCheckpoint::kEnabled)));
}
TEST_P(ScheduledFeatureGeopositionTest, CyclesThroughCheckpoints) {
// Sunrise, morning, late afternoon, and sunset
static constexpr size_t kNumCheckpointsPerDay = 4;
const CheckpointObserver checkpoint_observer(feature(), this);
FastForwardBy(base::Days(1));
// This legitimately happens in regions with no daylight/darkness.
if (checkpoint_observer.changes().empty()) {
return;
}
const size_t num_checkpoints_observed = checkpoint_observer.changes().size();
// There are a couple of corner cases where 3 or 5 checkpoints are observed in
// 24 hours.
//
// Example of 5:
// Now: 5:59 AM
// Sunrise today: 6:00 AM
// Sunrise tomorrow: 5:58 AM
//
// Expected checkpoint changes:
// * Sunrise 1 (6 AM)
// * Morning (10 AM)
// * Late Afternoon (4 PM)
// * Sunset (6 PM)
// * Sunrise 2 (5:58 AM)
//
// Example of 3:
// Now: 6:01 AM
// Sunrise today: 6:00 AM
// Sunrise tomorrow: 6:02 AM
//
// Expected checkpoint changes:
// * Morning (10 AM)
// * Late Afternoon (4 PM)
// * Sunset (6 PM)
ASSERT_GE(num_checkpoints_observed, kNumCheckpointsPerDay - 1);
ASSERT_LE(num_checkpoints_observed, kNumCheckpointsPerDay + 1);
for (size_t i = 1; i < num_checkpoints_observed; ++i) {
EXPECT_EQ(
checkpoint_observer.changes()[i].second,
GetNextExpectedCheckpoint(checkpoint_observer.changes()[i - 1].second));
}
}
TEST_F(ScheduledFeatureTest, RecordsScheduleTypeHistogram) {
const std::string test_histogram_name = "Ash.Test.ScheduleType";
base::HistogramTester histogram_tester;
feature()->SetScheduleType(ScheduleType::kCustom);
histogram_tester.ExpectTotalCount(test_histogram_name, 0);
feature()->set_schedule_type_histogram_name(test_histogram_name);
feature()->SetScheduleType(ScheduleType::kSunsetToSunrise);
feature()->SetScheduleType(ScheduleType::kNone);
feature()->SetScheduleType(ScheduleType::kCustom);
histogram_tester.ExpectBucketCount(test_histogram_name, ScheduleType::kNone,
1);
histogram_tester.ExpectBucketCount(test_histogram_name,
ScheduleType::kSunsetToSunrise, 1);
histogram_tester.ExpectBucketCount(test_histogram_name, ScheduleType::kCustom,
1);
// Switching users should not count as a schedule type change even if second
// user's schedule type is different from the first.
base::HistogramTester histogram_tester_2;
const ScheduleType user_1_schedule_type = feature()->GetScheduleType();
SwitchActiveUser(kUser2Email);
ASSERT_NE(feature()->GetScheduleType(), user_1_schedule_type);
histogram_tester_2.ExpectTotalCount(test_histogram_name, 0);
}
} // namespace
} // namespace ash
Codebase Browser
chromium