testing/proto_test_utils.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_PROTO_TEST_UTILS_H_
#define THIRD_PARTY_CREDENTIO_TESTING_PROTO_TEST_UTILS_H_

#include <type_traits>

#include "absl/log/absl_check.h"
#include "absl/strings/string_view.h"
#include "gmock/gmock.h"
#include "google/protobuf/text_format.h"
#include "google/protobuf/util/message_differencer.h"

namespace credentio_testing {

template <typename T, typename M>
bool CompareProtos(const M& arg, const T& expected) {
  if constexpr (std::is_convertible_v<T, absl::string_view>) {
    M expected_msg;
    ABSL_CHECK(
        google::protobuf::TextFormat::ParseFromString(expected, &expected_msg));
    return google::protobuf::util::MessageDifferencer::Equals(arg,
                                                              expected_msg);
  } else {
    return google::protobuf::util::MessageDifferencer::Equals(arg, expected);
  }
}

MATCHER(EqualsProto, "") {
  return CompareProtos(std::get<0>(arg), std::get<1>(arg));
}

MATCHER_P(EqualsProto, expected, "") { return CompareProtos(arg, expected); }

MATCHER_P(PartiallyEqualsProto, expected, "") {
  google::protobuf::util::MessageDifferencer differencer;
  differencer.set_scope(google::protobuf::util::MessageDifferencer::PARTIAL);
  return differencer.Compare(expected, arg);
}

class ParseTextProtoOrDieProxy {
 public:
  explicit ParseTextProtoOrDieProxy(absl::string_view text_proto)
      : text_proto_(text_proto) {}

  template <typename T>
  operator T() const {  // NOLINT(google-explicit-constructor)
    T proto;
    ABSL_CHECK(
        google::protobuf::TextFormat::ParseFromString(text_proto_, &proto));
    return proto;
  }

 private:
  absl::string_view text_proto_;
};

template <typename T = ParseTextProtoOrDieProxy>
T ParseTextProtoOrDie(absl::string_view text_proto) {
  if constexpr (std::is_same_v<T, ParseTextProtoOrDieProxy>) {
    return ParseTextProtoOrDieProxy(text_proto);
  } else {
    T proto;
    ABSL_CHECK(
        google::protobuf::TextFormat::ParseFromString(text_proto, &proto));
    return proto;
  }
}

}  // namespace credentio_testing

#endif  // THIRD_PARTY_CREDENTIO_TESTING_PROTO_TEST_UTILS_H_