| // 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/feedback_data/metadata.h" |
| |
| #include <lib/fpromise/result.h> |
| #include <lib/syslog/cpp/macros.h> |
| |
| #include <cstring> |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| #include <gmock/gmock.h> |
| #include <gtest/gtest.h> |
| |
| #include "src/developer/forensics/feedback/attachments/types.h" |
| #include "src/developer/forensics/feedback_data/constants.h" |
| #include "src/developer/forensics/feedback_data/metadata_schema.h" |
| #include "src/developer/forensics/testing/unit_test_fixture.h" |
| #include "src/developer/forensics/utils/errors.h" |
| #include "src/developer/forensics/utils/redact/redactor.h" |
| #include "src/lib/files/file.h" |
| #include "src/lib/files/path.h" |
| #include "src/lib/timekeeper/test_clock.h" |
| #include "third_party/rapidjson/include/rapidjson/document.h" |
| #include "third_party/rapidjson/include/rapidjson/schema.h" |
| |
| #define ANNOTATIONS_JSON_STATE_IS(json, state) \ |
| { \ |
| ASSERT_TRUE(json.HasMember("files")); \ |
| auto& files = json["files"]; \ |
| ASSERT_TRUE(files.HasMember("annotations.json")); \ |
| ASSERT_TRUE(files["annotations.json"].HasMember("state")); \ |
| EXPECT_STREQ(files["annotations.json"]["state"].GetString(), state); \ |
| } |
| |
| #define HAS_PRESENT_ANNOTATION(json, name) \ |
| { \ |
| ASSERT_TRUE(json.HasMember("files")); \ |
| auto& files = json["files"]; \ |
| ASSERT_TRUE(files.HasMember("annotations.json")); \ |
| ASSERT_TRUE(files["annotations.json"].HasMember("present annotations")); \ |
| { \ |
| bool has_annotation = false; \ |
| for (const auto& annotation : files["annotations.json"]["present annotations"].GetArray()) { \ |
| if (strcmp(annotation.GetString(), name) == 0) { \ |
| has_annotation = true; \ |
| break; \ |
| } \ |
| } \ |
| EXPECT_TRUE(has_annotation&& name); \ |
| } \ |
| } |
| |
| #define HAS_MISSING_ANNOTATION(json, name, error) \ |
| { \ |
| ASSERT_TRUE(json.HasMember("files")); \ |
| auto& files = json["files"]; \ |
| ASSERT_TRUE(files.HasMember("annotations.json")); \ |
| ASSERT_TRUE(files["annotations.json"].HasMember("missing annotations")); \ |
| ASSERT_TRUE(files["annotations.json"]["missing annotations"].HasMember(name)); \ |
| EXPECT_STREQ(files["annotations.json"]["missing annotations"][name].GetString(), error); \ |
| } |
| |
| #define HAS_COMPLETE_ATTACHMENT(json, name) \ |
| { \ |
| ASSERT_TRUE(json.HasMember("files")); \ |
| auto& files = json["files"]; \ |
| ASSERT_TRUE(files.HasMember(name)); \ |
| ASSERT_TRUE(files[name].HasMember("state")); \ |
| EXPECT_STREQ(files[name]["state"].GetString(), "complete"); \ |
| } |
| |
| #define HAS_PARTIAL_ATTACHMENT(json, name, error) \ |
| { \ |
| ASSERT_TRUE(json.HasMember("files")); \ |
| auto& files = json["files"]; \ |
| ASSERT_TRUE(files.HasMember(name)); \ |
| ASSERT_TRUE(files[name].HasMember("state")); \ |
| EXPECT_STREQ(files[name]["state"].GetString(), "partial"); \ |
| ASSERT_TRUE(files[name].HasMember("error")); \ |
| EXPECT_STREQ(files[name]["error"].GetString(), error); \ |
| } |
| |
| #define HAS_MISSING_ATTACHMENT(json, name, error) \ |
| { \ |
| ASSERT_TRUE(json.HasMember("files")); \ |
| auto& files = json["files"]; \ |
| ASSERT_TRUE(files.HasMember(name)); \ |
| ASSERT_TRUE(files[name].HasMember("state")); \ |
| EXPECT_STREQ(files[name]["state"].GetString(), "missing"); \ |
| ASSERT_TRUE(files[name].HasMember("error")); \ |
| EXPECT_STREQ(files[name]["error"].GetString(), error); \ |
| } |
| |
| #define UTC_MONOTONIC_DIFFERENCE_IS(json, name, utc_monotonic_difference) \ |
| { \ |
| ASSERT_TRUE(json.HasMember("files")); \ |
| auto& files = json["files"]; \ |
| ASSERT_TRUE(files.HasMember(name)); \ |
| ASSERT_TRUE(files[name].HasMember("utc_monotonic_difference_nanos")); \ |
| ASSERT_TRUE(files[name]["utc_monotonic_difference_nanos"].IsInt64()); \ |
| EXPECT_EQ(files[name]["utc_monotonic_difference_nanos"].GetInt64(), \ |
| utc_monotonic_difference.get()); \ |
| } |
| |
| namespace forensics { |
| namespace feedback_data { |
| namespace { |
| |
| constexpr zx::duration kPreviousBootUtcMonotonicDifference = zx::sec(100); |
| constexpr const char* kSnapshotUuid = "snapshot_uuid"; |
| |
| template <typename C> |
| std::vector<std::string> ToVector(const C& json_array) { |
| FX_CHECK(json_array.IsArray()); |
| std::vector<std::string> v; |
| for (const auto& e : json_array.GetArray()) { |
| FX_CHECK(e.IsString()); |
| v.push_back(e.GetString()); |
| } |
| |
| return v; |
| } |
| |
| static const std::string kSuccessfullyRedactedCanary = "SUCCESSFULLY REDACTED CANARY"; |
| static const std::string kUnsuccessfullyRedactedCanary = "UNSUCCESSFULLY REDACTED CANARY"; |
| |
| class RedactorForTest : public RedactorBase { |
| public: |
| RedactorForTest() : RedactorBase(inspect::BoolProperty{}) {} |
| |
| std::string& Redact(std::string& text) override { |
| if (text == UnredactedCanary()) { |
| text = std::string(kSuccessfullyRedactedCanary); |
| } else { |
| text = std::string(kUnsuccessfullyRedactedCanary); |
| } |
| return text; |
| } |
| |
| std::string UnredactedCanary() const override { return "UNREDACTED CANARY MESSAGE"; } |
| std::string RedactedCanary() const override { return ""; } |
| }; |
| |
| class MetadataTest : public UnitTestFixture { |
| protected: |
| void SetUp() override { |
| FX_CHECK(files::WriteFile(files::JoinPath("/cache", kUtcMonotonicDifferenceFile), |
| std::to_string(kPreviousBootUtcMonotonicDifference.get()))); |
| } |
| |
| void TearDown() override { |
| files::DeletePath(files::JoinPath("/tmp", kUtcMonotonicDifferenceFile), /*recursive=*/false); |
| files::DeletePath(files::JoinPath("/cache", kUtcMonotonicDifferenceFile), /*recursive=*/false); |
| } |
| |
| void SetUpMetadata(const std::set<std::string>& annotation_allowlist, |
| const feedback::AttachmentKeys& attachment_allowlist) { |
| metadata_ = |
| std::make_unique<Metadata>(dispatcher(), &clock_, &redactor_, /*is_first_instance=*/true, |
| annotation_allowlist, attachment_allowlist); |
| } |
| |
| // Get the integrity metadata for the provided annotations and attachments, check that it adheres |
| // to the schema, and turn it into a json document |
| rapidjson::Document MakeJsonReport(const feedback::Annotations& annotations, |
| const feedback::Attachments& attachments, |
| const bool missing_non_platform_annotations = false) { |
| FX_CHECK(metadata_); |
| const auto metadata_str = metadata_->MakeMetadata(annotations, attachments, kSnapshotUuid, |
| missing_non_platform_annotations); |
| |
| rapidjson::Document json; |
| FX_CHECK(!json.Parse(metadata_str.c_str()).HasParseError()); |
| |
| rapidjson::Document schema_json; |
| FX_CHECK(!schema_json.Parse(kMetadataSchema).HasParseError()); |
| rapidjson::SchemaDocument schema(schema_json); |
| rapidjson::SchemaValidator validator(schema); |
| FX_CHECK(json.Accept(validator)); |
| |
| // Convert to std::string to use its '==' operator. |
| FX_CHECK(json["snapshot_version"].GetString() == std::string(SnapshotVersion::kString)); |
| FX_CHECK(json["metadata_version"].GetString() == std::string(Metadata::kVersion)); |
| FX_CHECK(json["snapshot_uuid"].GetString() == std::string(kSnapshotUuid)); |
| FX_CHECK(ToVector(json["log_redaction_canary"]) == |
| std::vector<std::string>({kSuccessfullyRedactedCanary})); |
| |
| return json; |
| } |
| |
| timekeeper::TestClock clock_; |
| RedactorForTest redactor_; |
| std::unique_ptr<Metadata> metadata_; |
| }; |
| |
| TEST_F(MetadataTest, Check_AddsMissingAnnotationsOnNoAnnotations) { |
| const std::set<std::string> annotation_allowlist = { |
| "annotation 1", |
| }; |
| |
| SetUpMetadata(annotation_allowlist, /*attachment_allowlist=*/{}); |
| |
| const auto metadata_json = MakeJsonReport({}, {}); |
| HAS_MISSING_ANNOTATION(metadata_json, "annotation 1", "feedback logic error"); |
| } |
| |
| TEST_F(MetadataTest, Check_AddsMissingAnnotationsOnEmptyAnnotations) { |
| const std::set<std::string> annotation_allowlist = { |
| "annotation 1", |
| }; |
| |
| SetUpMetadata(annotation_allowlist, /*attachment_allowlist=*/{}); |
| |
| const auto metadata_json = MakeJsonReport({}, {}); |
| HAS_MISSING_ANNOTATION(metadata_json, "annotation 1", "feedback logic error"); |
| } |
| |
| TEST_F(MetadataTest, Check_AddsMissingAttachmentsOnNoAttachments) { |
| const feedback::AttachmentKeys attachment_allowlist = { |
| "attachment 1", |
| }; |
| |
| SetUpMetadata(/*annotation_allowlist=*/{}, attachment_allowlist); |
| |
| const auto metadata_json = MakeJsonReport({}, {}); |
| HAS_MISSING_ATTACHMENT(metadata_json, "attachment 1", "feedback logic error"); |
| } |
| |
| TEST_F(MetadataTest, Check_AddsMissingAttachmentsOnEmptyAttachments) { |
| const feedback::AttachmentKeys attachment_allowlist = { |
| "attachment 1", |
| }; |
| |
| SetUpMetadata(/*annotation_allowlist=*/{}, attachment_allowlist); |
| |
| const auto metadata_json = MakeJsonReport({}, {}); |
| HAS_MISSING_ATTACHMENT(metadata_json, "attachment 1", "feedback logic error"); |
| } |
| |
| TEST_F(MetadataTest, Check_FormatAnnotationsProperly) { |
| const std::set<std::string> annotation_allowlist = { |
| "present annotation 1", |
| "present annotation 2", |
| "missing annotation 1", |
| "missing annotation 2", |
| }; |
| |
| const feedback::Annotations annotations = { |
| {"present annotation 1", ""}, |
| {"present annotation 2", ""}, |
| {"missing annotation 1", Error::kConnectionError}, |
| {"missing annotation 2", Error::kFileWriteFailure}, |
| }; |
| |
| SetUpMetadata(annotation_allowlist, /*attachment_allowlist=*/{}); |
| |
| const auto metadata_json = MakeJsonReport(std::move(annotations), {}); |
| |
| ANNOTATIONS_JSON_STATE_IS(metadata_json, "partial"); |
| |
| HAS_PRESENT_ANNOTATION(metadata_json, "present annotation 1"); |
| HAS_PRESENT_ANNOTATION(metadata_json, "present annotation 2"); |
| |
| HAS_MISSING_ANNOTATION(metadata_json, "missing annotation 1", "FIDL connection error"); |
| HAS_MISSING_ANNOTATION(metadata_json, "missing annotation 2", "file write failure"); |
| } |
| |
| TEST_F(MetadataTest, Check_FormatAttachmentsProperly) { |
| const feedback::AttachmentKeys attachment_allowlist = { |
| "complete attachment 1", "complete attachment 2", "partial attachment 1", |
| "partial attachment 2", "missing attachment 1", "missing attachment 2", |
| }; |
| |
| const feedback::Attachments attachments = { |
| {"complete attachment 1", feedback::AttachmentValue("")}, |
| {"complete attachment 2", feedback::AttachmentValue("")}, |
| {"partial attachment 1", feedback::AttachmentValue("", Error::kTimeout)}, |
| {"partial attachment 2", feedback::AttachmentValue("", Error::kAsyncTaskPostFailure)}, |
| {"missing attachment 1", feedback::AttachmentValue(Error::kBadValue)}, |
| {"missing attachment 2", feedback::AttachmentValue(Error::kFileReadFailure)}, |
| }; |
| |
| SetUpMetadata(/*annotation_allowlist=*/{}, attachment_allowlist); |
| |
| const auto metadata_json = MakeJsonReport({}, std::move(attachments)); |
| |
| HAS_COMPLETE_ATTACHMENT(metadata_json, "complete attachment 1"); |
| HAS_COMPLETE_ATTACHMENT(metadata_json, "complete attachment 2"); |
| |
| HAS_PARTIAL_ATTACHMENT(metadata_json, "partial attachment 1", "data collection timeout"); |
| HAS_PARTIAL_ATTACHMENT(metadata_json, "partial attachment 2", "async post task failure"); |
| |
| HAS_MISSING_ATTACHMENT(metadata_json, "missing attachment 1", "bad data returned"); |
| HAS_MISSING_ATTACHMENT(metadata_json, "missing attachment 2", "file read failure"); |
| } |
| |
| TEST_F(MetadataTest, Check_NonPlatformAnnotationsComplete) { |
| const feedback::Annotations annotations = { |
| {"non-platform annotation", ""}, |
| }; |
| |
| SetUpMetadata(/*annotation_allowlist=*/{}, /*attachment_allowlist=*/{}); |
| |
| const auto metadata_json = MakeJsonReport(std::move(annotations), {}); |
| |
| HAS_PRESENT_ANNOTATION(metadata_json, "non-platform annotations"); |
| } |
| |
| TEST_F(MetadataTest, Check_NonPlatformAnnotationsPartial) { |
| const feedback::Annotations annotations = { |
| {"non-platform annotation", ""}, |
| }; |
| |
| SetUpMetadata(/*annotation_allowlist=*/{}, /*attachment_allowlist=*/{}); |
| |
| const auto metadata_json = MakeJsonReport(std::move(annotations), {}, |
| /*missing_non_platform_annotations=*/true); |
| |
| HAS_MISSING_ANNOTATION(metadata_json, "non-platform annotations", |
| "too many non-platfrom annotations added"); |
| } |
| |
| TEST_F(MetadataTest, Check_NonPlatformAnnotationsMissing) { |
| SetUpMetadata(/*annotation_allowlist=*/{}, /*attachment_allowlist=*/{}); |
| |
| const auto metadata_json = MakeJsonReport({}, {}, |
| /*missing_non_platform_annotations=*/true); |
| |
| HAS_MISSING_ANNOTATION(metadata_json, "non-platform annotations", |
| "too many non-platfrom annotations added"); |
| } |
| |
| TEST_F(MetadataTest, Check_SmokeTest) { |
| const std::set<std::string> annotation_allowlist = { |
| "present annotation 1", "present annotation 2", "missing annotation 1", |
| "missing annotation 2", "missing annotation 3", |
| }; |
| |
| const feedback::Annotations annotations = { |
| {"present annotation 1", ""}, |
| {"present annotation 2", ""}, |
| {"missing annotation 1", Error::kConnectionError}, |
| {"missing annotation 2", Error::kFileWriteFailure}, |
| {"non-platform annotation 1", ""}, |
| }; |
| |
| const feedback::AttachmentKeys attachment_allowlist = { |
| "complete attachment 1", "complete attachment 2", "partial attachment 1", |
| "partial attachment 2", "missing attachment 1", "missing attachment 2", |
| "missing attachment 3", |
| }; |
| const feedback::Attachments attachments = { |
| {"complete attachment 1", feedback::AttachmentValue("")}, |
| {"complete attachment 2", feedback::AttachmentValue("")}, |
| {"partial attachment 1", feedback::AttachmentValue("", Error::kTimeout)}, |
| {"partial attachment 2", feedback::AttachmentValue("", Error::kAsyncTaskPostFailure)}, |
| {"missing attachment 1", feedback::AttachmentValue(Error::kBadValue)}, |
| {"missing attachment 2", feedback::AttachmentValue(Error::kFileReadFailure)}, |
| }; |
| |
| SetUpMetadata(annotation_allowlist, attachment_allowlist); |
| |
| const auto metadata_json = MakeJsonReport(std::move(annotations), std::move(attachments), |
| /*missing_non_platform_annotations=*/true); |
| |
| HAS_COMPLETE_ATTACHMENT(metadata_json, "complete attachment 1"); |
| HAS_COMPLETE_ATTACHMENT(metadata_json, "complete attachment 2"); |
| |
| HAS_PARTIAL_ATTACHMENT(metadata_json, "partial attachment 1", "data collection timeout"); |
| HAS_PARTIAL_ATTACHMENT(metadata_json, "partial attachment 2", "async post task failure"); |
| |
| HAS_MISSING_ATTACHMENT(metadata_json, "missing attachment 1", "bad data returned"); |
| HAS_MISSING_ATTACHMENT(metadata_json, "missing attachment 2", "file read failure"); |
| HAS_MISSING_ATTACHMENT(metadata_json, "missing attachment 3", "feedback logic error"); |
| |
| ANNOTATIONS_JSON_STATE_IS(metadata_json, "partial"); |
| |
| HAS_PRESENT_ANNOTATION(metadata_json, "present annotation 1"); |
| HAS_PRESENT_ANNOTATION(metadata_json, "present annotation 2"); |
| |
| HAS_MISSING_ANNOTATION(metadata_json, "missing annotation 1", "FIDL connection error"); |
| HAS_MISSING_ANNOTATION(metadata_json, "missing annotation 2", "file write failure"); |
| HAS_MISSING_ANNOTATION(metadata_json, "missing annotation 3", "feedback logic error"); |
| |
| HAS_MISSING_ANNOTATION(metadata_json, "non-platform annotations", |
| "too many non-platfrom annotations added"); |
| } |
| |
| TEST_F(MetadataTest, Check_EmptySnapshot) { |
| SetUpMetadata(/*annotation_allowlist=*/{}, /*attachment_allowlist=*/{}); |
| |
| auto metadata_str = metadata_->MakeMetadata({}, {}, kSnapshotUuid, |
| /*missing_non_platform_annotations=*/false); |
| |
| rapidjson::Document json; |
| ASSERT_TRUE(!json.Parse(metadata_str.c_str()).HasParseError()); |
| |
| rapidjson::Document schema_json; |
| ASSERT_TRUE(!schema_json.Parse(kMetadataSchema).HasParseError()); |
| rapidjson::SchemaDocument schema(schema_json); |
| rapidjson::SchemaValidator validator(schema); |
| ASSERT_TRUE(json.Accept(validator)); |
| |
| // Convert to std::string to use its '==' operator. |
| EXPECT_STREQ(json["snapshot_version"].GetString(), SnapshotVersion::kString); |
| EXPECT_STREQ(json["metadata_version"].GetString(), Metadata::kVersion); |
| EXPECT_STREQ(json["snapshot_uuid"].GetString(), kSnapshotUuid); |
| EXPECT_EQ(ToVector(json["log_redaction_canary"]), |
| std::vector<std::string>({kSuccessfullyRedactedCanary})); |
| |
| EXPECT_TRUE(json.HasMember("files")); |
| EXPECT_TRUE(json["files"].IsObject()); |
| EXPECT_TRUE(json["files"].GetObject().ObjectEmpty()); |
| } |
| |
| TEST_F(MetadataTest, Check_UtcMonotonicDifference) { |
| const std::set<std::string> annotation_allowlist = { |
| "annotation 1", |
| }; |
| |
| const feedback::AttachmentKeys attachment_allowlist = { |
| kAttachmentInspect, |
| kAttachmentLogKernel, |
| kAttachmentLogSystem, |
| kPreviousLogsFilePath, |
| }; |
| |
| const feedback::Annotations annotations = { |
| {"annotation 1", "annotation"}, |
| }; |
| |
| const feedback::Attachments attachments = { |
| {kAttachmentInspect, feedback::AttachmentValue("")}, |
| {kAttachmentLogKernel, feedback::AttachmentValue("")}, |
| {kAttachmentLogSystem, feedback::AttachmentValue("")}, |
| {kAttachmentLogSystemPrevious, feedback::AttachmentValue("")}, |
| }; |
| |
| SetUpMetadata(annotation_allowlist, attachment_allowlist); |
| RunLoopUntilIdle(); |
| |
| zx::time monotonic; |
| timekeeper::time_utc utc; |
| |
| clock_.Set(zx::time(0)); |
| |
| const zx::duration utc_monotonic_difference(utc.get() - monotonic.get()); |
| |
| monotonic = clock_.Now(); |
| ASSERT_EQ(clock_.UtcNow(&utc), ZX_OK); |
| |
| const auto metadata_json = MakeJsonReport(std::move(annotations), std::move(attachments)); |
| |
| UTC_MONOTONIC_DIFFERENCE_IS(metadata_json, kAttachmentInspect, utc_monotonic_difference); |
| UTC_MONOTONIC_DIFFERENCE_IS(metadata_json, kAttachmentLogKernel, utc_monotonic_difference); |
| UTC_MONOTONIC_DIFFERENCE_IS(metadata_json, kAttachmentLogSystem, utc_monotonic_difference); |
| UTC_MONOTONIC_DIFFERENCE_IS(metadata_json, kAttachmentLogSystemPrevious, |
| kPreviousBootUtcMonotonicDifference); |
| |
| ASSERT_TRUE(metadata_json["files"].HasMember(kAttachmentAnnotations)); |
| ASSERT_FALSE( |
| metadata_json["files"][kAttachmentAnnotations].HasMember("utc_monotonic_difference")); |
| } |
| |
| TEST_F(MetadataTest, Check_NoUtcMontonicDifferenceAvailable) { |
| const std::set<std::string> annotation_allowlist = { |
| "annotation 1", |
| }; |
| |
| const feedback::AttachmentKeys attachment_allowlist = { |
| "attachment 1", |
| }; |
| |
| const feedback::Annotations annotations = { |
| {"annotation 1", ""}, |
| }; |
| |
| const feedback::Attachments attachments = { |
| {"attachment 1", feedback::AttachmentValue("")}, |
| }; |
| |
| SetUpMetadata(annotation_allowlist, attachment_allowlist); |
| |
| const auto metadata_json = MakeJsonReport(std::move(annotations), std::move(attachments)); |
| |
| ASSERT_TRUE(metadata_json["files"].HasMember(kAttachmentAnnotations)); |
| ASSERT_FALSE( |
| metadata_json["files"][kAttachmentAnnotations].HasMember("utc_monotonic_difference")); |
| |
| ASSERT_TRUE(metadata_json["files"].HasMember("attachment 1")); |
| ASSERT_FALSE(metadata_json["files"]["attachment 1"].HasMember("utc_monotonic_difference")); |
| } |
| |
| TEST_F(MetadataTest, Check_NoUtcMonotonicDifferenceMissingFile) { |
| const std::set<std::string> annotation_allowlist = { |
| "annotation 1", |
| }; |
| |
| const feedback::AttachmentKeys attachment_allowlist = { |
| kAttachmentInspect, |
| kAttachmentLogKernel, |
| kAttachmentLogSystem, |
| kPreviousLogsFilePath, |
| }; |
| |
| const feedback::Annotations annotations = { |
| {"annotation 1", "annotation"}, |
| }; |
| |
| const feedback::Attachments attachments = { |
| {kAttachmentInspect, feedback::AttachmentValue("")}, |
| {kAttachmentLogKernel, feedback::AttachmentValue("")}, |
| {kAttachmentLogSystem, feedback::AttachmentValue("")}, |
| {kAttachmentLogSystemPrevious, feedback::AttachmentValue(Error::kCustom)}, |
| }; |
| |
| SetUpMetadata(annotation_allowlist, attachment_allowlist); |
| RunLoopUntilIdle(); |
| |
| zx::time monotonic; |
| timekeeper::time_utc utc; |
| |
| clock_.Set(zx::time(0)); |
| |
| const zx::duration utc_monotonic_difference(utc.get() - monotonic.get()); |
| |
| monotonic = clock_.Now(); |
| ASSERT_EQ(clock_.UtcNow(&utc), ZX_OK); |
| |
| const auto metadata_json = MakeJsonReport(std::move(annotations), std::move(attachments)); |
| |
| UTC_MONOTONIC_DIFFERENCE_IS(metadata_json, kAttachmentInspect, utc_monotonic_difference); |
| UTC_MONOTONIC_DIFFERENCE_IS(metadata_json, kAttachmentLogKernel, utc_monotonic_difference); |
| UTC_MONOTONIC_DIFFERENCE_IS(metadata_json, kAttachmentLogSystem, utc_monotonic_difference); |
| |
| ASSERT_TRUE(metadata_json["files"].HasMember(kAttachmentLogSystemPrevious)); |
| ASSERT_FALSE( |
| metadata_json["files"][kAttachmentLogSystemPrevious].HasMember("utc_monotonic_difference")); |
| |
| ASSERT_TRUE(metadata_json["files"].HasMember(kAttachmentAnnotations)); |
| ASSERT_FALSE( |
| metadata_json["files"][kAttachmentAnnotations].HasMember("utc_monotonic_difference")); |
| } |
| |
| struct TestParam { |
| std::string test_name; |
| std::set<std::string> annotation_allowlist; |
| feedback::Annotations annotations; |
| bool missing_non_platform_annotations; |
| std::string state; |
| }; |
| |
| class AnnotationsJsonStateTest : public MetadataTest, |
| public testing::WithParamInterface<TestParam> {}; |
| |
| INSTANTIATE_TEST_SUITE_P(WithVariousAnnotations, AnnotationsJsonStateTest, |
| ::testing::ValuesIn( |
| std::vector<TestParam>( |
| { |
| TestParam{ |
| .test_name = "CompletePlatform_CompleteNonPlatform", |
| .annotation_allowlist = {"platform"}, |
| .annotations = |
| { |
| {"platform", ""}, |
| {"non-platform", ""}, |
| }, |
| .missing_non_platform_annotations = false, |
| .state = "complete", |
| |
| }, |
| TestParam{ |
| .test_name = "CompletePlatform_PartialNonPlatform", |
| .annotation_allowlist = {"platform"}, |
| .annotations = |
| { |
| {"platform", ""}, |
| {"non-platform", ""}, |
| }, |
| .missing_non_platform_annotations = true, |
| .state = "partial", |
| |
| }, |
| TestParam{ |
| .test_name = "CompletePlatform_MissingNonPlatform", |
| .annotation_allowlist = {"platform"}, |
| .annotations = |
| { |
| {"platform", ""}, |
| }, |
| .missing_non_platform_annotations = true, |
| .state = "partial", |
| |
| }, |
| TestParam{ |
| .test_name = "PartialPlatform_CompleteNonPlatform", |
| .annotation_allowlist = {"platform 1", "platform 2"}, |
| .annotations = |
| { |
| {"platform 1", ""}, |
| {"non-platform", ""}, |
| }, |
| .missing_non_platform_annotations = false, |
| .state = "partial", |
| |
| }, |
| TestParam{ |
| .test_name = "PartialPlatform_PartialNonPlatform", |
| .annotation_allowlist = {"platform 1", "platform 2"}, |
| .annotations = |
| { |
| {"platform 1", ""}, |
| {"non-platform", ""}, |
| }, |
| .missing_non_platform_annotations = true, |
| .state = "partial", |
| |
| }, |
| TestParam{ |
| .test_name = "PartialPlatform_MissingNonPlatform", |
| .annotation_allowlist = {"platform 1", "platform 2"}, |
| .annotations = |
| { |
| {"platform 1", ""}, |
| }, |
| .missing_non_platform_annotations = true, |
| .state = "partial", |
| |
| }, |
| TestParam{ |
| .test_name = "MissingPlatform_CompleteNonPlatform", |
| .annotation_allowlist = {"platform"}, |
| .annotations = |
| { |
| {"non-platform", ""}, |
| }, |
| .missing_non_platform_annotations = false, |
| .state = "partial", |
| |
| }, |
| TestParam{ |
| .test_name = "MissingPlatform_PartialNonPlatform", |
| .annotation_allowlist = {"platform"}, |
| .annotations = |
| { |
| {"non-platform", ""}, |
| }, |
| .missing_non_platform_annotations = true, |
| .state = "partial", |
| |
| }, |
| TestParam{ |
| .test_name = "MissingPlatform_MissingNonPlatform", |
| .annotation_allowlist = {"platform"}, |
| .annotations = {}, |
| .missing_non_platform_annotations = true, |
| .state = "missing", |
| |
| }, |
| })), |
| [](const testing::TestParamInfo<TestParam>& info) { |
| return info.param.test_name; |
| }); |
| TEST_P(AnnotationsJsonStateTest, Succeed) { |
| const auto param = GetParam(); |
| SetUpMetadata(param.annotation_allowlist, /*attachment_allowlist=*/{}); |
| |
| const auto metadata_json = |
| MakeJsonReport(param.annotations, {}, param.missing_non_platform_annotations); |
| ANNOTATIONS_JSON_STATE_IS(metadata_json, param.state.c_str()); |
| } |
| |
| } // namespace |
| } // namespace feedback_data |
| } // namespace forensics |
