public InvoiceSubmissionRouter(TestUntil testUntil) :
base(new RouterSpecification(
0,
Definition.Has <ERPSpecificInvoiceSubmitter>(Definition.Parameters(ERPSystemCode.None, testUntil)),
typeof(IInvoiceSubmitter)))
{
}
public void TestActuallyCompletes()
{
var properties = new Properties();
properties.SetProperty("plugin.name.pooledCompletes", "true");
properties.SetProperty("plugin.pooledCompletes.classname", "Vlingo.Actors.Plugin.Completes.PooledCompletesPlugin");
properties.SetProperty("plugin.pooledCompletes.pool", "10");
var pluginProperties = new PluginProperties("pooledCompletes", properties);
var plugin = new PooledCompletesPlugin();
plugin.Configuration.BuildWith(world.Configuration, pluginProperties);
plugin.Start(world);
var clientCompletes = new MockCompletes <object>();
clientCompletes.UntilWith = TestUntil.Happenings(1);
var asyncCompletes = world.CompletesFor(clientCompletes);
asyncCompletes.With(5);
clientCompletes.UntilWith.Completes();
Assert.Equal(1, clientCompletes.WithCount);
Assert.Equal(5, clientCompletes.Outcome);
}
public MathCommandRouter(int poolSize, TestUntil testUntil) :
base(new RouterSpecification(
poolSize,
Definition.Has <MathCommandWorker>(Definition.Parameters(testUntil)),
typeof(IThreeArgConsumerProtocol)))
{
}
public void TestRedistributeUnconfirmed()
{
var allOtherNodes = Config.AllOtherNodes(_localNodeId).ToList();
var channel2 = _channelProvider.ChannelFor(allOtherNodes[0].Id);
Mock(channel2).Until = TestUntil.Happenings(1);
var channel3 = _channelProvider.ChannelFor(allOtherNodes[1].Id);
Mock(channel3).Until = TestUntil.Happenings(1);
var set = AttributeSet.Named("test-set");
var tracked = set.AddIfAbsent(Attribute <string> .From("test-attr", "test-value"));
_confirmingDistributor.Distribute(set, tracked, ApplicationMessageType.AddAttribute);
_confirmingDistributor.RedistributeUnconfirmed();
Mock(channel2).Until.Completes();
Assert.Single(Mock(channel2).Writes);
Mock(channel3).Until.Completes();
Assert.Single(Mock(channel3).Writes);
}
public void TestStopActors()
{
var testResults = new TestResults();
testResults.untilStart = TestUntil.Happenings(12);
var stoppables = SetUpActors(World, testResults);
for (int idx = 0; idx < stoppables.Length; ++idx)
{
stoppables[idx].CreateChildren();
}
testResults.untilStart.CompletesWithin(2000);
testResults.untilStop = TestUntil.Happenings(12);
for (int idx = 0; idx < stoppables.Length; ++idx)
{
stoppables[idx].Stop();
}
testResults.untilStop.CompletesWithin(2000);
Assert.Equal(12, testResults.stopCount.Get());
testResults.untilTerminatingStop = TestUntil.Happenings(0);
testResults.terminating.Set(true);
World.Terminate();
testResults.untilTerminatingStop.CompletesWithin(2000);
Assert.Equal(0, testResults.terminatingStopCount.Get());
}
public OrderRouterActor(int poolSize, TestUntil testUntil)
: base(
new RouterSpecification(
poolSize,
Definition.Has <OrderRouterWorker>(Definition.Parameters(testUntil)),
typeof(IRoundRobinOrderRouter)),
new RoundRobinRoutingStrategy())
{
}
private AccessSafely(int happenings)
{
_totalWrites = new AtomicInteger(0);
_until = TestUntil.Happenings(happenings);
_biConsumers = new Dictionary <string, object>();
_consumers = new Dictionary <string, object>();
_functions = new Dictionary <string, object>();
_suppliers = new Dictionary <string, object>();
_lock = new object();
}
private AccessSafely(AccessSafely existing, int happenings)
{
_totalWrites = existing._totalWrites;
_until = TestUntil.Happenings(happenings);
_biConsumers = existing._biConsumers;
_consumers = existing._consumers;
_functions = existing._functions;
_suppliers = existing._suppliers;
_lock = new object();
}
public void TestPlayPingPong()
{
var world = World.StartWithDefaults("playground");
var until = TestUntil.Happenings(1);
var pinger = world.ActorFor <IPinger>(() => new PingerActor(until));
var ponger = world.ActorFor <IPonger>(() => new PongerActor());
pinger.Ping(ponger);
until.Completes();
world.Terminate();
}
public void TestStartWorldWithDefaultConfiguration()
{
var worldDefaultConfig = World.Start("defaults");
var testResults = new TestResults();
var simple = worldDefaultConfig.ActorFor<ISimpleWorldForDefaultConfig>(
Definition.Has<SimpleActor>(
Definition.Parameters(testResults)));
testResults.UntilSimple = TestUntil.Happenings(1);
simple.SimplySay();
testResults.UntilSimple.Completes();
Assert.True(testResults.Invoked.Get());
}
public void TestThatItRoutes()
{
var world = World.StartWithDefault("RoundRobinRouterTest");
const int poolSize = 4, messagesToSend = 8;
var until = TestUntil.Happenings(messagesToSend);
var orderRouter = world.ActorFor <IRoundRobinOrderRouter>(
Definition.Has <OrderRouterActor>(Definition.Parameters(poolSize, until)));
for (var i = 0; i < messagesToSend; ++i)
{
orderRouter.RouteOrder(new RoundRobinOrder(i));
}
until.Completes();
}
public void TestDeliverWithParameters()
{
var testResults = new SimpleTestResults();
TestWorld.ActorFor <ISimple>(Definition.Has <SimpleActor>(Definition.Parameters(testResults), "test1-actor"));
testResults.UntilSimple = TestUntil.Happenings(1);
Action <ISimple> consumer = x => x.Simple2(2);
var message = new LocalMessage <ISimple>(SimpleActor.Instance.Value, consumer, "Simple2(int)");
message.Deliver();
testResults.UntilSimple.Completes();
Assert.Equal(1, testResults.Deliveries.Get());
}
public void TestActorForNoDefinitionAndProtocol()
{
var testResults = new TestResults();
var simple = World.Stage.ActorFor <ISimpleWorld>(typeof(SimpleActor), testResults);
testResults.UntilSimple = TestUntil.Happenings(1);
simple.SimpleSay();
testResults.UntilSimple.Completes();
Assert.True(testResults.Invoked.Get());
var test = World.Stage.ActorFor <INoProtocol>(typeof(TestInterfaceActor));
Assert.NotNull(test);
Assert.NotNull(TestInterfaceActor.Instance.Value);
Assert.Equal(World.DefaultParent, TestInterfaceActor.Instance.Value.LifeCycle.Environment.Parent);
}
public void TestThatItRoutes()
{
var world = World.StartWithDefault("RandomRouterTest");
const int poolSize = 4, messagesToSend = 40;
var until = TestUntil.Happenings(messagesToSend);
var orderRouter = world.ActorFor <IOrderRandomRouter>(Definition.Has <OrderRouterActor>(Definition.Parameters(poolSize, until)));
var random = new Random();
for (int i = 0; i < messagesToSend; i++)
{
orderRouter.RouteOrder(new RandomRouterOrder());
}
until.Completes();
}
public void TestPlayPingPong()
{
var world = World.Start("playground");
var until = TestUntil.Happenings(1);
var pinger = world.ActorFor <IPinger>(
Definition.Has <PingerActor>(Definition.Parameters(until)));
var ponger = world.ActorFor <IPonger>(
Definition.Has <PongerActor>(
Definition.NoParameters));
pinger.Ping(ponger);
until.Completes();
world.Terminate();
}
public void TestDeliverStopped()
{
var testResults = new SimpleTestResults();
TestWorld.ActorFor <ISimple>(Definition.Has <SimpleActor>(Definition.Parameters(testResults), "test1-actor"));
testResults.UntilSimple = TestUntil.Happenings(1);
SimpleActor.Instance.Value.Stop();
Action <ISimple> consumer = actor => actor.Simple();
var message = new LocalMessage <ISimple>(SimpleActor.Instance.Value, consumer, "Simple()");
message.Deliver();
Assert.Equal(1, testResults.UntilSimple.Remaining);
Assert.Equal(0, testResults.Deliveries.Get());
}
public void TestThatItRoutes()
{
var world = World.StartWithDefault("ContentBasedRouterTest");
const int poolSize = 4, messagesToSend = 40;
var until = TestUntil.Happenings(messagesToSend);
var orderRouter = world.ActorFor <IOrderContentRouter>(Definition.Has <OrderRouterActor>(Definition.Parameters(poolSize, until)));
var customerIds = new[] { "Customer1", "Customer2", "Customer3", "Customer4" };
var random = new Random();
for (int i = 0; i < messagesToSend; i++)
{
var customerId = customerIds[random.Next(customerIds.Length)];
orderRouter.RouteOrder(new Order(customerId));
}
until.Completes();
}
public void TestThreeArgConsumerProtocol()
{
var poolSize = 4;
var rounds = 2;
var messagesToSend = poolSize * rounds;
var until = TestUntil.Happenings(messagesToSend);
var testRouter = TestWorld.ActorFor <IThreeArgConsumerProtocol>(
Definition.Has <MathCommandRouter>(Definition.Parameters(poolSize, until)));
for (var round = 0; round < messagesToSend; ++round)
{
testRouter.Actor.DoSomeMath(round, round, round);
}
until.Completes();
var routerActor = (MathCommandRouter)testRouter.ActorInside;
foreach (var routee in routerActor.Routees)
{
Assert.Equal(messagesToSend, routee.MessageCount);
}
}
public void TestCompletesAddressMatches()
{
var properties = new Properties();
properties.SetProperty("plugin.name.pooledCompletes", "true");
properties.SetProperty("plugin.pooledCompletes.classname", "Vlingo.Actors.Plugin.Completes.PooledCompletesPlugin");
properties.SetProperty("plugin.pooledCompletes.pool", "10");
var pluginProperties = new PluginProperties("pooledCompletes", properties);
var plugin = new PooledCompletesPlugin();
plugin.Configuration.BuildWith(World.Configuration, pluginProperties);
plugin.Start(World);
var clientCompletes1 = new MockCompletes <int>();
var clientCompletes2 = new MockCompletes <int>();
clientCompletes1.UntilWith = TestUntil.Happenings(1);
var completes1 = World.CompletesFor(clientCompletes1);
completes1.With(5);
clientCompletes1.UntilWith.Completes();
clientCompletes2.UntilWith = TestUntil.Happenings(1);
var completes2 = World.CompletesFor(completes1.Address, clientCompletes2);
completes2.With(10);
clientCompletes2.UntilWith.Completes();
Assert.Equal(1, clientCompletes1.WithCount);
Assert.Equal(5, clientCompletes1.Outcome);
Assert.Equal(1, clientCompletes2.WithCount);
Assert.Equal(10, clientCompletes2.Outcome);
Assert.Equal(completes1, completes2);
}
public PingerActor(TestUntil until)
{
_count = 0;
_self = SelfAs <IPinger>();
_until = until;
}
public MockCompletes()
: base((Scheduler)null)
{
UntilWith = TestUntil.Happenings(0);
WithCount = 0;
}
public TestResult(int happenings)
{
deadLetters = new List <DeadLetter>();
until = TestUntil.Happenings(happenings);
}
public OrderRouterWorker(TestUntil testUntil)
{
this.testUntil = testUntil;
}
public ERPSpecificInvoiceSubmitter(ERPSystemCode erp, TestUntil testUntil)
{
this.erp = erp;
this.testUntil = testUntil;
submitted = new List <Invoice>();
}
public void TestThatItRoutes()
{
var messagesToSend = 63;
var until = TestUntil.Happenings(messagesToSend);
var erpsToTest = new[] { ERPSystemCode.Alpha, ERPSystemCode.Beta, ERPSystemCode.Charlie };
var routerTestActorProtocols = World.ActorFor(
new[] { typeof(IInvoiceSubmitter), typeof(IInvoiceSubmitterSubscription) },
typeof(InvoiceSubmissionRouter),
until);
var routerProtocols = Protocols.Two <IInvoiceSubmitter, IInvoiceSubmitterSubscription>(routerTestActorProtocols);
var routerAsInvoiceSubmitter = routerProtocols._1;
var routerAsInvoiceSubmitterSubscription = routerProtocols._2;
var alphaSubmitterTestActor = TestWorld.ActorFor <IInvoiceSubmitter>(typeof(ERPSpecificInvoiceSubmitter), ERPSystemCode.Alpha, until);
routerAsInvoiceSubmitterSubscription.Subscribe(alphaSubmitterTestActor.ActorAs <IInvoiceSubmitter>());
var betaSubmitterTestActor = TestWorld.ActorFor <IInvoiceSubmitter>(typeof(ERPSpecificInvoiceSubmitter), ERPSystemCode.Beta, until);
routerAsInvoiceSubmitterSubscription.Subscribe(betaSubmitterTestActor.ActorAs <IInvoiceSubmitter>());
var charlieSubmitterTestActor = TestWorld.ActorFor <IInvoiceSubmitter>(typeof(ERPSpecificInvoiceSubmitter), ERPSystemCode.Charlie, until);
routerAsInvoiceSubmitterSubscription.Subscribe(charlieSubmitterTestActor.ActorAs <IInvoiceSubmitter>());
var random = new Random();
var countByERP = new int[erpsToTest.Length];
Array.Fill(countByERP, 0);
for (var i = 0; i < messagesToSend; ++i)
{
var erpIndex = random.Next(3);
var erp = erpsToTest[erpIndex];
var invoice = Invoice.With(erp, i, RandomMoney(random));
routerAsInvoiceSubmitter.SubmitInvoice(invoice);
countByERP[erpIndex] += 1;
}
until.Completes();
var alphaSubmitter = (ERPSpecificInvoiceSubmitter)alphaSubmitterTestActor.ActorInside;
Assert.Equal(countByERP[0], alphaSubmitter.submitted.Count);
foreach (var invoice in alphaSubmitter.submitted)
{
Assert.Equal(ERPSystemCode.Alpha, invoice.erp);
}
var betaSubmitter = (ERPSpecificInvoiceSubmitter)betaSubmitterTestActor.ActorInside;
Assert.Equal(countByERP[1], betaSubmitter.submitted.Count);
foreach (var invoice in betaSubmitter.submitted)
{
Assert.Equal(ERPSystemCode.Beta, invoice.erp);
}
var charlieSubmitter = (ERPSpecificInvoiceSubmitter)charlieSubmitterTestActor.ActorInside;
Assert.Equal(countByERP[2], charlieSubmitter.submitted.Count);
foreach (var invoice in charlieSubmitter.submitted)
{
Assert.Equal(ERPSystemCode.Charlie, invoice.erp);
}
}
public CompletesActorProtocolTest()
{
untilHello = TestUntil.Happenings(1);
untilOne = TestUntil.Happenings(1);
}
public MockManagedOutboundChannel(Id id)
{
Id = id;
Writes = new List <string>();
Until = TestUntil.Happenings(0);
}
public Results(int times)
{
until = TestUntil.Happenings(times);
}
public TestUntil Until(int times) => TestUntil.Happenings(times);
public Results(int overrideReceived, int stowReceived)
{
this.overrideReceived = TestUntil.Happenings(overrideReceived);
this.stowReceived = TestUntil.Happenings(stowReceived);
}
