public GrpcTestContext(GrpcTestFixture <TStartup> fixture, ITestOutputHelper outputHelper)
{
_stopwatch = Stopwatch.StartNew();
_fixture = fixture;
_outputHelper = outputHelper;
_fixture.LoggedMessage += WriteMessage;
}
static Task <DataMessage> MakeCall(GrpcTestFixture <FunctionalTestsWebsite.Startup> fixture, GrpcChannel channel, DataMessage request, SyncPoint syncPoint)
{
var callCount = 0;
async Task <DataMessage> UnaryFailure(DataMessage request, ServerCallContext context)
{
Interlocked.Increment(ref callCount);
if (callCount == 1)
{
await syncPoint.WaitToContinue();
throw new RpcException(new Status(StatusCode.Unavailable, ""));
}
else
{
return(request);
}
}
// Arrange
var method = fixture.DynamicGrpc.AddUnaryMethod <DataMessage, DataMessage>(UnaryFailure);
var client = TestClientFactory.Create(channel, method);
var call = client.UnaryCall(request);
return(call.ResponseAsync);
}
public MockedGreeterServiceTests(GrpcTestFixture <Startup> fixture,
ITestOutputHelper outputHelper) : base(fixture, outputHelper)
{
var mockGreeter = new Mock <IGreeter>();
mockGreeter.Setup(
m => m.Greet(It.IsAny <string>())).Returns((string s) => $"Test {s}");
Fixture.ConfigureWebHost(builder =>
{
builder.ConfigureServices(
services => services.AddSingleton(mockGreeter.Object));
});
}
public void OneTimeSetUp()
{
Fixture = new GrpcTestFixture<Server.Startup>(ConfigureServices);
}
public async Task DeadlocksOnClientMoveNextCancellation()
{
// setup server side scenario
// - server block on req.MoveNext and verify expectations on client cancellation
bool serverCancellationCallbackInvoked = false;
var serverMoveNextOperationCancelled = false;
bool?serverMoveNextResult = null;
var serverMoveNextTrigger = new ManualResetEventSlim();
var serviceTestFixture = new GrpcTestFixture <Startup>(true, (sc) =>
{
// test-specific dependency injection
sc.TryAddSingleton <DuplexMethodImplementation>(new DuplexMethodImplementation(async(req, res, ctx) =>
{
ctx.CancellationToken.Register(() =>
{
serverCancellationCallbackInvoked = true;
});
try
{
serverMoveNextTrigger.Set();
serverMoveNextResult = await req.MoveNext(CancellationToken.None);
}
catch (OperationCanceledException)
{
serverMoveNextOperationCancelled = true;
}
// keep alive?
}));
});
// setup client side scenario
// - client starts streaming call which invokes serviceTestFixture
// - client block on ResponseStream.MoveNext w/ cancellation token
bool?clientMoveNextResult = null;
CancellationTokenSource clientMoveNextCts = new CancellationTokenSource();
var channel = GrpcChannel.ForAddress(serviceTestFixture.Client.BaseAddress, new GrpcChannelOptions
{
LoggerFactory = serviceTestFixture.LoggerFactory,
HttpClient = serviceTestFixture.Client
});
var client = new SimpleDuplex.SimpleDuplexClient(channel);
var clientStreamingCall = client.Start();
// setup complete, execute test
// start clientReadTask that blocks awaiting client.MoveNext
var clientReadTask = Task.Run(async() =>
{
clientMoveNextResult = await clientStreamingCall.ResponseStream.MoveNext(clientMoveNextCts.Token);
});
// pause to ensure server has reached req.MoveNext and to allow background task to reach MoveNext
serverMoveNextTrigger.Wait();
await Task.Delay(200);
// cancel the client
clientMoveNextCts.Cancel();
// ***********************************************************
// DEADLOCK manifests on await clientReadTask below
// ***********************************************************
// await clientReadTask, with expectation of RpcException with StatusCode.Cancelled
var exception = await Assert.ThrowsAsync <RpcException>(async() => await clientReadTask);
Assert.True(exception.StatusCode == StatusCode.Cancelled);
// expect server cancellation callback to have been invoked
Assert.True(serverCancellationCallbackInvoked);
// expect server MoveNext to have exited with OperationCanceledException
Assert.True(serverMoveNextOperationCancelled);
// DO NOT expect server MoveNext to have return value
Assert.Null(serverMoveNextResult);
// DO NOT expect client MoveeNext to have return value
Assert.Null(clientMoveNextResult);
}
public void SetUp()
{
Fixture = new GrpcTestFixture <FunctionalTestsWebsite.Startup>();
}
public EndpointContext(GrpcTestFixture <Startup> server, Method <TRequest, TResponse> method, Uri address)
{
_server = server;
Method = method;
Address = address;
}
public UnaryTests(GrpcTestFixture <Startup> fixture, ITestOutputHelper outputHelper)
: base(fixture, outputHelper)
{
}
public void OneTimeSetUp()
{
Fixture = new GrpcTestFixture <FunctionalTestsWebsite.Startup>(ConfigureServices);
}
public GreeterServiceTests(GrpcTestFixture <Startup> fixture, ITestOutputHelper outputHelper)
: base(fixture, outputHelper)
{
}
public ServerStreamingTests(GrpcTestFixture <Startup> fixture, ITestOutputHelper outputHelper)
: base(fixture, outputHelper)
{
}
public IntegrationTestBase(GrpcTestFixture <Startup> fixture, ITestOutputHelper outputHelper)
{
Fixture = fixture;
_testContext = Fixture.GetTestContext(outputHelper);
}
