public Bar CallFoo()
{
FooRequest request = ...
var response = Invoke(svc => svc.Foo(request));
return(new Bar(response));
}
private static async Task RunClientStreamingRpc(FooService.FooServiceClient client)
{
WriteLine("Starting client streaming RPC example...\n", ConsoleColor.Blue);
Console.WriteLine("You will be requested for messages that should be streamed to server.");
Console.WriteLine("Each message will be streamed to server until request client requests finishes.");
Console.WriteLine("To finish the request just leave the message empty.");
var clientStreamingCall = client.SendFoos(new CallOptions());
while (true)
{
WriteRequestInput("Enter a message that should be streamed to gRPC server:");
var result = Console.ReadLine();
if (string.IsNullOrEmpty(result))
{
await clientStreamingCall.RequestStream.CompleteAsync().ConfigureAwait(false);
break;
}
var fooRequest = new FooRequest {
Message = result
};
await clientStreamingCall.RequestStream.WriteAsync(fooRequest).ConfigureAwait(false);
}
var response = await clientStreamingCall.ResponseAsync.ConfigureAwait(false);
Console.WriteLine($"\n\tgRPC Server response:\n\t> {response.Message}\n");
WriteLine("Finished client streaming RPC example...", ConsoleColor.Blue);
WriteSeparator();
}
public void CallMethodFoo()
{
MockRepository mocks = new MockRepository();
FooRequest fooRequest = FooRequest.CreateBuilder().Build();
FooResponse fooResponse = FooResponse.CreateBuilder().Build();
IRpcController controller = mocks.StrictMock <IRpcController>();
bool fooCalled = false;
TestService service = new TestServiceImpl((request, responseAction) => {
Assert.AreSame(fooRequest, request);
fooCalled = true;
responseAction(fooResponse);
}, null, controller);
bool doneHandlerCalled = false;
Action <IMessage> doneHandler = (response => {
Assert.AreSame(fooResponse, response);
doneHandlerCalled = true;
});
using (mocks.Record()) {
// No mock interactions to record
}
service.CallMethod(FooDescriptor, controller, fooRequest, doneHandler);
Assert.IsTrue(doneHandlerCalled);
Assert.IsTrue(fooCalled);
mocks.VerifyAll();
}
public void CallMethodFoo()
{
FooRequest fooRequest = FooRequest.CreateBuilder().Build();
FooResponse fooResponse = FooResponse.CreateBuilder().Build();
IRpcController controller = new RpcTestController();
bool fooCalled = false;
TestGenericService service = new TestServiceImpl((request, responseAction) =>
{
Assert.AreSame(fooRequest, request);
fooCalled = true;
responseAction(fooResponse);
}, null, controller);
bool doneHandlerCalled = false;
Action <IMessage> doneHandler = (response =>
{
Assert.AreSame(fooResponse, response);
doneHandlerCalled = true;
});
service.CallMethod(FooDescriptor, controller, fooRequest, doneHandler);
Assert.IsTrue(doneHandlerCalled);
Assert.IsTrue(fooCalled);
}
public FooResponse GetData(FooRequest request)
{
return(new FooResponse()
{
Code = "OK",
Message = string.Format("{0} is {1} (at {2})", request.Name, request.Age, DateTime.UtcNow)
});
}
public FooResponse Delete(FooRequest request)
{
return(new FooResponse
{
StringValue2 = request.StringValue2,
IntValue2 = request.IntValue2
});
}
public async Task <FooResponse> Handle(FooRequest busRequest)
{
RecordMessageReceipt(busRequest);
return(new FooResponse
{
RequestSentAt = busRequest.WhenSent
});
}
/// <summary>
/// Unary RPC
/// </summary>
public override Task <FooResponse> GetFoo(FooRequest request, ServerCallContext context)
{
var response = new FooResponse
{
Message = $"Request message: {request.Message}"
};
return(Task.FromResult(response));
}
// Update is called once per frame
void Update()
{
if (_client.Running)
{
FooRequest request = new FooRequest();
request.text = "helloworld";
request.times = 1;
_client.Send(1, request);
_client.Update();
}
}
public void Get_ShouldCallMapAndCalculate()
{
var mapper = new Mock <IMapper>();
var fooCalculatorStrategy = new Mock <IFooCalculatorStrategy>();
var target = new FooController(mapper.Object, fooCalculatorStrategy.Object);
target.Request = new HttpRequestMessage();
target.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());
var request = new FooRequest();
var response = target.Get(request, "base");
mapper.Verify(m => m.Map <FooCalculatorRequest>(It.IsAny <object>()));
fooCalculatorStrategy.Verify(m => m.Calculate(It.IsAny <FooCalculatorRequest>(), "base"));
mapper.Verify(m => m.Map <FooResult>(It.IsAny <object>()));
}
public void Dispatch_should_only_handle_appropriate_request_methods(string requestMethod, Type expectedResultType)
{
// Given a POST FooRequest CommandPipeline
CommandPipeline <FooRequest> pipeline = new CommandPipeline <FooRequest>(HttpVerb.Post, new TestFooHandler());
// And an HttpContext for a GET operation
HttpContext httpContext = new DefaultHttpContext();
httpContext.Request.Method = requestMethod;
// When I try to dispatch a FooRequest
FooRequest request = new FooRequest();
IHandlerResult handlerResult = pipeline.Dispatch(httpContext, request);
// Then the pipeline should not handle the request
handlerResult.Should().BeOfType(expectedResultType);
}
public async void CachingBehavior_CallHandlerWithNormalRequest_ReturnExpectedObject()
{
//Given
var request = new FooRequest();
var actual = new RefTypeObject
{
Foo = 1,
Bar = "bar",
Created = DateTime.UtcNow
};
var sut = new CachingBehavior <FooRequest, RefTypeObject>(_cache, _loggerFactory);
//When
var expected = await sut.Handle(request, CancellationToken.None,
async() => await Task.FromResult(actual));
//Then
Assert.Equal(expected, actual);
}
private static async Task RunUnaryRpc(FooService.FooServiceClient client)
{
WriteLine("Starting unary RPC example...\n", ConsoleColor.Blue);
// Synchronous unary RPC
var fooSynchronousRequest = new FooRequest {
Message = "Sample synchronous request"
};
var fooSynchronousResponse = client.GetFoo(fooSynchronousRequest);
// Asynchronous unary RPC
var fooAsynchronousRequest = new FooRequest {
Message = "Sample asynchronous request"
};
var fooAsynchronousResponse = await client.GetFooAsync(fooAsynchronousRequest);
Console.WriteLine($"\t{fooSynchronousResponse.Message}");
Console.WriteLine($"\t{fooAsynchronousResponse.Message}\n");
WriteLine("Finished unary RPC example...", ConsoleColor.Blue);
WriteSeparator();
}
public void GeneratedStubFooCall()
{
FooRequest fooRequest = FooRequest.CreateBuilder().Build();
MockRepository mocks = new MockRepository();
IRpcChannel mockChannel = mocks.StrictMock <IRpcChannel>();
IRpcController mockController = mocks.StrictMock <IRpcController>();
TestService service = TestService.CreateStub(mockChannel);
Action <FooResponse> doneHandler = mocks.StrictMock <Action <FooResponse> >();
using (mocks.Record()) {
// Nasty way of mocking out "the channel calls the done handler".
Expect.Call(() => mockChannel.CallMethod(null, null, null, null, null))
.IgnoreArguments()
.Constraints(Is.Same(FooDescriptor), Is.Same(mockController), Is.Same(fooRequest),
Is.Same(FooResponse.DefaultInstance), Is.Anything())
.Do((CallFooDelegate)((p1, p2, p3, response, done) => done(response)));
doneHandler.Invoke(FooResponse.DefaultInstance);
}
service.Foo(mockController, fooRequest, doneHandler);
mocks.VerifyAll();
}
public HttpResponseMessage Get([FromUri] FooRequest request, [FromUri] string provider = "base")
{
if (ModelState.IsValid)
{
provider = string.IsNullOrWhiteSpace(provider) ? "base" : provider;
// FooRequest (view model) -> FooCalculatorRequest (domain model)
var calculatorRequest = this.mapper.Map <FooCalculatorRequest>(request);
// Run business logic
var calculatorResult = this.fooCalculatorStrategy.Calculate(calculatorRequest, provider);
// FooCalculatorResult (domain model) -> FooResult (view model)
var result = this.mapper.Map <FooResult>(calculatorResult);
// Return result as JSON
return(Request.CreateResponse(HttpStatusCode.OK, result));
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
}
public FooResponse Foo(FooRequest request)
{
return(new FooResponse {
FooResponseValue = $"Foo{request.FooRequestValue}"
});
}
public override void Foo(IRpcController controller, FooRequest request, Action <FooResponse> done)
{
Assert.AreSame(expectedController, controller);
fooHandler(request, done);
}
public override void Foo(IRpcController controller, FooRequest request, Action<FooResponse> done)
{
Assert.AreSame(expectedController, controller);
fooHandler(request, done);
}
public async Task <FooResponse> Handle(FooRequest busRequest)
{
RecordMessageReceipt();
return(new FooResponse());
}
public FooResponse GetFoo([FromBody] FooRequest fooRequest)
{
return(new FooResponse {
Id = 1, FooText = "Foooooo"
});
}
public void WhenUserInvokesFooFunctionality(FooRequest request)
{
ScenarioData.FooRequest = request;
ScenarioData.FooResponse = ScenarioData.ApplicationService.Foo(request);
}
public static FooRequest CreateRequest <T>(Expression <Func <FooResponse <T> > > func)
{
return(FooRequest.Create(func));
}
