// Copyright 2020 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 "src/developer/forensics/crash_reports/crash_reporter.h"

#include <fuchsia/feedback/cpp/fidl.h>
#include <fuchsia/mem/cpp/fidl.h>
#include <fuchsia/settings/cpp/fidl.h>
#include <lib/fpromise/result.h>
#include <lib/syslog/cpp/macros.h>
#include <lib/zx/time.h>
#include <zircon/errors.h>
#include <zircon/types.h>
#include <zircon/utc.h>

#include <algorithm>
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>

#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include "src/developer/forensics/crash_reports/config.h"
#include "src/developer/forensics/crash_reports/constants.h"
#include "src/developer/forensics/crash_reports/info/info_context.h"
#include "src/developer/forensics/crash_reports/tests/stub_crash_server.h"
#include "src/developer/forensics/testing/fakes/privacy_settings.h"
#include "src/developer/forensics/testing/stubs/channel_control.h"
#include "src/developer/forensics/testing/stubs/cobalt_logger_factory.h"
#include "src/developer/forensics/testing/stubs/data_provider.h"
#include "src/developer/forensics/testing/stubs/device_id_provider.h"
#include "src/developer/forensics/testing/stubs/network_reachability_provider.h"
#include "src/developer/forensics/testing/unit_test_fixture.h"
#include "src/developer/forensics/utils/cobalt/event.h"
#include "src/developer/forensics/utils/cobalt/metrics.h"
#include "src/lib/files/directory.h"
#include "src/lib/files/file.h"
#include "src/lib/files/path.h"
#include "src/lib/files/scoped_temp_dir.h"
#include "src/lib/fsl/vmo/strings.h"
#include "src/lib/timekeeper/test_clock.h"

namespace forensics {
namespace crash_reports {
namespace {

using fuchsia::feedback::Annotation;
using fuchsia::feedback::Attachment;
using fuchsia::feedback::CrashReport;
using fuchsia::feedback::NativeCrashReport;
using fuchsia::feedback::RuntimeCrashReport;
using fuchsia::feedback::SpecificCrashReport;
using fuchsia::settings::PrivacySettings;
using inspect::testing::ChildrenMatch;
using inspect::testing::NameMatches;
using inspect::testing::NodeMatches;
using inspect::testing::PropertyList;
using inspect::testing::StringIs;
using inspect::testing::UintIs;
using testing::ByRef;
using testing::Contains;
using testing::ElementsAre;
using testing::IsEmpty;
using testing::IsSupersetOf;
using testing::Not;
using testing::UnorderedElementsAre;
using testing::UnorderedElementsAreArray;

constexpr CrashServer::UploadStatus kUploadSuccessful = CrashServer::UploadStatus::kSuccess;
constexpr CrashServer::UploadStatus kUploadFailed = CrashServer::UploadStatus::kFailure;
constexpr CrashServer::UploadStatus kUploadThrottled = CrashServer::UploadStatus::kThrottled;

constexpr char kProgramName[] = "crashing_program";

constexpr char kBuildVersion[] = "some-version";
constexpr char kDefaultChannel[] = "some-channel";
constexpr char kDefaultDeviceId[] = "some-device-id";

constexpr char kSingleAttachmentKey[] = "attachment.key";
constexpr char kSingleAttachmentValue[] = "attachment.value";

constexpr bool kUserOptInDataSharing = true;
constexpr bool kUserOptOutDataSharing = false;

constexpr size_t kDailyPerProductQuota = 100u;

const std::map<std::string, std::string> kDefaultAnnotations = {
    {"feedback.annotation.1.key", "feedback.annotation.1.value"},
    {"feedback.annotation.2.key", "feedback.annotation.2.value"},
};

const std::map<std::string, std::string> kEmptyAnnotations = {};

constexpr char kDefaultAttachmentBundleKey[] = "feedback.attachment.bundle.key";
constexpr char kEmptyAttachmentBundleKey[] = "empty.attachment.key";

constexpr zx::duration kSnapshotSharedRequestWindow = zx::sec(5);

Attachment BuildAttachment(const std::string& key, const std::string& value) {
  Attachment attachment;
  attachment.key = key;
  FX_CHECK(fsl::VmoFromString(value, &attachment.value));
  return attachment;
}

PrivacySettings MakePrivacySettings(const std::optional<bool> user_data_sharing_consent) {
  PrivacySettings settings;
  if (user_data_sharing_consent.has_value()) {
    settings.set_user_data_sharing_consent(user_data_sharing_consent.value());
  }
  return settings;
}

template <typename K, typename V>
std::vector<testing::internal::PairMatcher<K, V>> Linearize(const std::map<K, V>& annotations) {
  std::vector<testing::internal::PairMatcher<K, V>> linearized;
  for (const auto& [k, v] : annotations) {
    linearized.push_back(testing::Pair(k, v));
  }
  return linearized;
}

// Unit-tests the implementation of the fuchsia.feedback.CrashReporter FIDL interface.
//
// This does not test the environment service. It directly instantiates the class, without
// connecting through FIDL.
class CrashReporterTest : public UnitTestFixture {
 public:
  void SetUp() override {
    clock_.Set(zx::time(0u));
    info_context_ =
        std::make_shared<InfoContext>(&InspectRoot(), &clock_, dispatcher(), services());
    crash_register_ = std::make_unique<CrashRegister>(
        dispatcher(), services(), info_context_, std::string(kBuildVersion), RegisterJsonPath());

    SetUpCobaltServer(std::make_unique<stubs::CobaltLoggerFactory>());
    SetUpNetworkReachabilityProviderServer();
    RunLoopUntilIdle();
  }

  void TearDown() override {
    ASSERT_TRUE(files::DeletePath(kStoreTmpPath, /*recursive=*/true));
    ASSERT_TRUE(files::DeletePath(kStoreCachePath, /*recursive=*/true));
  }

 protected:
  // Sets up the underlying crash reporter using the given |config| and |crash_server|.
  void SetUpCrashReporter(
      Config config, const std::vector<CrashServer::UploadStatus>& upload_attempt_results = {}) {
    FX_CHECK(data_provider_server_);
    snapshot_manager_ = std::make_unique<SnapshotManager>(
        dispatcher(), &clock_, data_provider_server_.get(), kSnapshotSharedRequestWindow,
        kGarbageCollectedSnapshotsPath, StorageSize::Gigabytes(1u), StorageSize::Gigabytes(1u)),
    crash_server_ =
        std::make_unique<StubCrashServer>(dispatcher(), services(), upload_attempt_results);

    crash_reporter_ = std::make_unique<CrashReporter>(
        dispatcher(), services(), &clock_, info_context_, config,
        AnnotationMap({{"osName", "Fuchsia"}, {"osVersion", kBuildVersion}}), crash_register_.get(),
        &tags_, snapshot_manager_.get(), crash_server_.get());
    FX_CHECK(crash_reporter_);
  }

  // Sets up the underlying crash reporter using a default config.
  void SetUpCrashReporterDefaultConfig(
      const std::vector<CrashServer::UploadStatus>& upload_attempt_results = {}) {
    SetUpCrashReporter(
        Config{/*crash_server=*/
               {
                   /*upload_policy=*/CrashServerConfig::UploadPolicy::ENABLED,
               },
               /*daily_per_product_quota=*/kDailyPerProductQuota,
               /*houry_snapshot=*/true},
        upload_attempt_results);
  }

  void SetUpChannelProviderServer(std::unique_ptr<stubs::ChannelControlBase> server) {
    channel_provider_server_ = std::move(server);
    if (channel_provider_server_) {
      InjectServiceProvider(channel_provider_server_.get());
    }
  }

  void SetUpDataProviderServer(std::unique_ptr<stubs::DataProviderBase> server) {
    data_provider_server_ = std::move(server);
  }

  void SetUpDeviceIdProviderServer(std::unique_ptr<stubs::DeviceIdProviderBase> server) {
    device_id_provider_server_ = std::move(server);
    if (device_id_provider_server_) {
      InjectServiceProvider(device_id_provider_server_.get());
    }
  }

  void SetUpNetworkReachabilityProviderServer() {
    network_reachability_provider_server_ = std::make_unique<stubs::NetworkReachabilityProvider>();
    InjectServiceProvider(network_reachability_provider_server_.get());
  }

  void SetUpPrivacySettingsServer(std::unique_ptr<fakes::PrivacySettings> server) {
    privacy_settings_server_ = std::move(server);
    if (privacy_settings_server_) {
      InjectServiceProvider(privacy_settings_server_.get());
    }
  }

  std::string RegisterJsonPath() { return files::JoinPath(tmp_dir_.path(), "register.json"); }

  // Checks that on the crash server the annotations received match the concatenation of:
  //   * |expected_extra_annotations|
  //   * default annotations
  //
  // In case of duplicate keys, the value from |expected_extra_annotations| is picked.
  void CheckAnnotationsOnServer(
      const std::map<std::string, std::string>& expected_extra_annotations = {}) {
    ASSERT_TRUE(crash_server_);

    std::map<std::string, testing::Matcher<std::string>> expected_annotations = {
        {"product", "Fuchsia"},
        {"version", kBuildVersion},
        {"program", testing::StartsWith("crashing_program")},
        {"ptype", testing::StartsWith("crashing_program")},
        {"osName", "Fuchsia"},
        {"osVersion", kBuildVersion},
        {"reportTimeMillis", Not(IsEmpty())},
        {"guid", kDefaultDeviceId},
        {"channel", kDefaultChannel},
        {"should_process", "false"},
        {"debug.snapshot.shared-request.num-clients", Not(IsEmpty())},
        {"debug.snapshot.shared-request.uuid", Not(IsEmpty())},
    };
    for (const auto& [key, value] : expected_extra_annotations) {
      expected_annotations[key] = value;
    }

    EXPECT_THAT(crash_server_->latest_annotations().Raw(),
                testing::UnorderedElementsAreArray(Linearize(expected_annotations)));
  }

  // Checks that on the crash server the keys for the attachments received match the
  // concatenation of:
  //   * |expected_extra_attachment_keys|
  //   * data_provider_->attachment_bundle_key()
  void CheckAttachmentsOnServer(
      const std::vector<std::string>& expected_extra_attachment_keys = {}) {
    ASSERT_TRUE(crash_server_);

    std::vector<std::string> expected_attachment_keys = expected_extra_attachment_keys;

    EXPECT_THAT(crash_server_->latest_attachment_keys(),
                testing::UnorderedElementsAreArray(expected_attachment_keys));
  }

  // Checks that the crash server is still expecting at least one more request.
  //
  // This is useful to check that an upload request hasn't been made as we are using a strict stub.
  void CheckServerStillExpectRequests() {
    ASSERT_TRUE(crash_server_);
    EXPECT_TRUE(crash_server_->ExpectRequest());
  }

  // Files one crash report.
  ::fpromise::result<void, zx_status_t> FileOneCrashReport(CrashReport report) {
    FX_CHECK(crash_reporter_ != nullptr)
        << "crash_reporter_ is nullptr. Call SetUpCrashReporter() or one of its variants "
           "at the beginning of a test case.";
    std::optional<::fpromise::result<void, zx_status_t>> out_result{std::nullopt};
    crash_reporter_->File(std::move(report),
                          [&out_result](::fpromise::result<void, zx_status_t> result) {
                            out_result = std::move(result);
                          });
    RunLoopFor(kSnapshotSharedRequestWindow);
    FX_CHECK(out_result.has_value());
    return out_result.value();
  }

  // Files one crash report.
  ::fpromise::result<void, zx_status_t> FileOneCrashReport(
      const std::vector<Annotation>& annotations = {}, std::vector<Attachment> attachments = {}) {
    CrashReport report;
    report.set_program_name(kProgramName);
    if (!annotations.empty()) {
      report.set_annotations(annotations);
    }
    if (!attachments.empty()) {
      report.set_attachments(std::move(attachments));
    }
    return FileOneCrashReport(std::move(report));
  }

  // Files one crash report.
  //
  // |attachment| is useful to control the lower bound of the size of the report by controlling the
  // size of some of the attachment(s).
  ::fpromise::result<void, zx_status_t> FileOneCrashReportWithSingleAttachment(
      const std::string& attachment = kSingleAttachmentValue) {
    std::vector<Attachment> attachments;
    attachments.emplace_back(BuildAttachment(kSingleAttachmentKey, attachment));
    return FileOneCrashReport(/*annotations=*/{},
                              /*attachments=*/std::move(attachments));
  }

  // Files one native crash report.
  ::fpromise::result<void, zx_status_t> FileOneNativeCrashReport(
      std::optional<fuchsia::mem::Buffer> minidump,
      const std::optional<std::string>& crash_signature) {
    NativeCrashReport native_report;
    if (minidump.has_value()) {
      native_report.set_minidump(std::move(minidump.value()));
    }
    native_report.set_process_name("crashing_process");
    native_report.set_process_koid(123u);
    native_report.set_thread_name("crashing_thread");
    native_report.set_thread_koid(1234u);

    SpecificCrashReport specific_report;
    specific_report.set_native(std::move(native_report));

    CrashReport report;
    report.set_program_name("crashing_program_native");
    report.set_specific_report(std::move(specific_report));

    if (crash_signature.has_value()) {
      report.set_crash_signature(crash_signature.value());
    }

    return FileOneCrashReport(std::move(report));
  }

  // Files one Dart crash report.
  ::fpromise::result<void, zx_status_t> FileOneDartCrashReport(
      const std::optional<std::string>& exception_type,
      const std::optional<std::string>& exception_message,
      std::optional<fuchsia::mem::Buffer> exception_stack_trace) {
    RuntimeCrashReport dart_report;
    if (exception_type.has_value()) {
      dart_report.set_exception_type(exception_type.value());
    }
    if (exception_message.has_value()) {
      dart_report.set_exception_message(exception_message.value());
    }
    if (exception_stack_trace.has_value()) {
      dart_report.set_exception_stack_trace(std::move(exception_stack_trace.value()));
    }

    SpecificCrashReport specific_report;
    specific_report.set_dart(std::move(dart_report));

    CrashReport report;
    report.set_program_name("crashing_program_dart");
    report.set_specific_report(std::move(specific_report));

    return FileOneCrashReport(std::move(report));
  }

  // Files one empty crash report.
  ::fpromise::result<void, zx_status_t> FileOneEmptyCrashReport() {
    CrashReport report;
    return FileOneCrashReport(std::move(report));
  }

  // Files one crash report with the provided crash signature.
  ::fpromise::result<void, zx_status_t> FileOneCrashReportWithSignature(
      const std::string& signature) {
    CrashReport report;
    report.set_program_name("crashing_program_generic");
    report.set_crash_signature(signature);

    return FileOneCrashReport(std::move(report));
  }

  // Files one crash report with the provided is fatal value.
  ::fpromise::result<void, zx_status_t> FileOneCrashReportWithIsFatal(const bool is_fatal) {
    CrashReport report;
    report.set_program_name("crashing_program_generic");
    report.set_is_fatal(is_fatal);

    return FileOneCrashReport(std::move(report));
  }

  void SetPrivacySettings(std::optional<bool> user_data_sharing_consent) {
    FX_CHECK(privacy_settings_server_);

    ::fpromise::result<void, fuchsia::settings::Error> set_result;
    privacy_settings_server_->Set(
        MakePrivacySettings(user_data_sharing_consent),
        [&set_result](::fpromise::result<void, fuchsia::settings::Error> result) {
          set_result = std::move(result);
        });
    EXPECT_TRUE(set_result.is_ok());
  }

 private:
  files::ScopedTempDir tmp_dir_;

  LogTags tags_;

  // Stubs and fake servers.
  std::unique_ptr<stubs::ChannelControlBase> channel_provider_server_;
  std::unique_ptr<stubs::DataProviderBase> data_provider_server_;
  std::unique_ptr<stubs::DeviceIdProviderBase> device_id_provider_server_;
  std::unique_ptr<stubs::NetworkReachabilityProvider> network_reachability_provider_server_;
  std::unique_ptr<fakes::PrivacySettings> privacy_settings_server_;

 protected:
  std::unique_ptr<StubCrashServer> crash_server_;

 private:
  timekeeper::TestClock clock_;
  std::shared_ptr<InfoContext> info_context_;

 protected:
  std::unique_ptr<SnapshotManager> snapshot_manager_;
  std::unique_ptr<CrashRegister> crash_register_;
  std::unique_ptr<CrashReporter> crash_reporter_;
};

TEST_F(CrashReporterTest, Succeed_OnInputCrashReport) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kDefaultAnnotations, kDefaultAttachmentBundleKey));
  SetUpCrashReporterDefaultConfig({kUploadSuccessful});
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  ASSERT_TRUE(FileOneCrashReport().is_ok());
  CheckAnnotationsOnServer(kDefaultAnnotations);
  CheckAttachmentsOnServer({kDefaultAttachmentBundleKey});
}

TEST_F(CrashReporterTest, EnforcesQuota) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kDefaultAnnotations, kDefaultAttachmentBundleKey));
  SetUpCrashReporterDefaultConfig(
      std::vector<CrashServer::UploadStatus>(kDailyPerProductQuota, kUploadSuccessful));
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  for (size_t i = 0; i < kDailyPerProductQuota + 1; ++i) {
    ASSERT_TRUE(FileOneCrashReport().is_ok());
  }
}

TEST_F(CrashReporterTest, ResetsQuota) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kDefaultAnnotations, kDefaultAttachmentBundleKey));
  SetUpCrashReporterDefaultConfig(
      std::vector<CrashServer::UploadStatus>(kDailyPerProductQuota * 2, kUploadSuccessful));
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  for (size_t i = 0; i < kDailyPerProductQuota; ++i) {
    ASSERT_TRUE(FileOneCrashReport().is_ok());
  }
  RunLoopFor(zx::hour(24));

  for (size_t i = 0; i < kDailyPerProductQuota; ++i) {
    ASSERT_TRUE(FileOneCrashReport().is_ok());
  }
}

TEST_F(CrashReporterTest, NoQuota) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kDefaultAnnotations, kDefaultAttachmentBundleKey));
  SetUpCrashReporter(
      Config{/*crash_server=*/
             {
                 /*upload_policy=*/CrashServerConfig::UploadPolicy::ENABLED,
             },
             /*daily_per_product_quota=*/std::nullopt,
             /*houry_snapshot=*/true},
      std::vector<CrashServer::UploadStatus>(kDailyPerProductQuota + 1 /*first hourly snapshot*/,
                                             kUploadSuccessful));
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  for (size_t i = 0; i < kDailyPerProductQuota; ++i) {
    ASSERT_TRUE(FileOneCrashReport().is_ok());
  }
}

TEST_F(CrashReporterTest, Check_UnknownChannel) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kEmptyAnnotations, kDefaultAttachmentBundleKey));
  SetUpCrashReporterDefaultConfig({kUploadSuccessful});
  SetUpChannelProviderServer(std::make_unique<stubs::ChannelControlClosesConnection>());
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  ASSERT_TRUE(FileOneCrashReport().is_ok());
  CheckAttachmentsOnServer({kDefaultAttachmentBundleKey});

  ASSERT_TRUE(crash_server_->latest_annotations().Contains("channel"));
  EXPECT_EQ(crash_server_->latest_annotations().Get("channel"), "unknown");

  ASSERT_TRUE(crash_server_->latest_annotations().Contains("debug.channel.error"));
  EXPECT_EQ(crash_server_->latest_annotations().Get("debug.channel.error"),
            "FIDL connection error");
}

TEST_F(CrashReporterTest, Check_RegisteredProduct) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kEmptyAnnotations, kDefaultAttachmentBundleKey));
  SetUpCrashReporterDefaultConfig({kUploadSuccessful});
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  fuchsia::feedback::CrashReportingProduct product;
  product.set_name("some name");
  product.set_version("some version");
  product.set_channel("some channel");
  crash_register_->Upsert(kProgramName, std::move(product));

  ASSERT_TRUE(FileOneCrashReport().is_ok());

  ASSERT_TRUE(crash_server_->latest_annotations().Contains("product"));
  EXPECT_EQ(crash_server_->latest_annotations().Get("product"), "some name");
  ASSERT_TRUE(crash_server_->latest_annotations().Contains("version"));
  EXPECT_EQ(crash_server_->latest_annotations().Get("version"), "some version");
  ASSERT_TRUE(crash_server_->latest_annotations().Contains("channel"));
  EXPECT_EQ(crash_server_->latest_annotations().Get("channel"), "some channel");
}

TEST_F(CrashReporterTest, Succeed_OnInputCrashReportWithAdditionalData) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kEmptyAnnotations, kEmptyAttachmentBundleKey));
  SetUpCrashReporterDefaultConfig({kUploadSuccessful});
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  std::vector<Attachment> attachments;
  attachments.emplace_back(BuildAttachment(kSingleAttachmentKey, kSingleAttachmentValue));

  ASSERT_TRUE(FileOneCrashReport(
                  /*annotations=*/
                  {
                      {"annotation.key", "annotation.value"},
                  },
                  /*attachments=*/std::move(attachments))
                  .is_ok());
  CheckAnnotationsOnServer({
      {"annotation.key", "annotation.value"},
  });
  CheckAttachmentsOnServer({kSingleAttachmentKey, kEmptyAttachmentBundleKey});
}

TEST_F(CrashReporterTest, Succeed_OnInputCrashReportWithEventId) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kEmptyAnnotations, kDefaultAttachmentBundleKey));
  SetUpCrashReporterDefaultConfig({kUploadSuccessful});
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  CrashReport report;
  report.set_program_name(kProgramName);
  report.set_event_id("some-event-id");

  ASSERT_TRUE(FileOneCrashReport(std::move(report)).is_ok());
  CheckAnnotationsOnServer({
      {"comments", "some-event-id"},
  });
  CheckAttachmentsOnServer({kDefaultAttachmentBundleKey});
}

TEST_F(CrashReporterTest, Succeed_OnInputCrashReportWithProgramUptime) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kEmptyAnnotations, kDefaultAttachmentBundleKey));
  SetUpCrashReporterDefaultConfig({kUploadSuccessful});
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  CrashReport report;
  report.set_program_name(kProgramName);
  const zx::duration uptime =
      zx::hour(3) * 24 + zx::hour(15) + zx::min(33) + zx::sec(17) + zx::msec(54);
  report.set_program_uptime(uptime.get());

  ASSERT_TRUE(FileOneCrashReport(std::move(report)).is_ok());
  CheckAnnotationsOnServer({
      {"ptime", std::to_string(uptime.to_msecs())},
  });
  CheckAttachmentsOnServer({kDefaultAttachmentBundleKey});
}

TEST_F(CrashReporterTest, Succeed_OnNativeInputCrashReport) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kEmptyAnnotations, kDefaultAttachmentBundleKey));
  SetUpCrashReporterDefaultConfig({kUploadSuccessful});
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  fuchsia::mem::Buffer minidump;
  fsl::VmoFromString("minidump", &minidump);

  ASSERT_TRUE(FileOneNativeCrashReport(std::move(minidump), std::nullopt).is_ok());
  CheckAnnotationsOnServer({
      {"crash.process.name", "crashing_process"},
      {"crash.process.koid", "123"},
      {"crash.thread.name", "crashing_thread"},
      {"crash.thread.koid", "1234"},
      {"should_process", "true"},
  });
  CheckAttachmentsOnServer({"uploadFileMinidump", kDefaultAttachmentBundleKey});
}

TEST_F(CrashReporterTest, Succeed_OnNativeInputCrashReportWithoutMinidump) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kEmptyAnnotations, kDefaultAttachmentBundleKey));
  SetUpCrashReporterDefaultConfig({kUploadSuccessful});
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  ASSERT_TRUE(FileOneNativeCrashReport(std::nullopt, std::nullopt).is_ok());
  CheckAnnotationsOnServer({
      {"crash.process.name", "crashing_process"},
      {"crash.process.koid", "123"},
      {"crash.thread.name", "crashing_thread"},
      {"crash.thread.koid", "1234"},
      {"signature", "fuchsia-no-minidump"},
  });
  CheckAttachmentsOnServer({kDefaultAttachmentBundleKey});
}

TEST_F(CrashReporterTest, Succeed_OnNativeInputCrashReportWithoutMinidumpButCrashSignature) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kEmptyAnnotations, kDefaultAttachmentBundleKey));
  SetUpCrashReporterDefaultConfig({kUploadSuccessful});
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  ASSERT_TRUE(FileOneNativeCrashReport(std::nullopt, "some-signature").is_ok());
  CheckAnnotationsOnServer({
      {"crash.process.name", "crashing_process"},
      {"crash.process.koid", "123"},
      {"crash.thread.name", "crashing_thread"},
      {"crash.thread.koid", "1234"},
      {"signature", "some-signature"},
  });
  CheckAttachmentsOnServer({kDefaultAttachmentBundleKey});
}

TEST_F(CrashReporterTest, Succeed_OnDartInputCrashReport) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kEmptyAnnotations, kEmptyAttachmentBundleKey));
  SetUpCrashReporterDefaultConfig({kUploadSuccessful});
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  fuchsia::mem::Buffer stack_trace;
  fsl::VmoFromString("#0", &stack_trace);

  ASSERT_TRUE(
      FileOneDartCrashReport("FileSystemException", "cannot open file", std::move(stack_trace))
          .is_ok());
  CheckAnnotationsOnServer({
      {"error_runtime_type", "FileSystemException"},
      {"error_message", "cannot open file"},
      {"type", "DartError"},
      {"should_process", "true"},
  });
  CheckAttachmentsOnServer({"DartError", kEmptyAttachmentBundleKey});
}

TEST_F(CrashReporterTest, Succeed_OnDartInputCrashReportWithoutExceptionData) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kEmptyAnnotations, kDefaultAttachmentBundleKey));
  SetUpCrashReporterDefaultConfig({kUploadSuccessful});
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  ASSERT_TRUE(FileOneDartCrashReport(std::nullopt, std::nullopt, std::nullopt).is_ok());
  CheckAnnotationsOnServer({
      {"type", "DartError"},
      {"signature", "fuchsia-no-dart-stack-trace"},
  });
  CheckAttachmentsOnServer({kDefaultAttachmentBundleKey});
}

TEST_F(CrashReporterTest, Succeed_OnInputCrashReportWithSignature) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kEmptyAnnotations, kDefaultAttachmentBundleKey));
  SetUpCrashReporterDefaultConfig({kUploadSuccessful});
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  ASSERT_TRUE(FileOneCrashReportWithSignature("some-signature").is_ok());
  CheckAnnotationsOnServer({
      {"signature", "some-signature"},
  });
  CheckAttachmentsOnServer({kDefaultAttachmentBundleKey});
}

TEST_F(CrashReporterTest, Fail_OnInvalidInputCrashReport) {
  SetUpDataProviderServer(std::make_unique<stubs::DataProviderReturnsEmptySnapshot>());
  SetUpCrashReporterDefaultConfig();
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  EXPECT_TRUE(FileOneEmptyCrashReport().is_error());
}

TEST_F(CrashReporterTest, Succeed_OnInputCrashReportWithIsFatalTrue) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kEmptyAnnotations, kDefaultAttachmentBundleKey));
  SetUpCrashReporterDefaultConfig({kUploadSuccessful});
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  ASSERT_TRUE(FileOneCrashReportWithIsFatal(true).is_ok());
  CheckAnnotationsOnServer({
      {"isFatal", "true"},
  });
  CheckAttachmentsOnServer({kDefaultAttachmentBundleKey});
}

TEST_F(CrashReporterTest, Succeed_OnInputCrashReportWithIsFatalFalse) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kEmptyAnnotations, kDefaultAttachmentBundleKey));
  SetUpCrashReporterDefaultConfig({kUploadSuccessful});
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  ASSERT_TRUE(FileOneCrashReportWithIsFatal(false).is_ok());
  CheckAnnotationsOnServer({
      {"isFatal", "false"},
  });
  CheckAttachmentsOnServer({kDefaultAttachmentBundleKey});
}

TEST_F(CrashReporterTest, Upload_OnUserAlreadyOptedInDataSharing) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kDefaultAnnotations, kDefaultAttachmentBundleKey));
  SetUpCrashReporter(
      Config{/*crash_server=*/
             {
                 /*upload_policy=*/CrashServerConfig::UploadPolicy::READ_FROM_PRIVACY_SETTINGS,
             },
             /*daily_per_product_quota=*/kDailyPerProductQuota,
             /*houry_snapshot=*/true},
      std::vector({kUploadSuccessful}));
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));
  SetUpPrivacySettingsServer(std::make_unique<fakes::PrivacySettings>());
  SetPrivacySettings(kUserOptInDataSharing);

  ASSERT_TRUE(FileOneCrashReport().is_ok());
  CheckAnnotationsOnServer(kDefaultAnnotations);
  CheckAttachmentsOnServer({kDefaultAttachmentBundleKey});
}

TEST_F(CrashReporterTest, Archive_OnUserAlreadyOptedOutDataSharing) {
  SetUpDataProviderServer(std::make_unique<stubs::DataProviderTracksNumCalls>(0u));
  SetUpCrashReporter(Config{
      /*crash_server=*/
      {
          /*upload_policy=*/CrashServerConfig::UploadPolicy::READ_FROM_PRIVACY_SETTINGS,
      },
      /*daily_per_product_quota=*/kDailyPerProductQuota,
      /*houry_snapshot=*/true});
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));
  SetUpPrivacySettingsServer(std::make_unique<fakes::PrivacySettings>());
  SetPrivacySettings(kUserOptOutDataSharing);
  RunLoopUntilIdle();

  ASSERT_TRUE(FileOneCrashReport().is_ok());
}

TEST_F(CrashReporterTest, Upload_OnceUserOptInDataSharing) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kDefaultAnnotations, kDefaultAttachmentBundleKey));
  SetUpCrashReporter(
      Config{/*crash_server=*/
             {
                 /*upload_policy=*/CrashServerConfig::UploadPolicy::READ_FROM_PRIVACY_SETTINGS,
             },
             /*daily_per_product_quota=*/kDailyPerProductQuota,
             /*hourly_snapshot=*/true},
      std::vector({kUploadSuccessful}));
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));
  SetUpPrivacySettingsServer(std::make_unique<fakes::PrivacySettings>());

  ASSERT_TRUE(FileOneCrashReport().is_ok());
  CheckServerStillExpectRequests();

  SetPrivacySettings(kUserOptInDataSharing);
  ASSERT_TRUE(RunLoopUntilIdle());

  CheckAnnotationsOnServer(kDefaultAnnotations);
  CheckAttachmentsOnServer({kDefaultAttachmentBundleKey});
}

TEST_F(CrashReporterTest, Succeed_OnFailedUpload) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kEmptyAnnotations, kEmptyAttachmentBundleKey));
  SetUpCrashReporter(
      Config{/*crash_server=*/
             {
                 /*upload_policy=*/CrashServerConfig::UploadPolicy::ENABLED,
             },
             /*daily_per_product_quota=*/kDailyPerProductQuota,
             /*hourly_snapshot=*/true},
      std::vector({kUploadFailed}));
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  EXPECT_TRUE(FileOneCrashReport().is_ok());
}

TEST_F(CrashReporterTest, Succeed_OnThrottledUpload) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kEmptyAnnotations, kEmptyAttachmentBundleKey));
  SetUpCrashReporter(
      Config{/*crash_server=*/
             {
                 /*upload_policy=*/CrashServerConfig::UploadPolicy::ENABLED,
             },
             /*daily_per_product_quota=*/kDailyPerProductQuota,
             /*hourly_snapshot=*/true},
      std::vector({kUploadThrottled}));
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  EXPECT_TRUE(FileOneCrashReport().is_ok());
}

TEST_F(CrashReporterTest, Succeed_OnDisabledUpload) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kEmptyAnnotations, kEmptyAttachmentBundleKey));
  SetUpCrashReporter(Config{/*crash_server=*/
                            {
                                /*upload_policy=*/CrashServerConfig::UploadPolicy::DISABLED,
                            },
                            /*daily_per_product_quota=*/kDailyPerProductQuota,
                            /*hourly_snapshot=*/true});
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  EXPECT_TRUE(FileOneCrashReport().is_ok());
}

TEST_F(CrashReporterTest, Succeed_OnNoFeedbackAttachments) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProviderReturnsNoAttachment>(kDefaultAnnotations));
  SetUpCrashReporterDefaultConfig({kUploadSuccessful});
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  EXPECT_TRUE(FileOneCrashReportWithSingleAttachment().is_ok());
  CheckAnnotationsOnServer(kDefaultAnnotations);
  CheckAttachmentsOnServer({kSingleAttachmentKey});
}

TEST_F(CrashReporterTest, Succeed_OnNoFeedbackAnnotations) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProviderReturnsNoAnnotation>(kEmptyAttachmentBundleKey));
  SetUpCrashReporterDefaultConfig({kUploadSuccessful});
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  EXPECT_TRUE(FileOneCrashReportWithSingleAttachment().is_ok());
  CheckAnnotationsOnServer();
  CheckAttachmentsOnServer({kSingleAttachmentKey, kEmptyAttachmentBundleKey});
}

TEST_F(CrashReporterTest, Succeed_OnNoFeedbackData) {
  SetUpDataProviderServer(std::make_unique<stubs::DataProviderReturnsEmptySnapshot>());
  SetUpCrashReporterDefaultConfig({kUploadSuccessful});
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  EXPECT_TRUE(FileOneCrashReportWithSingleAttachment().is_ok());
  CheckAnnotationsOnServer({
      {"debug.snapshot.present", "false"},
  });
  CheckAttachmentsOnServer({kSingleAttachmentKey});
}

TEST_F(CrashReporterTest, Upload_HourlySnapshot) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kDefaultAnnotations, kDefaultAttachmentBundleKey));
  SetUpCrashReporterDefaultConfig({kUploadSuccessful, kUploadSuccessful});
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  RunLoopFor(zx::min(5));
  EXPECT_THAT(crash_server_->latest_annotations().Raw(),
              IsSupersetOf(Linearize(std::map<std::string, testing::Matcher<std::string>>({
                  {"ptime", Not(IsEmpty())},
                  {"signature", kHourlySnapshotSignature},
              }))));
  CheckAttachmentsOnServer({kDefaultAttachmentBundleKey});

  RunLoopFor(zx::hour(1));
  EXPECT_THAT(crash_server_->latest_annotations().Raw(),
              IsSupersetOf(Linearize(std::map<std::string, testing::Matcher<std::string>>({
                  {"ptime", Not(IsEmpty())},
                  {"signature", kHourlySnapshotSignature},
              }))));
  CheckAttachmentsOnServer({kDefaultAttachmentBundleKey});
}

TEST_F(CrashReporterTest, Skip_HourlySnapshotIfPending) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kDefaultAnnotations, kDefaultAttachmentBundleKey));
  SetUpCrashReporterDefaultConfig({
      // Initial upload attempt.
      kUploadFailed,

      // 4 failed periodic uploads by the queue.
      kUploadFailed,
      kUploadFailed,
      kUploadFailed,
      kUploadFailed,
  });
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  RunLoopFor(zx::min(5));
  RunLoopFor(zx::hour(1));

  EXPECT_THAT(crash_server_->latest_annotations().Raw(),
              IsSupersetOf(Linearize(std::map<std::string, testing::Matcher<std::string>>({
                  {"ptime", Not(IsEmpty())},
                  {"signature", kHourlySnapshotSignature},
              }))));
  CheckAttachmentsOnServer({kDefaultAttachmentBundleKey});
}

TEST_F(CrashReporterTest, Skip_HourlySnapshotIfNegativeConsent) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kDefaultAnnotations, kDefaultAttachmentBundleKey));
  SetUpCrashReporter(
      Config{/*crash_server=*/
             {
                 /*upload_policy=*/CrashServerConfig::UploadPolicy::READ_FROM_PRIVACY_SETTINGS,
             },
             /*daily_per_product_quota=*/kDailyPerProductQuota,
             /*houry_snapshot=*/true},
      std::vector<CrashServer::UploadStatus>({}));
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));
  SetUpPrivacySettingsServer(std::make_unique<fakes::PrivacySettings>());
  SetPrivacySettings(kUserOptOutDataSharing);

  RunLoopFor(zx::min(5));
}

TEST_F(CrashReporterTest, Check_CobaltAfterSuccessfulUpload) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kEmptyAnnotations, kEmptyAttachmentBundleKey));
  SetUpCrashReporterDefaultConfig({kUploadSuccessful});
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  EXPECT_TRUE(FileOneCrashReport().is_ok());

  EXPECT_THAT(ReceivedCobaltEvents(),
              UnorderedElementsAreArray({
                  cobalt::Event(cobalt::CrashState::kFiled),
                  cobalt::Event(cobalt::CrashState::kUploaded),
                  cobalt::Event(cobalt::UploadAttemptState::kUploadAttempt, 1u),
                  cobalt::Event(cobalt::UploadAttemptState::kUploaded, 1u),
              }));
}

TEST_F(CrashReporterTest, Check_CobaltAfterQuotaReached) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kEmptyAnnotations, kEmptyAttachmentBundleKey));
  SetUpCrashReporter(Config{/*crash_server=*/
                            {
                                /*upload_policy=*/CrashServerConfig::UploadPolicy::ENABLED,
                            },
                            /*daily_per_product_quota=*/0u,
                            /*hourly_snapshot=*/true});
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  EXPECT_TRUE(FileOneCrashReport().is_ok());
  EXPECT_THAT(ReceivedCobaltEvents(), UnorderedElementsAreArray({
                                          cobalt::Event(cobalt::CrashState::kOnDeviceQuotaReached),
                                      }));
}

TEST_F(CrashReporterTest, Check_CobaltAfterInvalidInputCrashReport) {
  SetUpDataProviderServer(std::make_unique<stubs::DataProviderReturnsEmptySnapshot>());
  SetUpCrashReporterDefaultConfig();
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  EXPECT_TRUE(FileOneEmptyCrashReport().is_error());
  EXPECT_THAT(ReceivedCobaltEvents(), UnorderedElementsAreArray({
                                          cobalt::Event(cobalt::CrashState::kDropped),
                                      }));
}

// Test fixture that replaces the runtime clock before starting.
class CrashReporterTestWithClock : public CrashReporterTest {
 public:
  CrashReporterTestWithClock() {
    // Create a |test_clock_|.
    zx_clock_create_args_v1_t clock_args{.backstop_time = 0};
    FX_CHECK(zx::clock::create(0u, &clock_args, &test_clock_) == ZX_OK);

    // Duplicate |test_clock| into |tmp_clock|.
    zx::clock tmp_clock;
    zx_info_handle_basic_t clock_info;
    FX_CHECK(test_clock_.get_info(ZX_INFO_HANDLE_BASIC, &clock_info, sizeof(clock_info), nullptr,
                                  nullptr) == ZX_OK);
    FX_CHECK(test_clock_.duplicate(clock_info.rights, &tmp_clock) == ZX_OK);

    // Install |tmp_clock_| and save the old clock in |old_clock_|.
    FX_CHECK(zx_utc_reference_swap(tmp_clock.release(), old_clock_.reset_and_get_address()) ==
             ZX_OK);
  }

  ~CrashReporterTestWithClock() {
    // Swapping clocks while |crash_reporter_| is waiting on |test_clock_| causes a crash.
    crash_reporter_.reset();

    // Reinstall the old clock.
    zx::clock tmp_clock;
    FX_CHECK(zx_utc_reference_swap(old_clock_.release(), tmp_clock.reset_and_get_address()) ==
             ZX_OK);
  }

 private:
  zx::clock test_clock_;
  zx::clock old_clock_;
};

TEST_F(CrashReporterTestWithClock, Check_UtcTimeIsNotReady) {
  SetUpDataProviderServer(
      std::make_unique<stubs::DataProvider>(kDefaultAnnotations, kDefaultAttachmentBundleKey));
  SetUpCrashReporterDefaultConfig({kUploadSuccessful});
  SetUpChannelProviderServer(
      std::make_unique<stubs::ChannelControl>(stubs::ChannelControlBase::Params{
          .current = kDefaultChannel,
          .target = std::nullopt,
      }));
  SetUpDeviceIdProviderServer(std::make_unique<stubs::DeviceIdProvider>(kDefaultDeviceId));

  ASSERT_TRUE(FileOneCrashReport().is_ok());
  CheckAttachmentsOnServer({kDefaultAttachmentBundleKey});

  EXPECT_FALSE(crash_server_->latest_annotations().Contains("reportTimeMillis"));
  ASSERT_TRUE(crash_server_->latest_annotations().Contains("debug.report-time.set"));
  EXPECT_EQ(crash_server_->latest_annotations().Get("debug.report-time.set"), "false");
}

}  // namespace
}  // namespace crash_reports
}  // namespace forensics