// Copyright 2018 The Fuchsia 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 "logger/logger.h"

#include <google/protobuf/text_format.h>
#include <google/protobuf/util/message_differencer.h>

#include <chrono>
#include <memory>
#include <string>

#include "./gtest.h"
#include "./observation.pb.h"
#include "./observation2.pb.h"
#include "algorithms/rappor/rappor_encoder.h"
#include "config/encodings.pb.h"
#include "encoder/client_secret.h"
#include "encoder/encoder.h"
#include "logger/encoder.h"
#include "logger/event_aggregator.h"
#include "logger/logger_test_utils.h"
#include "logger/project_context.h"
#include "logger/status.h"
#include "util/clock.h"
#include "util/datetime_util.h"
#include "util/encrypted_message_util.h"

using ::google::protobuf::RepeatedPtrField;
using ::google::protobuf::util::MessageDifferencer;

namespace cobalt {

using encoder::ClientSecret;
using encoder::SystemDataInterface;
using rappor::BasicRapporEncoder;
using util::EncryptedMessageMaker;
using util::IncrementingClock;
using util::MessageDecrypter;
using util::TimeToDayIndex;

namespace logger {

using testing::CheckNumericEventObservations;
using testing::CheckUniqueActivesObservations;
using testing::ExpectedAggregationParams;
using testing::ExpectedUniqueActivesObservations;
using testing::FakeObservationStore;
using testing::FetchAggregatedObservations;
using testing::FetchObservations;
using testing::FetchSingleObservation;
using testing::MakeNullExpectedUniqueActivesObservations;
using testing::MockConsistentProtoStore;
using testing::PopulateMetricDefinitions;
using testing::TestUpdateRecipient;

namespace {
// Number of seconds in an ideal year
const int kYear = kDay * 365;

static const uint32_t kCustomerId = 1;
static const uint32_t kProjectId = 1;
static const char kCustomerName[] = "Fuchsia";
static const char kProjectName[] = "Cobalt";

// Filenames for constructors of ConsistentProtoStores
static const char kAggregateStoreFilename[] = "local_aggregate_store_backup";
static const char kObsHistoryFilename[] = "obs_history_backup";

// Metric IDs
const uint32_t kErrorOccurredMetricId = 1;
const uint32_t kReadCacheHitsMetricId = 2;
const uint32_t kModuleLoadTimeMetricId = 3;
const uint32_t kLoginModuleFrameRateMetricId = 4;
const uint32_t kLedgerMemoryUsageMetricId = 5;
const uint32_t kFileSystemWriteTimesMetricId = 6;
const uint32_t kModuleDownloadsMetricId = 7;
const uint32_t kModuleInstallsMetricId = 8;
const uint32_t kDeviceBootsMetricId = 9;
const uint32_t kFeaturesActiveMetricId = 10;
const uint32_t kEventsOccurredMetricId = 11;

// MetricReportIds
const MetricReportId kDeviceBoots_UniqueDevicesMetricReportId =
    MetricReportId(kDeviceBootsMetricId, 91);
const MetricReportId kFeaturesActive_UniqueDevicesMetricReportId =
    MetricReportId(kFeaturesActiveMetricId, 201);
const MetricReportId kEventsOccurred_SimpleOccurrenceCountMetricReportId =
    MetricReportId(kEventsOccurredMetricId, 301);
const MetricReportId kEventsOccurred_UniqueDevicesMetricReportId =
    MetricReportId(kEventsOccurredMetricId, 401);

static const char kMetricDefinitions[] = R"(
metric {
  metric_name: "ErrorOccurred"
  metric_type: EVENT_OCCURRED
  customer_id: 1
  project_id: 1
  id: 1
  max_event_code: 100
  reports: {
    report_name: "ErrorCountsByCode"
    id: 123
    report_type: SIMPLE_OCCURRENCE_COUNT
    local_privacy_noise_level: SMALL
  }
}

metric {
  metric_name: "ReadCacheHits"
  metric_type: EVENT_COUNT
  customer_id: 1
  project_id: 1
  id: 2
  reports: {
    report_name: "ReadCacheHitCounts"
    id: 111
    report_type: EVENT_COMPONENT_OCCURRENCE_COUNT
  }
}

metric {
  metric_name: "ModuleLoadTime"
  metric_type: ELAPSED_TIME
  customer_id: 1
  project_id: 1
  id: 3
  reports: {
    report_name: "ModuleLoadTime_Aggregated"
    id: 121
    report_type: NUMERIC_AGGREGATION
  }
  reports: {
    report_name: "ModuleLoadTime_Histogram"
    id: 221
    report_type: INT_RANGE_HISTOGRAM
  }
  reports: {
    report_name: "ModuleLoadTime_RawDump"
    id: 321
    report_type: NUMERIC_PERF_RAW_DUMP
  }
}

metric {
  metric_name: "LoginModuleFrameRate"
  metric_type: FRAME_RATE
  customer_id: 1
  project_id: 1
  id: 4
  reports: {
    report_name: "LoginModuleFrameRate_Aggregated"
    id: 131
    report_type: NUMERIC_AGGREGATION
  }
  reports: {
    report_name: "LoginModuleFrameRate_Histogram"
    id: 231
    report_type: INT_RANGE_HISTOGRAM
  }
  reports: {
    report_name: "LoginModuleFrameRate_RawDump"
    id: 331
    report_type: NUMERIC_PERF_RAW_DUMP
  }
}

metric {
  metric_name: "LedgerMemoryUsage"
  metric_type: MEMORY_USAGE
  customer_id: 1
  project_id: 1
  id: 5
  reports: {
    report_name: "LedgerMemoryUsage_Aggregated"
    id: 141
    report_type: NUMERIC_AGGREGATION
  }
  reports: {
    report_name: "LedgerMemoryUsage_Histogram"
    id: 241
    report_type: INT_RANGE_HISTOGRAM
  }
}

metric {
  metric_name: "FileSystemWriteTimes"
  metric_type: INT_HISTOGRAM
  int_buckets: {
    linear: {
      floor: 0
      num_buckets: 10
      step_size: 1
    }
  }
  customer_id: 1
  project_id: 1
  id: 6
  reports: {
    report_name: "FileSystemWriteTimes_Histogram"
    id: 151
    report_type: INT_RANGE_HISTOGRAM
  }
}

metric {
  metric_name: "ModuleDownloads"
  metric_type: STRING_USED
  customer_id: 1
  project_id: 1
  id: 7
  reports: {
    report_name: "ModuleDownloads_HeavyHitters"
    id: 161
    report_type: HIGH_FREQUENCY_STRING_COUNTS
    local_privacy_noise_level: SMALL
    expected_population_size: 20000
    expected_string_set_size: 10000
  }
  reports: {
    report_name: "ModuleDownloads_WithThreshold"
    id: 261
    report_type: STRING_COUNTS_WITH_THRESHOLD
    threshold: 200
  }
}

metric {
  metric_name: "ModuleInstalls"
  metric_type: CUSTOM
  customer_id: 1
  project_id: 1
  id: 8
  reports: {
    report_name: "ModuleInstalls_DetailedData"
    id: 125
    report_type: CUSTOM_RAW_DUMP
  }
}

metric {
  metric_name: "DeviceBoots"
  metric_type: EVENT_OCCURRED
  customer_id: 1
  project_id: 1
  id: 9
  max_event_code: 1
  reports: {
    report_name: "DeviceBoots_UniqueDevices"
    id: 91
    report_type: UNIQUE_N_DAY_ACTIVES
    local_privacy_noise_level: SMALL
    window_size: 1
  }
}

metric {
  metric_name: "FeaturesActive"
  metric_type: EVENT_OCCURRED
  customer_id: 1
  project_id: 1
  id: 10
  max_event_code: 4
  reports: {
    report_name: "FeaturesActive_UniqueDevices"
    id: 201
    report_type: UNIQUE_N_DAY_ACTIVES
    local_privacy_noise_level: LARGE
    window_size: 1
    window_size: 7
    window_size: 30
  }
}

metric {
  metric_name: "EventsOccurred"
  metric_type: EVENT_OCCURRED
  customer_id: 1
  project_id: 1
  id: 11
  max_event_code: 4
  reports: {
    report_name: "SomeEventsOccurred_SimpleCount"
    id: 301
    report_type: SIMPLE_OCCURRENCE_COUNT
    local_privacy_noise_level: MEDIUM
  }
  reports: {
    report_name: "EventsOccurred_UniqueDevices"
    id: 401
    report_type: UNIQUE_N_DAY_ACTIVES
    local_privacy_noise_level: MEDIUM
    window_size: 1
    window_size: 7
  }
}

)";

// Expected parameters of the locally aggregated reports in
// |kMetricDefinitions|.
static const ExpectedAggregationParams kExpectedAggregationParams = {
    /* The total number of locally aggregated Observations which should be
       generated for each day index. */
    27,
    /* The MetricReportIds of the locally aggregated reports in this
configuration. */
    {kDeviceBoots_UniqueDevicesMetricReportId,
     kFeaturesActive_UniqueDevicesMetricReportId,
     kEventsOccurred_UniqueDevicesMetricReportId},
    /* The number of Observations which should be generated for each day
       index, broken down by MetricReportId. */
    {{kDeviceBoots_UniqueDevicesMetricReportId, 2},
     {kFeaturesActive_UniqueDevicesMetricReportId, 15},
     {kEventsOccurred_UniqueDevicesMetricReportId, 10}},
    /* The number of event codes for each MetricReportId. */
    {{kDeviceBoots_UniqueDevicesMetricReportId, 2},
     {kFeaturesActive_UniqueDevicesMetricReportId, 5},
     {kEventsOccurred_UniqueDevicesMetricReportId, 5}},
    /* The set of window sizes for each MetricReportId. */
    {{kDeviceBoots_UniqueDevicesMetricReportId, {1}},
     {kFeaturesActive_UniqueDevicesMetricReportId, {1, 7, 30}},
     {kEventsOccurred_UniqueDevicesMetricReportId, {1, 7}}}};

// A set of MetricDefinitions of type EVENT_OCCURRED, each of which has a
// UNIQUE_N_DAY_ACTIVES report with local_privacy_noise_level set to NONE.
static const char kNoiseFreeUniqueActivesMetricDefinitions[] = R"(
metric {
  metric_name: "DeviceBoots"
  metric_type: EVENT_OCCURRED
  customer_id: 1
  project_id: 1
  id: 9
  max_event_code: 1
  reports: {
    report_name: "DeviceBoots_UniqueDevices"
    id: 91
    report_type: UNIQUE_N_DAY_ACTIVES
    local_privacy_noise_level: NONE
    window_size: 1
  }
}

metric {
  metric_name: "FeaturesActive"
  metric_type: EVENT_OCCURRED
  customer_id: 1
  project_id: 1
  id: 10
  max_event_code: 4
  reports: {
    report_name: "SomeFeaturesActive_UniqueDevices"
    id: 201
    report_type: UNIQUE_N_DAY_ACTIVES
    local_privacy_noise_level: NONE
    window_size: 1
    window_size: 7
    window_size: 30
  }
}

metric {
  metric_name: "EventsOccurred"
  metric_type: EVENT_OCCURRED
  customer_id: 1
  project_id: 1
  id: 11
  max_event_code: 4
  reports: {
    report_name: "SomeEventsOccurred_SimpleCount"
    id: 301
    report_type: SIMPLE_OCCURRENCE_COUNT
    local_privacy_noise_level: NONE
  }
  reports: {
    report_name: "SomeEventsOccurred_UniqueDevices"
    id: 401
    report_type: UNIQUE_N_DAY_ACTIVES
    local_privacy_noise_level: NONE
    window_size: 1
    window_size: 7
  }
}

)";

// Expected parameters of the locally aggregated reports in
// |kNoiseFreeUniqueActivesMetricDefinitions|.
static const ExpectedAggregationParams
    kNoiseFreeUniqueActivesExpectedAggregationParams = {
        /* The total number of locally aggregated Observations which should be
            generated for each day index. */
        27,
        /* The MetricReportIds of the locally aggregated reports in this
    configuration. */
        {kDeviceBoots_UniqueDevicesMetricReportId,
         kFeaturesActive_UniqueDevicesMetricReportId,
         kEventsOccurred_UniqueDevicesMetricReportId},
        /* The number of Observations which should be generated for each day
           index, broken down by MetricReportId. */
        {{kDeviceBoots_UniqueDevicesMetricReportId, 2},
         {kFeaturesActive_UniqueDevicesMetricReportId, 15},
         {kEventsOccurred_UniqueDevicesMetricReportId, 10}},
        /* The number of event codes for each MetricReportId. */
        {{kDeviceBoots_UniqueDevicesMetricReportId, 2},
         {kFeaturesActive_UniqueDevicesMetricReportId, 5},
         {kEventsOccurred_UniqueDevicesMetricReportId, 5}},
        /* The set of window sizes for each MetricReportId. */
        {{kDeviceBoots_UniqueDevicesMetricReportId, {1}},
         {kFeaturesActive_UniqueDevicesMetricReportId, {1, 7, 30}},
         {kEventsOccurred_UniqueDevicesMetricReportId, {1, 7}}}};

HistogramPtr NewHistogram(std::vector<uint32_t> indices,
                          std::vector<uint32_t> counts) {
  CHECK(indices.size() == counts.size());
  HistogramPtr histogram =
      std::make_unique<RepeatedPtrField<HistogramBucket>>();
  for (auto i = 0u; i < indices.size(); i++) {
    auto* bucket = histogram->Add();
    bucket->set_index(indices[i]);
    bucket->set_count(counts[i]);
  }
  return histogram;
}

EventValuesPtr NewCustomEvent(std::vector<std::string> dimension_names,
                              std::vector<CustomDimensionValue> values) {
  CHECK(dimension_names.size() == values.size());
  EventValuesPtr custom_event = std::make_unique<
      google::protobuf::Map<std::string, CustomDimensionValue>>();
  for (auto i = 0u; i < values.size(); i++) {
    (*custom_event)[dimension_names[i]] = values[i];
  }
  return custom_event;
}

}  // namespace

class LoggerTest : public ::testing::Test {
 protected:
  void SetUp() {
    SetUpFromMetrics(kMetricDefinitions, kExpectedAggregationParams);
  }

  // Set up LoggerTest using serialized MetricDefinitions.
  void SetUpFromMetrics(
      const char metric_string[],
      const ExpectedAggregationParams expected_aggregation_params) {
    auto metric_definitions = std::make_unique<MetricDefinitions>();
    ASSERT_TRUE(
        PopulateMetricDefinitions(metric_string, metric_definitions.get()));
    expected_aggregation_params_ = expected_aggregation_params;
    project_context_.reset(new ProjectContext(kCustomerId, kProjectId,
                                              kCustomerName, kProjectName,
                                              std::move(metric_definitions)));
    observation_store_.reset(new FakeObservationStore);
    update_recipient_.reset(new TestUpdateRecipient);
    observation_encrypter_.reset(
        new EncryptedMessageMaker("", EncryptedMessage::NONE));
    observation_writer_.reset(
        new ObservationWriter(observation_store_.get(), update_recipient_.get(),
                              observation_encrypter_.get()));
    encoder_.reset(
        new Encoder(ClientSecret::GenerateNewSecret(), system_data_.get()));
    local_aggregate_proto_store_.reset(
        new MockConsistentProtoStore(kAggregateStoreFilename));
    obs_history_proto_store_.reset(
        new MockConsistentProtoStore(kObsHistoryFilename));
    event_aggregator_.reset(new EventAggregator(
        encoder_.get(), observation_writer_.get(),
        local_aggregate_proto_store_.get(), obs_history_proto_store_.get()));
    logger_.reset(new Logger(encoder_.get(), event_aggregator_.get(),
                             observation_writer_.get(),
                             project_context_.get()));
    // Create a mock clock which does not increment by default when called.
    // Set the time to 1 year after the start of Unix time so that the start
    // date of any aggregation window falls after the start of time.
    mock_clock_ = new IncrementingClock(std::chrono::system_clock::duration(0));
    mock_clock_->set_time(
        std::chrono::system_clock::time_point(std::chrono::seconds(kYear)));
    logger_->SetClock(mock_clock_);
  }

  void TearDown() {
    event_aggregator_.reset();
    logger_.reset();
  }

  // Returns the day index of the current day according to |mock_clock_|, in
  // |time_zone|, without incrementing the clock.
  uint32_t CurrentDayIndex(MetricDefinition::TimeZonePolicy time_zone) {
    return TimeToDayIndex(
        std::chrono::system_clock::to_time_t(mock_clock_->peek_now()),
        time_zone);
  }

  // Advances |mock_clock_| by |num_days| days.
  void AdvanceDay(int num_days) {
    mock_clock_->increment_by(std::chrono::seconds(kDay) * num_days);
  }

  // Clears the FakeObservationStore and resets counts of Observations received
  // by the FakeObservationStore and the TestUpdateRecipient.
  void ResetObservationStore() {
    observation_store_->messages_received.clear();
    observation_store_->metadata_received.clear();
    observation_store_->ResetObservationCounter();
    update_recipient_->invocation_count = 0;
  }

  Status GenerateAggregatedObservations(uint32_t day_index) {
    return event_aggregator_->GenerateObservationsNoWorker(day_index);
  }

  Status GarbageCollectAggregateStore(uint32_t day_index) {
    return event_aggregator_->GarbageCollect(day_index);
  }

  std::unique_ptr<Logger> logger_;
  std::unique_ptr<Encoder> encoder_;
  std::unique_ptr<EventAggregator> event_aggregator_;
  std::unique_ptr<ObservationWriter> observation_writer_;
  std::unique_ptr<FakeObservationStore> observation_store_;
  std::unique_ptr<TestUpdateRecipient> update_recipient_;
  std::unique_ptr<EncryptedMessageMaker> observation_encrypter_;
  std::unique_ptr<ProjectContext> project_context_;
  std::unique_ptr<SystemDataInterface> system_data_;
  std::unique_ptr<MockConsistentProtoStore> local_aggregate_proto_store_;
  std::unique_ptr<MockConsistentProtoStore> obs_history_proto_store_;
  ExpectedAggregationParams expected_aggregation_params_;
  IncrementingClock* mock_clock_;
};

// Creates a Logger whose ProjectContext contains only EVENT_OCCURRED metrics,
// each of which has a report of type UNIQUE_N_DAY_ACTIVES with
// local_privacy_noise_level set to NONE. Used to test the values of
// UniqueActivesObservations generated by the EventAggregator.
class UniqueActivesLoggerTest : public LoggerTest {
 protected:
  void SetUp() {
    SetUpFromMetrics(kNoiseFreeUniqueActivesMetricDefinitions,
                     kNoiseFreeUniqueActivesExpectedAggregationParams);
  }
};

// Tests the method LogEvent().
TEST_F(LoggerTest, LogEvent) {
  ASSERT_EQ(kOK, logger_->LogEvent(kErrorOccurredMetricId, 42));
  Observation2 observation;
  uint32_t expected_report_id = 123;
  ASSERT_TRUE(FetchSingleObservation(&observation, expected_report_id,
                                     observation_store_.get(),
                                     update_recipient_.get()));
  ASSERT_TRUE(observation.has_basic_rappor());
  EXPECT_FALSE(observation.basic_rappor().data().empty());
}

// Tests the method LogEventCount().
TEST_F(LoggerTest, LogEventcount) {
  std::vector<uint32_t> expected_report_ids = {111};
  ASSERT_EQ(kOK, logger_->LogEventCount(kReadCacheHitsMetricId, 43,
                                        "component2", 1, 303));
  EXPECT_TRUE(CheckNumericEventObservations(
      expected_report_ids, 43u, "component2", 303, observation_store_.get(),
      update_recipient_.get()));
}

// Tests the method LogElapsedTime().
TEST_F(LoggerTest, LogElapsedTime) {
  std::vector<uint32_t> expected_report_ids = {121, 221, 321};
  ASSERT_EQ(kOK, logger_->LogElapsedTime(kModuleLoadTimeMetricId, 44,
                                         "component4", 4004));
  EXPECT_TRUE(CheckNumericEventObservations(
      expected_report_ids, 44u, "component4", 4004, observation_store_.get(),
      update_recipient_.get()));
}

// Tests the method LogFrameRate().
TEST_F(LoggerTest, LogFrameRate) {
  std::vector<uint32_t> expected_report_ids = {131, 231, 331};
  ASSERT_EQ(kOK, logger_->LogFrameRate(kLoginModuleFrameRateMetricId, 45,
                                       "component5", 5.123));
  EXPECT_TRUE(CheckNumericEventObservations(
      expected_report_ids, 45u, "component5", 5123, observation_store_.get(),
      update_recipient_.get()));
}

// Tests the method LogMemoryUsage().
TEST_F(LoggerTest, LogMemoryUsage) {
  std::vector<uint32_t> expected_report_ids = {141, 241};
  ASSERT_EQ(kOK, logger_->LogMemoryUsage(kLedgerMemoryUsageMetricId, 46,
                                         "component6", 606));
  EXPECT_TRUE(CheckNumericEventObservations(
      expected_report_ids, 46u, "component6", 606, observation_store_.get(),
      update_recipient_.get()));
}

// Tests the method LogIntHistogram().
TEST_F(LoggerTest, LogIntHistogram) {
  std::vector<uint32_t> indices = {0, 1, 2, 3};
  std::vector<uint32_t> counts = {100, 101, 102, 103};
  auto histogram = NewHistogram(indices, counts);
  ASSERT_EQ(kOK, logger_->LogIntHistogram(kFileSystemWriteTimesMetricId, 47,
                                          "component7", std::move(histogram)));
  Observation2 observation;
  uint32_t expected_report_id = 151;
  ASSERT_TRUE(FetchSingleObservation(&observation, expected_report_id,
                                     observation_store_.get(),
                                     update_recipient_.get()));
  ASSERT_TRUE(observation.has_histogram());
  auto histogram_observation = observation.histogram();
  EXPECT_EQ(47u, histogram_observation.event_code());
  EXPECT_EQ(histogram_observation.component_name_hash().size(), 32u);
  EXPECT_EQ(static_cast<size_t>(histogram_observation.buckets_size()),
            indices.size());
  for (auto i = 0u; i < indices.size(); i++) {
    const auto& bucket = histogram_observation.buckets(i);
    EXPECT_EQ(bucket.index(), indices[i]);
    EXPECT_EQ(bucket.count(), counts[i]);
  }
}

// Tests the method LogString().
TEST_F(LoggerTest, LogString) {
  ASSERT_EQ(kOK,
            logger_->LogString(kModuleDownloadsMetricId, "www.mymodule.com"));
  std::vector<Observation2> observations(2);
  std::vector<uint32_t> expected_report_ids = {161, 261};
  ASSERT_TRUE(FetchObservations(&observations, expected_report_ids,
                                observation_store_.get(),
                                update_recipient_.get()));

  ASSERT_TRUE(observations[0].has_string_rappor());
  EXPECT_FALSE(observations[0].string_rappor().data().empty());

  ASSERT_TRUE(observations[1].has_forculus());
  EXPECT_FALSE(observations[1].forculus().ciphertext().empty());
}

// Tests the method LogCustomEvent().
TEST_F(LoggerTest, LogCustomEvent) {
  CustomDimensionValue module_value, number_value;
  module_value.set_string_value("gmail");
  number_value.set_int_value(3);
  std::vector<std::string> dimension_names = {"module", "number"};
  std::vector<CustomDimensionValue> values = {module_value, number_value};
  auto custom_event = NewCustomEvent(dimension_names, values);
  ASSERT_EQ(kOK, logger_->LogCustomEvent(kModuleInstallsMetricId,
                                         std::move(custom_event)));
  Observation2 observation;
  uint32_t expected_report_id = 125;
  ASSERT_TRUE(FetchSingleObservation(&observation, expected_report_id,
                                     observation_store_.get(),
                                     update_recipient_.get()));
  ASSERT_TRUE(observation.has_custom());
  const CustomObservation& custom_observation = observation.custom();
  for (auto i = 0u; i < values.size(); i++) {
    auto obs_dimension = custom_observation.values().at(dimension_names[i]);
    EXPECT_TRUE(MessageDifferencer::Equals(obs_dimension, values[i]));
  }
}

// Tests that the expected number of locally aggregated Observations are
// generated when no events have been logged.
TEST_F(LoggerTest, CheckNumAggregatedObsNoEvents) {
  ASSERT_EQ(kOK, GenerateAggregatedObservations(
                     CurrentDayIndex(MetricDefinition::UTC)));
  std::vector<Observation2> observations(0);
  EXPECT_TRUE(FetchAggregatedObservations(
      &observations, expected_aggregation_params_, observation_store_.get(),
      update_recipient_.get()));
}

// Tests that the expected number of locally aggregated Observations are
// generated when one Event has been logged for a locally aggregated report.
TEST_F(LoggerTest, CheckNumAggregatedObsOneEvent) {
  // Log 1 occurrence of event code 0 for the DeviceBoots metric, which has no
  // immediate reports.
  ASSERT_EQ(kOK, logger_->LogEvent(kDeviceBootsMetricId, 0));
  // Check that no immediate Observation was generated.
  std::vector<Observation2> immediate_observations(0);
  std::vector<uint32_t> expected_immediate_report_ids = {};
  ASSERT_TRUE(
      FetchObservations(&immediate_observations, expected_immediate_report_ids,
                        observation_store_.get(), update_recipient_.get()));
  // Generate locally aggregated observations for the current day index.
  ASSERT_EQ(kOK, GenerateAggregatedObservations(
                     CurrentDayIndex(MetricDefinition::UTC)));
  // Check that the expected numbers of aggregated observations were generated.
  std::vector<Observation2> aggregated_observations;
  EXPECT_TRUE(FetchAggregatedObservations(
      &aggregated_observations, expected_aggregation_params_,
      observation_store_.get(), update_recipient_.get()));
}

// Tests that the expected number of locally aggregated Observations are
// generated when multiple Events have been logged for locally aggregated
// reports.
TEST_F(LoggerTest, CheckNumAggregatedObsMultipleEvents) {
  // Log 2 occurrences of event code 0 for the DeviceBoots metric, which has 1
  // locally aggregated report and no immediate reports.
  ASSERT_EQ(kOK, logger_->LogEvent(kDeviceBootsMetricId, 0));
  ASSERT_EQ(kOK, logger_->LogEvent(kDeviceBootsMetricId, 0));
  // Log 2 occurrences of event codes for the FeaturesActive metric, which
  // has 1 locally aggregated report and no immediate reports.
  ASSERT_EQ(kOK, logger_->LogEvent(kFeaturesActiveMetricId, 0));
  ASSERT_EQ(kOK, logger_->LogEvent(kFeaturesActiveMetricId, 1));
  // Check that no immediate Observations were generated.
  std::vector<Observation2> immediate_observations(0);
  std::vector<uint32_t> expected_immediate_report_ids = {};
  ASSERT_TRUE(
      FetchObservations(&immediate_observations, expected_immediate_report_ids,
                        observation_store_.get(), update_recipient_.get()));
  // Generate locally aggregated observations for the current day index.
  ASSERT_EQ(kOK, GenerateAggregatedObservations(
                     CurrentDayIndex(MetricDefinition::UTC)));
  // Check that the expected numbers of aggregated observations were
  // generated.
  std::vector<Observation2> aggregated_observations;
  EXPECT_TRUE(FetchAggregatedObservations(
      &aggregated_observations, expected_aggregation_params_,
      observation_store_.get(), update_recipient_.get()));
}

// Tests that the expected number of locally aggregated Observations are
// generated when multiple Events have been logged for locally aggregated
// and immediate reports.
TEST_F(LoggerTest, CheckNumAggregatedObsImmediateAndAggregatedEvents) {
  // Log 3 occurrences of event codes for the EventsOccurred metric, which
  // has 1 locally aggregated report and 1 immediate report.
  ASSERT_EQ(kOK, logger_->LogEvent(kEventsOccurredMetricId, 0));
  ASSERT_EQ(kOK, logger_->LogEvent(kEventsOccurredMetricId, 0));
  ASSERT_EQ(kOK, logger_->LogEvent(kEventsOccurredMetricId, 2));
  // Check that each of the 3 logged events resulted in an immediate
  // Observation.
  std::vector<Observation2> immediate_observations(3);
  std::vector<uint32_t> expected_immediate_report_ids(
      3, kEventsOccurred_SimpleOccurrenceCountMetricReportId.second);
  ASSERT_TRUE(
      FetchObservations(&immediate_observations, expected_immediate_report_ids,
                        observation_store_.get(), update_recipient_.get()));
  // Clear the FakeObservationStore.
  ResetObservationStore();
  // Generate locally aggregated observations for the current day index.
  ASSERT_EQ(kOK, GenerateAggregatedObservations(
                     CurrentDayIndex(MetricDefinition::UTC)));
  // Check that the expected aggregated observations were generated.
  std::vector<Observation2> observations;
  EXPECT_TRUE(FetchAggregatedObservations(
      &observations, expected_aggregation_params_, observation_store_.get(),
      update_recipient_.get()));
}

// Tests that UniqueActivesObservations with the expected values are generated
// when no events have been logged.
TEST_F(UniqueActivesLoggerTest, CheckUniqueActivesObsValuesNoEvents) {
  auto current_day_index = CurrentDayIndex(MetricDefinition::UTC);
  // Generate locally aggregated Observations without logging any events.
  ASSERT_EQ(kOK, GenerateAggregatedObservations(current_day_index));
  // Check that all generated Observations are of non-activity.
  auto expected_obs = MakeNullExpectedUniqueActivesObservations(
      expected_aggregation_params_, current_day_index);
  EXPECT_TRUE(CheckUniqueActivesObservations(
      expected_obs, observation_store_.get(), update_recipient_.get()));
}

// Tests that UniqueActivesObservations with the expected values are generated
// when events have been logged for UNIQUE_N_DAY_ACTIVES reports on a single
// day.
TEST_F(UniqueActivesLoggerTest, CheckUniqueActivesObsValuesSingleDay) {
  auto current_day_index = CurrentDayIndex(MetricDefinition::UTC);
  // Log 2 occurrences of event code 0 for the DeviceBoots metric, which has 1
  // locally aggregated report and no immediate reports.
  ASSERT_EQ(kOK, logger_->LogEvent(kDeviceBootsMetricId, 0));
  ASSERT_EQ(kOK, logger_->LogEvent(kDeviceBootsMetricId, 0));
  // Log 2 occurrences of event codes for the SomeFeaturesActive metric, which
  // has 1 locally aggregated report and no immediate reports.
  ASSERT_EQ(kOK, logger_->LogEvent(kFeaturesActiveMetricId, 0));
  ASSERT_EQ(kOK, logger_->LogEvent(kFeaturesActiveMetricId, 1));
  // Generate locally aggregated observations for the current day index.
  ASSERT_EQ(kOK, GenerateAggregatedObservations(current_day_index));
  // Form the expected observations for the current day index.
  auto expected_obs = MakeNullExpectedUniqueActivesObservations(
      expected_aggregation_params_, current_day_index);
  expected_obs[{kDeviceBoots_UniqueDevicesMetricReportId, current_day_index}] =
      {{1, {true, false}}};
  expected_obs[{kFeaturesActive_UniqueDevicesMetricReportId,
                current_day_index}] = {{1, {true, true, false, false, false}},
                                       {7, {true, true, false, false, false}},
                                       {30, {true, true, false, false, false}}};
  // Check that the expected aggregated observations were generated.
  EXPECT_TRUE(CheckUniqueActivesObservations(
      expected_obs, observation_store_.get(), update_recipient_.get()));
}

// Tests that UniqueActivesObservations with the expected values are generated
// when events have been logged for a UniqueActives report over multiple days.
//
// Logs events for the EventsOccurred_UniqueDevices report (whose parent metric
// has max_event_code = 5, and whose report ID is 401) for 10 days, according to
// the following pattern:
//
// * Never log event code 0.
// * On the i-th day (0-indexed) of logging, log an event for event code k,
//   1 <= k < 5, if 3*k divides i.
//
// Each day following the first day, generates Observations for the previous
// day index and checks them against the expected set of Observations, then
// garbage-collects the LocalAggregateStore for the current day index.
//
// The EventsOccurred_UniqueDevices report has window sizes 1 and 7, and
// the expected pattern of those Observations' values on the i-th day is:
//
// (i, window size)            active for event codes
// ------------------------------------------------------
// (0, 1)                           1, 2, 3, 4
// (0, 7)                           1, 2, 3, 4
// (1, 1)                          ---
// (1, 7)                           1, 2, 3, 4
// (2, 1)                          ---
// (2, 7)                           1, 2, 3, 4
// (3, 1)                           1
// (3, 7)                           1, 2, 3, 4
// (4, 1)                          ---
// (4, 7)                           1, 2, 3, 4
// (5, 1)                          ---
// (5, 7)                           1, 2, 3, 4
// (6, 1)                           1, 2
// (6, 7)                           1, 2, 3, 4
// (7, 1)                          ---
// (7, 7)                           1, 2
// (8, 1)                          ---
// (8, 7)                           1, 2
// (9, 1)                           1, 3
// (9, 7)                           1, 2, 3
//
// All Observations for all other locally aggregated reports should be
// observations of non-occurrence.
TEST_F(UniqueActivesLoggerTest, CheckUniqueActivesObservationValues) {
  // Form expected Observations for the 10 days of logging.
  auto start_day_index = CurrentDayIndex(MetricDefinition::UTC);
  std::vector<ExpectedUniqueActivesObservations> expected_obs(10);
  for (uint32_t i = 0; i < expected_obs.size(); i++) {
    expected_obs[i] = MakeNullExpectedUniqueActivesObservations(
        expected_aggregation_params_, start_day_index + i);
  }
  expected_obs[0][{kEventsOccurred_UniqueDevicesMetricReportId,
                   start_day_index}] = {{1, {false, true, true, true, true}},
                                        {7, {false, true, true, true, true}}};
  expected_obs[1][{kEventsOccurred_UniqueDevicesMetricReportId,
                   start_day_index + 1}] = {
      {1, {false, false, false, false, false}},
      {7, {false, true, true, true, true}}};
  expected_obs[2][{kEventsOccurred_UniqueDevicesMetricReportId,
                   start_day_index + 2}] = {
      {1, {false, false, false, false, false}},
      {7, {false, true, true, true, true}}};
  expected_obs[3][{kEventsOccurred_UniqueDevicesMetricReportId,
                   start_day_index + 3}] = {
      {1, {false, true, false, false, false}},
      {7, {false, true, true, true, true}}};
  expected_obs[4][{kEventsOccurred_UniqueDevicesMetricReportId,
                   start_day_index + 4}] = {
      {1, {false, false, false, false, false}},
      {7, {false, true, true, true, true}}};
  expected_obs[5][{kEventsOccurred_UniqueDevicesMetricReportId,
                   start_day_index + 5}] = {
      {1, {false, false, false, false, false}},
      {7, {false, true, true, true, true}}};
  expected_obs[6][{kEventsOccurred_UniqueDevicesMetricReportId,
                   start_day_index + 6}] = {
      {1, {false, true, true, false, false}},
      {7, {false, true, true, true, true}}};
  expected_obs[7][{kEventsOccurred_UniqueDevicesMetricReportId,
                   start_day_index + 7}] = {
      {1, {false, false, false, false, false}},
      {7, {false, true, true, false, false}}};
  expected_obs[8][{kEventsOccurred_UniqueDevicesMetricReportId,
                   start_day_index + 8}] = {
      {1, {false, false, false, false, false}},
      {7, {false, true, true, false, false}}};
  expected_obs[9][{kEventsOccurred_UniqueDevicesMetricReportId,
                   start_day_index + 9}] = {
      {1, {false, true, false, true, false}},
      {7, {false, true, true, true, false}}};

  for (uint32_t i = 0; i < 10; i++) {
    if (i < 10) {
      for (uint32_t event_code = 1; event_code < 5; event_code++) {
        if (i % (3 * event_code) == 0) {
          ASSERT_EQ(kOK,
                    logger_->LogEvent(kEventsOccurredMetricId, event_code));
        }
      }
    }
    // Clear the FakeObservationStore.
    ResetObservationStore();
    // Advance the Logger's clock by 1 day.
    AdvanceDay(1);
    // Generate locally aggregated Observations for the previous day
    // index.
    ASSERT_EQ(kOK, GenerateAggregatedObservations(
                       CurrentDayIndex(MetricDefinition::UTC) - 1));
    // Check the generated Observations against the expectation.
    EXPECT_TRUE(CheckUniqueActivesObservations(
        expected_obs[i], observation_store_.get(), update_recipient_.get()));
    // Garbage-collect the LocalAggregateStore for the current day index.
    ASSERT_EQ(kOK, GarbageCollectAggregateStore(
                       CurrentDayIndex(MetricDefinition::UTC)));
  }
}

}  // namespace logger
}  // namespace cobalt