|
|
@@ -0,0 +1,899 @@
|
|
|
+#region Copyright notice and license
|
|
|
+
|
|
|
+// Copyright 2015-2016 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.
|
|
|
+
|
|
|
+#endregion
|
|
|
+
|
|
|
+using System;
|
|
|
+using System.Collections.Generic;
|
|
|
+using System.IO;
|
|
|
+using System.Linq;
|
|
|
+using System.Net.Http;
|
|
|
+using System.Security.Cryptography.X509Certificates;
|
|
|
+using System.Threading;
|
|
|
+using System.Threading.Tasks;
|
|
|
+using CommandLine;
|
|
|
+using Google.Apis.Auth.OAuth2;
|
|
|
+using Google.Protobuf;
|
|
|
+using Grpc.Auth;
|
|
|
+using Grpc.Core;
|
|
|
+using Grpc.Core.Utils;
|
|
|
+using Grpc.Net.Client;
|
|
|
+using Grpc.Testing;
|
|
|
+using Microsoft.Extensions.DependencyInjection;
|
|
|
+using Microsoft.Extensions.Logging;
|
|
|
+using Newtonsoft.Json.Linq;
|
|
|
+
|
|
|
+namespace InteropTestsClient
|
|
|
+{
|
|
|
+ public class InteropClient : IDisposable
|
|
|
+ {
|
|
|
+ internal const string CompressionRequestAlgorithmMetadataKey = "grpc-internal-encoding-request";
|
|
|
+
|
|
|
+ private class ClientOptions
|
|
|
+ {
|
|
|
+ [Option("client_type", Default = "httpclient")]
|
|
|
+ public string? ClientType { get; set; }
|
|
|
+
|
|
|
+ [Option("server_host", Default = "localhost")]
|
|
|
+ public string? ServerHost { get; set; }
|
|
|
+
|
|
|
+ [Option("server_host_override")]
|
|
|
+ public string? ServerHostOverride { get; set; }
|
|
|
+
|
|
|
+ [Option("server_port"
|
|
|
+#if DEBUG
|
|
|
+ , Default = 50052
|
|
|
+#endif
|
|
|
+ )]
|
|
|
+ public int ServerPort { get; set; }
|
|
|
+
|
|
|
+ [Option("test_case"
|
|
|
+#if DEBUG
|
|
|
+ , Default = "large_unary"
|
|
|
+#endif
|
|
|
+ )]
|
|
|
+ public string? TestCase { get; set; }
|
|
|
+
|
|
|
+ // Deliberately using nullable bool type to allow --use_tls=true syntax (as opposed to --use_tls)
|
|
|
+ [Option("use_tls", Default = false)]
|
|
|
+ public bool? UseTls { get; set; }
|
|
|
+
|
|
|
+ // Deliberately using nullable bool type to allow --use_test_ca=true syntax (as opposed to --use_test_ca)
|
|
|
+ [Option("use_test_ca", Default = false)]
|
|
|
+ public bool? UseTestCa { get; set; }
|
|
|
+
|
|
|
+ [Option("default_service_account", Required = false)]
|
|
|
+ public string? DefaultServiceAccount { get; set; }
|
|
|
+
|
|
|
+ [Option("oauth_scope", Required = false)]
|
|
|
+ public string? OAuthScope { get; set; }
|
|
|
+
|
|
|
+ [Option("service_account_key_file", Required = false)]
|
|
|
+ public string? ServiceAccountKeyFile { get; set; }
|
|
|
+ }
|
|
|
+
|
|
|
+ private ServiceProvider serviceProvider;
|
|
|
+ private ILoggerFactory loggerFactory;
|
|
|
+ private ClientOptions options;
|
|
|
+
|
|
|
+ private InteropClient(ClientOptions options)
|
|
|
+ {
|
|
|
+ this.options = options;
|
|
|
+
|
|
|
+ var services = new ServiceCollection();
|
|
|
+ services.AddLogging(configure =>
|
|
|
+ {
|
|
|
+ configure.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Trace);
|
|
|
+ configure.AddConsole(loggerOptions => loggerOptions.IncludeScopes = true);
|
|
|
+ });
|
|
|
+
|
|
|
+ serviceProvider = services.BuildServiceProvider();
|
|
|
+
|
|
|
+ loggerFactory = serviceProvider.GetRequiredService<ILoggerFactory>();
|
|
|
+ }
|
|
|
+
|
|
|
+ public void Dispose()
|
|
|
+ {
|
|
|
+ serviceProvider.Dispose();
|
|
|
+ }
|
|
|
+
|
|
|
+ public static void Run(string[] args)
|
|
|
+ {
|
|
|
+ var parserResult = Parser.Default.ParseArguments<ClientOptions>(args)
|
|
|
+ .WithNotParsed(errors => Environment.Exit(1))
|
|
|
+ .WithParsed(options =>
|
|
|
+ {
|
|
|
+ Console.WriteLine("Use TLS: " + options.UseTls);
|
|
|
+ Console.WriteLine("Use Test CA: " + options.UseTestCa);
|
|
|
+ Console.WriteLine("Client type: " + options.ClientType);
|
|
|
+ Console.WriteLine("Server host: " + options.ServerHost);
|
|
|
+ Console.WriteLine("Server port: " + options.ServerPort);
|
|
|
+
|
|
|
+ using (var interopClient = new InteropClient(options))
|
|
|
+ {
|
|
|
+ interopClient.Run().GetAwaiter().GetResult();
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ private async Task Run()
|
|
|
+ {
|
|
|
+ var channel = await HttpClientCreateChannel();
|
|
|
+ await RunTestCaseAsync(channel, options);
|
|
|
+ await channel.ShutdownAsync();
|
|
|
+ }
|
|
|
+
|
|
|
+ private async Task<IChannelWrapper> HttpClientCreateChannel()
|
|
|
+ {
|
|
|
+ var credentials = await CreateCredentialsAsync(useTestCaOverride: false);
|
|
|
+
|
|
|
+ string scheme;
|
|
|
+ if (!(options.UseTls ?? false))
|
|
|
+ {
|
|
|
+ AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
|
|
|
+ scheme = "http";
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ scheme = "https";
|
|
|
+ }
|
|
|
+
|
|
|
+ var httpClientHandler = new HttpClientHandler();
|
|
|
+ httpClientHandler.ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidator;
|
|
|
+
|
|
|
+ if (options.UseTestCa ?? false)
|
|
|
+ {
|
|
|
+ var pem = File.ReadAllText("Certs/ca.pem");
|
|
|
+ var certData = GetBytesFromPem(pem, "CERTIFICATE");
|
|
|
+ var cert = new X509Certificate2(certData!);
|
|
|
+
|
|
|
+ httpClientHandler.ClientCertificates.Add(cert);
|
|
|
+ }
|
|
|
+
|
|
|
+ var httpClient = new HttpClient(httpClientHandler);
|
|
|
+
|
|
|
+ var channel = GrpcChannel.ForAddress($"{scheme}://{options.ServerHost}:{options.ServerPort}", new GrpcChannelOptions
|
|
|
+ {
|
|
|
+ Credentials = credentials,
|
|
|
+ HttpClient = httpClient,
|
|
|
+ LoggerFactory = loggerFactory
|
|
|
+ });
|
|
|
+
|
|
|
+ return new GrpcChannelWrapper(channel);
|
|
|
+ }
|
|
|
+
|
|
|
+ private bool IsHttpClient() => string.Equals(options.ClientType, "httpclient", StringComparison.OrdinalIgnoreCase);
|
|
|
+
|
|
|
+ private async Task<ChannelCredentials> CreateCredentialsAsync(bool? useTestCaOverride = null)
|
|
|
+ {
|
|
|
+ var credentials = ChannelCredentials.Insecure;
|
|
|
+ if (options.UseTls.GetValueOrDefault())
|
|
|
+ {
|
|
|
+ credentials = new SslCredentials();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (options.TestCase == "jwt_token_creds")
|
|
|
+ {
|
|
|
+ var googleCredential = await GoogleCredential.GetApplicationDefaultAsync();
|
|
|
+ Assert.IsTrue(googleCredential.IsCreateScopedRequired);
|
|
|
+ credentials = ChannelCredentials.Create(credentials, googleCredential.ToCallCredentials());
|
|
|
+ }
|
|
|
+
|
|
|
+ if (options.TestCase == "compute_engine_creds")
|
|
|
+ {
|
|
|
+ var googleCredential = await GoogleCredential.GetApplicationDefaultAsync();
|
|
|
+ Assert.IsFalse(googleCredential.IsCreateScopedRequired);
|
|
|
+ credentials = ChannelCredentials.Create(credentials, googleCredential.ToCallCredentials());
|
|
|
+ }
|
|
|
+ return credentials;
|
|
|
+ }
|
|
|
+
|
|
|
+ private TClient CreateClient<TClient>(IChannelWrapper channel) where TClient : ClientBase
|
|
|
+ {
|
|
|
+ return (TClient)Activator.CreateInstance(typeof(TClient), channel.Channel)!;
|
|
|
+ }
|
|
|
+
|
|
|
+ private async Task RunTestCaseAsync(IChannelWrapper channel, ClientOptions options)
|
|
|
+ {
|
|
|
+ var client = CreateClient<TestService.TestServiceClient>(channel);
|
|
|
+ switch (options.TestCase)
|
|
|
+ {
|
|
|
+ case "empty_unary":
|
|
|
+ RunEmptyUnary(client);
|
|
|
+ break;
|
|
|
+ case "large_unary":
|
|
|
+ RunLargeUnary(client);
|
|
|
+ break;
|
|
|
+ case "client_streaming":
|
|
|
+ await RunClientStreamingAsync(client);
|
|
|
+ break;
|
|
|
+ case "server_streaming":
|
|
|
+ await RunServerStreamingAsync(client);
|
|
|
+ break;
|
|
|
+ case "ping_pong":
|
|
|
+ await RunPingPongAsync(client);
|
|
|
+ break;
|
|
|
+ case "empty_stream":
|
|
|
+ await RunEmptyStreamAsync(client);
|
|
|
+ break;
|
|
|
+ case "compute_engine_creds":
|
|
|
+ RunComputeEngineCreds(client, options.DefaultServiceAccount!, options.OAuthScope!);
|
|
|
+ break;
|
|
|
+ case "jwt_token_creds":
|
|
|
+ RunJwtTokenCreds(client);
|
|
|
+ break;
|
|
|
+ case "oauth2_auth_token":
|
|
|
+ await RunOAuth2AuthTokenAsync(client, options.OAuthScope!);
|
|
|
+ break;
|
|
|
+ case "per_rpc_creds":
|
|
|
+ await RunPerRpcCredsAsync(client, options.OAuthScope!);
|
|
|
+ break;
|
|
|
+ case "cancel_after_begin":
|
|
|
+ await RunCancelAfterBeginAsync(client);
|
|
|
+ break;
|
|
|
+ case "cancel_after_first_response":
|
|
|
+ await RunCancelAfterFirstResponseAsync(client);
|
|
|
+ break;
|
|
|
+ case "timeout_on_sleeping_server":
|
|
|
+ await RunTimeoutOnSleepingServerAsync(client);
|
|
|
+ break;
|
|
|
+ case "custom_metadata":
|
|
|
+ await RunCustomMetadataAsync(client);
|
|
|
+ break;
|
|
|
+ case "status_code_and_message":
|
|
|
+ await RunStatusCodeAndMessageAsync(client);
|
|
|
+ break;
|
|
|
+ case "unimplemented_service":
|
|
|
+ RunUnimplementedService(CreateClient<UnimplementedService.UnimplementedServiceClient>(channel));
|
|
|
+ break;
|
|
|
+ case "special_status_message":
|
|
|
+ await RunSpecialStatusMessageAsync(client);
|
|
|
+ break;
|
|
|
+ case "unimplemented_method":
|
|
|
+ RunUnimplementedMethod(client);
|
|
|
+ break;
|
|
|
+ case "client_compressed_unary":
|
|
|
+ RunClientCompressedUnary(client);
|
|
|
+ break;
|
|
|
+ case "client_compressed_streaming":
|
|
|
+ await RunClientCompressedStreamingAsync(client);
|
|
|
+ break;
|
|
|
+ case "server_compressed_unary":
|
|
|
+ await RunServerCompressedUnary(client);
|
|
|
+ break;
|
|
|
+ case "server_compressed_streaming":
|
|
|
+ await RunServerCompressedStreamingAsync(client);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ throw new ArgumentException("Unknown test case " + options.TestCase);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public static void RunEmptyUnary(TestService.TestServiceClient client)
|
|
|
+ {
|
|
|
+ Console.WriteLine("running empty_unary");
|
|
|
+ var response = client.EmptyCall(new Empty());
|
|
|
+ Assert.IsNotNull(response);
|
|
|
+ Console.WriteLine("Passed!");
|
|
|
+ }
|
|
|
+
|
|
|
+ public static void RunLargeUnary(TestService.TestServiceClient client)
|
|
|
+ {
|
|
|
+ Console.WriteLine("running large_unary");
|
|
|
+ var request = new SimpleRequest
|
|
|
+ {
|
|
|
+ ResponseSize = 314159,
|
|
|
+ Payload = CreateZerosPayload(271828)
|
|
|
+ };
|
|
|
+ var response = client.UnaryCall(request);
|
|
|
+
|
|
|
+ Assert.AreEqual(314159, response.Payload.Body.Length);
|
|
|
+ Console.WriteLine("Passed!");
|
|
|
+ }
|
|
|
+
|
|
|
+ public static async Task RunClientStreamingAsync(TestService.TestServiceClient client)
|
|
|
+ {
|
|
|
+ Console.WriteLine("running client_streaming");
|
|
|
+
|
|
|
+ var bodySizes = new List<int> { 27182, 8, 1828, 45904 }.Select((size) => new StreamingInputCallRequest { Payload = CreateZerosPayload(size) });
|
|
|
+
|
|
|
+ using (var call = client.StreamingInputCall())
|
|
|
+ {
|
|
|
+ await call.RequestStream.WriteAllAsync(bodySizes);
|
|
|
+
|
|
|
+ var response = await call.ResponseAsync;
|
|
|
+ Assert.AreEqual(74922, response.AggregatedPayloadSize);
|
|
|
+ }
|
|
|
+ Console.WriteLine("Passed!");
|
|
|
+ }
|
|
|
+
|
|
|
+ public static async Task RunServerStreamingAsync(TestService.TestServiceClient client)
|
|
|
+ {
|
|
|
+ Console.WriteLine("running server_streaming");
|
|
|
+
|
|
|
+ var bodySizes = new List<int> { 31415, 9, 2653, 58979 };
|
|
|
+
|
|
|
+ var request = new StreamingOutputCallRequest
|
|
|
+ {
|
|
|
+ ResponseParameters = { bodySizes.Select((size) => new ResponseParameters { Size = size }) }
|
|
|
+ };
|
|
|
+
|
|
|
+ using (var call = client.StreamingOutputCall(request))
|
|
|
+ {
|
|
|
+ var responseList = await call.ResponseStream.ToListAsync();
|
|
|
+ CollectionAssert.AreEqual(bodySizes, responseList.Select((item) => item.Payload.Body.Length).ToList());
|
|
|
+ }
|
|
|
+ Console.WriteLine("Passed!");
|
|
|
+ }
|
|
|
+
|
|
|
+ public static async Task RunPingPongAsync(TestService.TestServiceClient client)
|
|
|
+ {
|
|
|
+ Console.WriteLine("running ping_pong");
|
|
|
+
|
|
|
+ using (var call = client.FullDuplexCall())
|
|
|
+ {
|
|
|
+ await call.RequestStream.WriteAsync(new StreamingOutputCallRequest
|
|
|
+ {
|
|
|
+ ResponseParameters = { new ResponseParameters { Size = 31415 } },
|
|
|
+ Payload = CreateZerosPayload(27182)
|
|
|
+ });
|
|
|
+
|
|
|
+ Assert.IsTrue(await call.ResponseStream.MoveNext());
|
|
|
+ Assert.AreEqual(31415, call.ResponseStream.Current.Payload.Body.Length);
|
|
|
+
|
|
|
+ await call.RequestStream.WriteAsync(new StreamingOutputCallRequest
|
|
|
+ {
|
|
|
+ ResponseParameters = { new ResponseParameters { Size = 9 } },
|
|
|
+ Payload = CreateZerosPayload(8)
|
|
|
+ });
|
|
|
+
|
|
|
+ Assert.IsTrue(await call.ResponseStream.MoveNext());
|
|
|
+ Assert.AreEqual(9, call.ResponseStream.Current.Payload.Body.Length);
|
|
|
+
|
|
|
+ await call.RequestStream.WriteAsync(new StreamingOutputCallRequest
|
|
|
+ {
|
|
|
+ ResponseParameters = { new ResponseParameters { Size = 2653 } },
|
|
|
+ Payload = CreateZerosPayload(1828)
|
|
|
+ });
|
|
|
+
|
|
|
+ Assert.IsTrue(await call.ResponseStream.MoveNext());
|
|
|
+ Assert.AreEqual(2653, call.ResponseStream.Current.Payload.Body.Length);
|
|
|
+
|
|
|
+ await call.RequestStream.WriteAsync(new StreamingOutputCallRequest
|
|
|
+ {
|
|
|
+ ResponseParameters = { new ResponseParameters { Size = 58979 } },
|
|
|
+ Payload = CreateZerosPayload(45904)
|
|
|
+ });
|
|
|
+
|
|
|
+ Assert.IsTrue(await call.ResponseStream.MoveNext());
|
|
|
+ Assert.AreEqual(58979, call.ResponseStream.Current.Payload.Body.Length);
|
|
|
+
|
|
|
+ await call.RequestStream.CompleteAsync();
|
|
|
+
|
|
|
+ Assert.IsFalse(await call.ResponseStream.MoveNext());
|
|
|
+ }
|
|
|
+ Console.WriteLine("Passed!");
|
|
|
+ }
|
|
|
+
|
|
|
+ public static async Task RunEmptyStreamAsync(TestService.TestServiceClient client)
|
|
|
+ {
|
|
|
+ Console.WriteLine("running empty_stream");
|
|
|
+ using (var call = client.FullDuplexCall())
|
|
|
+ {
|
|
|
+ await call.RequestStream.CompleteAsync();
|
|
|
+
|
|
|
+ var responseList = await call.ResponseStream.ToListAsync();
|
|
|
+ Assert.AreEqual(0, responseList.Count);
|
|
|
+ }
|
|
|
+ Console.WriteLine("Passed!");
|
|
|
+ }
|
|
|
+
|
|
|
+ public static void RunComputeEngineCreds(TestService.TestServiceClient client, string defaultServiceAccount, string oauthScope)
|
|
|
+ {
|
|
|
+ Console.WriteLine("running compute_engine_creds");
|
|
|
+
|
|
|
+ var request = new SimpleRequest
|
|
|
+ {
|
|
|
+ ResponseSize = 314159,
|
|
|
+ Payload = CreateZerosPayload(271828),
|
|
|
+ FillUsername = true,
|
|
|
+ FillOauthScope = true
|
|
|
+ };
|
|
|
+
|
|
|
+ // not setting credentials here because they were set on channel already
|
|
|
+ var response = client.UnaryCall(request);
|
|
|
+
|
|
|
+ Assert.AreEqual(314159, response.Payload.Body.Length);
|
|
|
+ Assert.IsFalse(string.IsNullOrEmpty(response.OauthScope));
|
|
|
+ Assert.IsTrue(oauthScope.Contains(response.OauthScope));
|
|
|
+ Assert.AreEqual(defaultServiceAccount, response.Username);
|
|
|
+ Console.WriteLine("Passed!");
|
|
|
+ }
|
|
|
+
|
|
|
+ public static void RunJwtTokenCreds(TestService.TestServiceClient client)
|
|
|
+ {
|
|
|
+ Console.WriteLine("running jwt_token_creds");
|
|
|
+
|
|
|
+ var request = new SimpleRequest
|
|
|
+ {
|
|
|
+ ResponseSize = 314159,
|
|
|
+ Payload = CreateZerosPayload(271828),
|
|
|
+ FillUsername = true,
|
|
|
+ };
|
|
|
+
|
|
|
+ // not setting credentials here because they were set on channel already
|
|
|
+ var response = client.UnaryCall(request);
|
|
|
+
|
|
|
+ Assert.AreEqual(314159, response.Payload.Body.Length);
|
|
|
+ Assert.AreEqual(GetEmailFromServiceAccountFile(), response.Username);
|
|
|
+ Console.WriteLine("Passed!");
|
|
|
+ }
|
|
|
+
|
|
|
+ public static async Task RunOAuth2AuthTokenAsync(TestService.TestServiceClient client, string oauthScope)
|
|
|
+ {
|
|
|
+ Console.WriteLine("running oauth2_auth_token");
|
|
|
+ ITokenAccess credential = (await GoogleCredential.GetApplicationDefaultAsync()).CreateScoped(new[] { oauthScope });
|
|
|
+ string oauth2Token = await credential.GetAccessTokenForRequestAsync();
|
|
|
+
|
|
|
+ var credentials = GoogleGrpcCredentials.FromAccessToken(oauth2Token);
|
|
|
+ var request = new SimpleRequest
|
|
|
+ {
|
|
|
+ FillUsername = true,
|
|
|
+ FillOauthScope = true
|
|
|
+ };
|
|
|
+
|
|
|
+ var response = client.UnaryCall(request, new CallOptions(credentials: credentials));
|
|
|
+
|
|
|
+ Assert.IsFalse(string.IsNullOrEmpty(response.OauthScope));
|
|
|
+ Assert.IsTrue(oauthScope.Contains(response.OauthScope));
|
|
|
+ Assert.AreEqual(GetEmailFromServiceAccountFile(), response.Username);
|
|
|
+ Console.WriteLine("Passed!");
|
|
|
+ }
|
|
|
+
|
|
|
+ public static async Task RunPerRpcCredsAsync(TestService.TestServiceClient client, string oauthScope)
|
|
|
+ {
|
|
|
+ Console.WriteLine("running per_rpc_creds");
|
|
|
+ ITokenAccess googleCredential = await GoogleCredential.GetApplicationDefaultAsync();
|
|
|
+
|
|
|
+ var credentials = googleCredential.ToCallCredentials();
|
|
|
+ var request = new SimpleRequest
|
|
|
+ {
|
|
|
+ FillUsername = true,
|
|
|
+ };
|
|
|
+
|
|
|
+ var response = client.UnaryCall(request, new CallOptions(credentials: credentials));
|
|
|
+
|
|
|
+ Assert.AreEqual(GetEmailFromServiceAccountFile(), response.Username);
|
|
|
+ Console.WriteLine("Passed!");
|
|
|
+ }
|
|
|
+
|
|
|
+ public static async Task RunCancelAfterBeginAsync(TestService.TestServiceClient client)
|
|
|
+ {
|
|
|
+ Console.WriteLine("running cancel_after_begin");
|
|
|
+
|
|
|
+ var cts = new CancellationTokenSource();
|
|
|
+ using (var call = client.StreamingInputCall(cancellationToken: cts.Token))
|
|
|
+ {
|
|
|
+ // TODO(jtattermusch): we need this to ensure call has been initiated once we cancel it.
|
|
|
+ await Task.Delay(1000);
|
|
|
+ cts.Cancel();
|
|
|
+
|
|
|
+ var ex = await Assert.ThrowsAsync<RpcException>(() => call.ResponseAsync);
|
|
|
+ Assert.AreEqual(StatusCode.Cancelled, ex.Status.StatusCode);
|
|
|
+ }
|
|
|
+ Console.WriteLine("Passed!");
|
|
|
+ }
|
|
|
+
|
|
|
+ public static async Task RunCancelAfterFirstResponseAsync(TestService.TestServiceClient client)
|
|
|
+ {
|
|
|
+ Console.WriteLine("running cancel_after_first_response");
|
|
|
+
|
|
|
+ var cts = new CancellationTokenSource();
|
|
|
+ using (var call = client.FullDuplexCall(cancellationToken: cts.Token))
|
|
|
+ {
|
|
|
+ await call.RequestStream.WriteAsync(new StreamingOutputCallRequest
|
|
|
+ {
|
|
|
+ ResponseParameters = { new ResponseParameters { Size = 31415 } },
|
|
|
+ Payload = CreateZerosPayload(27182)
|
|
|
+ });
|
|
|
+
|
|
|
+ Assert.IsTrue(await call.ResponseStream.MoveNext());
|
|
|
+ Assert.AreEqual(31415, call.ResponseStream.Current.Payload.Body.Length);
|
|
|
+
|
|
|
+ cts.Cancel();
|
|
|
+
|
|
|
+ try
|
|
|
+ {
|
|
|
+ // cannot use Assert.ThrowsAsync because it uses Task.Wait and would deadlock.
|
|
|
+ await call.ResponseStream.MoveNext();
|
|
|
+ Assert.Fail();
|
|
|
+ }
|
|
|
+ catch (RpcException ex)
|
|
|
+ {
|
|
|
+ Assert.AreEqual(StatusCode.Cancelled, ex.Status.StatusCode);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ Console.WriteLine("Passed!");
|
|
|
+ }
|
|
|
+
|
|
|
+ public static async Task RunTimeoutOnSleepingServerAsync(TestService.TestServiceClient client)
|
|
|
+ {
|
|
|
+ Console.WriteLine("running timeout_on_sleeping_server");
|
|
|
+
|
|
|
+ var deadline = DateTime.UtcNow.AddMilliseconds(1);
|
|
|
+ using (var call = client.FullDuplexCall(deadline: deadline))
|
|
|
+ {
|
|
|
+ try
|
|
|
+ {
|
|
|
+ await call.RequestStream.WriteAsync(new StreamingOutputCallRequest { Payload = CreateZerosPayload(27182) });
|
|
|
+ }
|
|
|
+ catch (InvalidOperationException)
|
|
|
+ {
|
|
|
+ // Deadline was reached before write has started. Eat the exception and continue.
|
|
|
+ }
|
|
|
+ catch (RpcException)
|
|
|
+ {
|
|
|
+ // Deadline was reached before write has started. Eat the exception and continue.
|
|
|
+ }
|
|
|
+
|
|
|
+ try
|
|
|
+ {
|
|
|
+ await call.ResponseStream.MoveNext();
|
|
|
+ Assert.Fail();
|
|
|
+ }
|
|
|
+ catch (RpcException ex)
|
|
|
+ {
|
|
|
+ Assert.AreEqual(StatusCode.DeadlineExceeded, ex.StatusCode);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ Console.WriteLine("Passed!");
|
|
|
+ }
|
|
|
+
|
|
|
+ public static async Task RunCustomMetadataAsync(TestService.TestServiceClient client)
|
|
|
+ {
|
|
|
+ Console.WriteLine("running custom_metadata");
|
|
|
+ {
|
|
|
+ // step 1: test unary call
|
|
|
+ var request = new SimpleRequest
|
|
|
+ {
|
|
|
+ ResponseSize = 314159,
|
|
|
+ Payload = CreateZerosPayload(271828)
|
|
|
+ };
|
|
|
+
|
|
|
+ var call = client.UnaryCallAsync(request, headers: CreateTestMetadata());
|
|
|
+ await call.ResponseAsync;
|
|
|
+
|
|
|
+ var responseHeaders = await call.ResponseHeadersAsync;
|
|
|
+ var responseTrailers = call.GetTrailers();
|
|
|
+
|
|
|
+ Assert.AreEqual("test_initial_metadata_value", responseHeaders.First((entry) => entry.Key == "x-grpc-test-echo-initial").Value);
|
|
|
+ CollectionAssert.AreEqual(new byte[] { 0xab, 0xab, 0xab }, responseTrailers.First((entry) => entry.Key == "x-grpc-test-echo-trailing-bin").ValueBytes);
|
|
|
+ }
|
|
|
+
|
|
|
+ {
|
|
|
+ // step 2: test full duplex call
|
|
|
+ var request = new StreamingOutputCallRequest
|
|
|
+ {
|
|
|
+ ResponseParameters = { new ResponseParameters { Size = 31415 } },
|
|
|
+ Payload = CreateZerosPayload(27182)
|
|
|
+ };
|
|
|
+
|
|
|
+ var call = client.FullDuplexCall(headers: CreateTestMetadata());
|
|
|
+
|
|
|
+ await call.RequestStream.WriteAsync(request);
|
|
|
+ await call.RequestStream.CompleteAsync();
|
|
|
+ await call.ResponseStream.ToListAsync();
|
|
|
+
|
|
|
+ var responseHeaders = await call.ResponseHeadersAsync;
|
|
|
+ var responseTrailers = call.GetTrailers();
|
|
|
+
|
|
|
+ Assert.AreEqual("test_initial_metadata_value", responseHeaders.First((entry) => entry.Key == "x-grpc-test-echo-initial").Value);
|
|
|
+ CollectionAssert.AreEqual(new byte[] { 0xab, 0xab, 0xab }, responseTrailers.First((entry) => entry.Key == "x-grpc-test-echo-trailing-bin").ValueBytes);
|
|
|
+ }
|
|
|
+
|
|
|
+ Console.WriteLine("Passed!");
|
|
|
+ }
|
|
|
+
|
|
|
+ public static async Task RunStatusCodeAndMessageAsync(TestService.TestServiceClient client)
|
|
|
+ {
|
|
|
+ Console.WriteLine("running status_code_and_message");
|
|
|
+ var echoStatus = new EchoStatus
|
|
|
+ {
|
|
|
+ Code = 2,
|
|
|
+ Message = "test status message"
|
|
|
+ };
|
|
|
+
|
|
|
+ {
|
|
|
+ // step 1: test unary call
|
|
|
+ var request = new SimpleRequest { ResponseStatus = echoStatus };
|
|
|
+
|
|
|
+ var e = Assert.Throws<RpcException>(() => client.UnaryCall(request));
|
|
|
+ Assert.AreEqual(StatusCode.Unknown, e.Status.StatusCode);
|
|
|
+ Assert.AreEqual(echoStatus.Message, e.Status.Detail);
|
|
|
+ }
|
|
|
+
|
|
|
+ {
|
|
|
+ // step 2: test full duplex call
|
|
|
+ var request = new StreamingOutputCallRequest { ResponseStatus = echoStatus };
|
|
|
+
|
|
|
+ var call = client.FullDuplexCall();
|
|
|
+ await call.RequestStream.WriteAsync(request);
|
|
|
+ await call.RequestStream.CompleteAsync();
|
|
|
+
|
|
|
+ try
|
|
|
+ {
|
|
|
+ // cannot use Assert.ThrowsAsync because it uses Task.Wait and would deadlock.
|
|
|
+ await call.ResponseStream.ToListAsync();
|
|
|
+ Assert.Fail();
|
|
|
+ }
|
|
|
+ catch (RpcException e)
|
|
|
+ {
|
|
|
+ Assert.AreEqual(StatusCode.Unknown, e.Status.StatusCode);
|
|
|
+ Assert.AreEqual(echoStatus.Message, e.Status.Detail);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ Console.WriteLine("Passed!");
|
|
|
+ }
|
|
|
+
|
|
|
+ private static async Task RunSpecialStatusMessageAsync(TestService.TestServiceClient client)
|
|
|
+ {
|
|
|
+ Console.WriteLine("running special_status_message");
|
|
|
+
|
|
|
+ var echoStatus = new EchoStatus
|
|
|
+ {
|
|
|
+ Code = 2,
|
|
|
+ Message = "\t\ntest with whitespace\r\nand Unicode BMP ☺ and non-BMP 😈\t\n"
|
|
|
+ };
|
|
|
+
|
|
|
+ try
|
|
|
+ {
|
|
|
+ await client.UnaryCallAsync(new SimpleRequest
|
|
|
+ {
|
|
|
+ ResponseStatus = echoStatus
|
|
|
+ });
|
|
|
+ Assert.Fail();
|
|
|
+ }
|
|
|
+ catch (RpcException e)
|
|
|
+ {
|
|
|
+ Assert.AreEqual(StatusCode.Unknown, e.Status.StatusCode);
|
|
|
+ Assert.AreEqual(echoStatus.Message, e.Status.Detail);
|
|
|
+ }
|
|
|
+
|
|
|
+ Console.WriteLine("Passed!");
|
|
|
+ }
|
|
|
+
|
|
|
+ public static void RunUnimplementedService(UnimplementedService.UnimplementedServiceClient client)
|
|
|
+ {
|
|
|
+ Console.WriteLine("running unimplemented_service");
|
|
|
+ var e = Assert.Throws<RpcException>(() => client.UnimplementedCall(new Empty()));
|
|
|
+
|
|
|
+ Assert.AreEqual(StatusCode.Unimplemented, e.Status.StatusCode);
|
|
|
+ Console.WriteLine("Passed!");
|
|
|
+ }
|
|
|
+
|
|
|
+ public static void RunUnimplementedMethod(TestService.TestServiceClient client)
|
|
|
+ {
|
|
|
+ Console.WriteLine("running unimplemented_method");
|
|
|
+ var e = Assert.Throws<RpcException>(() => client.UnimplementedCall(new Empty()));
|
|
|
+
|
|
|
+ Assert.AreEqual(StatusCode.Unimplemented, e.Status.StatusCode);
|
|
|
+ Console.WriteLine("Passed!");
|
|
|
+ }
|
|
|
+
|
|
|
+ public static void RunClientCompressedUnary(TestService.TestServiceClient client)
|
|
|
+ {
|
|
|
+ Console.WriteLine("running client_compressed_unary");
|
|
|
+ var probeRequest = new SimpleRequest
|
|
|
+ {
|
|
|
+ ExpectCompressed = new BoolValue
|
|
|
+ {
|
|
|
+ Value = true // lie about compression
|
|
|
+ },
|
|
|
+ ResponseSize = 314159,
|
|
|
+ Payload = CreateZerosPayload(271828)
|
|
|
+ };
|
|
|
+ var e = Assert.Throws<RpcException>(() => client.UnaryCall(probeRequest, CreateClientCompressionMetadata(false)));
|
|
|
+ Assert.AreEqual(StatusCode.InvalidArgument, e.Status.StatusCode);
|
|
|
+
|
|
|
+ var compressedRequest = new SimpleRequest
|
|
|
+ {
|
|
|
+ ExpectCompressed = new BoolValue
|
|
|
+ {
|
|
|
+ Value = true
|
|
|
+ },
|
|
|
+ ResponseSize = 314159,
|
|
|
+ Payload = CreateZerosPayload(271828)
|
|
|
+ };
|
|
|
+ var response1 = client.UnaryCall(compressedRequest, CreateClientCompressionMetadata(true));
|
|
|
+ Assert.AreEqual(314159, response1.Payload.Body.Length);
|
|
|
+
|
|
|
+ var uncompressedRequest = new SimpleRequest
|
|
|
+ {
|
|
|
+ ExpectCompressed = new BoolValue
|
|
|
+ {
|
|
|
+ Value = false
|
|
|
+ },
|
|
|
+ ResponseSize = 314159,
|
|
|
+ Payload = CreateZerosPayload(271828)
|
|
|
+ };
|
|
|
+ var response2 = client.UnaryCall(uncompressedRequest, CreateClientCompressionMetadata(false));
|
|
|
+ Assert.AreEqual(314159, response2.Payload.Body.Length);
|
|
|
+
|
|
|
+ Console.WriteLine("Passed!");
|
|
|
+ }
|
|
|
+
|
|
|
+ public static async Task RunClientCompressedStreamingAsync(TestService.TestServiceClient client)
|
|
|
+ {
|
|
|
+ Console.WriteLine("running client_compressed_streaming");
|
|
|
+ try
|
|
|
+ {
|
|
|
+ var probeCall = client.StreamingInputCall(CreateClientCompressionMetadata(false));
|
|
|
+ await probeCall.RequestStream.WriteAsync(new StreamingInputCallRequest
|
|
|
+ {
|
|
|
+ ExpectCompressed = new BoolValue
|
|
|
+ {
|
|
|
+ Value = true
|
|
|
+ },
|
|
|
+ Payload = CreateZerosPayload(27182)
|
|
|
+ });
|
|
|
+
|
|
|
+ // cannot use Assert.ThrowsAsync because it uses Task.Wait and would deadlock.
|
|
|
+ await probeCall;
|
|
|
+ Assert.Fail();
|
|
|
+ }
|
|
|
+ catch (RpcException e)
|
|
|
+ {
|
|
|
+ Assert.AreEqual(StatusCode.InvalidArgument, e.Status.StatusCode);
|
|
|
+ }
|
|
|
+
|
|
|
+ var call = client.StreamingInputCall(CreateClientCompressionMetadata(true));
|
|
|
+ await call.RequestStream.WriteAsync(new StreamingInputCallRequest
|
|
|
+ {
|
|
|
+ ExpectCompressed = new BoolValue
|
|
|
+ {
|
|
|
+ Value = true
|
|
|
+ },
|
|
|
+ Payload = CreateZerosPayload(27182)
|
|
|
+ });
|
|
|
+
|
|
|
+ call.RequestStream.WriteOptions = new WriteOptions(WriteFlags.NoCompress);
|
|
|
+ await call.RequestStream.WriteAsync(new StreamingInputCallRequest
|
|
|
+ {
|
|
|
+ ExpectCompressed = new BoolValue
|
|
|
+ {
|
|
|
+ Value = false
|
|
|
+ },
|
|
|
+ Payload = CreateZerosPayload(45904)
|
|
|
+ });
|
|
|
+ await call.RequestStream.CompleteAsync();
|
|
|
+
|
|
|
+ var response = await call.ResponseAsync;
|
|
|
+ Assert.AreEqual(73086, response.AggregatedPayloadSize);
|
|
|
+
|
|
|
+ Console.WriteLine("Passed!");
|
|
|
+ }
|
|
|
+
|
|
|
+ public static async Task RunServerCompressedUnary(TestService.TestServiceClient client)
|
|
|
+ {
|
|
|
+ Console.WriteLine("running server_compressed_unary");
|
|
|
+
|
|
|
+ var request = new SimpleRequest
|
|
|
+ {
|
|
|
+ ResponseSize = 314159,
|
|
|
+ Payload = CreateZerosPayload(271828),
|
|
|
+ ResponseCompressed = new BoolValue { Value = true }
|
|
|
+ };
|
|
|
+ var response = await client.UnaryCallAsync(request);
|
|
|
+
|
|
|
+ // Compression of response message is not verified because there is no API available
|
|
|
+ Assert.AreEqual(314159, response.Payload.Body.Length);
|
|
|
+
|
|
|
+ request = new SimpleRequest
|
|
|
+ {
|
|
|
+ ResponseSize = 314159,
|
|
|
+ Payload = CreateZerosPayload(271828),
|
|
|
+ ResponseCompressed = new BoolValue { Value = false }
|
|
|
+ };
|
|
|
+ response = await client.UnaryCallAsync(request);
|
|
|
+
|
|
|
+ // Compression of response message is not verified because there is no API available
|
|
|
+ Assert.AreEqual(314159, response.Payload.Body.Length);
|
|
|
+
|
|
|
+ Console.WriteLine("Passed!");
|
|
|
+ }
|
|
|
+
|
|
|
+ public static async Task RunServerCompressedStreamingAsync(TestService.TestServiceClient client)
|
|
|
+ {
|
|
|
+ Console.WriteLine("running server_compressed_streaming");
|
|
|
+
|
|
|
+ var bodySizes = new List<int> { 31415, 92653 };
|
|
|
+
|
|
|
+ var request = new StreamingOutputCallRequest
|
|
|
+ {
|
|
|
+ ResponseParameters = { bodySizes.Select((size) => new ResponseParameters { Size = size, Compressed = new BoolValue { Value = true } }) }
|
|
|
+ };
|
|
|
+
|
|
|
+ using (var call = client.StreamingOutputCall(request))
|
|
|
+ {
|
|
|
+ // Compression of response message is not verified because there is no API available
|
|
|
+ var responseList = await call.ResponseStream.ToListAsync();
|
|
|
+ CollectionAssert.AreEqual(bodySizes, responseList.Select((item) => item.Payload.Body.Length).ToList());
|
|
|
+ }
|
|
|
+
|
|
|
+ Console.WriteLine("Passed!");
|
|
|
+ }
|
|
|
+
|
|
|
+ private static Payload CreateZerosPayload(int size)
|
|
|
+ {
|
|
|
+ return new Payload { Body = ByteString.CopyFrom(new byte[size]) };
|
|
|
+ }
|
|
|
+
|
|
|
+ private static Metadata CreateClientCompressionMetadata(bool compressed)
|
|
|
+ {
|
|
|
+ var algorithmName = compressed ? "gzip" : "identity";
|
|
|
+ return new Metadata
|
|
|
+ {
|
|
|
+ { new Metadata.Entry(CompressionRequestAlgorithmMetadataKey, algorithmName) }
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ // extracts the client_email field from service account file used for auth test cases
|
|
|
+ private static string GetEmailFromServiceAccountFile()
|
|
|
+ {
|
|
|
+ string keyFile = Environment.GetEnvironmentVariable("GOOGLE_APPLICATION_CREDENTIALS")!;
|
|
|
+ Assert.IsNotNull(keyFile);
|
|
|
+ var jobject = JObject.Parse(File.ReadAllText(keyFile));
|
|
|
+ string email = jobject.GetValue("client_email").Value<string>();
|
|
|
+ Assert.IsTrue(email.Length > 0); // spec requires nonempty client email.
|
|
|
+ return email;
|
|
|
+ }
|
|
|
+
|
|
|
+ private static Metadata CreateTestMetadata()
|
|
|
+ {
|
|
|
+ return new Metadata
|
|
|
+ {
|
|
|
+ {"x-grpc-test-echo-initial", "test_initial_metadata_value"},
|
|
|
+ {"x-grpc-test-echo-trailing-bin", new byte[] {0xab, 0xab, 0xab}}
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ // TODO(JamesNK): PEM loading logic from https://stackoverflow.com/a/10498045/11829
|
|
|
+ // .NET does not have a built-in API for loading pem files
|
|
|
+ // Consider providing ca file in a different format and removing method
|
|
|
+ private byte[]? GetBytesFromPem(string pemString, string section)
|
|
|
+ {
|
|
|
+ var header = string.Format("-----BEGIN {0}-----", section);
|
|
|
+ var footer = string.Format("-----END {0}-----", section);
|
|
|
+
|
|
|
+ var start = pemString.IndexOf(header, StringComparison.Ordinal);
|
|
|
+ if (start == -1)
|
|
|
+ {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+
|
|
|
+ start += header.Length;
|
|
|
+ var end = pemString.IndexOf(footer, start, StringComparison.Ordinal) - start;
|
|
|
+
|
|
|
+ if (end == -1)
|
|
|
+ {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+
|
|
|
+ return Convert.FromBase64String(pemString.Substring(start, end));
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
John Luo