testing/fake_assertion_validator.h

// 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.
//

#ifndef THIRD_PARTY_CREDENTIO_TESTING_FAKE_ASSERTION_VALIDATOR_H_
#define THIRD_PARTY_CREDENTIO_TESTING_FAKE_ASSERTION_VALIDATOR_H_

#include <string>
#include <vector>

#include "absl/container/flat_hash_map.h"
#include "absl/container/flat_hash_set.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "absl/types/span.h"
#include "assertion/validator.h"
#include "constants/status_codes.h"
#include "jumbf/uri.h"
#include "validator/tracker.h"

namespace credentio {

class FakeAssertionValidator : public AssertionValidator {
 public:
  FakeAssertionValidator(absl::Span<const FailureStatusCode> failures,
                         absl::Span<const SuccessStatusCode> successes)
      : failures_(failures.begin(), failures.end()),
        successes_(successes.begin(), successes.end()) {}
  void ValidateClaimAssertions(
      const jumbf::UriResolver& uri_resolver,
      const absl::flat_hash_set<std::string>& redacted_assertion_paths,
      Manifest& manifest,
      ValidationTracker& validation_tracker) const override {
    // Record failures and successes.
    for (const auto& failure : failures_) {
      validation_tracker.RecordFailure(failure, {});
    }
    for (const auto& success : successes_) {
      validation_tracker.RecordSuccess(success, {});
    }
    // Populate `assertions_out` with assertions for the given manifest path.
    std::string manifest_path = absl::StrCat("/c2pa/", manifest.label());
    if (assertions_.contains(manifest_path)) {
      for (const auto& assertion : assertions_.at(manifest_path)) {
        *manifest.add_assertions() = assertion;
      }
    }
  }

  void SetOutputAssertions(absl::string_view manifest_path,
                           absl::Span<const Assertion> assertions) {
    assertions_[manifest_path] =
        std::vector<Assertion>(assertions.begin(), assertions.end());
  }

 private:
  std::vector<FailureStatusCode> failures_;
  std::vector<SuccessStatusCode> successes_;
  absl::flat_hash_map<std::string, std::vector<Assertion>> assertions_;
};

}  // namespace credentio

#endif  // THIRD_PARTY_CREDENTIO_TESTING_FAKE_ASSERTION_VALIDATOR_H_