// Copyright 2022 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "feature_usage/feature_usage_metrics.h"

#include <base/logging.h>
#include <base/power_monitor/power_monitor.h>
#include <base/power_monitor/power_monitor_device_source.h>
#include <base/run_loop.h>
#include <base/test/task_environment.h>
#include <base/time/clock.h>
#include <base/time/time.h>
#include <gtest/gtest.h>
#include <metrics/metrics_library_mock.h>

namespace feature_usage {

namespace {

const char kTestFeature[] = "TestFeature";
const char kTestMetric[] = "ChromeOS.FeatureUsage.TestFeature";
const char kTestUsetimeMetric[] = "ChromeOS.FeatureUsage.TestFeature.Usetime";
constexpr base::TimeDelta kDefaultUseTime = base::Minutes(10);

}  // namespace

class FeatureUsageMetricsTest : public ::testing::Test,
                                public FeatureUsageMetrics::Delegate {
 public:
  FeatureUsageMetricsTest() {
    if (!base::PowerMonitor::IsInitialized()) {
      base::PowerMonitor::Initialize(
          std::make_unique<base::PowerMonitorDeviceSource>());
    }

    feature_usage_metrics_ = std::make_unique<FeatureUsageMetrics>(
        kTestFeature, this, env_.GetMockClock(), env_.GetMockTickClock());

    feature_usage_metrics_->SetMetricsLibraryForTesting(
        std::make_unique<MetricsLibraryMock>());
  }

  // FeatureUsageMetrics::Delegate:
  bool IsEligible() const override { return is_eligible_; }
  std::optional<bool> IsAccessible() const override { return is_accessible_; }
  bool IsEnabled() const override { return is_enabled_; }

 protected:
  base::test::TaskEnvironment env_{
      base::test::TaskEnvironment::TimeSource::MOCK_TIME};

  bool is_eligible_ = true;
  std::optional<bool> is_accessible_;
  bool is_enabled_ = true;

  MetricsLibraryMock* GetMetricsLibraryMock() {
    return static_cast<MetricsLibraryMock*>(
        feature_usage_metrics_->metrics_library_for_testing());
  }

  std::unique_ptr<FeatureUsageMetrics> feature_usage_metrics_;
};

TEST_F(FeatureUsageMetricsTest, RecordUsageWithSuccess) {
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric, static_cast<int>(FeatureUsageMetrics::Event::kEligible),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1));
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric, static_cast<int>(FeatureUsageMetrics::Event::kEnabled),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1));
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric,
          static_cast<int>(FeatureUsageMetrics::Event::kUsedWithSuccess),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1));
  feature_usage_metrics_->RecordUsage(/*success=*/true);
}

TEST_F(FeatureUsageMetricsTest, RecordUsageWithFailure) {
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric, static_cast<int>(FeatureUsageMetrics::Event::kEligible),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1));
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric, static_cast<int>(FeatureUsageMetrics::Event::kEnabled),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1));
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric,
          static_cast<int>(FeatureUsageMetrics::Event::kUsedWithFailure),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1));
  feature_usage_metrics_->RecordUsage(/*success=*/false);
}

TEST_F(FeatureUsageMetricsTest, RecordUsetime) {
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric, static_cast<int>(FeatureUsageMetrics::Event::kEligible),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1));
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric, static_cast<int>(FeatureUsageMetrics::Event::kEnabled),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1));
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric,
          static_cast<int>(FeatureUsageMetrics::Event::kUsedWithSuccess),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1));
  EXPECT_CALL(*GetMetricsLibraryMock(),
              SendToUMA(kTestUsetimeMetric, kDefaultUseTime.InMilliseconds(),
                        base::Milliseconds(1).InMilliseconds(),
                        base::Hours(1).InMilliseconds(), 100));
  feature_usage_metrics_->RecordUsage(/*success=*/true);
  feature_usage_metrics_->StartSuccessfulUsage();
  env_.FastForwardBy(kDefaultUseTime);
  feature_usage_metrics_->StopSuccessfulUsage();
}

TEST_F(FeatureUsageMetricsTest, RecordLongUsetime) {
  size_t repeated_periods = 4;
  const base::TimeDelta extra_small_use_time = base::Minutes(3);
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric, static_cast<int>(FeatureUsageMetrics::Event::kEligible),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1))
      .Times(repeated_periods + 1);
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric, static_cast<int>(FeatureUsageMetrics::Event::kEnabled),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1))
      .Times(repeated_periods + 1);
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric,
          static_cast<int>(FeatureUsageMetrics::Event::kUsedWithSuccess),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1));
  EXPECT_CALL(*GetMetricsLibraryMock(),
              SendToUMA(kTestUsetimeMetric,
                        FeatureUsageMetrics::kRepeatedInterval.InMilliseconds(),
                        base::Milliseconds(1).InMilliseconds(),
                        base::Hours(1).InMilliseconds(), 100))
      .Times(repeated_periods);
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendToUMA(kTestUsetimeMetric, extra_small_use_time.InMilliseconds(),
                base::Milliseconds(1).InMilliseconds(),
                base::Hours(1).InMilliseconds(), 100));
  const base::TimeDelta use_time =
      FeatureUsageMetrics::kRepeatedInterval * repeated_periods +
      extra_small_use_time;

  feature_usage_metrics_->RecordUsage(/*success=*/true);
  feature_usage_metrics_->StartSuccessfulUsage();
  env_.FastForwardBy(use_time);
  feature_usage_metrics_->StopSuccessfulUsage();
}

TEST_F(FeatureUsageMetricsTest, PeriodicMetricsTest) {
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric, static_cast<int>(FeatureUsageMetrics::Event::kEligible),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1))
      .Times(2);
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric, static_cast<int>(FeatureUsageMetrics::Event::kEnabled),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1));

  // Trigger initial periodic metrics report.
  env_.FastForwardBy(FeatureUsageMetrics::kInitialInterval);

  is_enabled_ = false;
  // Trigger repeated periodic metrics report.
  env_.FastForwardBy(FeatureUsageMetrics::kRepeatedInterval);

  is_eligible_ = false;
  // Trigger repeated periodic metrics report.
  env_.FastForwardBy(FeatureUsageMetrics::kRepeatedInterval);
}

TEST_F(FeatureUsageMetricsTest, PeriodicWithAccessibleMetricsTest) {
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric, static_cast<int>(FeatureUsageMetrics::Event::kEligible),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1))
      .Times(3);
  EXPECT_CALL(*GetMetricsLibraryMock(),
              SendEnumToUMA(
                  kTestMetric,
                  static_cast<int>(FeatureUsageMetrics::Event::kAccessible),
                  static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1))
      .Times(2);
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric, static_cast<int>(FeatureUsageMetrics::Event::kEnabled),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1));
  is_accessible_ = true;
  // Trigger initial periodic metrics report.
  env_.FastForwardBy(FeatureUsageMetrics::kInitialInterval);

  is_enabled_ = false;
  // Trigger repeated periodic metrics report.
  env_.FastForwardBy(FeatureUsageMetrics::kRepeatedInterval);

  is_accessible_ = false;
  // Trigger repeated periodic metrics report.
  env_.FastForwardBy(FeatureUsageMetrics::kRepeatedInterval);

  is_eligible_ = false;
  // Trigger repeated periodic metrics report.
  env_.FastForwardBy(FeatureUsageMetrics::kRepeatedInterval);
}

TEST_F(FeatureUsageMetricsTest, ReportUseTimeOnShutdown) {
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric, static_cast<int>(FeatureUsageMetrics::Event::kEligible),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1));
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric, static_cast<int>(FeatureUsageMetrics::Event::kEnabled),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1));
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric,
          static_cast<int>(FeatureUsageMetrics::Event::kUsedWithSuccess),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1));
  EXPECT_CALL(*GetMetricsLibraryMock(),
              SendToUMA(kTestUsetimeMetric, kDefaultUseTime.InMilliseconds(),
                        base::Milliseconds(1).InMilliseconds(),
                        base::Hours(1).InMilliseconds(), 100));
  feature_usage_metrics_->RecordUsage(/*success=*/true);
  feature_usage_metrics_->StartSuccessfulUsage();
  env_.FastForwardBy(kDefaultUseTime);
  feature_usage_metrics_.reset();
}

TEST_F(FeatureUsageMetricsTest, ReportPeriodicOnSuspend) {
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric, static_cast<int>(FeatureUsageMetrics::Event::kEligible),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1));
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric, static_cast<int>(FeatureUsageMetrics::Event::kEnabled),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1));
  base::PowerMonitorDeviceSource::HandleSystemSuspending();
  base::RunLoop().RunUntilIdle();

  // Undo global changes.
  base::PowerMonitorDeviceSource::HandleSystemResumed();
}

TEST_F(FeatureUsageMetricsTest, ReportUseTimeOnSuspend) {
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric, static_cast<int>(FeatureUsageMetrics::Event::kEligible),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1))
      .Times(2);
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric, static_cast<int>(FeatureUsageMetrics::Event::kEnabled),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1))
      .Times(2);
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric,
          static_cast<int>(FeatureUsageMetrics::Event::kUsedWithSuccess),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1));
  EXPECT_CALL(*GetMetricsLibraryMock(),
              SendToUMA(kTestUsetimeMetric, kDefaultUseTime.InMilliseconds(),
                        base::Milliseconds(1).InMilliseconds(),
                        base::Hours(1).InMilliseconds(), 100));
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendToUMA(kTestUsetimeMetric, 0, base::Milliseconds(1).InMilliseconds(),
                base::Hours(1).InMilliseconds(), 100));
  feature_usage_metrics_->RecordUsage(/*success=*/true);
  feature_usage_metrics_->StartSuccessfulUsage();
  env_.FastForwardBy(kDefaultUseTime);

  base::PowerMonitorDeviceSource::HandleSystemSuspending();
  base::RunLoop().RunUntilIdle();

  // Undo global changes.
  base::PowerMonitorDeviceSource::HandleSystemResumed();
}

TEST_F(FeatureUsageMetricsTest, SuspensionTimeNotReported) {
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric, static_cast<int>(FeatureUsageMetrics::Event::kEligible),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1))
      .Times(3);
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric, static_cast<int>(FeatureUsageMetrics::Event::kEnabled),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1))
      .Times(3);
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendEnumToUMA(
          kTestMetric,
          static_cast<int>(FeatureUsageMetrics::Event::kUsedWithSuccess),
          static_cast<int>(FeatureUsageMetrics::Event::kMaxValue) + 1));
  EXPECT_CALL(*GetMetricsLibraryMock(),
              SendToUMA(kTestUsetimeMetric, kDefaultUseTime.InMilliseconds(),
                        base::Milliseconds(1).InMilliseconds(),
                        base::Hours(1).InMilliseconds(), 100));
  EXPECT_CALL(*GetMetricsLibraryMock(),
              SendToUMA(kTestUsetimeMetric,
                        FeatureUsageMetrics::kInitialInterval.InMilliseconds(),
                        base::Milliseconds(1).InMilliseconds(),
                        base::Hours(1).InMilliseconds(), 100));
  EXPECT_CALL(
      *GetMetricsLibraryMock(),
      SendToUMA(kTestUsetimeMetric,
                kDefaultUseTime.InMilliseconds() -
                    FeatureUsageMetrics::kInitialInterval.InMilliseconds(),
                base::Milliseconds(1).InMilliseconds(),
                base::Hours(1).InMilliseconds(), 100));
  feature_usage_metrics_->RecordUsage(/*success=*/true);
  feature_usage_metrics_->StartSuccessfulUsage();
  env_.FastForwardBy(kDefaultUseTime);
  base::PowerMonitorDeviceSource::HandleSystemSuspending();
  base::RunLoop().RunUntilIdle();

  // Time during suspension must not be reported.
  env_.AdvanceClock(FeatureUsageMetrics::kRepeatedInterval * 1.33);

  base::PowerMonitorDeviceSource::HandleSystemResumed();
  base::RunLoop().RunUntilIdle();

  env_.FastForwardBy(kDefaultUseTime);
  feature_usage_metrics_->StopSuccessfulUsage();
}

}  // namespace feature_usage