// 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 "chromeos/ash/components/report/device_metrics/churn/active_status.h"
#include "base/check.h"
#include "base/test/task_environment.h"
#include "base/time/time.h"
#include "chromeos/ash/components/report/proto/fresnel_service.pb.h"
#include "chromeos/ash/components/report/report_controller.h"
#include "chromeos/ash/components/report/utils/test_utils.h"
#include "chromeos/ash/components/report/utils/time_utils.h"
#include "chromeos/ash/components/system/fake_statistics_provider.h"
#include "components/prefs/pref_service.h"
#include "components/prefs/testing_pref_service.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace ash::report::device_metrics {
class ActiveStatusTest : public testing::Test {
protected:
void SetUp() override {
// Set the mock time to |kFakeTimeNow|.
base::Time ts;
ASSERT_TRUE(base::Time::FromUTCString(utils::kFakeTimeNowString, &ts));
task_environment_.AdvanceClock(ts - base::Time::Now());
// Register all related local state prefs.
ReportController::RegisterPrefs(local_state_.registry());
system::StatisticsProvider::SetTestProvider(&statistics_provider_);
active_status_ = std::make_unique<ActiveStatus>(&local_state_);
}
void TearDown() override { active_status_.reset(); }
ActiveStatus* GetActiveStatus() { return active_status_.get(); }
base::Time GetFakeTimeNow() { return base::Time::Now(); }
protected:
void SetActivateDate(const std::string& activate_date) {
statistics_provider_.SetMachineStatistic(system::kActivateDateKey,
activate_date);
}
std::optional<base::Time> GetFirstActiveWeekForTest() {
return utils::GetFirstActiveWeek();
}
base::test::TaskEnvironment task_environment_{
base::test::TaskEnvironment::TimeSource::MOCK_TIME};
private:
TestingPrefServiceSimple local_state_;
system::FakeStatisticsProvider statistics_provider_;
std::unique_ptr<ActiveStatus> active_status_;
};
TEST_F(ActiveStatusTest, SetAndGetValue) {
// Set a value using SetValue method.
GetActiveStatus()->SetValue(42);
// Verify that GetValue returns the same value.
EXPECT_EQ(GetActiveStatus()->GetValue(), 42);
}
TEST_F(ActiveStatusTest, CalculateValue) {
// Verify initial active status value updates to current month timestamp.
base::Time ts = GetFakeTimeNow();
std::optional<int> value = GetActiveStatus()->CalculateNewValue(ts);
EXPECT_TRUE(value.has_value());
EXPECT_EQ(value.value(), 72351745);
// Verify uninitialized time object returns nullopt.
base::Time uninitialized_ts;
value = GetActiveStatus()->CalculateNewValue(uninitialized_ts);
EXPECT_FALSE(value.has_value());
// Verify unix epoch timestamp returns nullopt.
base::Time unix_epoch_ts = base::Time::UnixEpoch();
value = GetActiveStatus()->CalculateNewValue(unix_epoch_ts);
EXPECT_FALSE(value.has_value());
// Verify timestamp before |kActiveStatusInceptionDate| returns nullopt.
base::Time inception_ts;
EXPECT_TRUE(base::Time::FromUTCString(
ActiveStatus::kActiveStatusInceptionDate, &inception_ts));
value = GetActiveStatus()->CalculateNewValue(inception_ts - base::Days(1));
EXPECT_FALSE(value.has_value());
}
TEST_F(ActiveStatusTest, CalculateNewValueSameMonthAsPreviousReturnsNullopt) {
base::Time current_month_ts = GetFakeTimeNow();
// Set up the initial active status value and the current month timestamp.
std::optional<int> value =
GetActiveStatus()->CalculateNewValue(current_month_ts);
GetActiveStatus()->SetValue(value.value());
// Calculate the new value for the same month as the previous one.
value = GetActiveStatus()->CalculateNewValue(current_month_ts);
// Ensure that the new value is not calculated and nullopt is returned.
EXPECT_FALSE(value.has_value());
}
TEST_F(ActiveStatusTest, CalculateNewValueNewMonthReturnsUpdatedValue) {
base::Time current_month_ts = GetFakeTimeNow();
// Set up the initial active status value and the current month timestamp.
std::optional<int> value =
GetActiveStatus()->CalculateNewValue(current_month_ts);
GetActiveStatus()->SetValue(value.value());
// Set the previous month's timestamp to simulate a new month.
base::Time next_month_ts = utils::GetNextMonth(current_month_ts).value();
// Calculate the new value for the new month.
std::optional<int> new_value =
GetActiveStatus()->CalculateNewValue(next_month_ts);
// Ensure the updated new value is generated based on the newer timestamp.
EXPECT_TRUE(new_value.has_value());
EXPECT_GT(new_value.value(), value.value());
}
TEST_F(ActiveStatusTest, GetCurrentActiveMonthTimestamp) {
ASSERT_EQ(GetActiveStatus()->GetValue(), 0);
std::optional<base::Time> current_active_month_ts =
GetActiveStatus()->GetCurrentActiveMonthTimestamp();
// Return inception ts since active status value has never been updated (= 0).
base::Time inception_ts;
EXPECT_TRUE(base::Time::FromUTCString(
ActiveStatus::kActiveStatusInceptionDate, &inception_ts));
EXPECT_TRUE(current_active_month_ts.has_value());
EXPECT_EQ(current_active_month_ts.value(), inception_ts);
// Set value to a fake time.
int val = GetActiveStatus()->CalculateNewValue(GetFakeTimeNow()).value();
GetActiveStatus()->SetValue(val);
// Get the current active month timestamp. The value was set to
// |GetFakeTimeNow()|.
current_active_month_ts = GetActiveStatus()->GetCurrentActiveMonthTimestamp();
EXPECT_TRUE(current_active_month_ts.has_value());
EXPECT_EQ(current_active_month_ts.value(), GetFakeTimeNow());
}
TEST_F(ActiveStatusTest, CalculateCohortMetadataReturnExpectedMetadata) {
// Set up the initial active status value and the current month timestamp.
base::Time current_month_ts = GetFakeTimeNow();
int val = GetActiveStatus()->CalculateNewValue(current_month_ts).value();
GetActiveStatus()->SetValue(val);
// Simulate a new month when calculating churn cohort metadata.
base::Time next_month_ts = utils::GetNextMonth(current_month_ts).value();
// Calculate the cohort metadata.
ChurnCohortMetadata metadata =
GetActiveStatus()->CalculateCohortMetadata(next_month_ts).value();
// Ensure that the metadata is calculated correctly.
EXPECT_EQ(metadata.active_status_value(), 72613891);
EXPECT_FALSE(metadata.is_first_active_in_cohort());
// Ensure local state doesn't get updated on calculate cohort metadata call.
EXPECT_EQ(GetActiveStatus()->GetCurrentActiveMonthTimestamp(),
current_month_ts);
}
TEST_F(ActiveStatusTest, CalculateCohortMetadataReturnFirstActive) {
base::Time current_month_ts = GetFakeTimeNow();
// Initialize ActivateDate VPD field to be first active in current month ts.
SetActivateDate("2023-02");
// Calculate the cohort metadata.
ChurnCohortMetadata metadata =
GetActiveStatus()->CalculateCohortMetadata(current_month_ts).value();
// Ensure that the metadata is calculated correctly.
EXPECT_EQ(metadata.active_status_value(), 72351745);
EXPECT_TRUE(metadata.is_first_active_in_cohort());
}
TEST_F(ActiveStatusTest,
CalculateCohortMetadataSameMonthAsPreviousReturnsNullopt) {
// Set up the initial active status value and the current month timestamp.
base::Time current_month_ts = GetFakeTimeNow();
int val = GetActiveStatus()->CalculateNewValue(current_month_ts).value();
GetActiveStatus()->SetValue(val);
// Calculate the cohort metadata.
std::optional<ChurnCohortMetadata> metadata =
GetActiveStatus()->CalculateCohortMetadata(current_month_ts);
// Ensure the metadata is not regenerated for same |current_month_ts|.
EXPECT_FALSE(metadata.has_value());
}
TEST_F(ActiveStatusTest, CalculateObservationMetadataReturnsExpectedMetadata) {
// Setup initial value to be last active in Jan-2023.
// Value represents device was active each of the 18 months prior.
// Represents binary: 0100010100 111111111111111111
int cur_value = 72613887;
base::Time cur_ts = GetFakeTimeNow();
GetActiveStatus()->SetValue(cur_value);
// Calculate the observation metadata for 3 periods.
std::optional<ChurnObservationMetadata> metadata_0 =
GetActiveStatus()->CalculateObservationMetadata(cur_ts, 0);
std::optional<ChurnObservationMetadata> metadata_1 =
GetActiveStatus()->CalculateObservationMetadata(cur_ts, 1);
std::optional<ChurnObservationMetadata> metadata_2 =
GetActiveStatus()->CalculateObservationMetadata(cur_ts, 2);
// Ensure that the metadata is calculated correctly.
EXPECT_TRUE(metadata_0->monthly_active_status());
EXPECT_TRUE(metadata_1->monthly_active_status());
EXPECT_TRUE(metadata_2->monthly_active_status());
EXPECT_TRUE(metadata_0->yearly_active_status());
EXPECT_TRUE(metadata_1->yearly_active_status());
EXPECT_TRUE(metadata_2->yearly_active_status());
EXPECT_EQ(
metadata_0->first_active_during_cohort(),
ChurnObservationMetadata_FirstActiveDuringCohort_EXISTED_OR_NOT_ACTIVE_YET);
EXPECT_EQ(
metadata_1->first_active_during_cohort(),
ChurnObservationMetadata_FirstActiveDuringCohort_EXISTED_OR_NOT_ACTIVE_YET);
EXPECT_EQ(
metadata_2->first_active_during_cohort(),
ChurnObservationMetadata_FirstActiveDuringCohort_EXISTED_OR_NOT_ACTIVE_YET);
}
TEST_F(ActiveStatusTest,
CalculateObservationMetadataReturnsExpectedMetadataActiveMonths) {
// Setup initial value to be last active in Jan-2023.
// Value represents device was active each of the 18 months prior.
// Represents binary: 0100010100 111101111111111101
int cur_value = 72605693;
base::Time cur_ts = GetFakeTimeNow();
GetActiveStatus()->SetValue(cur_value);
// Calculate the observation metadata for 3 periods.
std::optional<ChurnObservationMetadata> metadata_0 =
GetActiveStatus()->CalculateObservationMetadata(cur_ts, 0);
std::optional<ChurnObservationMetadata> metadata_1 =
GetActiveStatus()->CalculateObservationMetadata(cur_ts, 1);
std::optional<ChurnObservationMetadata> metadata_2 =
GetActiveStatus()->CalculateObservationMetadata(cur_ts, 2);
// Ensure that the metadata is calculated correctly.
EXPECT_FALSE(metadata_0->monthly_active_status());
EXPECT_TRUE(metadata_1->monthly_active_status());
EXPECT_TRUE(metadata_2->monthly_active_status());
EXPECT_FALSE(metadata_0->yearly_active_status());
EXPECT_TRUE(metadata_1->yearly_active_status());
EXPECT_TRUE(metadata_2->yearly_active_status());
EXPECT_EQ(
metadata_0->first_active_during_cohort(),
ChurnObservationMetadata_FirstActiveDuringCohort_EXISTED_OR_NOT_ACTIVE_YET);
EXPECT_EQ(
metadata_1->first_active_during_cohort(),
ChurnObservationMetadata_FirstActiveDuringCohort_EXISTED_OR_NOT_ACTIVE_YET);
EXPECT_EQ(
metadata_2->first_active_during_cohort(),
ChurnObservationMetadata_FirstActiveDuringCohort_EXISTED_OR_NOT_ACTIVE_YET);
}
TEST_F(ActiveStatusTest,
CalculateObservationMetadataReturnsExpectedMetadataFirstActiveYearly) {
// Setup initial value to be last active in Jan-2023.
// Value represents device was active each of the 18 months prior.
// Represents binary: 0100010100 000010000000000001
int cur_value = 72359937;
base::Time cur_ts = GetFakeTimeNow();
GetActiveStatus()->SetValue(cur_value);
SetActivateDate("2021-52");
// Calculate the observation metadata for 3 periods.
std::optional<ChurnObservationMetadata> metadata_0 =
GetActiveStatus()->CalculateObservationMetadata(cur_ts, 0);
std::optional<ChurnObservationMetadata> metadata_1 =
GetActiveStatus()->CalculateObservationMetadata(cur_ts, 1);
std::optional<ChurnObservationMetadata> metadata_2 =
GetActiveStatus()->CalculateObservationMetadata(cur_ts, 2);
// Ensure that the metadata is calculated correctly.
EXPECT_FALSE(metadata_0->monthly_active_status());
EXPECT_FALSE(metadata_1->monthly_active_status());
EXPECT_FALSE(metadata_2->monthly_active_status());
EXPECT_TRUE(metadata_0->yearly_active_status());
EXPECT_FALSE(metadata_1->yearly_active_status());
EXPECT_FALSE(metadata_2->yearly_active_status());
EXPECT_EQ(
metadata_0->first_active_during_cohort(),
ChurnObservationMetadata_FirstActiveDuringCohort_FIRST_ACTIVE_IN_YEARLY_COHORT);
EXPECT_EQ(
metadata_1->first_active_during_cohort(),
ChurnObservationMetadata_FirstActiveDuringCohort_EXISTED_OR_NOT_ACTIVE_YET);
EXPECT_EQ(
metadata_2->first_active_during_cohort(),
ChurnObservationMetadata_FirstActiveDuringCohort_EXISTED_OR_NOT_ACTIVE_YET);
}
TEST_F(ActiveStatusTest,
CalculateObservationMetadataReturnsExpectedMetadataFirstActiveMonthly) {
// Setup initial value to be last active in Jan-2023.
// Value represents device was active each of the 18 months prior.
// Represents binary: 0100010100 000000000000000011
int cur_value = 72351747;
base::Time cur_ts = GetFakeTimeNow();
GetActiveStatus()->SetValue(cur_value);
SetActivateDate("2022-52");
// Calculate the observation metadata for 3 periods.
std::optional<ChurnObservationMetadata> metadata_0 =
GetActiveStatus()->CalculateObservationMetadata(cur_ts, 0);
std::optional<ChurnObservationMetadata> metadata_1 =
GetActiveStatus()->CalculateObservationMetadata(cur_ts, 1);
std::optional<ChurnObservationMetadata> metadata_2 =
GetActiveStatus()->CalculateObservationMetadata(cur_ts, 2);
// Ensure that the metadata is calculated correctly.
EXPECT_TRUE(metadata_0->monthly_active_status());
EXPECT_FALSE(metadata_1->monthly_active_status());
EXPECT_FALSE(metadata_2->monthly_active_status());
EXPECT_FALSE(metadata_0->yearly_active_status());
EXPECT_FALSE(metadata_1->yearly_active_status());
EXPECT_FALSE(metadata_2->yearly_active_status());
EXPECT_EQ(
metadata_0->first_active_during_cohort(),
ChurnObservationMetadata_FirstActiveDuringCohort_FIRST_ACTIVE_IN_MONTHLY_COHORT);
EXPECT_EQ(
metadata_1->first_active_during_cohort(),
ChurnObservationMetadata_FirstActiveDuringCohort_EXISTED_OR_NOT_ACTIVE_YET);
EXPECT_EQ(
metadata_2->first_active_during_cohort(),
ChurnObservationMetadata_FirstActiveDuringCohort_EXISTED_OR_NOT_ACTIVE_YET);
}
TEST_F(
ActiveStatusTest,
CalculateObservationMetadataReturnsNulloptMisalignedCohortAndObservation) {
// Setup initial value to be last active in Dec-2022.
// Value represents device was active each of the 18 months prior.
// Represents binary: 0100010011 000000000000000001
int cur_value = 72089601;
GetActiveStatus()->SetValue(cur_value);
// Simulate unexpected scenario of observation being 1 month ahead of cohort.
base::Time next_month_ts = GetFakeTimeNow();
// Calculate the observation metadata for 3 periods.
std::optional<ChurnObservationMetadata> metadata_0 =
GetActiveStatus()->CalculateObservationMetadata(next_month_ts, 0);
std::optional<ChurnObservationMetadata> metadata_1 =
GetActiveStatus()->CalculateObservationMetadata(next_month_ts, 1);
std::optional<ChurnObservationMetadata> metadata_2 =
GetActiveStatus()->CalculateObservationMetadata(next_month_ts, 2);
// Ensure that the metadata is calculated correctly.
EXPECT_FALSE(metadata_0.has_value());
EXPECT_FALSE(metadata_1.has_value());
EXPECT_FALSE(metadata_2.has_value());
}
TEST_F(ActiveStatusTest, GetFirstActiveWeekActivateDateNotSetReturnsNullopt) {
// Get the first active week.
std::optional<base::Time> first_active_week = GetFirstActiveWeekForTest();
// Ensure that nullopt is returned when the activate date is not set.
EXPECT_FALSE(first_active_week.has_value());
}
TEST_F(ActiveStatusTest, GetFirstActiveWeekActivateDateSetReturnsExpectedWeek) {
// Setup the activate date (ISO8601) and expected first active week for test.
std::string activate_date = "2021-23";
base::Time expected_activate_date_ts;
ASSERT_TRUE(base::Time::FromUTCString("2021-06-07 00:00:00 GMT",
&expected_activate_date_ts));
SetActivateDate(activate_date);
std::optional<base::Time> first_active_week = GetFirstActiveWeekForTest();
// Ensure that the returned week matches the expected value.
EXPECT_TRUE(first_active_week.has_value());
EXPECT_EQ(first_active_week.value(), expected_activate_date_ts);
// Setup the activate date (ISO8601) and expected first active week for test.
activate_date = "2023-52";
ASSERT_TRUE(base::Time::FromUTCString("2023-12-25 00:00:00 GMT",
&expected_activate_date_ts));
SetActivateDate(activate_date);
first_active_week = GetFirstActiveWeekForTest();
// Ensure that the returned week matches the expected value.
EXPECT_TRUE(first_active_week.has_value());
EXPECT_EQ(first_active_week.value(), expected_activate_date_ts);
}
TEST_F(ActiveStatusTest, GetFirstActiveWeekInvalidActivateDateSet) {
// Setup the activate date (ISO8601) and expected first active week for test.
std::string activate_date = "2021-xx";
SetActivateDate(activate_date);
std::optional<base::Time> first_active_week = GetFirstActiveWeekForTest();
EXPECT_FALSE(first_active_week.has_value());
// Setup the activate date (ISO8601) and expected first active week for test.
activate_date = "2023-99";
SetActivateDate(activate_date);
first_active_week = GetFirstActiveWeekForTest();
EXPECT_FALSE(first_active_week.has_value());
// Setup the activate date (ISO8601) and expected first active week for test.
activate_date = "-------";
SetActivateDate(activate_date);
first_active_week = GetFirstActiveWeekForTest();
EXPECT_FALSE(first_active_week.has_value());
}
} // namespace ash::report::device_metrics
Codebase Browser
chromium