public void TestRenderConnectionStringReturnsSameString(IIpcProvider provider)
{
var m1 = provider.CreateNewMoniker();
var connStr1 = provider.RenderConnectionString(m1);
var connStr2 = provider.RenderConnectionString(m1);
Assert.NotNull(connStr1);
Assert.NotNull(connStr2);
Assert.Equal(connStr1, connStr2);
}
public void TestConcurrentSynchronousOperations(IIpcProvider provider)
{
var testName = nameof(TestConcurrentSynchronousOperations);
WithIpcServer(
provider,
EchoingExecutor,
ServerConfigWithLogger(testName),
(moniker, server) =>
{
using (IClient client = provider.GetClient(provider.RenderConnectionString(moniker), ClientConfigWithLogger(testName)))
{
var threads = Enumerable
.Range(1, 10)
.Select(i => new Thread(() =>
{
var message = "hi" + i;
var op = new IpcOperation(message, waitForServerAck: true);
var result = SendWithTimeout(client, op);
Assert.True(result.Succeeded, "error: " + result.Payload);
Assert.Equal(op.Payload, result.Payload);
}))
.ToArray();
Start(threads);
Join(threads);
client.RequestStop();
client.Completion.GetAwaiter().GetResult();
}
});
}
public void TestWithExecutionError(IIpcProvider provider)
{
var testName = nameof(TestWithExecutionError);
WithIpcServer(
provider,
CrashingExecutor,
ServerConfigWithLogger(testName),
(moniker, server) =>
{
using (var client = provider.GetClient(provider.RenderConnectionString(moniker), ClientConfigWithLogger(testName)))
{
var syncOp = new IpcOperation("sync", waitForServerAck: true);
var asyncOp = new IpcOperation("async", waitForServerAck: false);
var syncResult = SendWithTimeout(client, syncOp);
var asyncResult = SendWithTimeout(client, asyncOp);
Assert.True(asyncResult.Succeeded, "Asynchronous operation is expected to succeed if executor crashes");
Assert.False(syncResult.Succeeded, "Synchronous operation is expected to fail if executor crashes");
Assert.Equal(IpcResultStatus.ExecutionError, syncResult.ExitCode);
Assert.True(syncResult.Payload.Contains("System.Exception")); // because CrashingExecutor throws System.Exception
Assert.True(syncResult.Payload.Contains(syncOp.Payload)); // because CrashingExecutor throws System.Exception whose message is equal to syncOp.Payload
client.RequestStop();
client.Completion.GetAwaiter().GetResult();
}
});
}
public void TestClientMultipleDispose(IIpcProvider provider)
{
var testName = nameof(TestClientMultipleDispose);
WithIpcServer(
provider,
EchoingExecutor,
ServerConfigWithLogger(testName),
(moniker, server) =>
{
using (var client = provider.GetClient(provider.RenderConnectionString(moniker), ClientConfigWithLogger(testName)))
{
client.Dispose();
}
});
}
/// <summary>
/// Async version of <see cref="WithIpcServer(IIpcProvider, IIpcOperationExecutor, IServerConfig, Action{IIpcMoniker, IServer})"/>
/// </summary>
protected static async Task WithIpcServer(IIpcProvider provider, IIpcOperationExecutor executor, IServerConfig config, Func <IIpcMoniker, IServer, Task> testAction)
{
var moniker = provider.CreateNewMoniker();
var server = provider.GetServer(provider.RenderConnectionString(moniker), config);
server.Start(executor);
try
{
await testAction(moniker, server);
}
finally
{
server.RequestStop();
await server.Completion;
server.Dispose();
}
}
public void TestSimpleSyncOperation(IIpcProvider provider)
{
var testName = nameof(TestSimpleSyncOperation);
WithIpcServer(
provider,
EchoingExecutor,
ServerConfigWithLogger(testName),
(moniker, server) =>
{
using (var client = provider.GetClient(provider.RenderConnectionString(moniker), ClientConfigWithLogger(testName)))
{
var payload = "sync";
var syncOp = new IpcOperation(payload, waitForServerAck: true);
var syncResult = SendWithTimeout(client, syncOp);
Assert.True(syncResult.Succeeded, syncResult.Payload);
Assert.Equal(syncResult.Payload, payload);
client.RequestStop();
client.Completion.GetAwaiter().GetResult();
}
});
}
private static Client CreateDummyBxlApiClient(IIpcProvider ipcProvider, IIpcMoniker moniker)
{
return(new Client(new MockClient(ipcProvider.GetClient(ipcProvider.RenderConnectionString(moniker), new ClientConfig()))));
}
/// <summary>
/// Creates a new moniker (<see cref="IIpcProvider.CreateNewMoniker"/>) and then renders
/// it to a connection string (<see cref="IIpcProvider.RenderConnectionString"/>).
/// </summary>
public static string CreateNewConnectionString(this IIpcProvider ipcProvider)
{
return(ipcProvider.RenderConnectionString(ipcProvider.CreateNewMoniker()));
}
/// <summary>
/// First calls <see cref="IIpcProvider.LoadOrCreateMoniker(string)"/>, then
/// <see cref="IIpcProvider.RenderConnectionString(IIpcMoniker)"/> on the returned moniker.
/// </summary>
public static string LoadAndRenderMoniker(this IIpcProvider ipcProvider, string monikerId)
{
return(ipcProvider.RenderConnectionString(ipcProvider.LoadOrCreateMoniker(monikerId)));
}
