// 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/event_aggregator.h"

#include <google/protobuf/text_format.h>
#include <google/protobuf/util/message_differencer.h>
#include <map>
#include <memory>
#include <set>
#include <utility>
#include <vector>

#include "./event.pb.h"
#include "./gtest.h"
#include "logger/logger_test_utils.h"
#include "util/proto_util.h"

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

namespace cobalt {

using encoder::ClientSecret;
using encoder::ObservationStoreUpdateRecipient;
using encoder::ObservationStoreWriterInterface;
using encoder::SystemDataInterface;
using util::EncryptedMessageMaker;
using util::SerializeToBase64;

namespace logger {

using testing::ExpectedActivity;
using testing::ExpectedAggregationParams;
using testing::FakeObservationStore;
using testing::FetchAggregatedObservations;
using testing::MakeAggregationConfig;
using testing::MakeAggregationKey;
using testing::MakeNullExpectedActivity;
using testing::PopulateMetricDefinitions;
using testing::TestUpdateRecipient;

namespace {

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

// Pairs (metric ID, report ID) for the locally aggregated reports defined in
// |kMetricDefinitions| and |kNoiseFreeUniqueActivesMetricDefinitions|.
const MetricReportId kDeviceBootsMetricReportId = MetricReportId(10, 101);
const MetricReportId kFeaturesActiveMetricReportId = MetricReportId(20, 201);
const MetricReportId kErrorsOccurredMetricReportId = MetricReportId(30, 302);
const MetricReportId kEventsOccurredMetricReportId = MetricReportId(40, 402);

// A set of metric definitions of type EVENT_OCCURRED, each of which has a
// UNIQUE_N_DAY_ACTIVES report.
static const char kUniqueActivesMetricDefinitions[] = R"(
metric {
  metric_name: "DeviceBoots"
  metric_type: EVENT_OCCURRED
  customer_id: 1
  project_id: 1
  id: 10
  max_event_code: 1
  reports: {
    report_name: "DeviceBoots_UniqueDevices"
    id: 101
    report_type: UNIQUE_N_DAY_ACTIVES
    local_privacy_noise_level: MEDIUM
    window_size: 1
  }
}

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

metric {
  metric_name: "ErrorsOccurred"
  metric_type: EVENT_OCCURRED
  customer_id: 1
  project_id: 1
  id: 30
  max_event_code: 2
  reports: {
    report_name: "ErrorsOccurred_SimpleCount"
    id: 301
    report_type: SIMPLE_OCCURRENCE_COUNT
    local_privacy_noise_level: NONE
  }
  reports: {
    report_name: "ErrorsOccurred_UniqueDevices"
    id: 302
    report_type: UNIQUE_N_DAY_ACTIVES
    local_privacy_noise_level: LARGE
    window_size: 1
    window_size: 7
    window_size: 30
  }
}

)";

// Properties of the locally aggregated reports in
// |kUniqueActivesMetricDefinitions|.
static const ExpectedAggregationParams kUniqueActivesExpectedParams = {
    /* The total number of locally aggregated Observations which should be
       generated for each day index. */
    21,
    /* The MetricReportIds of the locally aggregated reports in this
       configuration. */
    {kDeviceBootsMetricReportId, kFeaturesActiveMetricReportId,
     kErrorsOccurredMetricReportId},
    /* The number of Observations which should be generated for each day
       index, broken down by MetricReportId. */
    {{kDeviceBootsMetricReportId, 2},
     {kFeaturesActiveMetricReportId, 10},
     {kErrorsOccurredMetricReportId, 9}},
    /* The number of event codes for each MetricReportId. */
    {{kDeviceBootsMetricReportId, 2},
     {kFeaturesActiveMetricReportId, 5},
     {kErrorsOccurredMetricReportId, 3}},
    /* The set of window sizes for each MetricReportId. */
    {{kDeviceBootsMetricReportId, {1}},
     {kFeaturesActiveMetricReportId, {7, 30}},
     {kErrorsOccurredMetricReportId, {1, 7, 30}}}};

// 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: 10
  max_event_code: 1
  reports: {
    report_name: "DeviceBoots_UniqueDevices"
    id: 101
    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: 20
  max_event_code: 4
  reports: {
    report_name: "FeaturesActive_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: 40
  max_event_code: 4
  reports: {
    report_name: "EventsOccurred_SimpleCount"
    id: 401
    report_type: SIMPLE_OCCURRENCE_COUNT
    local_privacy_noise_level: NONE
  }
  reports: {
    report_name: "EventsOccurred_UniqueDevices"
    id: 402
    report_type: UNIQUE_N_DAY_ACTIVES
    local_privacy_noise_level: NONE
    window_size: 1
    window_size: 7
  }
}
)";

// Properties of the locally aggregated reports in
// |kNoiseFreeUniqueActivesMetricDefinitions|.
static const ExpectedAggregationParams kNoiseFreeUniqueActivesExpectedParams = {
    /* 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. */
    {kDeviceBootsMetricReportId, kFeaturesActiveMetricReportId,
     kEventsOccurredMetricReportId},
    /* The number of Observations which should be generated for each day
       index, broken down by MetricReportId. */
    {{kDeviceBootsMetricReportId, 2},
     {kFeaturesActiveMetricReportId, 15},
     {kEventsOccurredMetricReportId, 10}},
    /* The number of event codes for each MetricReportId. */
    {{kDeviceBootsMetricReportId, 2},
     {kFeaturesActiveMetricReportId, 5},
     {kEventsOccurredMetricReportId, 5}},
    /* The set of window sizes for each MetricReportId. */
    {{kDeviceBootsMetricReportId, {1}},
     {kFeaturesActiveMetricReportId, {1, 7, 30}},
     {kEventsOccurredMetricReportId, {1, 7}}}};

// A map keyed by base64-encoded, serialized ReportAggregationKeys. The value at
// a key is a map of event codes to sets of day indices. Used in tests as
// a record, external to the LocalAggregateStore, of the activity logged for
// UNIQUE_N_DAY_ACTIVES reports.
typedef std::map<std::string, std::map<uint32_t, std::set<uint32_t>>>
    LoggedActivity;

// Given a string representing a MetricDefinitions proto message, creates a
// ProjectContext from that MetricDefinitions and returns a unique pointer.
std::unique_ptr<ProjectContext> MakeProjectContext(const char metric_string[]) {
  auto metric_definitions = std::make_unique<MetricDefinitions>();
  if (!PopulateMetricDefinitions(metric_string, metric_definitions.get())) {
    return nullptr;
  }
  auto project_context = std::make_unique<ProjectContext>(
      kCustomerId, kProjectId, kCustomerName, kProjectName,
      std::move(metric_definitions));
  return project_context;
}

}  // namespace

// EventAggregatorTest creates an EventAggregator which sends its Observations
// to a FakeObservationStore. The EventAggregator is not pre-populated with
// aggregation configurations.
class EventAggregatorTest : public ::testing::Test {
 protected:
  void SetUp() {
    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_store_.reset(new LocalAggregateStore);
    event_aggregator_.reset(new EventAggregator(encoder_.get(),
                                                observation_writer_.get(),
                                                local_aggregate_store_.get()));
  }

  // Clears the FakeObservationStore and resets the TestUpdateRecipient's count
  // of received observations.
  void ResetObservationStore() {
    observation_store_->messages_received.clear();
    observation_store_->metadata_received.clear();
    update_recipient_->invocation_count = 0;
  }

  // Given a ProjectContext |project_context| and the MetricReportId of a
  // UNIQUE_N_DAY_ACTIVES report in |project_context|, as well as a day index
  // and an event code, logs a UniqueActivesEvent to the EventAggregator for
  // that report, day index, and event code. If a non-null LoggedActivity map is
  // provided, updates the map with information about the logged Event.
  Status LogUniqueActivesEvent(const ProjectContext& project_context,
                               const MetricReportId& metric_report_id,
                               uint32_t day_index, uint32_t event_code,
                               LoggedActivity* logged_activity = nullptr) {
    EventRecord event_record;
    event_record.metric = project_context.GetMetric(metric_report_id.first);
    event_record.event->set_day_index(day_index);
    event_record.event->mutable_occurrence_event()->set_event_code(event_code);
    auto status = event_aggregator_->LogUniqueActivesEvent(
        metric_report_id.second, &event_record);
    if (logged_activity == nullptr) {
      return status;
    }
    std::string key;
    if (!SerializeToBase64(
            MakeAggregationKey(project_context, metric_report_id), &key)) {
      return kInvalidArguments;
    }
    if (logged_activity->count(key) == 0) {
      logged_activity->insert(
          std::make_pair(key, std::map<uint32_t, std::set<uint32_t>>({})));
    }
    if (logged_activity->at(key).count(event_code) == 0) {
      logged_activity->at(key).insert(
          std::make_pair(event_code, std::set<uint32_t>({})));
    }
    (logged_activity->at(key).at(event_code)).insert(day_index);
    return status;
  }

  // Given a LoggedActivity map describing the events that have been logged to
  // the EventAggregator, checks whether the contents of the LocalAggregateStore
  // are as expected, accounting for any garbage collection.
  //
  // logged_activity: a LoggedActivity representing event occurrences
  // since the LocalAggregateStore was created. All day indices should be
  // greater than or equal to |kStartDayIndex| and less than or equal to
  // |current_day_index|.
  //
  // current_day_index: The day index of the current day in the test's frame
  // of reference.
  bool CheckAggregateStore(const LoggedActivity& logged_activity,
                           uint32_t current_day_index) {
    // Check that the LocalAggregateStore contains no more aggregates than
    // |logged_activity| and |day_last_garbage_collected_| should imply.
    for (const auto& report_pair : local_aggregate_store_->aggregates()) {
      const auto& report_key = report_pair.first;
      const auto& aggregates = report_pair.second;
      // Check whether this ReportAggregationKey is in |logged_activity|. If
      // not, expect that its by_event_code map is empty.
      if (logged_activity.count(report_key) == 0u) {
        EXPECT_TRUE(aggregates.by_event_code().empty());
        if (!aggregates.by_event_code().empty()) {
          return false;
        }
        break;
      }
      auto expected_events = logged_activity.at(report_key);
      for (const auto& event_pair : aggregates.by_event_code()) {
        // Check that this event code is in |logged_activity| under this
        // ReportAggregationKey.
        auto event_code = event_pair.first;
        EXPECT_GT(expected_events.count(event_code), 0u);
        if (expected_events.count(event_code) == 0u) {
          return false;
        }
        const auto& expected_days = expected_events[event_code];
        for (const auto& day_pair : event_pair.second.by_day_index()) {
          // Check that this day index is in |logged_activity| under this
          // ReportAggregationKey and event code.
          const auto& day_index = day_pair.first;
          EXPECT_GT(expected_days.count(day_index), 0u);
          if (expected_days.count(day_index) == 0u) {
            return false;
          }
          // Check that the day index is no earlier than is implied by the
          // dates of store creation and garbage collection.
          EXPECT_GE(day_index,
                    EarliestAllowedDayIndex(aggregates.aggregation_config()));
          if (day_index <
              EarliestAllowedDayIndex(aggregates.aggregation_config())) {
            return false;
          }
        }
      }
    }

    // Check that the LocalAggregateStore contains aggregates for all events in
    // |logged_activity|, as long as they are recent enough to have survived any
    // garbage collection.
    for (const auto& logged_pair : logged_activity) {
      const auto& logged_key = logged_pair.first;
      const auto& logged_event_map = logged_pair.second;
      // Check that this ReportAggregationKey is in the LocalAggregateStore.
      EXPECT_GT(local_aggregate_store_->aggregates().count(logged_key), 0u);
      if (local_aggregate_store_->aggregates().count(logged_key) == 0u) {
        return false;
      }
      for (const auto& logged_event_pair : logged_event_map) {
        const auto& logged_event_code = logged_event_pair.first;
        const auto& logged_days = logged_event_pair.second;
        auto earliest_allowed =
            EarliestAllowedDayIndex(local_aggregate_store_->aggregates()
                                        .at(logged_key)
                                        .aggregation_config());
        // Check whether this event code is in the LocalAggregateStore
        // under this ReportAggregationKey. If not, check that all day indices
        // for this event code are smaller than the day index of the earliest
        // allowed aggregate.
        if (local_aggregate_store_->aggregates()
                .at(logged_key)
                .by_event_code()
                .count(logged_event_code) == 0u) {
          for (auto day_index : logged_days) {
            EXPECT_LT(day_index, earliest_allowed);
            if (day_index >= earliest_allowed) {
              return false;
            }
          }
          break;
        }
        // Check that all of the day indices in |logged_activity| under this
        // ReportAggregationKey and event code are in the
        // LocalAggregateStore, as long as they are recent enough to have
        // survived any garbage collection. Check that each aggregate has its
        // activity field set to true.
        for (const auto& logged_day_index : logged_days) {
          if (logged_day_index >= earliest_allowed) {
            EXPECT_GT(local_aggregate_store_->aggregates()
                          .at(logged_key)
                          .by_event_code()
                          .at(logged_event_code)
                          .by_day_index()
                          .count(logged_day_index),
                      0u);
            if (local_aggregate_store_->aggregates()
                    .at(logged_key)
                    .by_event_code()
                    .at(logged_event_code)
                    .by_day_index()
                    .count(logged_day_index) == 0u) {
              return false;
            }
            EXPECT_TRUE(local_aggregate_store_->aggregates()
                            .at(logged_key)
                            .by_event_code()
                            .at(logged_event_code)
                            .by_day_index()
                            .at(logged_day_index)
                            .activity_daily_aggregate()
                            .activity_indicator());
            if (!local_aggregate_store_->aggregates()
                     .at(logged_key)
                     .by_event_code()
                     .at(logged_event_code)
                     .by_day_index()
                     .at(logged_day_index)
                     .activity_daily_aggregate()
                     .activity_indicator()) {
              return false;
            }
          }
        }
      }
    }
    return true;
  }

  // Given the AggregationConfig of a locally aggregated report, returns the
  // earliest (smallest) day index for which an aggregate may exist in the
  // LocalAggregateStore for that report, accounting for garbage
  // collection.
  uint32_t EarliestAllowedDayIndex(const AggregationConfig& config) {
    // If the LocalAggregateStore has never been garbage-collected, then the
    // earliest allowed day index is just the day when the store was created;
    // i.e., |kStartDayIndex|.
    if (day_last_garbage_collected_ == 0u) {
      return kStartDayIndex;
    } else {
      // Otherwise, it is the later of:
      // (a) The day index on which the store was created.
      // (b) The day index for which the store was last garbage-collected,
      // minus the largest window size in the report associated to |config|,
      // plus 1.
      uint32_t max_window_size = 1;
      for (uint32_t window_size : config.report().window_size()) {
        if (window_size > max_window_size) {
          max_window_size = window_size;
        }
      }
      if (day_last_garbage_collected_ < (max_window_size + 1)) {
        return kStartDayIndex;
      }
      return (kStartDayIndex <
              (day_last_garbage_collected_ - max_window_size + 1))
                 ? (day_last_garbage_collected_ - max_window_size + 1)
                 : kStartDayIndex;
    }
  }

  std::unique_ptr<LocalAggregateStore> local_aggregate_store_;
  std::unique_ptr<EventAggregator> event_aggregator_;

  std::unique_ptr<TestUpdateRecipient> update_recipient_;
  std::unique_ptr<FakeObservationStore> observation_store_;

  // The day index on which the LocalAggregateStore was last garbage-collected.
  // A value of 0 indicates that the store has never been garbage-collected.
  uint32_t day_last_garbage_collected_ = 0u;

  std::unique_ptr<ObservationWriter> observation_writer_;
  std::unique_ptr<Encoder> encoder_;
  std::unique_ptr<EncryptedMessageMaker> observation_encrypter_;

 private:
  std::unique_ptr<SystemDataInterface> system_data_;
};

// Creates an EventAggregator and provides it with MetricDefinitions from a
// serialized representation |metric_string|.
class EventAggregatorTestWithProjectContext : public EventAggregatorTest {
 protected:
  explicit EventAggregatorTestWithProjectContext(const char metric_string[]) {
    project_context_ = MakeProjectContext(metric_string);
  }

  void SetUp() {
    EventAggregatorTest::SetUp();
    event_aggregator_->UpdateAggregationConfigs(*project_context_);
  }

  // Logs a UniqueActivesEvent for the MetricReportId of a locally aggregated
  // report in |metric_string|. Overrides the method
  // EventAggregatorTest::LogUniqueActivesEvent.
  Status LogUniqueActivesEvent(const MetricReportId& metric_report_id,
                               uint32_t day_index, uint32_t event_code,
                               LoggedActivity* logged_activity = nullptr) {
    return EventAggregatorTest::LogUniqueActivesEvent(
        *project_context_, metric_report_id, day_index, event_code,
        logged_activity);
  }

 private:
  // A ProjectContext wrapping the MetricDefinitions passed to the constructor
  // in |metric_string|.
  std::unique_ptr<ProjectContext> project_context_;
};

// Creates an EventAggregator and provides it with
// |kUniqueActivesMetricDefinitions|.
class UniqueActivesEventAggregatorTest
    : public EventAggregatorTestWithProjectContext {
 protected:
  UniqueActivesEventAggregatorTest()
      : EventAggregatorTestWithProjectContext(kUniqueActivesMetricDefinitions) {
  }

  void SetUp() { EventAggregatorTestWithProjectContext::SetUp(); }
};

// Creates an EventAggregator as in EventAggregatorTest and provides it with
// |kNoiseFreeUniqueActivesMetricDefinitions|.
class NoiseFreeUniqueActivesEventAggregatorTest
    : public EventAggregatorTestWithProjectContext {
 protected:
  NoiseFreeUniqueActivesEventAggregatorTest()
      : EventAggregatorTestWithProjectContext(
            kNoiseFreeUniqueActivesMetricDefinitions) {}

  void SetUp() { EventAggregatorTestWithProjectContext::SetUp(); }
};

// Tests that an empty LocalAggregateStore is updated with ReportAggregationKeys
// and AggregationConfigs as expected when
// EventAggregator::UpdateAggregationConfigs is called.
TEST_F(EventAggregatorTest, UpdateAggregationConfigs) {
  // Check that the LocalAggregateStore is empty.
  EXPECT_EQ(0u, local_aggregate_store_->aggregates().size());
  // Provide |kUniqueActivesMetricDefinitions| to the EventAggregator.
  auto unique_actives_project_context =
      MakeProjectContext(kUniqueActivesMetricDefinitions);
  EXPECT_EQ(kOK, event_aggregator_->UpdateAggregationConfigs(
                     *unique_actives_project_context));
  // Check that the number of key-value pairs in the LocalAggregateStore is
  // now equal to the number of locally aggregated reports in
  // |kUniqueActivesMetricDefinitions|.
  EXPECT_EQ(kUniqueActivesExpectedParams.metric_report_ids.size(),
            local_aggregate_store_->aggregates().size());
  // Check that the LocalAggregateStore contains the expected
  // ReportAggregationKey and AggregationConfig for each locally aggregated
  // report in |kUniqueActivesMetricDefinitions|,
  for (const auto& metric_report_id :
       kUniqueActivesExpectedParams.metric_report_ids) {
    std::string key;
    SerializeToBase64(
        MakeAggregationKey(*unique_actives_project_context, metric_report_id),
        &key);
    auto config = MakeAggregationConfig(*unique_actives_project_context,
                                        metric_report_id);
    EXPECT_NE(local_aggregate_store_->aggregates().end(),
              local_aggregate_store_->aggregates().find(key));
    EXPECT_TRUE(MessageDifferencer::Equals(
        config,
        local_aggregate_store_->aggregates().at(key).aggregation_config()));
  }
}

// Tests two assumptions about the behavior of
// EventAggregator::UpdateAggregationConfigs when two projects with the same
// customer ID and project ID provide configurations to the EventAggregator.
// These assumptions are:
// (1) If the second project provides a report with a
// ReportAggregationKey which was not provided by the first project, then the
// EventAggregator accepts the new report.
// (2) If a report provided by the second project has a ReportAggregationKey
// which was already provided by the first project, then the EventAggregator
// rejects the new report, even if its ReportDefinition differs from that of
// existing report with the same ReportAggregationKey.
TEST_F(EventAggregatorTest, UpdateAggregationConfigsWithSameKey) {
  // Provide the EventAggregator with |kUniqueActivesMetricDefinitions|.
  auto unique_actives_project_context =
      MakeProjectContext(kUniqueActivesMetricDefinitions);
  EXPECT_EQ(kOK, event_aggregator_->UpdateAggregationConfigs(
                     *unique_actives_project_context));
  // Check that the number of key-value pairs in the LocalAggregateStore is
  // now equal to the number of locally aggregated reports in
  // |kUniqueActivesMetricDefinitions|.
  EXPECT_EQ(3u, local_aggregate_store_->aggregates().size());

  // Provide the EventAggregator with
  // |kNoiseFreeUniqueActivesMetricDefinitions|.
  auto noise_free_unique_actives_project_context =
      MakeProjectContext(kNoiseFreeUniqueActivesMetricDefinitions);
  EXPECT_EQ(kOK, event_aggregator_->UpdateAggregationConfigs(
                     *noise_free_unique_actives_project_context));
  // Check that the number of key-value pairs in the LocalAggregateStore is
  // now equal to the number of distinct MetricReportIds of locally aggregated
  // reports in |kUniqueActivesMetricDefinitions| and
  // |kNoiseFreeUniqueActivesMetricDefinitions|.
  EXPECT_EQ(4u, local_aggregate_store_->aggregates().size());
  // The MetricReportId |kFeaturesActiveMetricReportId| appears in both
  // |kUniqueActivesMetricDefinitions| and
  // |kNoiseFreeUniqueActivesMetricDefinitions|. The associated
  // ReportAggregationKeys are identical, but the AggregationConfigs are
  // different.
  //
  // Check that the AggregationConfig stored in the LocalAggregateStore under
  // the key associated to |kFeaturesActiveMetricReportId| is the first
  // AggregationConfig that was provided for that key; i.e., is derived from
  // |kUniqueActivesMetricDefinitions|.
  std::string key;
  EXPECT_TRUE(
      SerializeToBase64(MakeAggregationKey(*unique_actives_project_context,
                                           kFeaturesActiveMetricReportId),
                        &key));
  auto unique_actives_config = MakeAggregationConfig(
      *unique_actives_project_context, kFeaturesActiveMetricReportId);
  EXPECT_NE(local_aggregate_store_->aggregates().end(),
            local_aggregate_store_->aggregates().find(key));
  EXPECT_TRUE(MessageDifferencer::Equals(
      unique_actives_config,
      local_aggregate_store_->aggregates().at(key).aggregation_config()));
  auto noise_free_config =
      MakeAggregationConfig(*noise_free_unique_actives_project_context,
                            kFeaturesActiveMetricReportId);
  EXPECT_FALSE(MessageDifferencer::Equals(
      noise_free_config,
      local_aggregate_store_->aggregates().at(key).aggregation_config()));
}

// Tests that EventAggregator::LogUniqueActivesEvent returns
// |kInvalidArguments| when passed a report ID which is not associated to a
// key of the LocalAggregateStore, or when passed an EventRecord containing an
// Event proto message which is not of type OccurrenceEvent.
TEST_F(EventAggregatorTest, LogBadEvents) {
  // Provide the EventAggregator with |kUniqueActivesMetricDefinitions|.
  auto unique_actives_project_context =
      MakeProjectContext(kUniqueActivesMetricDefinitions);
  EXPECT_EQ(kOK, event_aggregator_->UpdateAggregationConfigs(
                     *unique_actives_project_context));
  // Attempt to log a UniqueActivesEvent for |kEventsOccurredMetricReportId|,
  // which is not in |kUniqueActivesMetricDefinitions|. Check that the result
  // is |kInvalidArguments|.
  auto noise_free_project_context =
      MakeProjectContext(kNoiseFreeUniqueActivesMetricDefinitions);
  EventRecord bad_event_record;
  bad_event_record.metric = noise_free_project_context->GetMetric(
      kEventsOccurredMetricReportId.first);
  bad_event_record.event->set_day_index(kStartDayIndex);
  bad_event_record.event->mutable_occurrence_event()->set_event_code(0u);
  EXPECT_EQ(kInvalidArguments,
            event_aggregator_->LogUniqueActivesEvent(
                kEventsOccurredMetricReportId.second, &bad_event_record));
  // Attempt to call LogUniqueActivesEvent() with a valid metric and report
  // ID, but with an EventRecord wrapping an Event which is not an
  // OccurrenceEvent. Check that the result is |kInvalidArguments|.
  bad_event_record.metric = unique_actives_project_context->GetMetric(
      kFeaturesActiveMetricReportId.first);
  bad_event_record.event->mutable_count_event();
  EXPECT_EQ(kInvalidArguments,
            event_aggregator_->LogUniqueActivesEvent(
                kFeaturesActiveMetricReportId.second, &bad_event_record));
}

// Tests that the LocalAggregateStore is updated as expected when
// EventAggregator::LogUniqueActivesEvent() is called with valid arguments;
// i.e., with a report ID associated to an existing key of the
// LocalAggregateStore, and with an EventRecord which wraps an OccurrenceEvent.
//
// Logs some valid events each day for 35 days, checking the contents of the
// LocalAggregateStore each day.
TEST_F(UniqueActivesEventAggregatorTest, LogUniqueActivesEvents) {
  LoggedActivity logged_activity;
  uint32_t num_days = 35;
  for (uint32_t offset = 0; offset < num_days; offset++) {
    // Log an event for the FeaturesActive_UniqueDevices report of
    // |kUniqueActivesMetricDefinitions| with event code 0. Check the contents
    // of the LocalAggregateStore.
    EXPECT_EQ(kOK, LogUniqueActivesEvent(kFeaturesActiveMetricReportId,
                                         kStartDayIndex + offset, 0u,
                                         &logged_activity));
    EXPECT_TRUE(CheckAggregateStore(logged_activity, kStartDayIndex));
    // Log another event for the same report, event code, and day index.
    // Check the contents of the LocalAggregateStore.
    EXPECT_EQ(kOK, LogUniqueActivesEvent(kFeaturesActiveMetricReportId,
                                         kStartDayIndex + offset, 0u,
                                         &logged_activity));
    EXPECT_TRUE(CheckAggregateStore(logged_activity, kStartDayIndex));
    // Log several more events for various valid reports and event codes. Check
    // the contents of the LocalAggregateStore.
    EXPECT_EQ(kOK, LogUniqueActivesEvent(kDeviceBootsMetricReportId,
                                         kStartDayIndex + offset, 0u,
                                         &logged_activity));
    EXPECT_EQ(kOK, LogUniqueActivesEvent(kFeaturesActiveMetricReportId,
                                         kStartDayIndex + offset, 4u,
                                         &logged_activity));
    EXPECT_EQ(kOK, LogUniqueActivesEvent(kErrorsOccurredMetricReportId,
                                         kStartDayIndex + offset, 1u,
                                         &logged_activity));
    EXPECT_TRUE(CheckAggregateStore(logged_activity, kStartDayIndex + offset));
  }
}

// Tests the method EventAggregator::GarbageCollect().
//
// For each value of N in the range [0, 34], logs some UniqueActivesEvents each
// day for N consecutive days and then garbage-collect the LocalAggregateStore.
// After garbage collection, verifies the contents of the LocalAggregateStore.
TEST_F(UniqueActivesEventAggregatorTest, GarbageCollect) {
  uint32_t max_days_before_gc = 35;
  for (uint32_t days_before_gc = 0; days_before_gc < max_days_before_gc;
       days_before_gc++) {
    SetUp();
    day_last_garbage_collected_ = 0u;
    LoggedActivity logged_activity;
    uint32_t end_day_index = kStartDayIndex + days_before_gc;
    for (uint32_t day_index = kStartDayIndex; day_index < end_day_index;
         day_index++) {
      for (const auto& metric_report_id :
           kUniqueActivesExpectedParams.metric_report_ids) {
        // Log 2 events with event code 0.
        EXPECT_EQ(kOK, LogUniqueActivesEvent(metric_report_id, day_index, 0u,
                                             &logged_activity));
        EXPECT_EQ(kOK, LogUniqueActivesEvent(metric_report_id, day_index, 0u,
                                             &logged_activity));
        // Log 1 event with event code 1.
        EXPECT_EQ(kOK, LogUniqueActivesEvent(metric_report_id, day_index, 1u,
                                             &logged_activity));
      }
    }
    EXPECT_EQ(kOK, event_aggregator_->GarbageCollect(end_day_index));
    day_last_garbage_collected_ = end_day_index;
    EXPECT_TRUE(CheckAggregateStore(logged_activity, end_day_index));
    TearDown();
  }
}

// Tests that EventAggregator::GenerateObservations() returns a positive status
// and that the expected number of Observations is generated when no Events have
// been logged to the EventAggregator.
TEST_F(UniqueActivesEventAggregatorTest, GenerateObservationsNoEvents) {
  EXPECT_EQ(kOK, event_aggregator_->GenerateObservations(kStartDayIndex));

  std::vector<Observation2> observations(0);
  EXPECT_TRUE(FetchAggregatedObservations(
      &observations, kUniqueActivesExpectedParams, observation_store_.get(),
      update_recipient_.get()));
}

// Tests that EventAggregator::GenerateObservations() returns a positive status
// and that the expected number of Observations is generated after some
// UniqueActivesEvents have been logged, without any garbage collection.
//
// For 35 days, logs 2 events each day for the ErrorsOccurred_UniqueDevices
// report and 2 events for the FeaturesActive_UniqueDevices report, all
// with event type index 0.
//
// Each day following the first day, calls GenerateObservations() with the day
// index of the previous day. Checks that a positive status is returned and
// that the FakeObservationStore has received the expected number of new
// observations for each locally aggregated report ID in
// |kUniqueActivesMetricDefinitions|.
TEST_F(UniqueActivesEventAggregatorTest, GenerateObservations) {
  int num_days = 35;
  std::vector<Observation2> observations(0);
  for (uint32_t day_index = kStartDayIndex;
       day_index < kStartDayIndex + num_days; day_index++) {
    if (day_index > kStartDayIndex) {
      observations.clear();
      ResetObservationStore();
      EXPECT_EQ(kOK, event_aggregator_->GenerateObservations(day_index - 1));
      EXPECT_TRUE(FetchAggregatedObservations(
          &observations, kUniqueActivesExpectedParams, observation_store_.get(),
          update_recipient_.get()));
    }
    for (int i = 0; i < 2; i++) {
      EXPECT_EQ(kOK, LogUniqueActivesEvent(kErrorsOccurredMetricReportId,
                                           day_index, 0u));
      EXPECT_EQ(kOK, LogUniqueActivesEvent(kFeaturesActiveMetricReportId,
                                           day_index, 0u));
    }
  }
  observations.clear();
  ResetObservationStore();
  EXPECT_EQ(kOK, event_aggregator_->GenerateObservations(kStartDayIndex +
                                                         num_days - 1));
  EXPECT_TRUE(FetchAggregatedObservations(
      &observations, kUniqueActivesExpectedParams, observation_store_.get(),
      update_recipient_.get()));
}

// Tests that GenerateObservations() returns a positive status and that the
// expected number of Observations is generated after some UniqueActivesEvents
// have been logged, in the presence of daily garbage collection.
//
// For 35 days, logs 2 events each day for the ErrorsOccurred_UniqueDevices
// report and 2 events for the FeaturesActive_UniqueDevices report, all
// with event type index 0.
//
// Each day following the first day, calls GenerateObservations() and then
// GarbageCollect() with the day index of the current day. Checks that positive
// statuses are returned and that the FakeObservationStore has received the
// expected number of new observations for each locally aggregated report ID in
// |kUniqueActivesMetricDefinitions|.
TEST_F(UniqueActivesEventAggregatorTest,
       GenerateObservationWithGarbageCollection) {
  int num_days = 35;
  std::vector<Observation2> observations(0);
  for (uint32_t day_index = kStartDayIndex;
       day_index < kStartDayIndex + num_days; day_index++) {
    if (day_index > kStartDayIndex) {
      observations.clear();
      ResetObservationStore();
      EXPECT_EQ(kOK, event_aggregator_->GenerateObservations(day_index - 1));
      EXPECT_TRUE(FetchAggregatedObservations(
          &observations, kUniqueActivesExpectedParams, observation_store_.get(),
          update_recipient_.get()));
      EXPECT_EQ(kOK, event_aggregator_->GarbageCollect(day_index));
    }
    for (int i = 0; i < 2; i++) {
      EXPECT_EQ(kOK, LogUniqueActivesEvent(kErrorsOccurredMetricReportId,
                                           day_index, 0u));
      EXPECT_EQ(kOK, LogUniqueActivesEvent(kFeaturesActiveMetricReportId,
                                           day_index, 0u));
    }
  }
  observations.clear();
  ResetObservationStore();
  EXPECT_EQ(kOK, event_aggregator_->GenerateObservations(kStartDayIndex +
                                                         num_days - 1));
  EXPECT_TRUE(FetchAggregatedObservations(
      &observations, kUniqueActivesExpectedParams, observation_store_.get(),
      update_recipient_.get()));
  EXPECT_EQ(kOK, event_aggregator_->GarbageCollect(kStartDayIndex + num_days));
}

// Checks that UniqueActivesObservations with the expected values (i.e.,
// non-active for all window sizes and event types) are generated when no Events
// have been logged to the EventAggregator.
TEST_F(NoiseFreeUniqueActivesEventAggregatorTest,
       CheckObservationValuesNoEvents) {
  EXPECT_EQ(kOK, event_aggregator_->GenerateObservations(kStartDayIndex));

  auto expected_activity =
      MakeNullExpectedActivity(kNoiseFreeUniqueActivesExpectedParams);

  EXPECT_TRUE(CheckUniqueActivesObservations(
      expected_activity, kNoiseFreeUniqueActivesExpectedParams,
      observation_store_.get(), update_recipient_.get()));
}

// Checks that UniqueActivesObservations with the expected values are generated
// when some events have been logged for a UNIQUE_N_DAY_ACTIVES report for over
// multiple days, without garbage collection.
//
// Logs events for the SomeEventsOccurred_UniqueDevices report (whose parent
// metric has max_event_type_index = 4) for 10 days, according to the following
// pattern:
//
// * Never log event type 0.
// * On the i-th day (0-indexed) of logging, log an event for event type k,
// 1 <= k < 5, if 3*k divides i.
//
// Each day following the first day, generates Observations for the previous
// day index and check them against the expected set of Observations. Also
// generates and check Observations for the last day of logging.
//
// The SomeEventsOccurred_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)            true for event types
// ------------------------------------------------------
// (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(NoiseFreeUniqueActivesEventAggregatorTest,
       CheckObservationValuesSingleDay) {
  // Log several events.
  EXPECT_EQ(kOK, LogUniqueActivesEvent(kFeaturesActiveMetricReportId,
                                       kStartDayIndex, 0u));
  EXPECT_EQ(kOK, LogUniqueActivesEvent(kFeaturesActiveMetricReportId,
                                       kStartDayIndex, 0u));
  EXPECT_EQ(kOK, LogUniqueActivesEvent(kEventsOccurredMetricReportId,
                                       kStartDayIndex, 1u));
  // Generate locally aggregated Observations.
  EXPECT_EQ(kOK, event_aggregator_->GenerateObservations(kStartDayIndex));

  // Form the expected activity map.
  auto expected_activity =
      MakeNullExpectedActivity(kNoiseFreeUniqueActivesExpectedParams);
  expected_activity[kFeaturesActiveMetricReportId] = {
      {1, {true, false, false, false, false}},
      {7, {true, false, false, false, false}},
      {30, {true, false, false, false, false}}};
  expected_activity[kEventsOccurredMetricReportId] = {
      {1, {false, true, false, false, false}},
      {7, {false, true, false, false, false}}};

  // Check the contents of the FakeObservationStore.
  EXPECT_TRUE(CheckUniqueActivesObservations(
      expected_activity, kNoiseFreeUniqueActivesExpectedParams,
      observation_store_.get(), update_recipient_.get()));
}

TEST_F(NoiseFreeUniqueActivesEventAggregatorTest,
       CheckObservationValuesMultiDay) {
  // Generate expected activity maps for the 10 days of logging.
  uint32_t num_days = 10;
  std::vector<ExpectedActivity> expected_activity(num_days);
  for (uint32_t offset = 0; offset < num_days; offset++) {
    expected_activity[offset] =
        MakeNullExpectedActivity(kNoiseFreeUniqueActivesExpectedParams);
  }
  expected_activity[0][kEventsOccurredMetricReportId] = {
      {1, {false, true, true, true, true}},
      {7, {false, true, true, true, true}}};
  expected_activity[1][kEventsOccurredMetricReportId] = {
      {1, {false, false, false, false, false}},
      {7, {false, true, true, true, true}}};
  expected_activity[2][kEventsOccurredMetricReportId] = {
      {1, {false, false, false, false, false}},
      {7, {false, true, true, true, true}}};
  expected_activity[3][kEventsOccurredMetricReportId] = {
      {1, {false, true, false, false, false}},
      {7, {false, true, true, true, true}}};
  expected_activity[4][kEventsOccurredMetricReportId] = {
      {1, {false, false, false, false, false}},
      {7, {false, true, true, true, true}}};
  expected_activity[5][kEventsOccurredMetricReportId] = {
      {1, {false, false, false, false, false}},
      {7, {false, true, true, true, true}}};
  expected_activity[6][kEventsOccurredMetricReportId] = {
      {1, {false, true, true, false, false}},
      {7, {false, true, true, true, true}}};
  expected_activity[7][kEventsOccurredMetricReportId] = {
      {1, {false, false, false, false, false}},
      {7, {false, true, true, false, false}}};
  expected_activity[8][kEventsOccurredMetricReportId] = {
      {1, {false, false, false, false, false}},
      {7, {false, true, true, false, false}}};
  expected_activity[9][kEventsOccurredMetricReportId] = {
      {1, {false, true, false, true, false}},
      {7, {false, true, true, true, false}}};

  for (uint32_t offset = 0; offset < num_days; offset++) {
    for (uint32_t event_code = 1;
         event_code < kNoiseFreeUniqueActivesExpectedParams.num_event_codes.at(
                          kEventsOccurredMetricReportId);
         event_code++) {
      if (offset % (3 * event_code) == 0) {
        EXPECT_EQ(kOK,
                  LogUniqueActivesEvent(kEventsOccurredMetricReportId,
                                        kStartDayIndex + offset, event_code));
      }
    }
    // Clear the FakeObservationStore.
    ResetObservationStore();
    // Generate locally aggregated Observations.
    EXPECT_EQ(kOK,
              event_aggregator_->GenerateObservations(kStartDayIndex + offset));
    // Check the generated Observations against the expectation.
    EXPECT_TRUE(CheckUniqueActivesObservations(
        expected_activity[offset], kNoiseFreeUniqueActivesExpectedParams,
        observation_store_.get(), update_recipient_.get()));
  }
}

// Checks that UniqueActivesObservations with the expected values are generated
// when some events have been logged for a UNIQUE_N_DAY_ACTIVES report for over
// multiple days, with daily garbage collection.
//
// Logs events for the SomeEventsOccurred_UniqueDevices report (whose parent
// metric has max_event_type_index = 4) for 10 days, according to the following
// pattern:
//
// * Never log event type 0.
// * On the i-th day (0-indexed) of logging, log an event for event type k,
// 1 <= k < 5, if 3*k divides i.
//
// Each day following the first day, generates Observations for the previous
// day index and check them against the expected set of Observations. Also
// generates and check Observations for the last day of logging.
//
// The SomeEventsOccurred_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)            true for event types
// ------------------------------------------------------
// (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(NoiseFreeUniqueActivesEventAggregatorTest,
       CheckObservationValuesMultiDayWithGarbageCollection) {
  // Generate expected activity maps for the 10 days of logging.
  uint32_t num_days = 10;
  std::vector<ExpectedActivity> expected_activity(num_days);
  for (uint32_t offset = 0; offset < num_days; offset++) {
    expected_activity[offset] =
        MakeNullExpectedActivity(kNoiseFreeUniqueActivesExpectedParams);
  }
  expected_activity[0][kEventsOccurredMetricReportId] = {
      {1, {false, true, true, true, true}},
      {7, {false, true, true, true, true}}};
  expected_activity[1][kEventsOccurredMetricReportId] = {
      {1, {false, false, false, false, false}},
      {7, {false, true, true, true, true}}};
  expected_activity[2][kEventsOccurredMetricReportId] = {
      {1, {false, false, false, false, false}},
      {7, {false, true, true, true, true}}};
  expected_activity[3][kEventsOccurredMetricReportId] = {
      {1, {false, true, false, false, false}},
      {7, {false, true, true, true, true}}};
  expected_activity[4][kEventsOccurredMetricReportId] = {
      {1, {false, false, false, false, false}},
      {7, {false, true, true, true, true}}};
  expected_activity[5][kEventsOccurredMetricReportId] = {
      {1, {false, false, false, false, false}},
      {7, {false, true, true, true, true}}};
  expected_activity[6][kEventsOccurredMetricReportId] = {
      {1, {false, true, true, false, false}},
      {7, {false, true, true, true, true}}};
  expected_activity[7][kEventsOccurredMetricReportId] = {
      {1, {false, false, false, false, false}},
      {7, {false, true, true, false, false}}};
  expected_activity[8][kEventsOccurredMetricReportId] = {
      {1, {false, false, false, false, false}},
      {7, {false, true, true, false, false}}};
  expected_activity[9][kEventsOccurredMetricReportId] = {
      {1, {false, true, false, true, false}},
      {7, {false, true, true, true, false}}};

  for (uint32_t offset = 0; offset < num_days; offset++) {
    for (uint32_t event_code = 1;
         event_code < kNoiseFreeUniqueActivesExpectedParams.num_event_codes.at(
                          kEventsOccurredMetricReportId);
         event_code++) {
      if (offset % (3 * event_code) == 0) {
        EXPECT_EQ(kOK,
                  LogUniqueActivesEvent(kEventsOccurredMetricReportId,
                                        kStartDayIndex + offset, event_code));
      }
    }
    // Clear the FakeObservationStore.
    ResetObservationStore();
    // Generate locally aggregated Observations.
    EXPECT_EQ(kOK,
              event_aggregator_->GenerateObservations(kStartDayIndex + offset));
    // Check the generated Observations against the expectation.
    EXPECT_TRUE(CheckUniqueActivesObservations(
        expected_activity[offset], kNoiseFreeUniqueActivesExpectedParams,
        observation_store_.get(), update_recipient_.get()));
    // Garbage collect for the next day index.
    EXPECT_EQ(kOK,
              event_aggregator_->GarbageCollect(kStartDayIndex + offset + 1));
  }
}

}  // namespace logger
}  // namespace cobalt