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();
}
private void InitializeFooSource()
{
NoMoreFoos = false;
fooSource = new FooSource(async(currentPage, itemsPerPage) =>
{
FooResponse response = null;
try
{
IsLoading = true;
response = await fooService.GetFoos(currentPage, itemsPerPage);
}
catch (Exception ex)//Something completely unexpected happened, write a debug line to ensure persistence of the error
{
//TODO ERROR HANDLING
}
finally
{
IsLoading = false;//Hide the progressbar
}
return(response);
});
this.Foos = new IncrementalCollection <FooSource, Foo>(fooSource);
this.Foos.HasMoreItemsChanged += (s, hasm) =>
{
this.NoMoreFoos = !hasm.HasMoreItems;
};
}
public void TestSeparateHeaderCheck()
{
FooResponse.CreateOK()
.AssertResponse()
.IsTrue(r => r.WWWAuthenticate == null)
.IsTrue(r => r.OK.Id == 5);
}
public void TestWrongContentOneStatement()
{
FooResponse.CreateOK()
.AssertResponse()
.HasValue(r => r.OK)
.IsTrue(r => r.Bar == "wrong" && r.Id == 1);
}
public void TestStatusInBooleanLogic()
{
// This **could** be nicer without the `OK.`
FooResponse.CreateOK()
.AssertResponse()
.IsTrue(r => r.WWWAuthenticate == null && r.OK.Id == 3);
}
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);
}
/// <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));
}
/// <summary>
/// Bidirectional streaming RPC
/// </summary>
public override async Task SendAndGetFoos(IAsyncStreamReader <FooRequest> requestStream, IServerStreamWriter <FooResponse> responseStream, ServerCallContext context)
{
while (await requestStream.MoveNext().ConfigureAwait(false))
{
var response = new FooResponse
{
Message = $"Request message: {requestStream.Current.Message}"
};
await responseStream.WriteAsync(response).ConfigureAwait(false);
}
}
public void GeneratedStubFooCall()
{
IRpcChannel channel = new RpcTestChannel();
IRpcController controller = new RpcTestController();
TestGenericService service = TestGenericService.CreateStub(channel);
FooResponse fooResponse = null;
Action <FooResponse> doneHandler = r => fooResponse = r;
service.Foo(controller, FooRequest.DefaultInstance, doneHandler);
Assert.IsNotNull(fooResponse);
Assert.IsFalse(controller.Failed);
}
/// <summary>
/// Server streaming RPC
/// </summary>
public override async Task GetFoos(FooServerStreamingRequest request, IServerStreamWriter <FooResponse> responseStream, ServerCallContext context)
{
var count = 0;
while (count < request.MessageCount && !context.CancellationToken.IsCancellationRequested)
{
count++;
var response = new FooResponse
{
Message = $"Request message: {request.Message} ({count})"
};
await responseStream.WriteAsync(response).ConfigureAwait(false);
await Task.Delay(1000).ConfigureAwait(false);
}
}
public async Task <FooResponse> GetFoos(int page, int items)
{
await Task.Delay(1500);//Simulate a network delay
FooResponse response = new FooResponse();
var foos = this.foos.Skip(page * items).Take(items).ToList();
response.Foos = foos;
var lastFoo = foos.LastOrDefault();
if (lastFoo == null)
{
response.HasMoreItems = false;
}
else
{
int fooIndex = this.foos.IndexOf(lastFoo);
if (fooIndex + 1 < this.foos.Count())
{
response.HasMoreItems = true;
}
}
return(response);
}
public void TestSuccessBadRequest()
{
FooResponse.CreateUnauthorized()
.AssertResponse()
.IsTrue(r => r.Unauthorized);
}
public void TestWrongContentTwoStatement()
{
FooResponse.CreateOK()
.AssertResponse()
.IsTrue(r => r.OK.Bar == "wrong" && r.OK.Id == 1);
}
public void TestWrongStatusBooleanProperty()
{
FooResponse.CreateUnauthorized()
.AssertResponse()
.HasValue(r => r.OK);
}
public void TestWrongStatus()
{
FooResponse.CreateBadRequest()
.AssertResponse()
.HasValue(r => r.OK);
}
public void TestComplicatedIsBadRequest()
{
FooResponse.CreateBadRequest()
.AssertResponse()
.IsTrue(r => r.OK.Bar == "wrong");
}
public void TestSuccessOK()
{
FooResponse.CreateOK()
.AssertResponse()
.HasValue(r => r.OK);
}
public void TestSuccessBadRequest()
{
FooResponse.CreateBadRequest()
.AssertResponse()
.IsTrue(r => r.BadRequest);
}
