public async Task Run(TestCtx ctx)
{
var hostA = ctx.HostA;
var hostB = ctx.HostB;
await Task.WhenAll(
Setup(hostA),
Setup(hostB));
await ctx.ConnectFrom(Host.A);
await hostB.ChannelRecv(0, amount);
await hostA.ChannelXmit(0, amount);
var durationMs = await ctx.Pause(50000, _ => _.Trace.GetLastTraceItemChannelFor(Host.B, null)?.Channels[0]?.RecvPosition == amount);
var xmitted = ctx.Trace.GetLastTraceItemChannelFor(Host.B, null).Channels[0].RecvPosition;
var speedKbps = xmitted / durationMs * 1000;
var speedStr = Utils.GetSizeAsString((long)speedKbps);
var amountStr = Utils.GetSizeAsString(xmitted
);
ctx.Log($@"Overall duration {durationMs} ms, amount {amountStr}, speed: {speedStr}/s");
await ctx.HostB.ExpectClose();
await ctx.HostA.Close();
await ctx.Pause(100);
await ctx.HostB.EnsureClosed();
}
public async Task ConfigurePipelineFor_WithCorrectExecution()
{
// arrange
var services = new ServiceCollection();
services.ConfigurePipelineFor <TestCtx>()
.Use <Middleware1>()
.Use(typeof(Middleware2));
var sp = services.BuildServiceProvider();
var pipeline = sp.GetRequiredService <IPipeline <TestCtx> >();
var testContext = new TestCtx();
Assert.IsNull(testContext.Msg);
Assert.Zero(testContext.ExecutedMiddlewaresCount);
// act
await pipeline.ExecuteAsync(testContext);
// assert
const string expectedMessage = "Before_" + nameof(Middleware1) +
"Before_" + nameof(Middleware2) +
"After_" + nameof(Middleware2) +
"After_" + nameof(Middleware1);
Assert.AreEqual(expectedMessage, testContext.Msg, "Pipeline execution order is not match");
Assert.AreEqual(2, testContext.ExecutedMiddlewaresCount, "ExecutedMiddlewaresCount is not match");
}
public async Task Executes_With_Register_MiddlewareDelegate()
{
// arrange
var services = new ServiceCollection();
services
.ConfigurePipelineFor <TestCtx>()
.Use(next =>
{
return((ctx, cancellationToken) =>
{
ctx.Msg = "123";
return next(ctx, cancellationToken);
});
});
var sp = services.BuildServiceProvider();
var pipeline = sp.GetRequiredService <IPipeline <TestCtx> >();
var testCtx = new TestCtx();
// act
await pipeline.ExecuteAsync(testCtx);
// assert
Assert.AreEqual("123", testCtx.Msg);
}
public async Task Should_BeCorrect_PipelineExecutionOrder_WithServiceProviderConditions([Values(true, false)] bool executeMiddleware2)
{
// arrange
var pipelineBuilder = new PipelineBuilder <TestCtx>();
pipelineBuilder.Use <Middleware1>();
pipelineBuilder.UseWhen(ctx => ctx.ExecuteMiddleware2, async(_, ctx, next) =>
{
ctx.ExecutedMiddlewaresCount++;
ctx.Msg += "Before_LambdaMiddleware";
await next();
ctx.Msg += "After_LambdaMiddleware";
});
pipelineBuilder.Use <Middleware2>();
var pipeline = pipelineBuilder.Build(new ServiceCollection().BuildServiceProvider());
var testContext = new TestCtx
{
ExecuteMiddleware2 = executeMiddleware2
};
Assert.IsNull(testContext.Msg);
Assert.Zero(testContext.ExecutedMiddlewaresCount);
// act
await pipeline.ExecuteAsync(testContext);
// assert
var expectedMessage = "Before_" + nameof(Middleware1) +
(executeMiddleware2 ? "Before_LambdaMiddleware" : string.Empty) +
"Before_" + nameof(Middleware2) +
"After_" + nameof(Middleware2) +
(executeMiddleware2 ? "After_LambdaMiddleware" : string.Empty) +
"After_" + nameof(Middleware1);
var expectedExecutedMiddlewaresCount = executeMiddleware2 ? 3 : 2;
Assert.AreEqual(expectedMessage, testContext.Msg, "Pipeline execution order is not match");
Assert.AreEqual(expectedExecutedMiddlewaresCount, testContext.ExecutedMiddlewaresCount, "ExecutedMiddlewaresCount is not match");
}
public async Task NoOp_WhenPipeline_Empty()
{
// arrange
var services = new ServiceCollection();
services.ConfigurePipelineFor <TestCtx>();
var sp = services.BuildServiceProvider();
var pipeline = sp.GetRequiredService <IPipeline <TestCtx> >();
var testCtx = new TestCtx();
// act
await pipeline.ExecuteAsync(testCtx);
// assert
Assert.IsNull(testCtx.Msg);
}
private async void ButtonStart(object sender, RoutedEventArgs e)
{
BtnStart.IsEnabled = false;
try
{
logContainer.Add(@"cmbTests.SelectedItem : {0}", CmbTests.SelectedItem);
logContainer.Add(@"cmbTests.SelectedValue: {0}", CmbTests.SelectedValue);
var ctx = new TestCtx(logContainer, Settings.Default.HostA, Settings.Default.HostB);
var test = (ITest)CmbTests.SelectedItem;
var runner = new TestRunner(test, ctx);
await runner.Run();
UpdateTrace(runner.GetTrace());
}
finally
{
BtnStart.IsEnabled = true;
}
}
public async Task Run(TestCtx ctx)
{
var hostA = ctx.HostA;
var hostB = ctx.HostB;
await Task.WhenAll(
Setup(hostA),
Setup(hostB));
await ctx.ConnectFrom(Host.A);
await ctx.Pause(100);
await ctx.HostB.ExpectClose();
await ctx.HostA.Close();
await ctx.Pause(300);
await ctx.HostB.EnsureClosed();
}
public async Task Pipeline_Should_Preserve_OwnPipelineComponents_AfterBuild()
{
// arrange
var sp = new ServiceCollection().BuildServiceProvider();
var pipelineBuilder = new PipelineBuilder <TestCtx>();
pipelineBuilder.Use <Middleware1>();
var firstPipeline = pipelineBuilder.Build(sp);
pipelineBuilder.Use(async(ctx, next) =>
{
ctx.Msg += "Before_LambdaMiddleware";
await next();
ctx.Msg += "After_LambdaMiddleware";
});
var secondPipeline = pipelineBuilder.Build(sp);
var testContext = new TestCtx();
// act
await firstPipeline.ExecuteAsync(testContext); // this pipeline has no lambda middleware in pipeline.
Assert.AreEqual("Before_Middleware1After_Middleware1", testContext.Msg);
testContext.Msg = null; // clear before second pipeline execution
await secondPipeline.ExecuteAsync(testContext); // this has full pipeline.
// assert
Assert.AreEqual(
"Before_Middleware1Before_LambdaMiddlewareAfter_LambdaMiddlewareAfter_Middleware1",
testContext.Msg
);
}
public async Task Should_BeCorrect_PipelineExecutionOrder()
{
// arrange
var pipelineBuilder = new PipelineBuilder <TestCtx>();
pipelineBuilder.Use <Middleware1>();
pipelineBuilder.Use <Middleware2>();
pipelineBuilder.Use(async(ctx, next) =>
{
ctx.ExecutedMiddlewaresCount++;
ctx.Msg += "Before_LambdaMiddleware";
await next();
ctx.Msg += "After_LambdaMiddleware";
});
var pipeline = pipelineBuilder.Build(new ServiceCollection().BuildServiceProvider());
var testContext = new TestCtx();
Assert.IsNull(testContext.Msg);
Assert.Zero(testContext.ExecutedMiddlewaresCount);
// act
await pipeline.ExecuteAsync(testContext);
// assert
const string expectedMessage = "Before_" + nameof(Middleware1) +
"Before_" + nameof(Middleware2) +
"Before_LambdaMiddleware" +
"After_LambdaMiddleware" +
"After_" + nameof(Middleware2) +
"After_" + nameof(Middleware1);
Assert.AreEqual(expectedMessage, testContext.Msg, "Pipeline execution order is not match");
Assert.AreEqual(3, testContext.ExecutedMiddlewaresCount, "ExecutedMiddlewaresCount is not match");
}
public async Task Should_BeCorrect_PipelineExecutionOrder_WithDeps()
{
// arrange
var services = new ServiceCollection();
var dep = new ExampleDependency();
services.AddSingleton(dep);
var sp = services.BuildServiceProvider();
var pipelineBuilder = new PipelineBuilder <TestCtx>();
pipelineBuilder.Use <Middleware1>();
pipelineBuilder.Use <Middleware2>();
pipelineBuilder.Use <TestCtx, ExampleDependency>(async(ctx, deps, next) =>
{
ctx.ExecutedMiddlewaresCount++;
deps.Resolved = true;
ctx.Msg += "Before_LambdaMiddleware";
await next();
ctx.Msg += "After_LambdaMiddleware";
});
var pipeline = pipelineBuilder.Build(sp);
var testContext = new TestCtx();
Assert.IsFalse(dep.Resolved);
// act
await pipeline.ExecuteAsync(testContext);
// assert
Assert.IsTrue(dep.Resolved, "Dependency is not resolved");
}
public async Task Run(TestCtx ctx)
{
await Task.CompletedTask;
}
