validator: add support for protoc-gen-validate 0.6.0 (#417)

* add support for new validation interface

* spelling

Author: danielhochman

testing/testproto/test.manual_validator.pb.go

@@ -2,11 +2,23 @@
 
 package mwitkow_testproto
 
-import "errors"
+import (
+	"errors"
+	"math"
+)
 
+// Implements the legacy validation interface from protoc-gen-validate.
 func (p *PingRequest) Validate() error {
 	if p.SleepTimeMs > 10000 {
 		return errors.New("cannot sleep for more than 10s")
 	}
 	return nil
 }
+
+// Implements the new validation interface from protoc-gen-validate.
+func (p *PingResponse) Validate(bool) error {
+	if p.Counter > math.MaxInt16 {
+		return errors.New("ping allocation exceeded")
+	}
+	return nil
+}

validator/validator.go

@@ -11,19 +11,38 @@ import (
 	"google.golang.org/grpc/status"
 )
 
+// The validate interface starting with protoc-gen-validate v0.6.0.
+// See https://github.com/envoyproxy/protoc-gen-validate/pull/455.
 type validator interface {
+	Validate(all bool) error
+}
+
+// The validate interface prior to protoc-gen-validate v0.6.0.
+type validatorLegacy interface {
 	Validate() error
 }
 
+func validate(req interface{}) error {
+	switch v := req.(type) {
+	case validatorLegacy:
+		if err := v.Validate(); err != nil {
+			return status.Error(codes.InvalidArgument, err.Error())
+		}
+	case validator:
+		if err := v.Validate(false); err != nil {
+			return status.Error(codes.InvalidArgument, err.Error())
+		}
+	}
+	return nil
+}
+
 // UnaryServerInterceptor returns a new unary server interceptor that validates incoming messages.
 //
 // Invalid messages will be rejected with `InvalidArgument` before reaching any userspace handlers.
 func UnaryServerInterceptor() grpc.UnaryServerInterceptor {
 	return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
-		if v, ok := req.(validator); ok {
-			if err := v.Validate(); err != nil {
-				return nil, status.Error(codes.InvalidArgument, err.Error())
-			}
+		if err := validate(req); err != nil {
+			return nil, err
 		}
 		return handler(ctx, req)
 	}
@@ -34,10 +53,8 @@ func UnaryServerInterceptor() grpc.UnaryServerInterceptor {
 // Invalid messages will be rejected with `InvalidArgument` before sending the request to server.
 func UnaryClientInterceptor() grpc.UnaryClientInterceptor {
 	return func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
-		if v, ok := req.(validator); ok {
-			if err := v.Validate(); err != nil {
-				return status.Error(codes.InvalidArgument, err.Error())
-			}
+		if err := validate(req); err != nil {
+			return err
 		}
 		return invoker(ctx, method, req, reply, cc, opts...)
 	}
@@ -64,10 +81,10 @@ func (s *recvWrapper) RecvMsg(m interface{}) error {
 	if err := s.ServerStream.RecvMsg(m); err != nil {
 		return err
 	}
-	if v, ok := m.(validator); ok {
-		if err := v.Validate(); err != nil {
-			return status.Error(codes.InvalidArgument, err.Error())
-		}
+
+	if err := validate(m); err != nil {
+		return err
 	}
+
 	return nil
 }

validator/validator_test.go

@@ -1,15 +1,15 @@
 // Copyright 2016 Michal Witkowski. All Rights Reserved.
 // See LICENSE for licensing terms.
 
-package grpc_validator_test
+package grpc_validator
 
 import (
 	"io"
+	"math"
 	"testing"
 
 	grpc_testing "github.com/grpc-ecosystem/go-grpc-middleware/testing"
 	pb_testproto "github.com/grpc-ecosystem/go-grpc-middleware/testing/testproto"
-	grpc_validator "github.com/grpc-ecosystem/go-grpc-middleware/validator"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
@@ -22,14 +22,26 @@ var (
 	// See test.manual_validator.pb.go for the validator check of SleepTimeMs.
 	goodPing = &pb_testproto.PingRequest{Value: "something", SleepTimeMs: 9999}
 	badPing  = &pb_testproto.PingRequest{Value: "something", SleepTimeMs: 10001}
+
+	// See test.manual_validator.pb.go for the validator check of the counter.
+	goodPingResponse = &pb_testproto.PingResponse{Counter: 100}
+	badPingResponse  = &pb_testproto.PingResponse{Counter: math.MaxInt16 + 1}
 )
 
+func TestValidateWrapper(t *testing.T) {
+	assert.NoError(t, validate(goodPing))
+	assert.Error(t, validate(badPing))
+
+	assert.NoError(t, validate(goodPingResponse))
+	assert.Error(t, validate(badPingResponse))
+}
+
 func TestValidatorTestSuite(t *testing.T) {
 	s := &ValidatorTestSuite{
 		InterceptorTestSuite: &grpc_testing.InterceptorTestSuite{
 			ServerOpts: []grpc.ServerOption{
-				grpc.StreamInterceptor(grpc_validator.StreamServerInterceptor()),
-				grpc.UnaryInterceptor(grpc_validator.UnaryServerInterceptor()),
+				grpc.StreamInterceptor(StreamServerInterceptor()),
+				grpc.UnaryInterceptor(UnaryServerInterceptor()),
 			},
 		},
 	}
@@ -38,7 +50,7 @@ func TestValidatorTestSuite(t *testing.T) {
 	cs := &ClientValidatorTestSuite{
 		InterceptorTestSuite: &grpc_testing.InterceptorTestSuite{
 			ClientOpts: []grpc.DialOption{
-				grpc.WithUnaryInterceptor(grpc_validator.UnaryClientInterceptor()),
+				grpc.WithUnaryInterceptor(UnaryClientInterceptor()),
 			},
 		},
 	}