Example #1
0
        public async Task <TAggregate> Read <TAggregate>(Guid id)
            where TAggregate : IAggregate, new()
        {
            var aggregate = new TAggregate();
            var stream    = $"{aggregate.StreamName}.{id}";

            var events = await streamLoader.LoadEvents(stream, selector.For(typeof(TAggregate)));

            aggregate.LoadHistory(events);

            return(aggregate);
        }
        public async void ItReturnsAnAggregate(Guid id, string stream)
        {
            var map = new EmployeeTypeMap();

            A.CallTo(() => selector.For(typeof(Employee)))
            .Returns(map);
            var events = A.CollectionOfDummy <EmployeeHired>(1);

            A.CallTo(() => loader.LoadEvents(
                         stream, map))
            .Returns(events);

            var employee = await sut.Read <Employee>(id);

            employee.Should().NotBeNull();
            employee.Version.Should().Be(1);
        }
Example #3
0
        // todo, wrap a test or three around this method.
        public async Task Write <TAggregate>(TAggregate aggregate)
            where TAggregate : IAggregate
        {
            var typeMap = selector.For(typeof(TAggregate));

            var eventData = ConvertEventsToEventData(aggregate.NewEvents, typeMap);

            var stream = $"{aggregate.StreamName}.{aggregate.Id}";

            await connection.ConnectAsync();

            await connection.AppendToStreamAsync(
                stream,
                ExpectedVersion.Any,
                eventData);

            connection.Close();
        }
 public void ItReturnsTypeMaps()
 {
     sut.For(null)
     .Should().BeOfType <EmployeeTypeMap>();
 }