Пример #1
0
        public CrudAggregateStoreTests()
        {
            crudRepository     = new InMemoryCrudRepository();
            entityTypeManager  = Substitute.For <IEntityTypeManager>();
            publishEventBuffer = Substitute.For <IPublishEventBuffer>();

            domainClasses = new List <DomainClassInfo>()
            {
                new DomainClassInfo(TestAggregateClassId, null, typeof(TestAggregate))
            };

            entityTypeManager.GetClassInfoByClassId(Guid.Empty)
            .ReturnsForAnyArgs(ci => domainClasses.Single(x => x.Id == ci.Arg <Guid>()));
            entityTypeManager.TryGetClassInfoByClrType(null)
            .ReturnsForAnyArgs(ci => domainClasses.SingleOrDefault(x => x.ClrType == ci.Arg <Type>()));
            entityTypeManager.GetClassInfoByClrType(null)
            .ReturnsForAnyArgs(ci => domainClasses.Single(x => x.ClrType == ci.Arg <Type>()));

            eventMessageFactory = Substitute.For <IEventMessageFactory>();
            eventMessageFactory.CreateMessageAsync(null).ReturnsForAnyArgs(ci =>
            {
                var @event       = ci.ArgAt <IEvent>(0);
                Type messageType = typeof(EventMessageDraft <>).MakeGenericType(@event.GetType());
                IEventMessageDraft messageDraft = (IEventMessageDraft)messageType.GetConstructor(new[] { @event.GetType() }).Invoke(new[] { @event });
                messageDraft.SetMetadata("TestKey", "TestValue");
                return(messageDraft);
            }); // TODO something more lightweight?


            sut = new CrudAggregateStore(crudRepository, entityTypeManager, publishEventBuffer, eventMessageFactory);
        }
Пример #2
0
        public UnitOfWork(Lazy <IUnitOfWorkListener[]> unitOfWorkListeners,
                          IPublishEventBuffer publishEventBuffer)
        {
            this.unitOfWorkListeners = unitOfWorkListeners;

            EventBuffer = publishEventBuffer;
        }
Пример #3
0
        public UnitOfWorkTests()
        {
            innerTransactions   = new[] { Substitute.For <ITransaction>(), Substitute.For <ITransaction>() };
            unitOfWorkListeners = new[] { Substitute.For <IUnitOfWorkListener>(), Substitute.For <IUnitOfWorkListener>() };
            publishEventBuffer  = Substitute.For <IPublishEventBuffer>();

            sut = new UnitOfWork(new Lazy <IUnitOfWorkListener[]>(unitOfWorkListeners), publishEventBuffer);
        }
Пример #4
0
 public EFCoreCrudAggregateStore(ICrudRepository crudRepository, IEntityTypeManager entityTypeManager,
                                 IPublishEventBuffer publishEventBuffer, IEventMessageFactory eventMessageFactory,
                                 IEFCoreTransactionCoordinator transactionCoordinator)
     : base(crudRepository, entityTypeManager, publishEventBuffer, eventMessageFactory)
 {
     this.transactionCoordinator = transactionCoordinator;
     transactionCoordinator.AddTransactionParticipant(this);
 }
 public EventSourcedAggregateRepository(IEventStore eventStore,
                                        IEntityTypeManager entityTypeManager,
                                        IPublishEventBuffer publishEventBuffer,
                                        IRepositoryFilter[] repositoryFilters,
                                        IEventMessageFactory eventMessageFactory,
                                        IEntityFactory entityFactory)
     : base(eventStore, entityTypeManager, publishEventBuffer, repositoryFilters, eventMessageFactory, entityFactory)
 {
 }
Пример #6
0
 public CrudAggregateStore(ICrudRepository crudRepository,
     IEntityTypeManager entityTypeManager,
     IPublishEventBuffer publishEventBuffer,
     IEventMessageFactory eventMessageFactory)
 {
     this.crudRepository = crudRepository;
     this.entityTypeManager = entityTypeManager;
     this.publishEventBuffer = publishEventBuffer;
     this.eventMessageFactory = eventMessageFactory;
 }
 protected EventSourcedAggregateRepository(IEventStore eventStore,
                                           IEntityTypeManager entityTypeManager,
                                           IPublishEventBuffer publishEventBuffer,
                                           IRepositoryFilter[] repositoryFilters,
                                           IEventMessageFactory eventMessageFactory,
                                           IEntityFactory entityFactory,
                                           Dictionary <Guid, IEventSourcedAggregateRoot> aggregates)
     : base(eventStore, entityTypeManager, publishEventBuffer, repositoryFilters, eventMessageFactory, entityFactory, aggregates)
 {
 }
Пример #8
0
 public EventSourcedAggregateStore(IEventStore eventStore, IEntityTypeManager entityTypeManager,
                                   IPublishEventBuffer publishEventBuffer, IRepositoryFilter[] repositoryFilters,
                                   IEventMessageFactory eventMessageFactory, IEventSourcedAggregateFactory eventSourcedAggregateFactory)
 {
     this.eventStore                   = eventStore;
     this.entityTypeManager            = entityTypeManager;
     this.publishEventBuffer           = publishEventBuffer;
     this.repositoryFilters            = repositoryFilters;
     this.eventMessageFactory          = eventMessageFactory;
     this.eventSourcedAggregateFactory = eventSourcedAggregateFactory;
 }
Пример #9
0
        public EFCoreEventSourcedAggregateStore(IEventStore eventStore, IEntityTypeManager entityTypeManager,
                                                IPublishEventBuffer publishEventBuffer, IRepositoryFilter[] repositoryFilters,
                                                IEventMessageFactory eventMessageFactory, IEventSourcedAggregateFactory eventSourcedAggregateFactory,
                                                IEFCoreTransactionCoordinator transactionCoordinator)
            : base(eventStore, entityTypeManager, publishEventBuffer, repositoryFilters, eventMessageFactory,
                   eventSourcedAggregateFactory)
        {
            this.transactionCoordinator = transactionCoordinator;

            transactionCoordinator.AddTransactionParticipant(this);
        }
Пример #10
0
 protected EventSourcedRepository(IEventStore eventStore,
                                  IEntityTypeManager entityTypeManager,
                                  IPublishEventBuffer publishEventBuffer,
                                  IRepositoryFilter[] repositoryFilters,
                                  IEventMessageFactory eventMessageFactory,
                                  IEntityFactory entityFactory,
                                  Dictionary <Guid, TBase> aggregates)
     : this(eventStore, entityTypeManager, publishEventBuffer, repositoryFilters, eventMessageFactory, entityFactory)
 {
     this.aggregates = aggregates;
 }
Пример #11
0
 protected virtual EventSourcedRepository <TBase> CloneWithFilters(
     IEventStore eventStore,
     IEntityTypeManager entityTypeManager,
     IPublishEventBuffer publishEventBuffer,
     IRepositoryFilter[] repositoryFilters,
     IEventMessageFactory eventMessageFactory,
     Dictionary <Guid, TBase> aggregates)
 {
     return(new EventSourcedRepository <TBase>(eventStore,
                                               entityTypeManager,
                                               publishEventBuffer,
                                               repositoryFilters,
                                               eventMessageFactory,
                                               EntityFactory,
                                               aggregates));
 }
 protected override EventSourcedRepository <IEventSourcedAggregateRoot> CloneWithFilters(
     IEventStore eventStore,
     IEntityTypeManager entityTypeManager,
     IPublishEventBuffer publishEventBuffer,
     IRepositoryFilter[] repositoryFilters,
     IEventMessageFactory eventMessageFactory,
     Dictionary <Guid, IEventSourcedAggregateRoot> aggregates)
 {
     return(new EventSourcedAggregateRepository(eventStore,
                                                entityTypeManager,
                                                publishEventBuffer,
                                                repositoryFilters,
                                                eventMessageFactory,
                                                EntityFactory,
                                                aggregates));
 }
Пример #13
0
        public RepositoryTests()
        {
            publishEventBuffer = Substitute.For <IPublishEventBuffer>();
            unitOfWork         = Substitute.For <IUnitOfWork>();
            unitOfWork.EventBuffer.Returns(publishEventBuffer);
            unitOfWork.When(x => x.AddInnerTransaction(Arg.Any <ITransaction>())).Do(ci => uowInnerTransaction = ci.ArgAt <ITransaction>(0));

            aggregateStore1 = Substitute.For <IAggregateStore>();
            aggregateStore1.CanHandleAggregateType(typeof(MyEntity1)).Returns(true);
            aggregateStoreFactory1 = Substitute.For <IAggregateStoreFactory>();
            aggregateStoreFactory1.CreateAggregateStore(unitOfWork).Returns(aggregateStore1);
            aggregateStoreFactory1.CanHandleAggregateType(typeof(MyEntity1)).Returns(true);

            aggregateStore2        = Substitute.For <IAggregateStore>();
            aggregateStoreFactory2 = Substitute.For <IAggregateStoreFactory>();
            aggregateStoreFactory2.CreateAggregateStore(unitOfWork).Returns(aggregateStore2);

            sut = Substitute.ForPartsOf <Repository>(new[] { aggregateStoreFactory1, aggregateStoreFactory2 }, unitOfWork);
        }
Пример #14
0
        public EventSourcedRepositoryTests()
        {
            publishEventBuffer = Substitute.For <IPublishEventBuffer>();
            eventStore         = Substitute.For <IEventStore>();
            entityTypeManager  = Substitute.For <IEntityTypeManager>();
            repositoryFilter1  = Substitute.For <IRepositoryFilter>();
            repositoryFilter2  = Substitute.For <IRepositoryFilter>();

            FakeClock.Setup();

            eventStore.GetEventsAsync(entity2Id)
            .Returns(new List <IEventStoreRecord>()
            {
                new FakeEventStoreRecord()
                {
                    Event = new SetFooEvent()
                    {
                        AggregateId = entity2Id
                    },
                    StreamSequenceNumber = 1
                }
            });

            eventStore.GetStreamMetadataAsync(entity2Id)
            .Returns(new Dictionary <string, string>()
            {
                { "TestKey", "TestValue" },
                { AggregateEventStreamMetadataNames.ClassId, entity2ClassId.ToString() }
            });

            eventStore.GetStreamMetadataAsync(entity3Id)
            .Returns(new Dictionary <string, string>()
            {
                { "TestKey", "TestValue" },
                { AggregateEventStreamMetadataNames.ClassId, entity3ClassId.ToString() }
            });

            eventStore.PushEventsAsync(Guid.Empty, null, null).ReturnsForAnyArgs(ci =>
            {
                var events = ci.ArgAt <IEnumerable <IUncommittedEventStoreRecord> >(1);
                return(events.Select(x => new FakeEventStoreRecord()
                {
                    AdditionalMetadata = x.Metadata,
                    Event = x.Event,
                    EventId = Guid.NewGuid(),
                    StoreDate = DateTimeOffset.Now,
                    StreamSequenceNumber = 0
                }).ToList());
            });

            DomainClassInfo[] domainClasses = new[]
            {
                new DomainClassInfo(entityClassId, null, typeof(MyEntity)),
                new DomainClassInfo(entity2ClassId, null, typeof(MyEntity2)),
                new DomainClassInfo(entity3ClassId, null, typeof(MyEntity3LoadsAsDeleted))
            };

            entityTypeManager.GetClassInfoByClassId(Guid.Empty)
            .ReturnsForAnyArgs(ci => domainClasses.Single(x => x.Id == ci.Arg <Guid>()));
            entityTypeManager.TryGetClassInfoByClrType(null)
            .ReturnsForAnyArgs(ci => domainClasses.SingleOrDefault(x => x.ClrType == ci.Arg <Type>()));
            entityTypeManager.GetClassInfoByClrType(null)
            .ReturnsForAnyArgs(ci => domainClasses.Single(x => x.ClrType == ci.Arg <Type>()));

            eventMessageFactory = Substitute.For <IEventMessageFactory>();
            eventMessageFactory.CreateMessageAsync(null).ReturnsForAnyArgs(ci =>
            {
                var @event       = ci.ArgAt <IEvent>(0);
                Type messageType = typeof(EventMessageDraft <>).MakeGenericType(@event.GetType());
                IEventMessageDraft messageDraft = (IEventMessageDraft)messageType.GetConstructor(new[] { @event.GetType() }).Invoke(new[] { @event });
                messageDraft.SetMetadata("TestKey", "TestValue");
                return(messageDraft);
            }); // TODO something more lightweight?

            sut = new EventSourcedAggregateRepository(eventStore,
                                                      entityTypeManager, publishEventBuffer, new IRepositoryFilter[] {}, eventMessageFactory, new EntityFactory());
        }
Пример #15
0
 public RebusEventCommandHandler(IPublishEventBuffer publishEventBuffer)
 {
     this.publishEventBuffer = publishEventBuffer;
 }
Пример #16
0
        public EventSourcedAggregateStoreTests()
        {
            publishEventBuffer = Substitute.For <IPublishEventBuffer>();
            eventStore         = Substitute.For <IEventStore>();
            entityTypeManager  = Substitute.For <IEntityTypeManager>();
            repositoryFilter1  = Substitute.For <IRepositoryFilter>();
            repositoryFilter2  = Substitute.For <IRepositoryFilter>();

            FakeClock.Setup();

            entityEvents = new Dictionary <Guid, List <IEventStoreRecord> >()
            {
                {
                    entity2Id,
                    new List <IEventStoreRecord>()
                    {
                        new FakeEventStoreRecord()
                        {
                            Event = new SetFooEvent()
                            {
                                AggregateId = entity2Id
                            },
                            StreamSequenceNumber = 1
                        }
                    }
                },
                {
                    entity3Id,
                    new List <IEventStoreRecord>()
                    {
                        new FakeEventStoreRecord()
                        {
                            Event = new SetFooEvent()
                            {
                                AggregateId = entity3Id
                            },
                            StreamSequenceNumber = 1
                        }
                    }
                },
                {
                    entity4Id,
                    new List <IEventStoreRecord>()
                    {
                        new FakeEventStoreRecord()
                        {
                            Event = new SetFooEvent()
                            {
                                AggregateId = entity4Id
                            },
                            StreamSequenceNumber = 1
                        }
                    }
                }
            };

            eventStore.FindEventsAsync(Arg.Any <Guid>())
            .Returns(ci =>
            {
                var id = ci.ArgAt <Guid>(0);
                if (entityEvents.TryGetValue(id, out var events))
                {
                    return(events);
                }

                return(new List <IEventStoreRecord>());
            });


            eventStore.BatchFindEventsAsync(Arg.Any <Guid[]>())
            .Returns(ci =>
            {
                var ids    = ci.ArgAt <Guid[]>(0);
                var result = new Dictionary <Guid, IReadOnlyCollection <IEventStoreRecord> >();
                foreach (Guid id in ids)
                {
                    if (entityEvents.TryGetValue(id, out var events))
                    {
                        result.Add(id, events);
                    }
                }

                return(result);
            });

            entityMetadata = new Dictionary <Guid, IReadOnlyDictionary <string, string> >()
            {
                {
                    entity2Id,
                    new Dictionary <string, string>()
                    {
                        { "TestKey", "TestValue" },
                        { AggregateEventStreamMetadataNames.ClassId, entity2ClassId.ToString() }
                    }
                },
                {
                    entity3Id,
                    new Dictionary <string, string>()
                    {
                        { "TestKey", "TestValue" },
                        { AggregateEventStreamMetadataNames.ClassId, entity3ClassId.ToString() }
                    }
                },
                {
                    entity4Id,
                    new Dictionary <string, string>()
                    {
                        { "TestKey", "TestValue" },
                        { AggregateEventStreamMetadataNames.ClassId, entity2ClassId.ToString() }
                    }
                }
            };

            eventStore.FindStreamMetadataAsync(Arg.Any <Guid>())
            .Returns(ci =>
            {
                var id = ci.ArgAt <Guid>(0);
                if (entityMetadata.TryGetValue(id, out var metadata))
                {
                    return(metadata);
                }

                return(new Dictionary <string, string>());
            });

            eventStore.BatchFindStreamMetadataAsync(Arg.Any <Guid[]>())
            .Returns(ci =>
            {
                var ids    = ci.ArgAt <Guid[]>(0);
                var result = new Dictionary <Guid, IReadOnlyDictionary <string, string> >();
                foreach (Guid id in ids)
                {
                    if (entityMetadata.TryGetValue(id, out var metadata))
                    {
                        result.Add(id, metadata);
                    }
                }

                return(result);
            });

            eventStore.PushEventsAsync(Guid.Empty, null).ReturnsForAnyArgs(ci =>
            {
                var events = ci.ArgAt <IEnumerable <IUncommittedEventStoreRecord> >(1);
                return(events.Select(x => new FakeEventStoreRecord()
                {
                    AdditionalMetadata = x.Metadata,
                    Event = x.Event,
                    EventId = Guid.NewGuid(),
                    StoreDate = DateTimeOffset.Now,
                    StreamSequenceNumber = 0
                }).ToList());
            });

            DomainClassInfo[] domainClasses = new[]
            {
                new DomainClassInfo(entityClassId, null, typeof(MyEntity)),
                new DomainClassInfo(entity2ClassId, null, typeof(MyEntity2)),
                new DomainClassInfo(entity3ClassId, null, typeof(MyEntity3LoadsAsDeleted))
            };

            entityTypeManager.GetClassInfoByClassId(Guid.Empty)
            .ReturnsForAnyArgs(ci => domainClasses.Single(x => x.Id == ci.Arg <Guid>()));
            entityTypeManager.TryGetClassInfoByClrType(null)
            .ReturnsForAnyArgs(ci => domainClasses.SingleOrDefault(x => x.ClrType == ci.Arg <Type>()));
            entityTypeManager.GetClassInfoByClrType(null)
            .ReturnsForAnyArgs(ci => domainClasses.Single(x => x.ClrType == ci.Arg <Type>()));

            eventMessageFactory = Substitute.For <IEventMessageFactory>();
            eventMessageFactory.CreateMessageAsync(null).ReturnsForAnyArgs(ci =>
            {
                var @event       = ci.ArgAt <IEvent>(0);
                Type messageType = typeof(EventMessageDraft <>).MakeGenericType(@event.GetType());
                IEventMessageDraft messageDraft = (IEventMessageDraft)messageType.GetConstructor(new[] { @event.GetType() }).Invoke(new[] { @event });
                messageDraft.SetMetadata("TestKey", "TestValue");
                return(messageDraft);
            }); // TODO something more lightweight?

            eventSourcedAggregateFactory = Substitute.For <IEventSourcedAggregateFactory>();

            entity2 = new MyEntity2(entity2Id);
            eventSourcedAggregateFactory.ConstructAndLoadEntityFromEvents(entity2Id,
                                                                          Arg.Is <IReadOnlyDictionary <string, string> >(x => x.SequenceEqual(entityMetadata[entity2Id])),
                                                                          Arg.Is <IReadOnlyCollection <IEventStoreRecord> >(x => x.SequenceEqual(entityEvents[entity2Id])))
            .Returns(entity2);

            entity3 = new MyEntity3LoadsAsDeleted(entity3Id);
            eventSourcedAggregateFactory.ConstructAndLoadEntityFromEvents(entity3Id,
                                                                          Arg.Is <IReadOnlyDictionary <string, string> >(x => x.SequenceEqual(entityMetadata[entity3Id])),
                                                                          Arg.Is <IReadOnlyCollection <IEventStoreRecord> >(x => x.SequenceEqual(entityEvents[entity3Id])))
            .Returns(entity3);

            entity4 = new MyEntity2(entity4Id);
            eventSourcedAggregateFactory.ConstructAndLoadEntityFromEvents(entity4Id,
                                                                          Arg.Is <IReadOnlyDictionary <string, string> >(x => x.SequenceEqual(entityMetadata[entity4Id])),
                                                                          Arg.Is <IReadOnlyCollection <IEventStoreRecord> >(x => x.SequenceEqual(entityEvents[entity4Id])))
            .Returns(entity4);

            sut = new EventSourcedAggregateStore(eventStore, entityTypeManager, publishEventBuffer,
                                                 new IRepositoryFilter[] { }, eventMessageFactory, eventSourcedAggregateFactory);
        }