| // Copyright 2026 Google LLC |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // https://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| |
| #include "assertion/parse_assertion.h" |
| |
| #include "absl/status/status.h" |
| #include "absl/status/status_matchers.h" |
| #include "absl/strings/string_view.h" |
| #include "gmock/gmock.h" |
| #include "google/protobuf/struct.pb.h" |
| #include "gtest/gtest.h" |
| #include "nlohmann/json.hpp" |
| #include "proto/actions_assertion.pb.h" |
| #include "proto/ai_disclosure_assertion.pb.h" |
| #include "proto/assertion.pb.h" |
| #include "proto/asset_reference_assertion.pb.h" |
| #include "proto/asset_types_assertion.pb.h" |
| #include "proto/bmff_based_hash_assertion.pb.h" |
| #include "proto/boxes_hash_assertion.pb.h" |
| #include "proto/collection_data_hash_assertion.pb.h" |
| #include "proto/data_hash_assertion.pb.h" |
| #include "proto/environmental_sustainability_assertion.pb.h" |
| #include "proto/ingredient_assertion.pb.h" |
| #include "proto/repository_receipt_assertion.pb.h" |
| #include "testing/cbor_utils.h" |
| #include "testing/proto_test_utils.h" |
| |
| namespace credentio { |
| namespace { |
| |
| using Json = ::nlohmann::json; |
| |
| using ::absl_testing::IsOk; |
| using ::absl_testing::StatusIs; |
| using ::cbor::FromJson; |
| using ::credentio::ParseStruct; |
| using ::credentio_testing::EqualsProto; |
| using ::credentio_testing::ParseTextProtoOrDie; |
| using ::testing::HasSubstr; |
| |
| TEST(ParseAssertionTest, ActionsAssertionOkay) { |
| auto cbor = FromJson(R"json( |
| { |
| "allActionsIncluded": true, |
| "actions": [ |
| { |
| "action": "c2pa.created", |
| "softwareAgent": { |
| "name": "Joe's Photo Editor", |
| "version": "2.0", |
| "operating_system": "Windows 10" |
| }, |
| "digitalSourceType": "http://cv.iptc.org/newscodes/digitalsourcetype/trainedAlgorithmicMedia", |
| "parameters": { |
| "instanceID": "ed610ae51f604002be3dbf0c589a2f1f", |
| "ingredients" : [ |
| { |
| "url": "self#jumbf=c2pa/joe-ed:urn:uuid:ABCD/c2pa.assertions/c2pa.ingredient.v3__1", |
| "alg": "sha256", |
| "hash" : "b64'aGFzaA=='" |
| }, |
| { |
| "url": "self#jumbf=c2pa/joe-ed:urn:uuid:EFGH/c2pa.assertions/c2pa.ingredient.v3__2", |
| "alg": "sha256", |
| "hash" : "b64'aGFzaA=='" |
| } |
| ], |
| "relatedAssertions": [ |
| { |
| "url": "self#jumbf=c2pa/joe-ed:urn:uuid:ABCD/c2pa.assertions/c2pa.other", |
| "alg": "sha256", |
| "hash" : "b64'aGFzaA=='" |
| } |
| ] |
| } |
| }, |
| { |
| "action": "c2pa.filtered", |
| "softwareAgent" : { |
| "name": "Joe's Photo Editor", |
| "version": "2.0", |
| "operating_system": "Windows 10" |
| } |
| }, |
| { |
| "action": "c2pa.cropped" |
| } |
| ], |
| "templates": [{ |
| "action": "com.joesphoto.filter", |
| "description": "Magic Filter", |
| "digitalSourceType": "http://cv.iptc.org/newscodes/digitalsourcetype/compositeSynthetic", |
| "softwareAgent" : { |
| "name": "Joe's Photo Editor", |
| "version": "2.0", |
| "schema.org.SoftwareApplication.operatingSystem": "Windows 10" |
| }, |
| "icon": { |
| "url": "http://cdn.examplephotoagency.com/logo.svg", |
| "hash": "b64'aGFzaA=='" |
| } |
| }] |
| })json"); |
| auto expected = ParseTextProtoOrDie<credentio::ActionsAssertion>(R"pb( |
| all_actions_included: true |
| actions { |
| action: "c2pa.created" |
| digital_source_type: "http://cv.iptc.org/newscodes/digitalsourcetype/trainedAlgorithmicMedia" |
| software_agent { |
| name: "Joe\'s Photo Editor" |
| version: "2.0" |
| operating_system: "Windows 10" |
| } |
| parameters { |
| instance_id: "ed610ae51f604002be3dbf0c589a2f1f" |
| ingredients { |
| url: "self#jumbf=c2pa/joe-ed:urn:uuid:ABCD/c2pa.assertions/c2pa.ingredient.v3__1" |
| algorithm: "sha256" |
| hash: "hash" |
| } |
| ingredients { |
| url: "self#jumbf=c2pa/joe-ed:urn:uuid:EFGH/c2pa.assertions/c2pa.ingredient.v3__2" |
| algorithm: "sha256" |
| hash: "hash" |
| } |
| related_assertions { |
| url: "self#jumbf=c2pa/joe-ed:urn:uuid:ABCD/c2pa.assertions/c2pa.other" |
| algorithm: "sha256" |
| hash: "hash" |
| } |
| } |
| } |
| actions { |
| action: "c2pa.filtered" |
| software_agent { |
| name: "Joe\'s Photo Editor" |
| version: "2.0" |
| operating_system: "Windows 10" |
| } |
| } |
| actions { action: "c2pa.cropped" } |
| templates { |
| action: "com.joesphoto.filter" |
| description: "Magic Filter" |
| digital_source_type: "http://cv.iptc.org/newscodes/digitalsourcetype/compositeSynthetic" |
| software_agent { name: "Joe\'s Photo Editor" version: "2.0" } |
| icon { url: "http://cdn.examplephotoagency.com/logo.svg" hash: "hash" } |
| } |
| )pb"); |
| credentio::ActionsAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), IsOk()); |
| EXPECT_THAT(result, EqualsProto(expected)); |
| } |
| |
| TEST(ParseAssertionTest, EmptyRelatedAssertionsFails) { |
| auto cbor = FromJson(R"json( |
| { |
| "actions": [ |
| { |
| "action": "c2pa.created", |
| "softwareAgent": { |
| "name": "Joe's Photo Editor", |
| "version": "2.0", |
| "operating_system": "Windows 10" |
| }, |
| "digitalSourceType": "http://cv.iptc.org/newscodes/digitalsourcetype/trainedAlgorithmicMedia", |
| "parameters": { |
| "instanceID": "ed610ae51f604002be3dbf0c589a2f1f", |
| "ingredients" : [ |
| { |
| "url": "self#jumbf=c2pa/joe-ed:urn:uuid:ABCD/c2pa.assertions/c2pa.ingredient.v3__1", |
| "alg": "sha256", |
| "hash" : "b64'aGFzaA=='" |
| }, |
| { |
| "url": "self#jumbf=c2pa/joe-ed:urn:uuid:EFGH/c2pa.assertions/c2pa.ingredient.v3__2", |
| "alg": "sha256", |
| "hash" : "b64'aGFzaA=='" |
| } |
| ], |
| "relatedAssertions": [] |
| } |
| }, |
| { |
| "action": "c2pa.filtered", |
| "softwareAgent" : { |
| "name": "Joe's Photo Editor", |
| "version": "2.0", |
| "operating_system": "Windows 10" |
| } |
| }, |
| { |
| "action": "c2pa.cropped" |
| } |
| ], |
| "templates": [{ |
| "action": "com.joesphoto.filter", |
| "description": "Magic Filter", |
| "digitalSourceType": "http://cv.iptc.org/newscodes/digitalsourcetype/compositeSynthetic", |
| "softwareAgent" : { |
| "name": "Joe's Photo Editor", |
| "version": "2.0", |
| "schema.org.SoftwareApplication.operatingSystem": "Windows 10" |
| }, |
| "icon": { |
| "url": "http://cdn.examplephotoagency.com/logo.svg", |
| "hash": "b64'aGFzaA=='" |
| } |
| }] |
| })json"); |
| credentio::ActionsAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), |
| StatusIs(absl::StatusCode::kInvalidArgument, |
| HasSubstr("Field relatedAssertions cannot be empty"))); |
| } |
| |
| TEST(ParseAssertionTest, ActionV1IngredientField) { |
| auto cbor = FromJson(R"json( |
| { |
| "actions": [ |
| { |
| "action": "c2pa.opened", |
| "parameters": { |
| "ingredient" : { |
| "url": "self#jumbf=c2pa/joe-ed:urn:uuid:ABCD/c2pa.assertions/c2pa.ingredient.v3", |
| "alg": "sha256", |
| "hash" : "b64'aGFzaA=='" |
| } |
| } |
| } |
| ] |
| })json"); |
| // The `ingredient` field in v1 `parameters-map` is exposed in `ingredients`. |
| auto expected = ParseTextProtoOrDie<credentio::ActionsAssertionV1>(R"pb( |
| actions { |
| action: "c2pa.opened" |
| parameters { |
| ingredients { |
| url: "self#jumbf=c2pa/joe-ed:urn:uuid:ABCD/c2pa.assertions/c2pa.ingredient.v3" |
| algorithm: "sha256" |
| hash: "hash" |
| } |
| } |
| } |
| )pb"); |
| credentio::ActionsAssertionV1 proto; |
| EXPECT_THAT(ParseAssertion(cbor, &proto), IsOk()); |
| EXPECT_THAT(proto, EqualsProto(expected)); |
| } |
| |
| TEST(ParseAssertionTest, ActionsAssertionInvalidNotAMap) { |
| auto cbor = FromJson(R"json([ |
| { |
| "action": "c2pa.cropped" |
| } |
| ])json"); |
| credentio::ActionsAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), |
| StatusIs(absl::StatusCode::kInvalidArgument, |
| HasSubstr("CBOR parsed result is not a map"))); |
| } |
| |
| TEST(ParseAssertionTest, ActionsAssertionInvalidNoAction) { |
| auto cbor = FromJson(R"json( |
| { |
| "actions": [ |
| { |
| "softwareAgent" : { |
| "name": "Joe's Photo Editor", |
| "version": "2.0", |
| "operating_system": "Windows 10" |
| } |
| } |
| ] |
| })json"); |
| credentio::ActionsAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), |
| StatusIs(absl::StatusCode::kInvalidArgument, |
| HasSubstr("Missing required field: action"))); |
| } |
| |
| TEST(ParseAssertionTest, ActionsAssertionInvalidActionNotAString) { |
| auto cbor = FromJson(R"json( |
| { |
| "actions": [ |
| { |
| "action": 123 |
| } |
| ] |
| })json"); |
| credentio::ActionsAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), |
| StatusIs(absl::StatusCode::kInvalidArgument, |
| HasSubstr("Missing required field: action"))); |
| } |
| |
| TEST(ParseAssertionTest, ActionsAssertionSkipsInvalidDigitalSourceType) { |
| auto cbor = FromJson(R"json( |
| { |
| "actions": [ |
| { |
| "action": "c2pa.created", |
| "digitalSourceType": 123 |
| } |
| ] |
| })json"); |
| auto expected = ParseTextProtoOrDie<credentio::ActionsAssertion>(R"pb( |
| actions { action: "c2pa.created" } |
| )pb"); |
| credentio::ActionsAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), IsOk()); |
| EXPECT_THAT(result, EqualsProto(expected)); |
| } |
| |
| TEST(ParseAssertionTest, ActionsAssertionInvalidActionArrayContainsNonMap) { |
| auto cbor = FromJson(R"json( |
| { |
| "actions": [ |
| { |
| "action": "c2pa.created", |
| "digitalSourceType": "http://cv.iptc.org/newscodes/digitalsourcetype/trainedAlgorithmicMedia" |
| }, |
| 123 |
| ] |
| })json"); |
| credentio::ActionsAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), |
| StatusIs(absl::StatusCode::kInvalidArgument, |
| HasSubstr("CBOR item is not a map"))); |
| } |
| |
| TEST(ParseAssertionTest, ActionsAssertionInvalidMalformedCbor) { |
| auto cbor = FromJson(R"json( |
| { |
| "actions": [ |
| { |
| "action": "c2pa.created" |
| } |
| ] |
| })json"); |
| credentio::ActionsAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor.substr(0, 10), &result), |
| StatusIs(absl::StatusCode::kInvalidArgument, |
| HasSubstr("CBOR parsing failed"))); |
| } |
| |
| TEST(ParseAssertionTest, ActionsAssertionSkipsInvalidNotArrayActions) { |
| // Invalid `actions`, as it should be an array, not a map. |
| auto cbor = FromJson(R"json( |
| { |
| "actions": |
| { |
| "action": "c2pa.created" |
| } |
| })json"); |
| credentio::ActionsAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), |
| StatusIs(absl::StatusCode::kInvalidArgument, |
| HasSubstr("Missing required field: actions"))); |
| } |
| |
| TEST(ParseAssertionTest, IngredientAssertionOkay) { |
| auto cbor = FromJson(R"json( |
| { |
| "dc:title": "ingredient-title", |
| "dc:format": "ingredient-format", |
| "relationship": "ingredient-relationship", |
| "instanceID": "ingredient-instance-id", |
| "data": { |
| "url": "ingredient-data-url", |
| "alg": "ingredient-data-alg", |
| "hash": "b64'aGFzaA=='", |
| "size": 1234567890 |
| }, |
| "activeManifest": { |
| "url": "ingredient-manifest-url", |
| "alg": "ingredient-manifest-alg", |
| "hash": "b64'aGFzaA=='" |
| }, |
| "thumbnail": { |
| "url": "ingredient-thumbnail-url", |
| "alg": "ingredient-thumbnail-alg", |
| "hash": "b64'aGFzaA=='" |
| }, |
| "validationResults": { |
| "activeManifest": { |
| "success": [ |
| { |
| "code": "status.1", |
| "url": "url.1", |
| "explanation": "explanation.1" |
| }, |
| { |
| "code": "status.2", |
| "url": "url.2", |
| "explanation": "explanation.2" |
| } |
| ], |
| "failure": [], |
| "informational": [] |
| } |
| }, |
| "description": "ingredient-description", |
| "informationalURI": "ingredient-informational-uri" |
| })json"); |
| auto expected = ParseTextProtoOrDie<credentio::IngredientAssertionV3>(R"pb( |
| title: "ingredient-title" |
| media_type: "ingredient-format" |
| relationship: "ingredient-relationship" |
| instance_id: "ingredient-instance-id" |
| data { |
| url: "ingredient-data-url" |
| algorithm: "ingredient-data-alg" |
| hash: "hash" |
| size: 1234567890 |
| } |
| active_manifest { |
| url: "ingredient-manifest-url" |
| algorithm: "ingredient-manifest-alg" |
| hash: "hash" |
| } |
| thumbnail { |
| url: "ingredient-thumbnail-url" |
| algorithm: "ingredient-thumbnail-alg" |
| hash: "hash" |
| } |
| validation_results { |
| active_manifest { |
| successes: { |
| code: "status.1" |
| url: "url.1" |
| explanation: "explanation.1" |
| } |
| successes: { |
| code: "status.2" |
| url: "url.2" |
| explanation: "explanation.2" |
| } |
| } |
| } |
| description: "ingredient-description" |
| informational_uri: "ingredient-informational-uri" |
| )pb"); |
| credentio::IngredientAssertionV3 result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), IsOk()); |
| EXPECT_THAT(result, EqualsProto(expected)); |
| } |
| |
| TEST(ParseAssertionTest, AssetReferenceAssertionOkay) { |
| auto cbor = FromJson(R"json( |
| { |
| "references": [ |
| { |
| "description": "A copy of the asset on the web", |
| "reference": { |
| "uri": "https://some.storage.us/foo" |
| } |
| }, |
| { |
| "description": "A copy of the asset on IPFS", |
| "reference": { |
| "uri": "ipfs://cid" |
| } |
| } |
| ] |
| })json"); |
| auto expected = ParseTextProtoOrDie<credentio::AssetReferenceAssertion>(R"pb( |
| references { |
| description: "A copy of the asset on the web" |
| reference { uri: "https://some.storage.us/foo" } |
| } |
| references { |
| description: "A copy of the asset on IPFS" |
| reference { uri: "ipfs://cid" } |
| } |
| )pb"); |
| credentio::AssetReferenceAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), IsOk()); |
| EXPECT_THAT(result, EqualsProto(expected)); |
| } |
| |
| TEST(ParseAssertionTest, AssetReferenceAssertionInvalidMissingRequiredField) { |
| auto cbor = FromJson(R"json( |
| { |
| "references": [ |
| { |
| "reference": { |
| } |
| } |
| ] |
| })json"); |
| credentio::AssetReferenceAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), |
| StatusIs(absl::StatusCode::kInvalidArgument, |
| HasSubstr("Missing required field: uri"))); |
| } |
| |
| TEST(ParseAssertionTest, AssetTypesAssertionOkay) { |
| auto cbor = FromJson(R"json( |
| { |
| "dc:format": "image/jpeg", |
| "types": |
| [ |
| { |
| "type": "c2pa.types.model.tensorflow", |
| "version": "2.11.0" |
| }, |
| { |
| "type": "c2pa.types.savedmodel", |
| "version": "2.11.0" |
| } |
| ] |
| })json"); |
| auto expected = ParseTextProtoOrDie<credentio::AssetTypesAssertion>(R"pb( |
| media_type: "image/jpeg" |
| types { type: "c2pa.types.model.tensorflow" version: "2.11.0" } |
| types { type: "c2pa.types.savedmodel" version: "2.11.0" } |
| )pb"); |
| credentio::AssetTypesAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), IsOk()); |
| EXPECT_THAT(result, EqualsProto(expected)); |
| } |
| |
| TEST(ParseAssertionTest, AssetTypesAssertionInvalidMissingRequiredField) { |
| auto cbor = FromJson(R"json( |
| { |
| "types": |
| [ |
| { |
| "version": "2.11.0" |
| } |
| ] |
| })json"); |
| credentio::AssetTypesAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), |
| StatusIs(absl::StatusCode::kInvalidArgument, |
| HasSubstr("Missing required field: type"))); |
| } |
| |
| TEST(ParseAssertionTest, DataHashAssertionOkay) { |
| // The `pad` and `pad2` fields are omitted by the parser. |
| auto cbor = FromJson(R"json( |
| { |
| "alg": "sha256", |
| "pad": "b64'Zm9v'", |
| "pad2": "b64'Zm9v'", |
| "hash": "b64'Zm9v'", |
| "name": "JUMBF manifest", |
| "exclusions": [ |
| { |
| "start": 9960, |
| "length": 4213 |
| }, |
| { |
| "start": 14173, |
| "length": 1000 |
| } |
| ] |
| })json"); |
| auto expected = ParseTextProtoOrDie<credentio::DataHashAssertion>(R"pb( |
| alg: "sha256" |
| hash: "foo" |
| name: "JUMBF manifest" |
| exclusions { start: 9960 length: 4213 } |
| exclusions { start: 14173 length: 1000 } |
| )pb"); |
| credentio::DataHashAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), IsOk()); |
| EXPECT_THAT(result, EqualsProto(expected)); |
| } |
| |
| TEST(ParseAssertionTest, DataHashAssertionInvalidMissingRequiredField) { |
| auto cbor = FromJson(R"json( |
| { |
| "alg": "sha256" |
| })json"); |
| credentio::DataHashAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), |
| StatusIs(absl::StatusCode::kInvalidArgument, |
| HasSubstr("Missing required field: hash"))); |
| } |
| |
| TEST(ParseAssertionTest, BmffBasedHashAssertionOkay) { |
| auto cbor = FromJson(R"json( |
| { |
| "hash": "b64'Zm9v'", |
| "name": "Example `c2pa.hash.bmff.v2` assertion", |
| "exclusions": [ |
| { |
| "data": [{ "value": "b64'Zm9v'", "offset": 8 }], |
| "xpath": "/uuid" |
| }, |
| { "xpath": "/ftyp" }, |
| { "xpath": "/mfra" }, |
| { "xpath": "/moov[1]/pssh" }, |
| { |
| "data": [{ "value": "b64'Zm9v'", "offset": 20 }], |
| "xpath": "/emsg" |
| } |
| ] |
| })json"); |
| auto expected = ParseTextProtoOrDie<credentio::BmffBasedHashAssertion>(R"pb( |
| hash: "foo" |
| name: "Example `c2pa.hash.bmff.v2` assertion" |
| exclusions { |
| data { value: "foo" offset: 8 } |
| xpath: "/uuid" |
| } |
| exclusions { xpath: "/ftyp" } |
| exclusions { xpath: "/mfra" } |
| exclusions { xpath: "/moov[1]/pssh" } |
| exclusions { |
| data { value: "foo" offset: 20 } |
| xpath: "/emsg" |
| } |
| )pb"); |
| credentio::BmffBasedHashAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), IsOk()); |
| EXPECT_THAT(result, EqualsProto(expected)); |
| } |
| |
| TEST(ParseAssertionTest, BmffBasedHashAssertionInvalidMissingRequiredField) { |
| auto cbor = FromJson(R"json( |
| { |
| "name": "Example `c2pa.hash.bmff.v2` assertion", |
| "exclusions": [ |
| { |
| "data": [ |
| { |
| "value": "2P7D1hsOSDySl1goh37EgQ==", |
| "offset": 8 |
| } |
| ] |
| } |
| ] |
| })json"); |
| credentio::BmffBasedHashAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), |
| StatusIs(absl::StatusCode::kInvalidArgument, |
| HasSubstr("Missing required field: xpath"))); |
| } |
| |
| TEST(ParseAssertionTest, BoxesHashAssertionOkay) { |
| auto cbor = FromJson(R"json({ |
| "alg" : "sha256", |
| "boxes": [ |
| { |
| "names" : ["SOI", "APP0", "APP2"], |
| "hash" : "b64'Zm9v'" |
| }, |
| { |
| "names" : ["C2PA"], |
| "hash" : "b64'YmFy'" |
| } |
| ] |
| })json"); |
| auto expected = ParseTextProtoOrDie<credentio::BoxesHashAssertion>(R"pb( |
| alg: "sha256" |
| boxes { names: "SOI" names: "APP0" names: "APP2" hash: "foo" } |
| boxes { names: "C2PA" hash: "bar" } |
| )pb"); |
| credentio::BoxesHashAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), IsOk()); |
| EXPECT_THAT(result, EqualsProto(expected)); |
| } |
| |
| TEST(ParseAssertionTest, BoxesHashAssertionInvalidMissingRequiredField) { |
| auto cbor = FromJson(R"json({ |
| "boxes": [ |
| { |
| "names" : ["SOI", "APP0", "APP2"] |
| } |
| ] |
| })json"); |
| credentio::BoxesHashAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), |
| StatusIs(absl::StatusCode::kInvalidArgument, |
| HasSubstr("Missing required field: hash"))); |
| } |
| |
| TEST(ParseAssertionTest, CollectionDataHashAssertionOkay) { |
| auto cbor = FromJson(R"json( |
| { |
| "alg": "sha256", |
| "uris": [ |
| { |
| "uri": "foo1.txt", |
| "hash": "b64'Zm9v'", |
| "size": 1234, |
| "dc:format": "text/plain", |
| "data_types": [ |
| { |
| "type": "c2pa.types.model.tensorflow", |
| "version": "2.11.0" |
| } |
| ] |
| }, |
| { |
| "uri": "foo2.jpg", |
| "hash": "b64'YmFy'", |
| "dc:format": "image/jpeg" |
| } |
| ], |
| "zip_central_directory_hash": "b64'emlwSGFzaA=='" |
| })json"); |
| auto expected = |
| ParseTextProtoOrDie<credentio::CollectionDataHashAssertion>(R"pb( |
| alg: "sha256" |
| uris { |
| uri: "foo1.txt" |
| hash: "foo" |
| size: 1234 |
| type: "text/plain" |
| data_types { type: "c2pa.types.model.tensorflow" version: "2.11.0" } |
| } |
| uris { uri: "foo2.jpg" hash: "bar" type: "image/jpeg" } |
| zip_central_directory_hash: "zipHash" |
| )pb"); |
| credentio::CollectionDataHashAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), IsOk()); |
| EXPECT_THAT(result, EqualsProto(expected)); |
| } |
| |
| TEST(ParseAssertionTest, |
| CollectionDataHashAssertionInvalidMissingRequiredField) { |
| auto cbor = FromJson(R"json( |
| { |
| "uris": [ |
| { |
| "uri": "foo1.txt", |
| "hash": "b64'Zm9v'" |
| } |
| ] |
| })json"); |
| credentio::CollectionDataHashAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), |
| StatusIs(absl::StatusCode::kInvalidArgument, |
| HasSubstr("Missing required field: alg"))); |
| } |
| |
| TEST(ParseAssertionTest, SoftBindingAssertionOkay) { |
| auto cbor = FromJson(R"json( |
| { |
| "alg": "soft-algorithm", |
| "name": "soft-binding-name", |
| "pad": "b64'Zm9v'", |
| "pad2": "b64'Zm9v'", |
| "alg-params": "b64'cGFyYW1z'", |
| "blocks": [ |
| { |
| "scope": { |
| "extent": "b64'ZXh0ZW50'", |
| "timespan": { |
| "start": 100, |
| "end": 200 |
| } |
| }, |
| "value": "b64'dmFsdWU='" |
| } |
| ], |
| "bindingMetadata": { |
| "description": "metadata-desc", |
| "contact": "metadata-contact", |
| "informationalUrl": "metadata-url" |
| } |
| })json"); |
| auto expected = ParseTextProtoOrDie<credentio::SoftBindingAssertion>(R"pb( |
| algorithm: "soft-algorithm" |
| name: "soft-binding-name" |
| alg_params: "params" |
| blocks { |
| scope { |
| extent: "extent" |
| timespan { start: 100 end: 200 } |
| } |
| value: "value" |
| } |
| binding_metadata { |
| description: "metadata-desc" |
| contact: "metadata-contact" |
| informational_url: "metadata-url" |
| } |
| )pb"); |
| credentio::SoftBindingAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), IsOk()); |
| EXPECT_THAT(result, EqualsProto(expected)); |
| } |
| |
| TEST(ParseAssertionTest, SoftBindingAssertionMissingRequiredField) { |
| auto cbor = FromJson(R"json( |
| { |
| "name": "soft-binding-name" |
| })json"); |
| credentio::SoftBindingAssertion result; |
| EXPECT_THAT(ParseAssertion(cbor, &result), |
| StatusIs(absl::StatusCode::kInvalidArgument, |
| HasSubstr("Missing required field: alg"))); |
| } |
| |
| TEST(ParseAssertionTest, ParseStructOkay) { |
| auto json = R"json({ |
| "string": "bar", |
| "int": 123, |
| "float": 123.456, |
| "bool": true, |
| "null": null, |
| "array": [1, 2, 3], |
| "object": { |
| "nested": "string" |
| } |
| })json"; |
| auto expected = ParseTextProtoOrDie<google::protobuf::Struct>(R"pb( |
| fields { |
| key: "string" |
| value { string_value: "bar" } |
| } |
| fields { |
| key: "int" |
| value { number_value: 123 } |
| } |
| fields { |
| key: "float" |
| value { number_value: 123.456 } |
| } |
| fields { |
| key: "bool" |
| value { bool_value: true } |
| } |
| fields { |
| key: "null" |
| value { null_value: NULL_VALUE } |
| } |
| fields { |
| key: "array" |
| value { |
| list_value { |
| values { number_value: 1 } |
| values { number_value: 2 } |
| values { number_value: 3 } |
| } |
| } |
| } |
| fields { |
| key: "object" |
| value { |
| struct_value { |
| fields { |
| key: "nested" |
| value { string_value: "string" } |
| } |
| } |
| } |
| } |
| )pb"); |
| google::protobuf::Struct result; |
| EXPECT_THAT(ParseStruct(json, &result), IsOk()); |
| EXPECT_THAT(result, EqualsProto(expected)); |
| } |
| |
| TEST(ParseAssertionTest, ParseStructInvalidJson) { |
| auto json = R"json({ |
| "failed |
| })json"; |
| google::protobuf::Struct result; |
| EXPECT_THAT(ParseStruct(json, &result), |
| StatusIs(absl::StatusCode::kInvalidArgument, |
| HasSubstr("Invalid JSON: could not parse"))); |
| } |
| |
| TEST(ParseAssertionTest, AiDisclosureAssertionOkay) { |
| auto cbor = FromJson(R"json( |
| { |
| "modelType": "c2pa.types.model.onnx", |
| "modelName": "My Awesome AI Model", |
| "modelIdentifier": "https://example.com/models/awesome-ai-v1", |
| "contentProfile": { |
| "humanOversightLevel": "prompt_guided", |
| "scientificDomain": ["cs.AI", "cs.CV"] |
| } |
| })json"); |
| auto expected = ParseTextProtoOrDie<credentio::AiDisclosureAssertion>(R"pb( |
| model_type: "c2pa.types.model.onnx" |
| model_name: "My Awesome AI Model" |
| model_identifier: "https://example.com/models/awesome-ai-v1" |
| content_profile { |
| human_oversight_level: "prompt_guided" |
| scientific_domain: "cs.AI" |
| scientific_domain: "cs.CV" |
| } |
| )pb"); |
| credentio::AiDisclosureAssertion actual; |
| ASSERT_THAT(credentio::ParseAssertion(cbor, &actual), IsOk()); |
| EXPECT_THAT(actual, EqualsProto(expected)); |
| } |
| |
| TEST(ParseAssertionTest, EnvironmentalSustainabilityAssertionOkay) { |
| auto cbor = FromJson(R"json( |
| { |
| "energy_kwh": { |
| "value": 1.23, |
| "measurementMethod": "com.example.direct-measurement" |
| }, |
| "carbon_kgco2e": { |
| "value": 0.456 |
| }, |
| "water_litres": { |
| "value": 7.89, |
| "measurementMethod": "com.example.estimation" |
| } |
| })json"); |
| auto expected = |
| ParseTextProtoOrDie<credentio::EnvironmentalSustainabilityAssertion>(R"pb( |
| energy_kwh { |
| value: 1.23 |
| measurement_method: "com.example.direct-measurement" |
| } |
| carbon_kgco2e { value: 0.456 } |
| water_litres { |
| value: 7.89 |
| measurement_method: "com.example.estimation" |
| } |
| )pb"); |
| credentio::EnvironmentalSustainabilityAssertion actual; |
| ASSERT_THAT(credentio::ParseAssertion(cbor, &actual), IsOk()); |
| EXPECT_THAT(actual, EqualsProto(expected)); |
| } |
| |
| TEST(ParseAssertionTest, RepositoryReceiptAssertionOkay) { |
| auto json = R"json( |
| { |
| "repository": { |
| "uri": "https://repository.example.com/manifests/xyz123", |
| "manifestId": "urn:uuid:12345678-1234-5678-1234-567812345678" |
| }, |
| "anchor": { |
| "uri": "https://anchor.example.com/receipts/9876", |
| "parameters": { |
| "version": "1.0" |
| }, |
| "proof": { |
| "signature": "c2lnbmF0dXJl" |
| } |
| } |
| })json"; |
| auto expected = |
| ParseTextProtoOrDie<credentio::RepositoryReceiptAssertion>(R"pb( |
| repository { |
| uri: "https://repository.example.com/manifests/xyz123" |
| manifest_id: "urn:uuid:12345678-1234-5678-1234-567812345678" |
| } |
| anchor { |
| uri: "https://anchor.example.com/receipts/9876" |
| parameters { |
| fields { |
| key: "version" |
| value { string_value: "1.0" } |
| } |
| } |
| proof { |
| fields { |
| key: "signature" |
| value { string_value: "c2lnbmF0dXJl" } |
| } |
| } |
| } |
| )pb"); |
| credentio::RepositoryReceiptAssertion actual; |
| ASSERT_THAT(credentio::ParseAssertion(json, &actual), IsOk()); |
| EXPECT_THAT(actual, EqualsProto(expected)); |
| } |
| |
| } // namespace |
| } // namespace credentio |
