ash / user_education / welcome_tour / welcome_tour_prefs_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/user_education/welcome_tour/welcome_tour_prefs.h"

#include <optional>

#include "ash/constants/ash_features.h"
#include "ash/public/cpp/ash_prefs.h"
#include "ash/user_education/user_education_types.h"
#include "ash/user_education/welcome_tour/welcome_tour_metrics.h"
#include "base/json/values_util.h"
#include "base/strings/strcat.h"
#include "base/test/scoped_feature_list.h"
#include "base/time/time.h"
#include "components/prefs/testing_pref_service.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace ash::welcome_tour_prefs {
namespace {

// Aliases ---------------------------------------------------------------------

using welcome_tour_metrics::kAllExperimentalArmsSet;
using welcome_tour_metrics::kAllInteractionsSet;
using welcome_tour_metrics::kAllPreventedReasonsSet;

using welcome_tour_metrics::ExperimentalArm;
using welcome_tour_metrics::Interaction;
using welcome_tour_metrics::PreventedReason;

// Constants -------------------------------------------------------------------

static constexpr char kFirstExperimentalArm[] =
    "ash.welcome_tour.v3.experimental_arm.first";
static constexpr char kTimeOfFirstTourAborted[] =
    "ash.welcome_tour.v3.aborted.first_time";
static constexpr char kTimeOfFirstTourCompletion[] =
    "ash.welcome_tour.v3.completed.first_time";
static constexpr char kTimeOfFirstTourPrevention[] =
    "ash.welcome_tour.v3.prevented.first_time";
static constexpr char kReasonForFirstTourPrevention[] =
    "ash.welcome_tour.v3.prevented.first_reason";

}  // namespace

// WelcomeTourPrefsTest --------------------------------------------------------

// Base class for tests that verify the behavior of Welcome Tour prefs.
class WelcomeTourPrefsTest : public testing::Test {
 public:
  WelcomeTourPrefsTest() {
    feature_list_.InitAndEnableFeature(features::kWelcomeTour);
    RegisterUserProfilePrefs(pref_service_.registry(), /*country=*/"",
                             /*for_test=*/true);
  }

 protected:
  TestingPrefServiceSimple* pref_service() { return &pref_service_; }

 private:
  base::test::ScopedFeatureList feature_list_;
  TestingPrefServiceSimple pref_service_;
};

// Tests -----------------------------------------------------------------------

// Expects that setting and fetching the first experimental arm will
// work for all valid values, and handle invalid ones properly.
TEST_F(WelcomeTourPrefsTest, ExperimentalArms) {
  // The arm should by default be absent.
  EXPECT_EQ(GetFirstExperimentalArm(pref_service()), std::nullopt);

  // Expect that all valid values for `ExperimentalArm` can be set and fetched.
  for (auto arm : kAllExperimentalArmsSet) {
    EXPECT_TRUE(MarkFirstExperimentalArm(pref_service(), arm));
    EXPECT_EQ(GetFirstExperimentalArm(pref_service()), arm);

    // Clear the first experimental arm pref for the next loop.
    // `MarkFirstExperimentalArm()` would exit early otherwise.
    pref_service()->ClearPref(kFirstExperimentalArm);
  }

  // For any values that are out of bounds of the enum, it should default to
  // `std::nullopt`.
  pref_service()->SetUserPref(
      kFirstExperimentalArm,
      base::Value(static_cast<int>(ExperimentalArm::kMaxValue) + 1));
  EXPECT_EQ(GetFirstExperimentalArm(pref_service()), std::nullopt);
}

// Expects the first experimental arm pref can be set exactly once.
TEST_F(WelcomeTourPrefsTest, FirstExperimentalArm) {
  // Should be unset by default.
  EXPECT_EQ(GetFirstExperimentalArm(pref_service()), std::nullopt);

  // The first time the mark method is called, it should succeed and mark the
  // experimental arm with the given value.
  EXPECT_TRUE(
      MarkFirstExperimentalArm(pref_service(), ExperimentalArm::kHoldback));
  EXPECT_EQ(GetFirstExperimentalArm(pref_service()),
            ExperimentalArm::kHoldback);

  // For any call beyond the first, the function should return false and the
  // marked first experimental arm should not change.
  EXPECT_FALSE(MarkFirstExperimentalArm(pref_service(), ExperimentalArm::kV3));
  EXPECT_EQ(GetFirstExperimentalArm(pref_service()),
            ExperimentalArm::kHoldback);
}

// Expects the first interaction time prefs can be set exactly once.
TEST_F(WelcomeTourPrefsTest, FirstInteraction) {
  MarkTimeOfFirstTourCompletion(pref_service());

  for (auto interaction : kAllInteractionsSet) {
    // Should be unset by default.
    EXPECT_EQ(GetTimeOfFirstInteraction(pref_service(), interaction),
              std::nullopt);

    // The first time the mark method is called, it should succeed and mark the
    // time as now.
    auto before = base::Time::Now();
    EXPECT_TRUE(MarkTimeOfFirstInteraction(pref_service(), interaction));
    auto after = base::Time::Now();

    auto interaction_time =
        GetTimeOfFirstInteraction(pref_service(), interaction);
    ASSERT_TRUE(interaction_time);
    EXPECT_GE(interaction_time, before);
    EXPECT_LE(interaction_time, after);

    // For any call beyond the first, the function should return false and the
    // marked time should not change.
    EXPECT_FALSE(MarkTimeOfFirstInteraction(pref_service(), interaction));
    EXPECT_EQ(GetTimeOfFirstInteraction(pref_service(), interaction),
              interaction_time);
  }
}

// Expects the first tour aborted time pref can be set exactly once.
TEST_F(WelcomeTourPrefsTest, FirstTourAborted) {
  // Should be unset by default.
  EXPECT_EQ(GetTimeOfFirstTourAborted(pref_service()), std::nullopt);

  // The first time the mark method is called, it should succeed and mark the
  // time as now.
  auto before = base::Time::Now();
  EXPECT_TRUE(MarkTimeOfFirstTourAborted(pref_service()));
  auto after = base::Time::Now();

  auto aborted_time = GetTimeOfFirstTourAborted(pref_service());
  ASSERT_TRUE(aborted_time);
  EXPECT_GE(aborted_time, before);
  EXPECT_LE(aborted_time, after);

  // For any call beyond the first, the function should return false and the
  // marked time should not change.
  EXPECT_FALSE(MarkTimeOfFirstTourAborted(pref_service()));
  EXPECT_EQ(GetTimeOfFirstTourAborted(pref_service()), aborted_time);
}

// Expects the first tour attempt time is minimum time among all attempts.
TEST_F(WelcomeTourPrefsTest, FirstTourAttemptAmongAllAttempts) {
  // Should be unset by default.
  EXPECT_EQ(GetTimeOfFirstTourAttempt(pref_service()), std::nullopt);

  // The first time the mark method is called, it should succeed and mark the
  // time as now and the given reason as the reason.
  auto before = base::Time::Now();
  EXPECT_TRUE(MarkFirstTourPrevention(pref_service(),
                                      PreventedReason::kHoldbackExperimentArm));
  auto after = base::Time::Now();

  EXPECT_EQ(GetReasonForFirstTourPrevention(pref_service()),
            PreventedReason::kHoldbackExperimentArm);

  auto prevention_time = GetTimeOfFirstTourPrevention(pref_service());
  ASSERT_TRUE(prevention_time);
  EXPECT_GE(prevention_time, before);
  EXPECT_LE(prevention_time, after);

  // Prevention reason of holdback will return the prevention time as the
  // attempt time.
  auto attempt_time = GetTimeOfFirstTourAttempt(pref_service());
  ASSERT_TRUE(attempt_time);
  EXPECT_GE(attempt_time, before);
  EXPECT_LE(attempt_time, after);
  EXPECT_EQ(attempt_time, prevention_time);

  // Set an aborted time.
  before = base::Time::Now();
  EXPECT_TRUE(MarkTimeOfFirstTourAborted(pref_service()));
  after = base::Time::Now();

  auto aborted_time = GetTimeOfFirstTourAborted(pref_service());
  ASSERT_TRUE(aborted_time);
  EXPECT_GE(aborted_time, before);
  EXPECT_LE(aborted_time, after);

  attempt_time = GetTimeOfFirstTourAttempt(pref_service());
  EXPECT_NE(attempt_time, aborted_time);
  EXPECT_EQ(attempt_time, prevention_time);

  // Set a completion time.
  before = base::Time::Now();
  EXPECT_TRUE(MarkTimeOfFirstTourCompletion(pref_service()));
  after = base::Time::Now();

  auto completion_time = GetTimeOfFirstTourCompletion(pref_service());
  ASSERT_TRUE(completion_time);
  EXPECT_GE(completion_time, before);
  EXPECT_LE(completion_time, after);

  attempt_time = GetTimeOfFirstTourAttempt(pref_service());
  EXPECT_NE(attempt_time, aborted_time);
  EXPECT_NE(attempt_time, completion_time);
  EXPECT_EQ(attempt_time, prevention_time);

  // Clear the prevention time and reason prefs.
  pref_service()->ClearPref(kReasonForFirstTourPrevention);
  pref_service()->ClearPref(kTimeOfFirstTourPrevention);

  attempt_time = GetTimeOfFirstTourAttempt(pref_service());
  EXPECT_EQ(attempt_time, aborted_time);
  EXPECT_NE(attempt_time, completion_time);
  EXPECT_NE(attempt_time, prevention_time);

  // Clear the aborted time.
  pref_service()->ClearPref(kTimeOfFirstTourAborted);

  attempt_time = GetTimeOfFirstTourAttempt(pref_service());
  EXPECT_NE(attempt_time, aborted_time);
  EXPECT_EQ(attempt_time, completion_time);
  EXPECT_NE(attempt_time, prevention_time);

  // Mark the aborted time again.
  EXPECT_TRUE(MarkTimeOfFirstTourAborted(pref_service()));
  aborted_time = GetTimeOfFirstTourAborted(pref_service());
  ASSERT_TRUE(aborted_time);

  attempt_time = GetTimeOfFirstTourAttempt(pref_service());
  EXPECT_NE(attempt_time, aborted_time);
  EXPECT_EQ(attempt_time, completion_time);
  EXPECT_NE(attempt_time, prevention_time);

  // Clear the completion time.
  pref_service()->ClearPref(kTimeOfFirstTourCompletion);

  attempt_time = GetTimeOfFirstTourAttempt(pref_service());
  EXPECT_EQ(attempt_time, aborted_time);
  EXPECT_NE(attempt_time, completion_time);
  EXPECT_NE(attempt_time, prevention_time);
}

// Expects the first tour attempt time is the aborted time.
TEST_F(WelcomeTourPrefsTest, FirstTourAttemptWhenAborted) {
  // Should be unset by default.
  EXPECT_EQ(GetTimeOfFirstTourAttempt(pref_service()), std::nullopt);

  // The first time the mark method is called, it should succeed and mark the
  // time as now.
  auto before = base::Time::Now();
  EXPECT_TRUE(MarkTimeOfFirstTourAborted(pref_service()));
  auto after = base::Time::Now();

  auto aborted_time = GetTimeOfFirstTourAborted(pref_service());
  ASSERT_TRUE(aborted_time);
  EXPECT_GE(aborted_time, before);
  EXPECT_LE(aborted_time, after);

  // Prevention reason of holdback will return the prevention time as the
  // attempt time.
  auto attempt_time = GetTimeOfFirstTourAttempt(pref_service());
  ASSERT_TRUE(attempt_time);
  EXPECT_GE(attempt_time, before);
  EXPECT_LE(attempt_time, after);

  EXPECT_EQ(attempt_time, aborted_time);
}

// Expects the first tour attempt time is the completion time.
TEST_F(WelcomeTourPrefsTest, FirstTourAttemptWhenCompleted) {
  // Should be unset by default.
  EXPECT_EQ(GetTimeOfFirstTourAttempt(pref_service()), std::nullopt);

  // The first time the mark method is called, it should succeed and mark the
  // time as now.
  auto before = base::Time::Now();
  EXPECT_TRUE(MarkTimeOfFirstTourCompletion(pref_service()));
  auto after = base::Time::Now();

  auto completion_time = GetTimeOfFirstTourCompletion(pref_service());
  ASSERT_TRUE(completion_time);
  EXPECT_GE(completion_time, before);
  EXPECT_LE(completion_time, after);

  // Prevention reason of holdback will return the prevention time as the
  // attempt time.
  auto attempt_time = GetTimeOfFirstTourAttempt(pref_service());
  ASSERT_TRUE(attempt_time);
  EXPECT_GE(attempt_time, before);
  EXPECT_LE(attempt_time, after);

  EXPECT_EQ(attempt_time, completion_time);
}

// Expects the first tour attempt time is nullopt if the prevention reason is
// not holdback.
TEST_F(WelcomeTourPrefsTest, FirstTourAttemptWhenPreventionIsNotHoldback) {
  // Should be unset by default.
  EXPECT_EQ(GetTimeOfFirstTourAttempt(pref_service()), std::nullopt);

  // Should be unset by default.
  EXPECT_EQ(GetReasonForFirstTourPrevention(pref_service()), std::nullopt);
  EXPECT_EQ(GetTimeOfFirstTourPrevention(pref_service()), std::nullopt);

  // The first time the mark method is called, it should succeed and mark the
  // time as now and the given reason as the reason.
  EXPECT_TRUE(MarkFirstTourPrevention(pref_service(),
                                      PreventedReason::kUserTypeNotRegular));
  EXPECT_EQ(GetReasonForFirstTourPrevention(pref_service()),
            PreventedReason::kUserTypeNotRegular);

  auto attempt_time = GetTimeOfFirstTourAttempt(pref_service());

  // Only prevention reason of holdback will return the prevention time as the
  // attempt time.
  ASSERT_FALSE(attempt_time);
}

// Expects the first tour attempt time is the prevention time if the prevention
// reason is holdback.
TEST_F(WelcomeTourPrefsTest, FirstTourAttemptWhenPreventionIsHoldback) {
  // Should be unset by default.
  EXPECT_EQ(GetTimeOfFirstTourAttempt(pref_service()), std::nullopt);

  // Should be unset by default.
  EXPECT_EQ(GetReasonForFirstTourPrevention(pref_service()), std::nullopt);
  EXPECT_EQ(GetTimeOfFirstTourPrevention(pref_service()), std::nullopt);

  // The first time the mark method is called, it should succeed and mark the
  // time as now and the given reason as the reason.
  auto before = base::Time::Now();
  EXPECT_TRUE(MarkFirstTourPrevention(pref_service(),
                                      PreventedReason::kHoldbackExperimentArm));
  auto after = base::Time::Now();

  EXPECT_EQ(GetReasonForFirstTourPrevention(pref_service()),
            PreventedReason::kHoldbackExperimentArm);

  // Prevention reason of holdback will return the prevention time as the
  // attempt time.
  auto attempt_time = GetTimeOfFirstTourAttempt(pref_service());
  ASSERT_TRUE(attempt_time);
  EXPECT_GE(attempt_time, before);
  EXPECT_LE(attempt_time, after);
}

// Expects the first tour completion time pref can be set exactly once.
TEST_F(WelcomeTourPrefsTest, FirstTourCompletion) {
  // Should be unset by default.
  EXPECT_EQ(GetTimeOfFirstTourCompletion(pref_service()), std::nullopt);

  // The first time the mark method is called, it should succeed and mark the
  // time as now.
  auto before = base::Time::Now();
  EXPECT_TRUE(MarkTimeOfFirstTourCompletion(pref_service()));
  auto after = base::Time::Now();

  auto completion_time = GetTimeOfFirstTourCompletion(pref_service());
  ASSERT_TRUE(completion_time);
  EXPECT_GE(completion_time, before);
  EXPECT_LE(completion_time, after);

  // For any call beyond the first, the function should return false and the
  // marked time should not change.
  EXPECT_FALSE(MarkTimeOfFirstTourCompletion(pref_service()));
  EXPECT_EQ(GetTimeOfFirstTourCompletion(pref_service()), completion_time);
}

// Expects the first tour prevention time pref and reason pref can be set
// exactly once.
TEST_F(WelcomeTourPrefsTest, FirstTourPrevention) {
  // Should be unset by default.
  EXPECT_EQ(GetReasonForFirstTourPrevention(pref_service()), std::nullopt);
  EXPECT_EQ(GetTimeOfFirstTourPrevention(pref_service()), std::nullopt);

  // The first time the mark method is called, it should succeed and mark the
  // time as now and the given reason as the reason.
  auto before = base::Time::Now();
  EXPECT_TRUE(
      MarkFirstTourPrevention(pref_service(), PreventedReason::kMaxValue));
  auto after = base::Time::Now();

  EXPECT_EQ(GetReasonForFirstTourPrevention(pref_service()),
            PreventedReason::kMaxValue);

  auto prevention_time = GetTimeOfFirstTourPrevention(pref_service());
  ASSERT_TRUE(prevention_time);
  EXPECT_GE(prevention_time, before);
  EXPECT_LE(prevention_time, after);

  // For any call beyond the first, the function should return false and the
  // marked time and reason should not change.
  EXPECT_FALSE(MarkFirstTourPrevention(pref_service(),
                                       PreventedReason::kChromeVoxEnabled));
  EXPECT_EQ(GetReasonForFirstTourPrevention(pref_service()),
            PreventedReason::kMaxValue);
  EXPECT_EQ(GetTimeOfFirstTourPrevention(pref_service()), prevention_time);
}

// Expects that setting and fetching the reason for first tour prevention will
// work for all valid values, and handle invalid ones properly.
TEST_F(WelcomeTourPrefsTest, ReasonForFirstTourPrevention) {
  // The reason should by default be absent.
  EXPECT_EQ(GetReasonForFirstTourPrevention(pref_service()), std::nullopt);

  // Expect that all valid values for `PreventedReason` can be set and fetched.
  for (auto reason : kAllPreventedReasonsSet) {
    MarkFirstTourPrevention(pref_service(), reason);
    EXPECT_EQ(GetReasonForFirstTourPrevention(pref_service()), reason);

    // Clear the time pref for the next loop. `MarkFirstTourPrevention()` would
    // exit early otherwise.
    pref_service()->ClearPref(kTimeOfFirstTourPrevention);
  }

  // For any values that are out of bounds of the enum, it should default to
  // `PreventedReason::kUnknown`.
  pref_service()->SetUserPref(
      kReasonForFirstTourPrevention,
      base::Value(static_cast<int>(PreventedReason::kMaxValue) + 1));
  EXPECT_EQ(GetReasonForFirstTourPrevention(pref_service()),
            PreventedReason::kUnknown);
}

}  // namespace ash::welcome_tour_prefs