public void AquireWillNotBlockIfAnotherLockAlreadyAquiredOnAnotherSaga()
{
var firstLockAquired = new ManualResetEvent(initialState: false);
var secondLockAquired = new ManualResetEvent(initialState: false);
var blockedTime = TimeSpan.Zero;
Task.Factory.StartNew(() =>
{
firstLockAquired.WaitOne();
using (var sagaLock = new SagaLock(typeof(Saga), GuidStrategy.NewGuid()))
{
var timer = Stopwatch.StartNew();
sagaLock.Aquire();
timer.Stop();
blockedTime = timer.Elapsed;
secondLockAquired.Set();
}
});
using (var sagaLock = new SagaLock(typeof(Saga), GuidStrategy.NewGuid()))
{
sagaLock.Aquire();
firstLockAquired.Set();
Thread.Sleep(100);
}
secondLockAquired.WaitOne();
Assert.InRange(blockedTime, TimeSpan.FromMilliseconds(0), TimeSpan.FromMilliseconds(50));
}
public void ReturnFriendlyDescription()
{
var correlationId = GuidStrategy.NewGuid();
var reference = new SagaReference(typeof(Saga), correlationId);
Assert.Equal($"{typeof (Saga)} - {correlationId}", reference.ToString());
}
public void AquireWillBlockIfAnotherLockAlreadyAquiredOnSameAggregate()
{
var correlationId = GuidStrategy.NewGuid();
var firstLockAquired = new ManualResetEvent(initialState: false);
var secondLockAquired = new ManualResetEvent(initialState: false);
var blockedTime = TimeSpan.Zero;
Task.Factory.StartNew(() =>
{
firstLockAquired.WaitOne();
using (var aggregateLock = new AggregateLock(typeof(Aggregate), correlationId))
{
var timer = Stopwatch.StartNew();
aggregateLock.Aquire();
timer.Stop();
blockedTime = timer.Elapsed;
secondLockAquired.Set();
}
});
using (var aggregateLock = new AggregateLock(typeof(Aggregate), correlationId))
{
aggregateLock.Aquire();
firstLockAquired.Set();
Thread.Sleep(100);
}
secondLockAquired.WaitOne();
Assert.InRange(blockedTime, TimeSpan.FromMilliseconds(50), TimeSpan.FromMilliseconds(150));
}
public void CorrelationIdIsSagaId()
{
var sagaId = GuidStrategy.NewGuid();
var saga = SagaStore.CreateSaga(typeof(FakeSaga), sagaId);
Assert.Equal(sagaId, saga.CorrelationId);
}
public void IgnoreUnknownSagaReferences()
{
var sagaStore = new Mock <IStoreSagas>();
var cache = new SagaTimeoutCache(sagaStore.Object, TimeSpan.FromMinutes(5));
cache.ClearTimeout(new SagaReference(typeof(Saga), GuidStrategy.NewGuid()));
}
public void CreateNewAggregateIfNoExistingEventStream()
{
var id = GuidStrategy.NewGuid();
var aggregateStore = new AggregateStore(aggregateUpdater.Object, snapshotStore.Object, eventStore.Object);
var aggregate = aggregateStore.Get(typeof(FakeAggregate), id);
Assert.Equal(0, aggregate.Version);
}
public void CanShortCircuitAccessToUserAddressHeader()
{
var e = new FakeEvent();
var headers = new HeaderCollection(new[] { new Header(Header.UserAddress, IPAddress.Loopback.ToString(), checkReservedNames: false) });
using (new EventContext(GuidStrategy.NewGuid(), headers, e))
Assert.Equal(IPAddress.Loopback, e.GetUserAddress());
}
public void CanShortCircuitAccessToOriginHeader()
{
var e = new FakeEvent();
var headers = new HeaderCollection(new[] { new Header(Header.Origin, "MyOrigin", checkReservedNames: false) });
using (new EventContext(GuidStrategy.NewGuid(), headers, e))
Assert.Equal("MyOrigin", e.GetOrigin());
}
public void ReturnHeadersFromEventContextIfNotNull()
{
var e = new FakeEvent();
var headers = new HeaderCollection(Enumerable.Empty <Header>());
using (new EventContext(GuidStrategy.NewGuid(), headers, e))
Assert.Same(headers, e.Headers);
}
public void ReturnIdFromEventContextIfNotNull()
{
var e = new FakeEvent();
var aggregateId = GuidStrategy.NewGuid();
using (new EventContext(aggregateId, HeaderCollection.Empty, e))
Assert.Equal(aggregateId, e.FakeId);
}
public static Guid NewGuid(GuidStrategy strategy)
{
if (strategy == GuidStrategy.NormalComb)
{
return GenerateComb();
}
return GenerateOrderedSequentialGuid();
}
public void AlwaysReturnConsistentValue()
{
var correlationId = GuidStrategy.NewGuid();
var reference1 = new SagaReference(typeof(Saga), correlationId);
var reference2 = new SagaReference(typeof(Saga), correlationId);
Assert.Equal(reference1.GetHashCode(), reference2.GetHashCode());
}
public void CanDisposeIfLockAquired()
{
var sagaLock = new SagaLock(typeof(Saga), GuidStrategy.NewGuid());
sagaLock.Aquire();
sagaLock.Dispose();
}
public void CanShortCircuitAccessToUserNameHeader()
{
var command = new FakeCommand();
var headers = new HeaderCollection(new[] { new Header(Header.UserName, "*****@*****.**", checkReservedNames: false) });
using (new CommandContext(GuidStrategy.NewGuid(), headers, CommandEnvelope.Empty))
Assert.Equal("*****@*****.**", command.GetUserName());
}
public void CanShortCircuitAccessToUserAddressHeader()
{
var command = new FakeCommand();
var headers = new HeaderCollection(new[] { new Header(Header.UserAddress, IPAddress.Loopback.ToString(), checkReservedNames: false) });
using (new CommandContext(GuidStrategy.NewGuid(), headers, CommandEnvelope.Empty))
Assert.Equal(IPAddress.Loopback, command.GetUserAddress());
}
public void CanShortCircuitAccessToOriginHeader()
{
var command = new FakeCommand();
var headers = new HeaderCollection(new[] { new Header(Header.Origin, "MyOrigin", checkReservedNames: false) });
using (new CommandContext(GuidStrategy.NewGuid(), headers, CommandEnvelope.Empty))
Assert.Equal("MyOrigin", command.GetOrigin());
}
public void ReturnHeadersFromCommandContextIfNotNull()
{
var command = new FakeCommand();
var headers = new HeaderCollection(Enumerable.Empty <Header>());
using (new CommandContext(GuidStrategy.NewGuid(), headers, CommandEnvelope.Empty))
Assert.Same(headers, command.Headers);
}
public void TypeAndIdMustBeEqual()
{
var correlationId = GuidStrategy.NewGuid();
var reference1 = new SagaReference(typeof(Saga), correlationId);
var reference2 = new SagaReference(typeof(Saga), correlationId);
Assert.True(reference1.Equals(reference2));
}
public void SagaReferenceCanBeBoxed()
{
var correlationId = GuidStrategy.NewGuid();
var reference1 = new SagaReference(typeof(Saga), correlationId);
var reference2 = new SagaReference(typeof(Saga), correlationId);
Assert.True(reference1.Equals((Object)reference2));
}
public void ReturnFriendlyDescription()
{
var correlationId = GuidStrategy.NewGuid();
Assert.Equal($"{typeof (FakeSaga)} - {correlationId}", new FakeSaga {
CorrelationId = correlationId
}.ToString());
}
public void CanShortCircuitAccessToUserNameHeader()
{
var e = new FakeEvent();
var headers = new HeaderCollection(new[] { new Header(Header.UserName, "*****@*****.**", checkReservedNames: false) });
using (new EventContext(GuidStrategy.NewGuid(), headers, e))
Assert.Equal("*****@*****.**", e.GetUserName());
}
protected UsingInitializedSagaStore()
{
SagaId = GuidStrategy.NewGuid();
SagaContext = new SagaContext(typeof(FakeSaga), SagaId, new FakeEvent());
TypeLocator.Setup(mock => mock.GetTypes(It.IsAny <Func <Type, Boolean> >())).Returns(new[] { typeof(FakeSaga) });
SagaStore = new SqlSagaStore(Dialect, Serializer, TypeLocator.Object);
SagaStore.Purge();
}
public void CanDisposeIfLockAquired()
{
var aggregateLock = new AggregateLock(typeof(Aggregate), GuidStrategy.NewGuid());
aggregateLock.Aquire();
aggregateLock.Dispose();
}
public void ReturnFriendlyDescription()
{
var sagaType = typeof(Saga);
var sagaId = GuidStrategy.NewGuid();
using (var context = new SagaContext(sagaType, sagaId, new FakeEvent()))
Assert.Equal($"{sagaType} - {sagaId}", context.ToString());
}
public void CanCallDisposeMoreThanOnce()
{
using (var context = new SagaContext(typeof(Saga), GuidStrategy.NewGuid(), new FakeEvent()))
{
context.Dispose();
context.Dispose();
}
}
public void ResolveCorrelationIdForKnownEvents()
{
var correlationId = GuidStrategy.NewGuid();
Assert.Equal(correlationId, sagaMetadata.GetCorrelationId(new FakeHandledEvent {
Id = correlationId
}));
}
public void ThrowInvalidOperationExceptionForUnknownEvents()
{
var ex = Assert.Throws <InvalidOperationException>(() => sagaMetadata.GetCorrelationId(new FakeUnhandledEvent {
Id = GuidStrategy.NewGuid()
}));
Assert.Equal(Exceptions.EventTypeNotConfigured.FormatWith(typeof(FakeSaga), typeof(FakeUnhandledEvent)), ex.Message);
}
public void AggregateCanBeNull()
{
var eventDispatcher = new EventDispatcher(eventStore.Object, eventPublisher.Object);
eventDispatcher.PostSave(null, new Commit(GuidStrategy.NewGuid(), GuidStrategy.NewGuid(), 1, HeaderCollection.Empty, EventCollection.Empty), null);
eventPublisher.Verify(mock => mock.Publish(HeaderCollection.Empty, It.IsAny <EventEnvelope>()), Times.Never());
}
public void CanShortCircuitAccessToTimestampHeader()
{
var now = DateTime.UtcNow;
var e = new FakeEvent();
var headers = new HeaderCollection(new[] { new Header(Header.Timestamp, now.ToString(DateTimeFormat.RoundTrip), checkReservedNames: false) });
using (new EventContext(GuidStrategy.NewGuid(), headers, e))
Assert.Equal(now, e.GetTimestamp());
}
public void CanAquireLockIfNoLockAquired()
{
using (var sagaLock = new SagaLock(typeof(Saga), GuidStrategy.NewGuid()))
{
sagaLock.Aquire();
Assert.True(sagaLock.Aquired);
}
}
public void DoNotDispatchCommitWithNoId()
{
var commit = new Commit(GuidStrategy.NewGuid(), GuidStrategy.NewGuid(), 1, HeaderCollection.Empty, EventCollection.Empty);
var eventDispatcher = new EventDispatcher(eventStore.Object, eventPublisher.Object);
eventDispatcher.PostSave(null, commit, null);
eventPublisher.Verify(mock => mock.Publish(HeaderCollection.Empty, It.IsAny <EventEnvelope>()), Times.Never());
}
