示例#1
0
        public async Task ConcurrencyCheck()
        {
            // Given
            const int    theSameVersion = 3;
            const string booId          = "001";
            var          booCreated     = new BooCreated(booId, 100M, false);

            var aggregateRecord1 = new AggregateRecord(booId, "Boo", theSameVersion);
            var eventRecords1    = new List <EventRecord <DomainEvent> >
            {
                new EventRecord <DomainEvent>(booCreated.Id, booCreated.CreatedAt, booCreated)
            };

            await _eventStoreRepository.SaveAsync(aggregateRecord1, eventRecords1).ConfigureAwait(false);

            // When
            var booActivated = new BooActivated(booId);

            var aggregateRecord2 = new AggregateRecord(booId, "Boo", theSameVersion);
            var eventRecords2    = new List <EventRecord <DomainEvent> >
            {
                new EventRecord <DomainEvent>(booActivated.Id, booActivated.CreatedAt, booCreated)
            };

            // Then
            await Assert.ThrowsAsync <ConcurrencyCheckException>(() => _eventStoreRepository.SaveAsync(aggregateRecord2, eventRecords2));
        }
示例#2
0
        private async Task <(Guid, Guid)> StoreBooCreatedAndActivated(string booId)
        {
            var booCreated   = new BooCreated(booId, 100M, false);
            var booActivated = new BooActivated(booId);

            var aggregateRecordBoo = new AggregateRecord(booId, "Boo", 0);
            var eventRecordsBoo    = new List <EventRecord <DomainEvent> >
            {
                new EventRecord <DomainEvent>(booCreated.Id, booCreated.CreatedAt, booCreated),
                new EventRecord <DomainEvent>(booActivated.Id, booActivated.CreatedAt, booActivated)
            };

            await _eventStoreRepository.SaveAsync(aggregateRecordBoo, eventRecordsBoo).ConfigureAwait(false);

            return(booCreated.Id, booActivated.Id);
        }
示例#3
0
        public async Task InsertAsync_GetAsync_SingleAggregate_MultipleEvents()
        {
            // Given
            const string booId        = "001";
            var          booCreated   = new BooCreated(booId, 100M, false);
            var          booActivated = new BooActivated(booId);

            // When
            var aggregateRecord = new AggregateRecord(booId, "Boo", 0);
            var eventRecords    = new List <EventRecord <DomainEvent> >
            {
                new EventRecord <DomainEvent>(booCreated.Id, booCreated.CreatedAt, booCreated),
                new EventRecord <DomainEvent>(booActivated.Id, booActivated.CreatedAt, booActivated)
            };

            await _eventStoreRepository.SaveAsync(aggregateRecord, eventRecords).ConfigureAwait(false);

            // Then
            var results = await _eventStoreRepository.GetAsync <DomainEvent>(booId).ConfigureAwait(false);

            Assert.Equal(2, results.Count);
            Assert.Equal(booCreated.GetType(), results.Single(x => x.Version == 1).Event.GetType());
            Assert.Equal(booActivated.GetType(), results.Single(x => x.Version == 2).Event.GetType());
        }