public when_events_are_published(StreamStoreConnectionFixture fixture) : base(fixture.Connection)
{
_listener = new SynchronizableStreamListener(
Logging.FullStreamName,
Connection,
StreamNameBuilder,
EventSerializer);
_listener.EventStream.Subscribe <Event>(this);
_listener.Start(Logging.FullStreamName);
_countedEventCount = 0;
_testDomainEventCount = 0;
CorrelatedMessage source = CorrelatedMessage.NewRoot();
// create and publish a set of events
for (int i = 0; i < _maxCountedEvents; i++)
{
var evt = new CountedEvent(i, source);
Bus.Publish(evt);
source = evt;
}
Bus.Subscribe(new AdHocHandler <TestEvent>(_ => Interlocked.Increment(ref _gotEvt)));
Bus.Publish(new TestEvent(source));
}
public void Handle(CountedEvent message)
{
lock (_lockThis)
{
EventsHandled++;
LastEventHandled = message.MessageNumber;
EventOrder.Add(message.MessageNumber);
}
}
public can_unsubscribe_queued_messages()
{
for (var i = 0; i < _msgCount; i++)
{
_messages.Add(new CountedTestMessage(i));
var evt = new CountedEvent(i);
_messages.Add(evt);
var cmd = new TestCommands.OrderedCommand(i);
_messages.Add(cmd);
}
}
public can_unsubscribe_queued_messages()
{
var source = CorrelatedMessage.NewRoot();
for (var i = 0; i < _msgCount; i++)
{
_messages.Add(new CountedTestMessage(i));
var evt = new CountedEvent(i, source);
_messages.Add(evt);
source = evt;
}
}
public void events_logged_only_while_logging_is_enabled()
{
_countedEventCount = 0;
CorrelatedMessage source = CorrelatedMessage.NewRoot();
// publish again, with logging disabled
for (int i = 0; i < _maxCountedEvents; i++)
{
var evt = new CountedEvent(i, source);
Bus.Publish(evt);
source = evt;
}
Assert.Throws <TrueException>(() => Assert.IsOrBecomesTrue(
() => _countedEventCount > 0,
1000,
$"Found {_countedEventCount} of first set of events on log. Should be 0"));
Logging.Enabled = true;
_countedEventCount = 0;
// create and publish a set of events
for (int i = 0; i < _maxCountedEvents; i++)
{
var evt = new CountedEvent(i, source);
Bus.Publish(evt);
source = evt;
}
Assert.IsOrBecomesTrue(
() => _countedEventCount == _maxCountedEvents,
1000,
$"Second set of Events count {_countedEventCount} - not properly logged");
Logging.Enabled = false;
_countedEventCount = 0;
// publish again, with logging disabled
for (int i = 0; i < _maxCountedEvents; i++)
{
var evt = new CountedEvent(i, source);
Bus.Publish(evt);
source = evt;
}
Assert.Throws <TrueException>(() => Assert.IsOrBecomesTrue(
() => _countedEventCount > 0,
1000,
$"Found {_countedEventCount} of third set of events on log. Should be 0"));
}
public when_logging_disabled_and_mixed_messages_are_published(StreamStoreConnectionFixture fixture) : base(fixture.Connection)
{
_countedEventCount = 0;
_testDomainEventCount = 0;
_cmdHandler = new TestCommandSubscriber(Bus);
_multiFireCount = 0;
_testCommandCount = 0;
_listener = new SynchronizableStreamListener(
Logging.FullStreamName,
Connection,
StreamNameBuilder,
EventSerializer);
_listener.EventStream.Subscribe <Message>(this);
_listener.Start(Logging.FullStreamName);
CorrelatedMessage source = CorrelatedMessage.NewRoot();
// create and fire a mixed set of commands and events
for (int i = 0; i < _maxCountedMessages; i++)
{
var evt = new CountedEvent(i, source);
Bus.Publish(evt);
// this is just an example command - choice to fire this one was random
var cmd = new TestCommands.Command2(evt);
Bus.Send(cmd,
$"exception message{i}",
TimeSpan.FromSeconds(2));
source = cmd;
}
for (int i = 0; i < _maxCountedEvents; i++)
{
var evt = new TestEvent(source);
Bus.Publish(evt);
source = evt;
}
var tstCmd = new TestCommands.Command3(source);
Bus.Send(tstCmd,
"Test Command exception message",
TimeSpan.FromSeconds(1));
}
public when_logging_high_volume_message_traffic(StreamStoreConnectionFixture fixture) : base(fixture.Connection)
{
// commands must have a commandHandler
_cmdHandler = new TestCommandSubscriber(Bus);
_commandFireCount = 0;
_commandAckCount = 0;
_commandSuccessCount = 0;
_lastCommandCount = 0;
_countedEventCount = 0;
_testDomainEventCount = 0;
_numberOfItemsLogged = 0;
_catchupSubscriptionMsgs = 0;
_listener = new SynchronizableStreamListener(
Logging.FullStreamName,
Connection,
StreamNameBuilder,
EventSerializer);
_listener.EventStream.Subscribe <Message>(this);
_listener.Start(Logging.FullStreamName);
CorrelatedMessage source = CorrelatedMessage.NewRoot();
// create and fire a mixed set of commands and events
for (int i = 0; i < _maxCountedMessages; i++)
{
var evt = new CountedEvent(i, source);
Bus.Publish(evt);
// this is just an example command - choice to fire this one was random
var cmd = new TestCommands.Command2(evt);
Bus.Send(cmd, $"exception message{i}", TimeSpan.FromSeconds(2));
var evt2 = new TestEvent(cmd);
Bus.Publish(evt2);
source = evt2;
}
var tstCmd = new TestCommands.Command3(source);
Bus.Send(tstCmd,
"TestCommand3 failed",
TimeSpan.FromSeconds(2));
}
public void mixed_messages_logged_only_while_logging_is_enabled()
{
_countedEventCount = 0;
CorrelatedMessage source = CorrelatedMessage.NewRoot();
// create and publish a set of events and commands
for (int i = 0; i < _maxCountedMessages; i++)
{
var evt = new CountedEvent(i, source);
Bus.Publish(evt);
var cmd = new TestCommands.Command2(evt);
Bus.Send(cmd, $"exception message{i}", TimeSpan.FromSeconds(1));
source = cmd;
}
Assert.Throws <TrueException>(() => Assert.IsOrBecomesTrue(
() => _countedEventCount > 0,
1000,
$"Found {_countedEventCount} of first set of events on log. Should be 0"));
Assert.Throws <TrueException>(() => Assert.IsOrBecomesTrue(
() => _multiFireCount > 0,
1000,
$"First set of commands count {_multiFireCount} - not properly logged"));
Logging.Enabled = true;
_countedEventCount = 0;
_multiFireCount = 0;
// repeat, with logging disabled
for (int i = 0; i < _maxCountedMessages; i++)
{
var evt = new CountedEvent(i, source);
Bus.Publish(evt);
var cmd = new TestCommands.Command2(evt);
Bus.Send(cmd, $"exception message{i}", TimeSpan.FromSeconds(1));
source = cmd;
}
Assert.IsOrBecomesTrue(
() => _countedEventCount == _maxCountedMessages,
1000,
$"Second set of Events count {_countedEventCount} - not properly logged");
Assert.IsOrBecomesTrue(
() => _multiFireCount == _maxCountedMessages,
1000,
$"Second set of commands count {_multiFireCount} - not properly logged");
Logging.Enabled = false;
_countedEventCount = 0;
_multiFireCount = 0;
// repeat, with logging enabled again
for (int i = 0; i < _maxCountedMessages; i++)
{
var evt = new CountedEvent(i, source);
Bus.Publish(evt);
var cmd = new TestCommands.Command2(evt);
Bus.Send(cmd, $"exception message{i}", TimeSpan.FromSeconds(1));
source = cmd;
}
Assert.Throws <TrueException>(() => Assert.IsOrBecomesTrue(
() => _countedEventCount > 0,
1000,
$"Found {_countedEventCount} of Third set of events on disabled log. Should be 0"));
Assert.Throws <TrueException>(() => Assert.IsOrBecomesTrue(
() => _multiFireCount > 0,
1000,
$"Third set of commands count {_multiFireCount} - not properly logged"));
}
