public void CreateReceiveResult_ReturnsAResult_WithMessageReceivedTrue()
{
// Arrange
var result = ReceiveOrSendResult <int, string> .CreateReceiveResult(3);
// Act
var messageSent = result.MessageReceived;
// Assert
messageSent.Should().BeTrue();
}
public void CreateSendResult_ReturnsAResult_WithMessageReceivedFalse()
{
// Arrange
var result = ReceiveOrSendResult <int, string> .CreateSendResult();
// Act
var messageReceived = result.MessageReceived;
// Assert
messageReceived.Should().BeFalse();
}
public void ReceiveOrSend_GivenAReceiveResult_FlushesTheMessageToSend()
{
// Arrange
resultOutlet.Setup(r => r.Receive()).Returns(ReceiveOrSendResult <int, string> .CreateReceiveResult(3));
// Act
valve.ReceiveOrSend("Wooo");
// Assert
flushOutlet.Verify(f => f.ReceiveImmediately(), Times.Once);
}
public void CreateReceiveResult_ReturnsAResult_WithTheMessageReceived()
{
// Arrange
const int expectedMessage = 3;
var result = ReceiveOrSendResult <int, string> .CreateReceiveResult(expectedMessage);
// Act
var actualMessage = result.GetReceivedMessage();
// Assert
actualMessage.Should().Be(expectedMessage);
}
public void ReceiveOrSend_GivenASendResultIsReturned_ReturnsThatResult()
{
// Arrange
var expectedResult = ReceiveOrSendResult <int, string> .CreateSendResult();
resultOutlet.Setup(r => r.Receive()).Returns(expectedResult);
// Act
var actualResult = valve.ReceiveOrSend("hello");
// Assert
actualResult.MessageSent.Should().BeTrue();
}
public void ReceiveOrSend_GivenAReceiveResultIsReturned_ReturnsThatResult()
{
// Arrange
const int message = 3;
var expectedResult = ReceiveOrSendResult <int, string> .CreateReceiveResult(message);
resultOutlet.Setup(r => r.Receive()).Returns(expectedResult);
// Act
var actualResult = valve.ReceiveOrSend("Hello");
// Assert
actualResult.MessageReceived.Should().BeTrue();
actualResult.GetReceivedMessage().Should().Be(message);
}
public BigValvedPipe(IReadOnlyList <ISimpleInlet <TReceive> > inlets, IReadOnlyList <ISimpleOutlet <TSend> > outlets, TTieBreaker tieBreaker)
: base(inlets, outlets)
{
Inlets = inlets;
Outlets = outlets;
TieBreaker = tieBreaker;
// Construct all necessary pipes
var preparationCapacityPipe = PipeBuilder.New.CapacityPipe <TSend>().WithCapacity(1).Build();
var flushEitherOutletPipe = PipeBuilder.New.BigEitherOutletPipe <TSend>().WithSize(Outlets.Count + 1).Build();
var splittingPipes = Enumerable.Repeat <Func <ISplittingPipe <TSend> > >(() =>
PipeBuilder.New.SplittingPipe <TSend>().Build(), Outlets.Count)
.Select(f => f()).ToList();
var sendTransformPipes = Enumerable.Repeat <Func <ITransformPipe <TSend, ReceiveOrSendResult <TReceive, TSend> > > >(() =>
PipeBuilder.New.TransformPipe <TSend, ReceiveOrSendResult <TReceive, TSend> >().WithMap(m => ReceiveOrSendResult <TReceive, TSend> .CreateSendResult()).Build(), Outlets.Count)
.Select(f => f()).ToList();
var receiveTransformPipes = Enumerable.Repeat <Func <ITransformPipe <TReceive, ReceiveOrSendResult <TReceive, TSend> > > >(() =>
PipeBuilder.New.TransformPipe <TReceive, ReceiveOrSendResult <TReceive, TSend> >().WithMap(ReceiveOrSendResult <TReceive, TSend> .CreateReceiveResult).Build(), Inlets.Count)
.Select(f => f()).ToList();
var resultPipe = PipeBuilder.New.BigEitherInletPipe <ReceiveOrSendResult <TReceive, TSend> >().WithSize(inlets.Count + outlets.Count).WithTieBreaker(TieBreaker).Build();
// Form the pipe system. Note that this DOES form a non-tree, but its correctness is guaranteed
// by the fact the individual receivers of the splitting pipes are distinct.
preparationCapacityPipe.Outlet.ConnectTo(flushEitherOutletPipe.Inlet, false);
for (var i = 0; i < Outlets.Count; i++)
{
flushEitherOutletPipe.Outlets[i].ConnectTo(splittingPipes[i].Inlet, false);
splittingPipes[i].RightOutlet.ConnectTo(sendTransformPipes[i].Inlet, false);
sendTransformPipes[i].Outlet.ConnectTo(resultPipe.Inlets[Inlets.Count + i], false);
CreateAndConnectAdapter(splittingPipes[i].LeftOutlet, Outlets[i]);
}
for (var i = 0; i < Inlets.Count; i++)
{
receiveTransformPipes[i].Outlet.ConnectTo(resultPipe.Inlets[i], false);
CreateAndConnectAdapter(receiveTransformPipes[i].Inlet, Inlets[i]);
}
Valve = new Valve <TReceive, TSend>(preparationCapacityPipe.Inlet, flushEitherOutletPipe.Outlets[outlets.Count], resultPipe.Outlet);
}
public ValvedPipe(ISimpleInlet <TReceive> inlet, ISimpleOutlet <TSend> outlet, TTieBreaker tieBreaker) : base(new[] { inlet }, new[] { outlet })
{
Inlet = inlet;
Outlet = outlet;
TieBreaker = tieBreaker;
var preparationCapacityPipe = PipeBuilder.New.CapacityPipe <TSend>().WithCapacity(1).Build();
var flushEitherOutletPipe = PipeBuilder.New.EitherOutletPipe <TSend>().Build();
var splittingPipe = PipeBuilder.New.SplittingPipe <TSend>().Build();
var sendTransformPipe = PipeBuilder.New.TransformPipe <TSend, ReceiveOrSendResult <TReceive, TSend> >().WithMap(m => ReceiveOrSendResult <TReceive, TSend> .CreateSendResult()).Build();
var receiveTransformPipe = PipeBuilder.New.TransformPipe <TReceive, ReceiveOrSendResult <TReceive, TSend> >().WithMap(ReceiveOrSendResult <TReceive, TSend> .CreateReceiveResult).Build();
var eitherInletPipe = PipeBuilder.New.EitherInletPipe <ReceiveOrSendResult <TReceive, TSend> >().WithTieBreaker(TieBreaker).Build();
preparationCapacityPipe.Outlet.ConnectTo(flushEitherOutletPipe.Inlet);
flushEitherOutletPipe.RightOutlet.ConnectTo(splittingPipe.Inlet);
splittingPipe.RightOutlet.ConnectTo(sendTransformPipe.Inlet);
sendTransformPipe.Outlet.ConnectTo(eitherInletPipe.LeftInlet);
receiveTransformPipe.Outlet.ConnectTo(eitherInletPipe.RightInlet);
CreateAndConnectAdapter(splittingPipe.LeftOutlet, Outlet);
CreateAndConnectAdapter(receiveTransformPipe.Inlet, Inlet);
Valve = new Valve <TReceive, TSend>(preparationCapacityPipe.Inlet, flushEitherOutletPipe.LeftOutlet, eitherInletPipe.Outlet);
}
