Add test.proto which is used in interops test in various gRPC projects.

The test.proto is adapted from grpc-java.

Author: creamsoup

BUILD.bazel

@@ -24,6 +24,7 @@ proto_library(
 proto_library(
     name = "messages_proto",
     srcs = ["grpc/testing/messages.proto"],
+    deps = ["@com_google_protobuf//:wrappers_proto"],
 )
 
 proto_library(
@@ -111,6 +112,16 @@ proto_library(
     visibility = ["//visibility:public"],
 )
 
+proto_library(
+    name = "test_proto",
+    srcs = ["grpc/testing/test.proto"],
+    visibility = ["//visibility:public"],
+    deps = [
+        ":messages_proto",
+        "@com_google_protobuf//:empty_proto",
+    ],
+)
+
 # Deprecated: do not use
 proto_library(
     name = "reflection_proto_deprecated",

grpc/testing/messages.proto

@@ -19,18 +19,20 @@ syntax = "proto3";
 
 package grpc.testing;
 
-// TODO(dgq): Go back to using well-known types once
-// https://github.com/grpc/grpc/issues/6980 has been fixed.
-// import "google/protobuf/wrappers.proto";
-message BoolValue {
-  // The bool value.
-  bool value = 1;
-}
+option java_package = "io.grpc.testing.integration";
+
+import "google/protobuf/wrappers.proto";
 
 // The type of payload that should be returned.
 enum PayloadType {
   // Compressable text format.
   COMPRESSABLE = 0;
+
+  // Uncompressable binary format.
+  UNCOMPRESSABLE = 1;
+
+  // Randomly chosen from all other formats defined in this enum.
+  RANDOM = 2;
 }
 
 // A block of data, to simply increase gRPC message size.
@@ -70,13 +72,13 @@ message SimpleRequest {
   // "nullable" in order to interoperate seamlessly with clients not able to
   // implement the full compression tests by introspecting the call to verify
   // the response's compression status.
-  BoolValue response_compressed = 6;
+  google.protobuf.BoolValue response_compressed = 6;
 
   // Whether server should return a given status
   EchoStatus response_status = 7;
 
   // Whether the server should expect this request to be compressed.
-  BoolValue expect_compressed = 8;
+  google.protobuf.BoolValue expect_compressed = 8;
 }
 
 // Unary response, as configured by the request.
@@ -90,6 +92,10 @@ message SimpleResponse {
   string oauth_scope = 3;
 }
 
+message SimpleContext {
+  string value = 1;
+}
+
 // Client-streaming request.
 message StreamingInputCallRequest {
   // Optional input payload sent along with the request.
@@ -99,7 +105,7 @@ message StreamingInputCallRequest {
   // is "nullable" in order to interoperate seamlessly with servers not able to
   // implement the full compression tests by introspecting the call to verify
   // the request's compression status.
-  BoolValue expect_compressed = 2;
+  google.protobuf.BoolValue expect_compressed = 2;
 
   // Not expecting any payload from the response.
 }
@@ -123,7 +129,7 @@ message ResponseParameters {
   // "nullable" in order to interoperate seamlessly with clients not able to
   // implement the full compression tests by introspecting the call to verify
   // the response's compression status.
-  BoolValue compressed = 3;
+  google.protobuf.BoolValue compressed = 3;
 }
 
 // Server-streaming request.

grpc/testing/test.proto

@@ -0,0 +1,81 @@
+// Copyright 2018 The gRPC Authors
+//
+// 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
+//
+//     http://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.
+// An integration test service that covers all the method signature permutations
+// of unary/streaming requests/responses.
+syntax = "proto3";
+
+import "google/protobuf/empty.proto";
+import "grpc/testing/messages.proto";
+
+package grpc.testing;
+
+option java_package = "io.grpc.testing.integration";
+
+// A simple service to test the various types of RPCs and experiment with
+// performance with various types of payload.
+service TestService {
+  // One empty request followed by one empty response.
+  rpc EmptyCall(google.protobuf.Empty) returns (google.protobuf.Empty);
+
+  // One request followed by one response.
+  rpc UnaryCall(SimpleRequest) returns (SimpleResponse);
+
+  // One request followed by one response. Response has cache control
+  // headers set such that a caching HTTP proxy (such as GFE) can
+  // satisfy subsequent requests.
+  rpc CacheableUnaryCall(SimpleRequest) returns (SimpleResponse);
+
+  // One request followed by a sequence of responses (streamed download).
+  // The server returns the payload with client desired type and sizes.
+  rpc StreamingOutputCall(StreamingOutputCallRequest)
+      returns (stream StreamingOutputCallResponse);
+
+  // A sequence of requests followed by one response (streamed upload).
+  // The server returns the aggregated size of client payload as the result.
+  rpc StreamingInputCall(stream StreamingInputCallRequest)
+      returns (StreamingInputCallResponse);
+
+  // A sequence of requests with each request served by the server immediately.
+  // As one request could lead to multiple responses, this interface
+  // demonstrates the idea of full duplexing.
+  rpc FullDuplexCall(stream StreamingOutputCallRequest)
+      returns (stream StreamingOutputCallResponse);
+
+  // A sequence of requests followed by a sequence of responses.
+  // The server buffers all the client requests and then serves them in order. A
+  // stream of responses are returned to the client when the server starts with
+  // first request.
+  rpc HalfDuplexCall(stream StreamingOutputCallRequest)
+      returns (stream StreamingOutputCallResponse);
+
+  // The test server will not implement this method. It will be used
+  // to test the behavior when clients call unimplemented methods.
+  rpc UnimplementedCall(google.protobuf.Empty) returns (google.protobuf.Empty);
+}
+
+// A simple service NOT implemented at servers so clients can test for
+// that case.
+service UnimplementedService {
+  // A call that no server should implement
+  rpc UnimplementedCall(google.protobuf.Empty) returns (google.protobuf.Empty);
+}
+
+// A service used to control reconnect server.
+service ReconnectService {
+  // Starts ReconnectService
+  rpc Start(google.protobuf.Empty) returns (google.protobuf.Empty);
+
+  // Stops ReconnectService
+  rpc Stop(google.protobuf.Empty) returns (grpc.testing.ReconnectInfo);
+}