public void GivenCtor_ThenCorrectlyInitialisesMembers_Test()
{
var expectedGeneratedOn = TimeSpan.FromSeconds(1);
var actual = new StubEvent(expectedGeneratedOn);
Assert.Equal(expectedGeneratedOn, actual.GeneratedOn);
}
public GetCommandHandlerGenericTEventArgsTests()
{
_factory = new MockBindingFactory();
_command = Substitute.For <ICommand <string> >();
var obj = new StubProducer();
_e = new StubEvent(obj, nameof(obj.GenericStringEvent));
}
public GetCommandHandlerTests()
{
_factory = new MockBindingFactory();
_command = Substitute.For <ICommand>();
var obj = new StubProducer();
_e = new StubEvent(obj, nameof(obj.SimpleEvent));
}
public void ShouldIgnoreException()
{
var exception = new Exception();
var stubEvent = new StubEvent(0);
var exceptionHandler = new IgnoreExceptionHandler();
exceptionHandler.HandleEventException(exception, 0L, stubEvent);
}
public void Should_Claim_And_Get_In_Separate_Thread()
{
var messages = GetMessages(0, 0);
var expectedEvent = new StubEvent(2701);
_ringBuffer.PublishEvent(StubEvent.Translator, expectedEvent.Value, expectedEvent.TestString);
Assert.Equal(expectedEvent, messages.Result[0]);
}
public override bool Equals(object value)
{
StubEvent inst = value as StubEvent;
if (System.Object.ReferenceEquals(null, inst))
{
return(false);
}
return(EventType.KillMob.Equals(inst.GetEventType()));
}
public void ShouldHandleFatalException()
{
var causeException = new Exception();
var evt = new StubEvent(0);
var exceptionHandler = new FatalExceptionHandler <StubEvent>();
var exception = Assert.Throws <ApplicationException>(() => exceptionHandler.HandleEventException(causeException, 0L, evt));
Assert.IsNotNull(exception);
Assert.AreEqual(causeException, exception !.InnerException);
}
public void ShouldClaimAndGetInSeparateThread()
{
var events = GetEvents(0, 0);
var expectedEvent = new StubEvent(2701);
using (var scope = _ringBuffer.PublishEvent())
{
scope.Event().Copy(expectedEvent);
}
Assert.AreEqual(expectedEvent, events.Result[0]);
}
public void shouldClaimAndGetInSeparateThread()
{
Future<List<StubEvent>> messages = getMessages(0, 0);
StubEvent expectedEvent = new StubEvent(2701);
long sequence = ringBuffer.next();
StubEvent oldEvent = ringBuffer.get(sequence);
oldEvent.copy(expectedEvent);
ringBuffer.publish(sequence);
assertEquals(expectedEvent, messages.get()[0]);
}
public void ShouldClaimAndGetInSeparateThread()
{
var events = GetEvents(0, 0);
var expectedEvent = new StubEvent(2701);
var sequence = _ringBuffer.Next();
StubEvent oldEvent = _ringBuffer[sequence];
oldEvent.Copy(expectedEvent);
_ringBuffer.Publish(sequence);
Assert.AreEqual(expectedEvent, events.Result[0]);
}
public void ShouldHandleFatalException()
{
var causeException = new Exception();
var evt = new StubEvent(0);
var exceptionHandler = new FatalExceptionHandler();
try
{
exceptionHandler.HandleEventException(causeException, 0L, evt);
}
catch (Exception ex)
{
Assert.AreEqual(causeException, ex.InnerException);
}
}
public void Should_Publish_And_Get()
{
Assert.Equal(Sequence.InitialValue, _ringBuffer.GetCursor());
var expectedEvent = new StubEvent(2701);
_ringBuffer.PublishEvent(StubEvent.Translator, expectedEvent.Value, expectedEvent.TestString);
var sequence = _barrier.WaitFor(0L);
Assert.Equal(0L, sequence);
var @event = _ringBuffer.Get(sequence);
Assert.Equal(expectedEvent, @event);
Assert.Equal(0L, _barrier.GetCursor());
}
public void shouldClaimAndGetWithTimeout()
{
assertEquals(Sequencer.INITIAL_CURSOR_VALUE, ringBuffer.getCursor());
StubEvent expectedEvent = new StubEvent(2701);
long claimSequence = ringBuffer.next();
StubEvent oldEvent = ringBuffer.get(claimSequence);
oldEvent.copy(expectedEvent);
ringBuffer.publish(claimSequence);
long sequence = sequenceBarrier.waitFor(0, TimeSpan.FromMilliseconds(5));
assertEquals(0, sequence);
StubEvent @event = ringBuffer.get(sequence);
assertEquals(expectedEvent, @event);
assertEquals(0L, ringBuffer.getCursor());
}
public void ShouldSetAtSpecificSequence()
{
const long expectedSequence = 5;
_ringBuffer.Claim(expectedSequence);
StubEvent expectedEvent = _ringBuffer[expectedSequence];
expectedEvent.Value = (int)expectedSequence;
_ringBuffer.ForcePublish(expectedSequence);
long sequence = _sequenceBarrier.WaitFor(expectedSequence);
Assert.AreEqual(expectedSequence, sequence);
StubEvent evt = _ringBuffer[sequence];
Assert.AreEqual(expectedEvent, evt);
Assert.AreEqual(expectedSequence, _ringBuffer.Cursor);
}
public void ShouldPreventProducersOvertakingEventProcessorsWrapPoint()
{
const int ringBufferSize = 4;
var mre = new ManualResetEvent(false);
var producerComplete = false;
var ringBuffer = new RingBuffer <StubEvent>(() => new StubEvent(-1), ringBufferSize);
var processor = new TestEventProcessor(ringBuffer.NewBarrier());
ringBuffer.SetGatingSequences(processor.Sequence);
var thread = new Thread(
() =>
{
for (int i = 0; i <= ringBufferSize; i++) // produce 5 events
{
var sequence = ringBuffer.Next();
StubEvent evt = ringBuffer[sequence];
evt.Value = i;
ringBuffer.Publish(sequence);
if (i == 3) // unblock main thread after 4th event published
{
mre.Set();
}
}
producerComplete = true;
});
thread.Start();
mre.WaitOne();
Assert.AreEqual(ringBufferSize - 1, ringBuffer.Cursor);
Assert.IsFalse(producerComplete);
processor.Run();
thread.Join();
Assert.IsTrue(producerComplete);
}
public async Task PersistAsync_WhenFailureEvent_WillCallFailureAuditRecord()
{
// Arrange
var recorder = new Mock <IRecordAuditableActions>();
var factory = new Mock <IAdapterFactory>();
factory.Setup(x => x.Create(It.IsAny <Event>())).Returns(new Mock <IAuditEventArguments>().Object);
var sut = new AuditSink(recorder.Object)
{
Factory = factory.Object
};
var successfulEvent = new StubEvent(string.Empty, string.Empty, EventTypes.Failure, -1);
// Act
await sut.PersistAsync(successfulEvent);
// Assert
recorder.Verify(x => x.RecordFailure(It.IsAny <IAuditEventArguments>()), Times.Once);
}
public void ShouldClaimAndGet()
{
Assert.AreEqual(Sequence.InitialCursorValue, _ringBuffer.Cursor);
var expectedEvent = new StubEvent(2701);
var claimSequence = _ringBuffer.Next();
var oldEvent = _ringBuffer[claimSequence];
oldEvent.Copy(expectedEvent);
_ringBuffer.Publish(claimSequence);
var waitResult = _sequenceBarrier.WaitFor(0);
Assert.AreEqual(new SequenceWaitResult(0), waitResult);
var evt = _ringBuffer[waitResult.UnsafeAvailableSequence];
Assert.AreEqual(expectedEvent, evt);
Assert.AreEqual(0L, _ringBuffer.Cursor);
}
public void ShouldClaimAndGet()
{
Assert.AreEqual(Sequencer.InitialCursorValue, _ringBuffer.Cursor);
var expectedEvent = new StubEvent(2701);
var claimSequence = _ringBuffer.Next();
var oldEvent = _ringBuffer[claimSequence];
oldEvent.Copy(expectedEvent);
_ringBuffer.Publish(claimSequence);
long sequence = _sequenceBarrier.WaitFor(0);
Assert.AreEqual(0, sequence);
StubEvent evt = _ringBuffer[sequence];
Assert.AreEqual(expectedEvent, evt);
Assert.AreEqual(0L, _ringBuffer.Cursor);
}
public void ShouldClaimAndGetWithTimeout()
{
Assert.AreEqual(Sequencer.InitialCursorValue, _ringBuffer.Cursor);
var expectedEvent = new StubEvent(2701);
long claimSequence = _ringBuffer.Next();
StubEvent oldEvent = _ringBuffer[claimSequence];
oldEvent.Copy(expectedEvent);
_ringBuffer.Publish(claimSequence);
long sequence = _sequenceBarrier.WaitFor(0, TimeSpan.FromMilliseconds(5));
Assert.AreEqual(0, sequence);
var evt = _ringBuffer[sequence];
Assert.AreEqual(expectedEvent, evt);
Assert.AreEqual(0L, _ringBuffer.Cursor);
}
public void ShouldClaimAndGetMultipleEvents()
{
var numEvents = _ringBuffer.BufferSize;
for (var i = 0; i < numEvents; i++)
{
var sequence = _ringBuffer.Next();
StubEvent evt = _ringBuffer[sequence];
evt.Value = i;
_ringBuffer.Publish(sequence);
}
var expectedSequence = numEvents - 1;
var available = _sequenceBarrier.WaitFor(expectedSequence);
Assert.AreEqual(expectedSequence, available);
for (var i = 0; i < numEvents; i++)
{
Assert.AreEqual(i, _ringBuffer[i].Value);
}
}
public void ShouldWrap()
{
var numEvents = _ringBuffer.BufferSize;
const int offset = 1000;
for (var i = 0; i < numEvents + offset; i++)
{
var sequence = _ringBuffer.Next();
StubEvent evt = _ringBuffer[sequence];
evt.Value = i;
_ringBuffer.Publish(sequence);
}
var expectedSequence = numEvents + offset - 1;
var available = _sequenceBarrier.WaitFor(expectedSequence);
Assert.AreEqual(expectedSequence, available);
for (var i = offset; i < numEvents + offset; i++)
{
Assert.AreEqual(i, _ringBuffer[i].Value);
}
}
