public void Setup()
{
_metrics = new Moq.Mock <IMetrics>();
_snapshots = new Moq.Mock <IStoreSnapshots>();
_eventstore = new Moq.Mock <IStoreEvents>();
_oobStore = new Moq.Mock <IOobWriter>();
_factory = new Moq.Mock <IEventFactory>();
_uow = new Moq.Mock <IDomainUnitOfWork>();
_event = new Moq.Mock <IFullEvent>();
_mapper = new Moq.Mock <IEventMapper>();
_mapper.Setup(x => x.GetMappedTypeFor(typeof(FakeEvent))).Returns(typeof(FakeEvent));
_resolver = new FakeResolver();
var fake = new FakeConfiguration();
fake.FakeContainer.Setup(x => x.Resolve <IEventMapper>()).Returns(_mapper.Object);
fake.FakeContainer.Setup(x => x.Resolve <IMetrics>()).Returns(_metrics.Object);
fake.FakeContainer.Setup(x => x.Resolve(typeof(FakeResolver))).Returns(_resolver);
fake.FakeContainer.Setup(x => x.Resolve <IStoreSnapshots>()).Returns(_snapshots.Object);
fake.FakeContainer.Setup(x => x.Resolve <IStoreEvents>()).Returns(_eventstore.Object);
Configuration.Settings = fake;
_snapshots.Setup(x => x.GetSnapshot <FakeEntity>(Moq.It.IsAny <string>(), Moq.It.IsAny <Id>(), Moq.It.IsAny <Id[]>()))
.Returns(Task.FromResult((ISnapshot)null));
_event.Setup(x => x.Event).Returns(new FakeEvent());
_repository = new Aggregates.Internal.Repository <FakeEntity, FakeState>(_metrics.Object, _eventstore.Object, _snapshots.Object, _oobStore.Object, _factory.Object, _uow.Object);
}
public void GetService_WidgetRegistered_InstanceOfWidget()
{
var sut = new FakeResolver(FakeResolver.Register(typeof(Widget), () => new Widget()));
var result = sut.GetService(typeof(Widget));
Assert.IsType<Widget>(result);
}
public void GetService_NonRegistered_Null()
{
var sut = new FakeResolver();
var instance = sut.GetService(typeof(Widget));
Assert.Null(instance);
}
public void LoadImageContent()
{
var resolver = new FakeResolver();
var image = new Content(resolver).Load<FakeResolver.FakeImage>("Test");
Assert.IsTrue(image.IsLoaded);
image.Dispose();
Assert.IsFalse(image.IsLoaded);
Assert.IsNull(resolver.Resolve<ContentLoaderTests>());
}
public void Setup()
{
_builder = new Moq.Mock <IBuilder>();
_snapshots = new Moq.Mock <IStoreSnapshots>();
_streams = new Moq.Mock <IStoreStreams>();
_stream = new Moq.Mock <IEventStream>();
_resolver = new FakeResolver();
_builder.Setup(x => x.Build <IStoreSnapshots>()).Returns(_snapshots.Object);
_builder.Setup(x => x.Build <IStoreStreams>()).Returns(_streams.Object);
_builder.Setup(x => x.Build(typeof(FakeResolver))).Returns(_resolver);
_repository = new Aggregates.Internal.Repository <Entity>(_builder.Object);
}
public async Task ShouldResolveConflicts()
{
var resolver = new FakeResolver();
A.CallTo(() => Aggregates.Configuration.Settings.Container.Resolve(A <Type> .Ignored)).Returns(resolver);
var store = Fake <IStoreEvents>();
A.CallTo(() => store.WriteEvents <FakeEntity>(A <string> .Ignored, A <Id> .Ignored, A <Id[]> .Ignored, A <IFullEvent[]> .Ignored, A <Dictionary <string, string> > .Ignored, A <long?> .Ignored)).Throws(new VersionException("test", new Exception()));
Inject(store);
var entity = await Sut.Get <FakeEntity, FakeState>("test", "test", null).ConfigureAwait(false);
entity.ApplyEvents(Many <FakeDomainEvent.FakeEvent>());
await Sut.Commit <FakeEntity, FakeState>(entity, Guid.NewGuid(), new Dictionary <string, string>()).ConfigureAwait(false);
resolver.WasCalled.Should().BeTrue();
}
