validator_service_test.cpp

#include <userver/utest/utest.hpp>
 
#include <buf/validate/validate.pb.h>
 
#include <userver/engine/async.hpp>
#include <userver/ugrpc/client/exceptions.hpp>
#include <userver/ugrpc/tests/service_fixtures.hpp>
 
#include <types/unit_test_client.usrv.pb.hpp>
#include <types/unit_test_service.usrv.pb.hpp>
 
#include <grpc-protovalidate/server/middleware.hpp>
#include "utils.hpp"
 
USERVER_NAMESPACE_BEGIN
 
namespace {
 
class UnitTestServiceValidator final : public types::UnitTestServiceBase {
public:
    CheckConstraintsUnaryResult CheckConstraintsUnary(CallContext&, types::ConstrainedRequest&& request) override {
        types::ConstrainedResponse response;
        response.set_field(request.field() + 1);
        return response;
    }
 
    CheckConstraintsStreamingResult CheckConstraintsStreaming(
        CallContext&,
        CheckConstraintsStreamingReaderWriter& stream
    ) override {
        types::ConstrainedRequest request;
        while (stream.Read(request)) {
            types::ConstrainedResponse response{};
            response.set_field(request.field());
            stream.Write(std::move(response));
        }
        return grpc::Status::OK;
    }
 
    CheckInvalidRequestConstraintsResult CheckInvalidRequestConstraints(CallContext&, types::InvalidConstraints&&)
        override {
        return google::protobuf::Empty{};
    }
};
 
class GrpcServerValidatorTest
    : public ugrpc::tests::ServiceWithClientFixture<UnitTestServiceValidator, types::UnitTestServiceClient>,
      public testing::WithParamInterface<grpc_protovalidate::server::Settings> {
public:
    GrpcServerValidatorTest()
        : ugrpc::tests::ServiceWithClientFixture<UnitTestServiceValidator, types::UnitTestServiceClient>({
              .server_middlewares = {std::make_shared<grpc_protovalidate::server::Middleware>(GetParam())},
          })
    {}
};
 
}  // namespace
 
INSTANTIATE_UTEST_SUITE_P(
    /*no prefix*/,
    GrpcServerValidatorTest,
    testing::Values(
        grpc_protovalidate::server::Settings{
            .per_method =
                {{"types.UnitTestService/CheckConstraintsUnary",
                  {.fail_fast = false, .send_violations = true, .validate_responses = true}},
                 {"/UnknownMethod", {.fail_fast = true, .send_violations = false}}}
        },
        grpc_protovalidate::server::Settings{
            .global = {.fail_fast = false, .send_violations = true},
            .per_method =
                {{"types.UnitTestService/CheckConstraintsUnary",
                  {.fail_fast = false, .send_violations = true, .validate_responses = true}},
                 {"/UnknownMethod", {.fail_fast = true, .send_violations = false}}}
        },
        grpc_protovalidate::server::Settings{
            .global = {.fail_fast = true, .send_violations = true},
            .per_method =
                {{"types.UnitTestService/CheckConstraintsUnary",
                  {.fail_fast = false, .send_violations = true, .validate_responses = true}},
                 {"/UnknownMethod", {.fail_fast = true, .send_violations = false}}}
        }
    )
);
 
UTEST_P_MT(GrpcServerValidatorTest, AllValid, 2) {
    constexpr std::size_t kRequestCount = 3;
 
    std::vector<types::ConstrainedMessage> messages;
    types::ConstrainedMessage msg;
    msg.set_required_rule(1);
    messages.push_back(std::move(msg));
    messages.push_back(tests::CreateValidMessage(2));
    messages.push_back(tests::CreateValidMessage(3));
 
    std::vector<types::ConstrainedRequest> requests(kRequestCount);
    for (std::size_t i = 0; i < kRequestCount; ++i) {
        requests[i].set_field(static_cast<int32_t>(i));
        requests[i].mutable_messages()->Add(messages.begin(), messages.end());
    }
 
    // check unary method
    types::ConstrainedResponse response;
    UASSERT_NO_THROW(response = GetClient().CheckConstraintsUnary(requests[0]));
    EXPECT_TRUE(response.has_field());
    EXPECT_EQ(response.field(), requests[0].field() + 1);
 
    // check streaming method
    auto stream = GetClient().CheckConstraintsStreaming();
    auto write_task = engine::AsyncNoTracing([&stream, &requests] {
        for (const auto& request : requests) {
            const bool success = stream.Write(request);
            if (!success) {
                return false;
            }
        }
 
        return stream.WritesDone();
    });
 
    std::vector<types::ConstrainedResponse> responses;
    while (stream.Read(response)) {
        responses.push_back(std::move(response));
    }
 
    ASSERT_TRUE(write_task.Get());
    ASSERT_EQ(responses.size(), kRequestCount);
 
    for (std::size_t i = 0; i < kRequestCount; ++i) {
        EXPECT_TRUE(responses[i].has_field());
        EXPECT_EQ(responses[i].field(), requests[i].field());
    }
}
 
UTEST_P_MT(GrpcServerValidatorTest, AllInvalid, 2) {
    constexpr std::size_t kRequestCount = 3;
 
    types::ConstrainedRequest request;
    request.set_field(1);
 
    types::ConstrainedRequest invalid_request;
    invalid_request.set_field(100);
    *invalid_request.add_messages() = types::ConstrainedMessage{};
    *invalid_request.add_messages() = tests::CreateInvalidMessage();
 
    std::vector<types::ConstrainedRequest> requests(kRequestCount);
    requests[0] = request;
    requests[1] = invalid_request;
    request.set_field(3);
    requests[2] = request;
 
    // check unary method
    try {
        [[maybe_unused]] auto response = GetClient().CheckConstraintsUnary(requests[1]);
        ADD_FAILURE() << "Call must fail";
    } catch (const ugrpc::client::InvalidArgumentError& err) {
        auto violations = tests::GetViolations(err);
        ASSERT_TRUE(violations);
        EXPECT_EQ(violations->violations().size(), 20);
    } catch (...) {
        ADD_FAILURE() << "'InvalidArgumentError' exception expected";
    }
 
    // check streaming method
    auto stream = GetClient().CheckConstraintsStreaming();
    auto write_task = engine::AsyncNoTracing([&stream, &requests] {
        for (const auto& request : requests) {
            const bool success = stream.Write(request);
            if (!success) {
                return false;
            }
        }
 
        return stream.WritesDone();
    });
 
    types::ConstrainedResponse response;
 
    ASSERT_TRUE(stream.Read(response));
    EXPECT_EQ(response.field(), 1);
 
    try {
        [[maybe_unused]] const bool result = stream.Read(response);
        ADD_FAILURE() << "Call must fail";
    } catch (const ugrpc::client::InvalidArgumentError& err) {
        const auto& streaming_settings = GetParam().Get("types.UnitTestService/CheckConstraintsStreaming");
        auto violations = tests::GetViolations(err);
 
        if (streaming_settings.send_violations) {
            ASSERT_TRUE(violations);
 
            if (streaming_settings.fail_fast) {
                EXPECT_EQ(violations->violations().size(), 1);
            } else {
                EXPECT_EQ(violations->violations().size(), 20);
            }
        } else {
            EXPECT_FALSE(violations);
        }
    } catch (...) {
        ADD_FAILURE() << "'InvalidArgumentError' exception expected";
    }
 
    write_task.Get();
}
 
UTEST_P(GrpcServerValidatorTest, InvalidConstraints) {
    types::InvalidConstraints request;
    request.set_field(1);
 
    UEXPECT_THROW_MSG(
        GetClient().CheckInvalidRequestConstraints(std::move(request)),
        ugrpc::client::InternalError,
        "'types.UnitTestService/CheckInvalidRequestConstraints' failed: code=INTERNAL, message='Message "
        "'types.InvalidConstraints' validation error: internal protovalidate error (check constraints syntax in the "
        "proto file) - INVALID_ARGUMENT: no_such_field : non_existent_field'"
    );
}
 
UTEST_P(GrpcServerValidatorTest, InvalidResponse) {
    types::ConstrainedRequest request;
    request.set_field(10);
 
    UEXPECT_THROW_MSG(
        GetClient().CheckConstraintsUnary(std::move(request)),
        ugrpc::client::DataLossError,
        "Message 'types.ConstrainedResponse' validation error: 1 constraint(s) violated"
    );
}
 
USERVER_NAMESPACE_END