public async Task RunAsync_SubProcessListSupplied_AllAreRun(int processCount)
{
// arrange
var processId = 0;
var expectedKeys = Enumerable.Range(1, processCount);
var dict = new ConcurrentDictionary <int, DateTime>();
_fixture.Register(() =>
{
var process = A.Fake <IProcess>();
A.CallTo(() => process.RunAsync(CancellationToken.None)).ReturnsLazily(() =>
{
var id = Interlocked.Increment(ref processId);
dict.TryAdd(id, DateTime.Now);
return(Task.CompletedTask);
});
return(process);
});
var processes = _fixture.CreateMany <IProcess>(processCount);
var sut = new SequentialProcess(processes);
// act
await sut.RunAsync(CancellationToken.None);
// assert
dict.Should().ContainKeys(expectedKeys);
}
public void Should_route_to_pared_down_process()
{
var messageABC = new SequentialProcess
{
StepAInfo = "Foo",
StepBInfo = "Bar",
StepCInfo = "Baz",
};
var destinations = new[]
{
"NServiceBus.MessageRouting.RoutingSlips.Samples.StepA",
"NServiceBus.MessageRouting.RoutingSlips.Samples.StepC",
"NServiceBus.MessageRouting.RoutingSlips.Samples.ResultHost",
};
Console.WriteLine("Sending message...");
var last = destinations.Last();
var events = _fixture.SendAndWait(
bus => bus.Route(messageABC, Guid.NewGuid(), destinations),
c => c.Endpoint != last,
TimeSpan.FromSeconds(60)).ToArray();
events.Count().ShouldEqual(3);
}
public void RunAsync_NoProcessesToRun_NoExceptions()
{
// arrange
var sut = new SequentialProcess();
// act + assert
sut.Invoking(async process => await process.RunAsync(CancellationToken.None))
.Should().NotThrow();
}
public void Create_ListOfProcesses_ShouldContainSameProcesses()
{
// arrange
var subProcesses = _fixture.CreateMany <IProcess>().ToArray();
var sut = new SequentialProcess();
// act
var process = sut.Create(subProcesses);
// assert
process.Should().BeEquivalentTo(subProcesses);
}
static Task SendToAC(IEndpointInstance endpoint)
{
var sequentialProcess = new SequentialProcess
{
StepAInfo = "Foo",
StepCInfo = "Baz",
};
log.Info("Sending message for step A, C");
return(endpoint.Route(sequentialProcess, Guid.NewGuid(),
"Samples.RoutingSlips.StepA",
"Samples.RoutingSlips.StepC",
"Samples.RoutingSlips.ResultHost"));
}
public void RunAsync_TaskThrows_Throws()
{
// arrange
var expectedException = new Exception("I'm failing You, I'm so sorry.");
var process = A.Fake <IProcess>();
A.CallTo(() => process.RunAsync(CancellationToken.None)).Returns(Task.FromException(expectedException));
var sut = new SequentialProcess(new[] { process });
// act + assert
sut.Invoking(async x => await x.RunAsync(CancellationToken.None))
.Should().Throw <Exception>().Where(ex => ex == expectedException);
}
static Task SendToABC(IEndpointInstance endpoint)
{
#region multi-message-Send
var sequentialProcess = new SequentialProcess
{
StepAInfo = "Foo",
StepBInfo = "Bar",
StepCInfo = "Baz",
};
#endregion
log.Info("Sending message for step A, B, C");
return(endpoint.Route(sequentialProcess, Guid.NewGuid(),
"Samples.RoutingSlips.StepA",
"Samples.RoutingSlips.StepB",
"Samples.RoutingSlips.StepC",
"Samples.RoutingSlips.ResultHost"));
}
public void Run()
{
bool toggle = false;
while (Console.ReadLine() != null)
{
if (toggle)
{
var messageABC = new SequentialProcess
{
StepAInfo = "Foo",
StepBInfo = "Bar",
StepCInfo = "Baz",
};
Logger.Info("Sending message for step A, B, C");
Bus.Route(messageABC, Guid.NewGuid(), new[]
{
"NServiceBus.MessageRouting.RoutingSlips.Samples.StepA",
"NServiceBus.MessageRouting.RoutingSlips.Samples.StepB",
"NServiceBus.MessageRouting.RoutingSlips.Samples.StepC",
"NServiceBus.MessageRouting.RoutingSlips.Samples.ResultHost",
});
}
else
{
var messageAC = new SequentialProcess
{
StepAInfo = "Foo",
StepCInfo = "Baz",
};
Logger.Info("Sending message for step A, C");
Bus.Route(messageAC, Guid.NewGuid(), new[]
{
"NServiceBus.MessageRouting.RoutingSlips.Samples.StepA",
"NServiceBus.MessageRouting.RoutingSlips.Samples.StepC",
"NServiceBus.MessageRouting.RoutingSlips.Samples.ResultHost",
});
}
toggle = !toggle;
}
}
public async Task RunAsync_ManyProcesses_RunInSequence(int processCount)
{
// arrange
var processIdCounter = 0;
var runOrder = new BlockingCollection <int>(processCount);
var parallelProcessCounter = 0;
var maxProcessesRunningInParallel = 0;
var randomizer = new Random(Environment.TickCount);
_fixture.Register(() =>
{
var process = A.Fake <IProcess>();
var processId = Interlocked.Increment(ref processIdCounter);
A.CallTo(() => process.RunAsync(CancellationToken.None)).ReturnsLazily(async() =>
{
var runningProcesses = Interlocked.Increment(ref parallelProcessCounter);
maxProcessesRunningInParallel = Math.Max(runningProcesses, maxProcessesRunningInParallel);
await Task.Delay(randomizer.Next(minValue: 1, maxValue: 100));
runOrder.Add(processId);
Interlocked.Decrement(ref parallelProcessCounter);
});
return(process);
});
var processes = _fixture.CreateMany <IProcess>(processCount);
var sut = new SequentialProcess(processes);
// act
await sut.RunAsync(CancellationToken.None);
// assert
maxProcessesRunningInParallel.Should().Be(1);
runOrder.Should().HaveCount(processCount);
runOrder.Should().BeInAscendingOrder();
}
public void RunAsync_FirstTaskThrows_SecondTaksNewerInvoked()
{
// arrange
var expectedException = new Exception("I'm failing You, I'm so sorry.");
var firstProcess = A.Fake <IProcess>();
A.CallTo(() => firstProcess.RunAsync(CancellationToken.None)).Returns(Task.FromException(expectedException));
var secondProcessWasInvoked = false;
var secondProcess = A.Fake <IProcess>();
A.CallTo(() => secondProcess.RunAsync(CancellationToken.None)).Invokes(() => secondProcessWasInvoked = true);
var sut = new SequentialProcess(new[] { firstProcess, secondProcess });
// act
sut.Invoking(async x => await x.RunAsync(CancellationToken.None))
.Should().Throw <Exception>().Where(ex => ex == expectedException);
// assert
secondProcessWasInvoked.Should().BeFalse();
}
static async Task RunBus()
{
IEndpointInstance endpoint = null;
try
{
var configuration = new EndpointConfiguration("NServiceBus.MessageRouting.RoutingSlips.Samples.Sender");
configuration.UseTransport <MsmqTransport>();
configuration.UsePersistence <InMemoryPersistence>();
configuration.EnableFeature <RoutingSlips>();
configuration.SendFailedMessagesTo("error");
endpoint = await Endpoint.Start(configuration);
var toggle = false;
while (Console.ReadLine() != null)
{
if (toggle)
{
var messageABC = new SequentialProcess
{
StepAInfo = "Foo",
StepBInfo = "Bar",
StepCInfo = "Baz",
};
Logger.Info("Sending message for step A, B, C");
await endpoint.Route(messageABC, Guid.NewGuid(), new[]
{
"NServiceBus.MessageRouting.RoutingSlips.Samples.StepA",
"NServiceBus.MessageRouting.RoutingSlips.Samples.StepB",
"NServiceBus.MessageRouting.RoutingSlips.Samples.StepC",
"NServiceBus.MessageRouting.RoutingSlips.Samples.ResultHost",
});
}
else
{
var messageAC = new SequentialProcess
{
StepAInfo = "Foo",
StepCInfo = "Baz",
};
Logger.Info("Sending message for step A, C");
await endpoint.Route(messageAC, Guid.NewGuid(), new[]
{
"NServiceBus.MessageRouting.RoutingSlips.Samples.StepA",
"NServiceBus.MessageRouting.RoutingSlips.Samples.StepC",
"NServiceBus.MessageRouting.RoutingSlips.Samples.ResultHost",
});
}
toggle = !toggle;
}
}
finally
{
await endpoint.Stop();
}
}
static async Task RunBus()
{
IEndpointInstance endpoint = null;
try
{
var configuration = new EndpointConfiguration("NServiceBus.MessageRouting.RoutingSlips.Samples.Sender");
configuration.UseTransport<MsmqTransport>();
configuration.UsePersistence<InMemoryPersistence>();
configuration.EnableFeature<RoutingSlips>();
configuration.SendFailedMessagesTo("error");
endpoint = await Endpoint.Start(configuration);
var toggle = false;
while (Console.ReadLine() != null)
{
if (toggle)
{
var messageABC = new SequentialProcess
{
StepAInfo = "Foo",
StepBInfo = "Bar",
StepCInfo = "Baz",
};
Logger.Info("Sending message for step A, B, C");
await endpoint.Route(messageABC, Guid.NewGuid(), new[]
{
"NServiceBus.MessageRouting.RoutingSlips.Samples.StepA",
"NServiceBus.MessageRouting.RoutingSlips.Samples.StepB",
"NServiceBus.MessageRouting.RoutingSlips.Samples.StepC",
"NServiceBus.MessageRouting.RoutingSlips.Samples.ResultHost",
});
}
else
{
var messageAC = new SequentialProcess
{
StepAInfo = "Foo",
StepCInfo = "Baz",
};
Logger.Info("Sending message for step A, C");
await endpoint.Route(messageAC, Guid.NewGuid(), new[]
{
"NServiceBus.MessageRouting.RoutingSlips.Samples.StepA",
"NServiceBus.MessageRouting.RoutingSlips.Samples.StepC",
"NServiceBus.MessageRouting.RoutingSlips.Samples.ResultHost",
});
}
toggle = !toggle;
}
}
finally
{
await endpoint.Stop();
}
}
