public void when_write_and_read_envelope()
{
var serializer = new TestMessageSerializer(new[] { typeof(SerializerTest1), typeof(SerializerTest2), });
var streamer = new EnvelopeStreamer(serializer);
var date = DateTime.UtcNow;
var savedBytes = streamer.SaveEnvelopeData(new ImmutableEnvelope("EnvId", date, new SerializerTest1 {
Name = "Test1"
},
new[]
{
new MessageAttribute("key1", "val1"),
new MessageAttribute("key2", "val2"),
}));
var envelope = streamer.ReadAsEnvelopeData(savedBytes);
Assert.AreEqual("EnvId", envelope.EnvelopeId);
Assert.AreEqual(date, envelope.CreatedUtc);
Assert.AreEqual(2, envelope.Attributes.Count);
Assert.AreEqual("key1", envelope.Attributes.ToArray()[0].Key);
Assert.AreEqual("val1", envelope.Attributes.ToArray()[0].Value);
Assert.AreEqual("key2", envelope.Attributes.ToArray()[1].Key);
Assert.AreEqual("val2", envelope.Attributes.ToArray()[1].Value);
Assert.AreEqual(typeof(SerializerTest1), envelope.Message.GetType());
Assert.AreEqual("Test1", (envelope.Message as SerializerTest1).Name);
}
public void Test()
{
// this test will start a simple web server on port 8082 (with a CQRS engine)
// You might need to reserve that port or run test as admin. Check out unit test
// output for the exact command line on port reservation (or MSDN docs)
//
// netsh http add urlacl url=http://+:8082/ user=RINAT-R5\Rinat.Abdullin
// after starting the test, navigate you browser to localhost:8082/index.htm
// and try dragging the image around
// in-memory structure to capture mouse movement
// statistics
var stats = new MouseStats();
// we accept a message just of this type, using a serializer
var messages = new[] { typeof(MouseMoved), typeof(MouseClick) };
var serializer = new MyJsonSerializer(messages);
var streamer = new EnvelopeStreamer(serializer);
var store = new MemoryAccount();
var atomic = store.CreateNuclear().Factory;
// let's configure our custom Http server to
// 1. serve resources
// 2. serve MouseStats View
// 3. accept commands
var environment = new HttpEnvironment {
Port = 8082
};
var builder = new CqrsEngineBuilder(streamer);
builder.AddProcess(new Listener(environment,
new EmbeddedResourceHttpRequestHandler(typeof(MouseMoved).Assembly, "Snippets.HttpEndpoint"),
new MouseStatsRequestHandler(stats),
new HeatMapRequestHandler(atomic.GetEntityReader <unit, HeatMapView>()),
new MouseEventsRequestHandler(store.CreateQueueWriter("inbox"), serializer, streamer)));
builder.Handle(store.CreateInbox("inbox"), envelope =>
{
if (envelope.Items.Any(i => i.Content is MouseMoved))
{
MouseStatHandler(envelope, stats);
}
else if (envelope.Items.Any(i => i.Content is MouseClick))
{
MouseClickHandler(envelope, atomic.GetEntityWriter <unit, PointsView>());
}
});
builder.AddProcess(new HeatMapGenerateTask(atomic.GetEntityReader <unit, PointsView>(), atomic.GetEntityWriter <unit, HeatMapView>()));
Process.Start("http://localhost:8082/index.htm");
// this is a test, so let's block everything
builder.Build().RunForever();
}
public void Run_in_test()
{
var streamer = EnvelopeStreamer.CreateDefault(typeof(CreateCustomer), typeof(CustomerCreated));
var builder = new CqrsEngineBuilder(streamer);
var account = new MemoryStorageConfig();
var nuclear = account.CreateNuclear(new TestStrategy());
var inbox = account.CreateInbox("input");
var sender = account.CreateSimpleSender(streamer, "input");
var handler = new RedirectToCommand();
handler.WireToLambda <CreateCustomer>(customer => Consume(customer, nuclear, sender));
handler.WireToLambda <CustomerCreated>(m => Console.WriteLine("Created!"));
builder.Handle(inbox, envelope => handler.InvokeMany(envelope.SelectContents()));
using (var engine = builder.Build())
{
sender.SendOne(new CreateCustomer
{
CustomerId = 1,
CustomerName = "Rinat Abdullin"
});
engine.RunForever();
}
}
public void Test()
{
var types = Assembly.GetExecutingAssembly().GetExportedTypes()
.Where(t => typeof(IPS_SampleMessage).IsAssignableFrom(t));
var streamer = EnvelopeStreamer.CreateDefault(types);
var builder = new CqrsEngineBuilder(streamer);
// only message contracts within this class
// configure in memory:
// -> sub 1
// inbox -> [PubSubRouter] <
// -> sub 2
//
var store = new MemoryAccount();
var nuclear = store.CreateNuclear();
var router = new PubSubRouter(nuclear, store.CreateWriteQueueFactory(), streamer);
router.Init();
builder.Dispatch(store.CreateInbox("sub1"), b => Console.WriteLine("sub1 hit"));
builder.Dispatch(store.CreateInbox("sub2"), b => Console.WriteLine("sub2 hit"));
builder.Handle(store.CreateInbox("inbox"), router.DispatchMessage);
var sender = store.CreateSimpleSender(streamer, "inbox");
using (var engine = builder.Build())
using (var cts = new CancellationTokenSource())
{
var task = engine.Start(cts.Token);
// no handler should get these.
sender.SendOne(new SomethingHappened());
sender.SendOne(new OtherHappened());
// subscribe sub1 to all messages and sub2 to specific message
sender.SendControl(eb =>
{
eb.AddString("router-subscribe:sub1", ".*");
eb.AddString("router-subscribe:sub2", "SomethingHappened");
});
sender.SendOne(new SomethingHappened());
sender.SendOne(new OtherHappened());
// unsubscribe all
sender.SendControl(eb =>
{
eb.AddString("router-unsubscribe:sub1", ".*");
eb.AddString("router-unsubscribe:sub2", "SomethingHappened");
});
sender.SendOne(new SomethingHappened());
sender.SendOne(new OtherHappened());
task.Wait(5000);
}
}
public void create_MessageSender()
{
var path = Path.Combine(Path.GetTempPath(), "lokad-cqrs-test", Guid.NewGuid().ToString());
var config = FileStorage.CreateConfig(new DirectoryInfo(path));
var serializer = new TestMessageSerializer(new[] { typeof(SerializerTest1), typeof(SerializerTest2), });
var streamer = new EnvelopeStreamer(serializer);
var sender = config.CreateMessageSender(streamer, "QueueName");
Assert.IsNotNull(sender);
}
void Configure(IComponentRegistry reg, ISystemObserver system)
{
reg.Register(system);
// domain should go before serialization
_directory(reg, _dataSerialization);
_storage.Configure(reg);
var types = _dataSerialization.GetAndMakeReadOnly();
var dataSerializer = _dataSerializer(types);
var streamer = new EnvelopeStreamer(_envelopeSerializer, dataSerializer);
reg.Register(BuildRegistry);
reg.Register(dataSerializer);
reg.Register <IEnvelopeStreamer>(c => streamer);
reg.Register(new MessageDuplicationManager());
}
public void SetUp()
{
_storeRecords = new List <StoreRecord>();
this._serializer = new TestMessageSerializer(new[] { typeof(SerializerTest1), typeof(SerializerTest2), typeof(string) });
this._path = Path.Combine(Path.GetTempPath(), "MessageStorePublisher", Guid.NewGuid().ToString());
this._appendOnlyStore = new FileAppendOnlyStore(new DirectoryInfo(this._path));
this._appendOnlyStore.Initialize();
this._store = new MessageStore(this._appendOnlyStore, this._serializer);
var streamer = new EnvelopeStreamer(this._serializer);
var queueWriter = new TestQueueWriter();
this._sender = new MessageSender(streamer, queueWriter);
var store = new FileDocumentStore(Path.Combine(this._path, "lokad-cqrs-test"), new DocumentStrategy());
this._nuclearStorage = new NuclearStorage(store);
this._publisher = new MessageStorePublisher("test-tape", this._store, this._sender, this._nuclearStorage, DoWePublishThisRecord);
}
public void Then_transactional_support_is_provided()
{
var streamer = EnvelopeStreamer.CreateDefault(typeof(Act));
var builder = new CqrsEngineBuilder(streamer);
var setup = ComposeComponents(streamer);
var handler = new CommandHandler();
handler.WireToLambda <Act>(act => Consume(act, setup.Storage));
builder.Handle(setup.Inbox, envelope =>
{
using (var tx = new TransactionScope(TransactionScopeOption.RequiresNew))
{
handler.HandleAll(envelope);
tx.Complete();
}
});
using (var source = new CancellationTokenSource())
using (TestObserver.When <EnvelopeDispatched>(e => source.Cancel()))
using (var engine = builder.Build())
{
setup.Sender.SendBatch(new[] { new Act(), new Act(), new Act {
Fail = true
} });
setup.Sender.SendBatch(new[] { new Act(), new Act(), new Act() });
var task = engine.Start(source.Token);
// Trace.WriteLine("Started");
if (!task.Wait(Debugger.IsAttached ? int.MaxValue : TestSpeed))
{
source.Cancel();
Assert.Fail("System should be stopped by now");
}
var storage = setup.Storage;
var count = storage.GetSingletonOrNew <int>();
Assert.AreEqual(3, count, "Three acts are expected");
}
}
