public async Task InvokeMethodGrpcAsync_WithNoReturnTypeAndData()
        {
            await using var client = TestClient.CreateForDaprClient(c =>
            {
                c.UseJsonSerializationOptions(this.jsonSerializerOptions);
            });

            var invokeRequest = new Request()
            {
                RequestParameter = "Hello"
            };
            var request = await client.CaptureGrpcRequestAsync(async daprClient =>
            {
                return(await daprClient.InvokeMethodGrpcAsync <Request, Response>("test", "test", invokeRequest));
            });

            request.Dismiss();

            // Get Request and validate
            var envelope = await request.GetRequestEnvelopeAsync <InvokeServiceRequest>();

            envelope.Id.Should().Be("test");
            envelope.Message.Method.Should().Be("test");
            envelope.Message.ContentType.Should().Be(Constants.ContentTypeApplicationGrpc);

            var actual = envelope.Message.Data.Unpack <Request>();

            Assert.Equal(invokeRequest.RequestParameter, actual.RequestParameter);
        }
        public void InvokeMethodGrpcAsync_CanInvokeMethodWithNoReturnTypeAndData()
        {
            var request = new Request()
            {
                RequestParameter = "Hello "
            };
            var client = new MockClient();
            var data   = new Response()
            {
                Name = "Look, I was invoked!"
            };
            var invokeResponse = new InvokeResponse
            {
                Data = Any.Pack(data),
            };

            var response =
                client.Call <InvokeResponse>()
                .SetResponse(invokeResponse)
                .Build();

            client.Mock
            .Setup(m => m.InvokeServiceAsync(It.IsAny <Autogen.Grpc.v1.InvokeServiceRequest>(), It.IsAny <CallOptions>()))
            .Returns(response);

            FluentActions.Awaiting(async() => await client.DaprClient.InvokeMethodGrpcAsync <Request>("test", "test", request)).Should().NotThrow();
        }
示例#3
0
        public async Task InvokeMethodGrpcAsync_WithReturnTypeAndData()
        {
            // Configure Client
            var httpClient = new TestHttpClient();
            var daprClient = CreateTestClientGrpc(httpClient);

            var invokeRequest = new Request()
            {
                RequestParameter = "Hello "
            };
            var invokedResponse = new Response {
                Name = "Look, I was invoked!"
            };

            var task = daprClient.InvokeMethodGrpcAsync <Request, Response>("test", "test", invokeRequest);

            // Get Request and validate
            httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
            var envelope = await GrpcUtils.GetRequestFromRequestMessageAsync <InvokeServiceRequest>(entry.Request);

            envelope.Id.Should().Be("test");
            envelope.Message.Method.Should().Be("test");
            envelope.Message.ContentType.Should().Be(Constants.ContentTypeApplicationGrpc);

            var actual = envelope.Message.Data.Unpack <Request>();

            Assert.Equal(invokeRequest.RequestParameter, actual.RequestParameter);

            await SendResponse(invokedResponse, entry);

            var response = await task;

            response.Name.Should().Be(invokedResponse.Name);
        }
示例#4
0
        public async Task InvokeMethodGrpcAsync_AppCallback_UnexpectedMethod()
        {
            // Configure Client
            var httpClient = new AppCallbackClient(new DaprAppCallbackService());
            var daprClient = CreateTestClientGrpc(httpClient);

            var request = new Request()
            {
                RequestParameter = "Look, I was invoked!"
            };

            var response = await daprClient.InvokeMethodGrpcAsync <Request, Response>("test", "not-existing", request);

            response.Name.Should().Be("unexpected");
        }
        public async Task InvokeMethodGrpcAsync_WithReturnTypeAndData()
        {
            await using var client = TestClient.CreateForDaprClient(c =>
            {
                c.UseJsonSerializationOptions(this.jsonSerializerOptions);
            });

            var invokeRequest = new Request()
            {
                RequestParameter = "Hello "
            };
            var invokeResponse = new Response {
                Name = "Look, I was invoked!"
            };
            var request = await client.CaptureGrpcRequestAsync(async daprClient =>
            {
                return(await daprClient.InvokeMethodGrpcAsync <Request, Response>("test", "test", invokeRequest));
            });

            // Get Request and validate
            var envelope = await request.GetRequestEnvelopeAsync <InvokeServiceRequest>();

            envelope.Id.Should().Be("test");
            envelope.Message.Method.Should().Be("test");
            envelope.Message.ContentType.Should().Be(Constants.ContentTypeApplicationGrpc);

            var actual = envelope.Message.Data.Unpack <Request>();

            Assert.Equal(invokeRequest.RequestParameter, actual.RequestParameter);

            // Create Response & Respond
            var data = new Response()
            {
                Name = "Look, I was invoked!"
            };
            var response = new Autogen.Grpc.v1.InvokeResponse()
            {
                Data = Any.Pack(data),
            };

            // Validate Response
            var invokedResponse = await request.CompleteWithMessageAsync(response);

            invokeResponse.Name.Should().Be(invokeResponse.Name);
        }
        public async Task InvokeMethodGrpcAsync_AppCallback_UnexpectedMethod()
        {
            // Configure Client
            var httpClient = new AppCallbackClient(new DaprAppCallbackService());
            var daprClient = new DaprClientBuilder()
                             .UseGrpcChannelOptions(new GrpcChannelOptions()
            {
                HttpClient = httpClient,
            })
                             .UseJsonSerializationOptions(this.jsonSerializerOptions)
                             .Build();

            var request = new Request()
            {
                RequestParameter = "Look, I was invoked!"
            };

            var response = await daprClient.InvokeMethodGrpcAsync <Request, Response>("test", "not-existing", request);

            response.Name.Should().Be("unexpected");
        }