예제 #1
0
        public AggregateRootTest(AggregateRootTestId id, string name, Guid correlationId)
            : this()
        {
            var @event = new AggregateCreated(correlationId, id, name);

            ApplyEvent(@event);
        }
예제 #2
0
        // public TAggregate Create<TAggregate>(Guid? id = null)
        //     where TAggregate : AggregateRoot<Guid>
        // {
        //     id = id == null || id.Value == Guid.Empty ? Guid.NewGuid() : id;
        //
        //     var existStream = _eventStore.Any(id.Value);
        //     if(existStream)
        //         throw new DuplicatedRootException(id.ToString());
        //
        //     var createEvent = new AggregateCreated<Guid>(id.Value);
        //     var events = new List<IEvent>() { createEvent};
        //
        //     var stream = new EventStream(){ Version = INITIAL_VERSION, Events = events};
        //
        //     TAggregate aggregate = (TAggregate) Activator.CreateInstance(typeof(TAggregate), new object[] {stream});
        //
        //     aggregate.Changes.Add(createEvent);
        //     return aggregate;
        // }


        public override TAggregate Create <TAggregate>(Guid?id = null)
        {
            id = id == null || id.Value == Guid.Empty ? Guid.NewGuid() : id;

            var existStream = _eventStore.Any(id.Value);

            if (existStream)
            {
                throw new DuplicatedRootException(id.ToString());
            }

            var createEvent = new AggregateCreated <Guid>(id.Value);
            var events      = new List <IEvent>()
            {
                createEvent
            };

            var stream = new EventStream()
            {
                Version = INITIAL_VERSION, Events = events
            };

            TAggregate aggregate = (TAggregate)Activator.CreateInstance(typeof(TAggregate), new object[] { stream });

            aggregate.Changes.Add(createEvent);
            return(aggregate);
        }
예제 #3
0
        public void SetUp()
        {
            _createSomething          = new CreateSomething();
            _somethingCreated         = new SomethingCreated();
            _somethingCreatedConcrete = new SomethingCreated();
            _events = new List <IEvent> {
                _somethingCreated
            };

            _createAggregate          = new CreateAggregate();
            _aggregateCreatedConcrete = new AggregateCreated();
            _aggregate        = new Aggregate();
            _aggregateCreated = (AggregateCreated)_aggregate.Events[0];

            _eventPublisher = new Mock <IEventPublisher>();
            _eventPublisher
            .Setup(x => x.Publish(_somethingCreatedConcrete));
            _eventPublisher
            .Setup(x => x.Publish(_aggregateCreatedConcrete));

            _eventStore = new Mock <IEventStore>();
            _eventStore
            .Setup(x => x.SaveEvent <Aggregate>(_aggregateCreatedConcrete));

            _eventFactory = new Mock <IEventFactory>();
            _eventFactory
            .Setup(x => x.CreateConcreteEvent(_somethingCreated))
            .Returns(_somethingCreatedConcrete);
            _eventFactory
            .Setup(x => x.CreateConcreteEvent(_aggregateCreated))
            .Returns(_aggregateCreatedConcrete);

            _commandHandler = new Mock <ICommandHandler <CreateSomething> >();
            _commandHandler
            .Setup(x => x.Handle(_createSomething));

            _commandHandlerWithEvents = new Mock <ICommandHandlerWithEvents <CreateSomething> >();
            _commandHandlerWithEvents
            .Setup(x => x.Handle(_createSomething))
            .Returns(_events);

            _domainCommandHandler = new Mock <ICommandHandlerWithAggregate <CreateAggregate> >();
            _domainCommandHandler
            .Setup(x => x.Handle(_createAggregate))
            .Returns(_aggregate);

            _resolver = new Mock <IResolver>();
            _resolver
            .Setup(x => x.Resolve <ICommandHandler <CreateSomething> >())
            .Returns(_commandHandler.Object);
            _resolver
            .Setup(x => x.Resolve <ICommandHandlerWithEvents <CreateSomething> >())
            .Returns(_commandHandlerWithEvents.Object);
            _resolver
            .Setup(x => x.Resolve <ICommandHandlerWithAggregate <CreateAggregate> >())
            .Returns(_domainCommandHandler.Object);

            _sut = new CommandSender(_resolver.Object, _eventPublisher.Object, _eventFactory.Object, _eventStore.Object);
        }
        public void SetUp()
        {
            _createSomething          = new CreateSomething();
            _somethingCreated         = new SomethingCreated();
            _somethingCreatedConcrete = new SomethingCreated();
            _events = new List <IEvent> {
                _somethingCreated
            };

            _createAggregate          = new CreateAggregate();
            _aggregateCreatedConcrete = new AggregateCreated();
            _aggregate        = new Aggregate();
            _aggregateCreated = (AggregateCreated)_aggregate.Events[0];

            _eventPublisher = new Mock <IEventPublisher>();
            _eventPublisher
            .Setup(x => x.PublishAsync(_somethingCreatedConcrete))
            .Returns(Task.CompletedTask);
            _eventPublisher
            .Setup(x => x.PublishAsync(_aggregateCreatedConcrete))
            .Returns(Task.CompletedTask);

            _eventFactory = new Mock <IEventFactory>();
            _eventFactory
            .Setup(x => x.CreateConcreteEvent(_somethingCreated))
            .Returns(_somethingCreatedConcrete);
            _eventFactory
            .Setup(x => x.CreateConcreteEvent(_aggregateCreated))
            .Returns(_aggregateCreatedConcrete);

            _commandHandlerAsync = new Mock <ICommandHandlerAsync <CreateSomething> >();
            _commandHandlerAsync
            .Setup(x => x.HandleAsync(_createSomething))
            .ReturnsAsync(_events);

            _domainCommandHandlerAsync = new Mock <IDomainCommandHandlerAsync <CreateAggregate> >();
            _domainCommandHandlerAsync
            .Setup(x => x.HandleAsync(_createAggregate))
            .ReturnsAsync(_aggregate.Events);

            _handlerResolver = new Mock <IHandlerResolver>();
            _handlerResolver
            .Setup(x => x.ResolveHandler <ICommandHandlerAsync <CreateSomething> >())
            .Returns(_commandHandlerAsync.Object);
            _handlerResolver
            .Setup(x => x.ResolveHandler <IDomainCommandHandlerAsync <CreateAggregate> >())
            .Returns(_domainCommandHandlerAsync.Object);

            _optionsMock = new Mock <IOptions <Options> >();
            _optionsMock
            .Setup(x => x.Value)
            .Returns(new Options());

            _sut = new CommandSender(_handlerResolver.Object,
                                     _eventPublisher.Object,
                                     _eventFactory.Object,
                                     _optionsMock.Object);
        }
예제 #5
0
        public void SetUp()
        {
            _createSomething          = new CreateSomething();
            _createSomethingConcrete  = new CreateSomething();
            _somethingCreated         = new SomethingCreated();
            _somethingCreatedConcrete = new SomethingCreated();
            _events = new List <IEvent> {
                _somethingCreated
            };

            _createAggregate          = new CreateAggregate();
            _createAggregateConcrete  = new CreateAggregate();
            _aggregateCreatedConcrete = new AggregateCreated();
            _aggregate        = new Aggregate();
            _aggregateCreated = (AggregateCreated)_aggregate.Events[0];

            _sampleCommandSequence     = new SampleCommandSequence();
            _commandInSequenceConcrete = new CommandInSequence();

            _commandResponse = new CommandResponse {
                Events = _events, Result = "Result"
            };
            _domainCommandResponse = new CommandResponse {
                Events = _aggregate.Events, Result = "Result"
            };

            _eventPublisher = new Mock <IEventPublisher>();
            _eventPublisher
            .Setup(x => x.PublishAsync(_aggregateCreatedConcrete))
            .Returns(Task.CompletedTask);

            _storeProvider = new Mock <IStoreProvider>();
            _storeProvider
            .Setup(x => x.SaveAsync(It.IsAny <SaveStoreData>()))
            .Callback <SaveStoreData>(x => _storeDataSaved = x)
            .Returns(Task.CompletedTask);

            _objectFactory = new Mock <IObjectFactory>();
            _objectFactory
            .Setup(x => x.CreateConcreteObject(_somethingCreated))
            .Returns(_somethingCreatedConcrete);
            _objectFactory
            .Setup(x => x.CreateConcreteObject(_aggregateCreated))
            .Returns(_aggregateCreatedConcrete);
            _objectFactory
            .Setup(x => x.CreateConcreteObject(_createSomething))
            .Returns(_createSomethingConcrete);
            _objectFactory
            .Setup(x => x.CreateConcreteObject(_createAggregate))
            .Returns(_createAggregateConcrete);
            _objectFactory
            .Setup(x => x.CreateConcreteObject(It.IsAny <CommandInSequence>()))
            .Returns(_commandInSequenceConcrete);

            _validationService = new Mock <IValidationService>();
            _validationService
            .Setup(x => x.ValidateAsync(It.IsAny <CreateSomething>()))
            .Returns(Task.CompletedTask);

            _commandHandlerAsync = new Mock <ICommandHandlerAsync <CreateSomething> >();
            _commandHandlerAsync
            .Setup(x => x.HandleAsync(_createSomethingConcrete))
            .ReturnsAsync(_commandResponse);

            _domainCommandHandlerAsync = new Mock <ICommandHandlerAsync <CreateAggregate> >();
            _domainCommandHandlerAsync
            .Setup(x => x.HandleAsync(_createAggregate))
            .ReturnsAsync(_domainCommandResponse);
            _domainCommandHandlerAsync
            .Setup(x => x.HandleAsync(_createAggregateConcrete))
            .ReturnsAsync(_domainCommandResponse);

            _sequenceCommandHandlerAsync = new Mock <ISequenceCommandHandlerAsync <CommandInSequence> >();
            _sequenceCommandHandlerAsync
            .Setup(x => x.HandleAsync(It.IsAny <CommandInSequence>(), It.IsAny <CommandResponse>()))
            .ReturnsAsync(_commandResponse);

            _handlerResolver = new Mock <IHandlerResolver>();
            _handlerResolver
            .Setup(x => x.ResolveHandler <ICommandHandlerAsync <CreateSomething> >())
            .Returns(_commandHandlerAsync.Object);
            _handlerResolver
            .Setup(x => x.ResolveHandler <ICommandHandlerAsync <CreateAggregate> >())
            .Returns(_domainCommandHandlerAsync.Object);
            _handlerResolver
            .Setup(x => x.ResolveHandler <ISequenceCommandHandlerAsync <CommandInSequence> >())
            .Returns(_sequenceCommandHandlerAsync.Object);

            _mainOptionsMock = new Mock <IOptions <MainOptions> >();
            _mainOptionsMock
            .Setup(x => x.Value)
            .Returns(new MainOptions());

            _validationOptionsMock = new Mock <IOptions <ValidationOptions> >();
            _validationOptionsMock
            .Setup(x => x.Value)
            .Returns(new ValidationOptions());

            _sut = new CommandSender(_handlerResolver.Object,
                                     _eventPublisher.Object,
                                     _objectFactory.Object,
                                     _storeProvider.Object,
                                     _validationService.Object,
                                     _mainOptionsMock.Object,
                                     _validationOptionsMock.Object);
        }
예제 #6
0
        public void SetUp()
        {
            _createSomething          = new CreateSomething();
            _somethingCreated         = new SomethingCreated();
            _somethingCreatedConcrete = new SomethingCreated();
            _events = new List <IEvent> {
                _somethingCreated
            };

            _createAggregate          = new CreateAggregate();
            _aggregateCreatedConcrete = new AggregateCreated();
            _aggregate        = new Aggregate();
            _aggregateCreated = (AggregateCreated)_aggregate.Events[0];

            _eventPublisher = new Mock <IEventPublisher>();
            _eventPublisher
            .Setup(x => x.PublishAsync(_somethingCreatedConcrete))
            .Returns(Task.CompletedTask);
            _eventPublisher
            .Setup(x => x.PublishAsync(_aggregateCreatedConcrete))
            .Returns(Task.CompletedTask);

            _eventStore = new Mock <IEventStore>();
            _eventStore
            .Setup(x => x.SaveEventAsync <Aggregate>(_aggregateCreatedConcrete, null))
            .Returns(Task.CompletedTask);

            _commandStore = new Mock <ICommandStore>();
            _commandStore
            .Setup(x => x.SaveCommandAsync <Aggregate>(_createAggregate))
            .Returns(Task.CompletedTask);

            _eventFactory = new Mock <IEventFactory>();
            _eventFactory
            .Setup(x => x.CreateConcreteEvent(_somethingCreated))
            .Returns(_somethingCreatedConcrete);
            _eventFactory
            .Setup(x => x.CreateConcreteEvent(_aggregateCreated))
            .Returns(_aggregateCreatedConcrete);

            _commandHandlerAsync = new Mock <ICommandHandlerAsync <CreateSomething> >();
            _commandHandlerAsync
            .Setup(x => x.HandleAsync(_createSomething))
            .Returns(Task.CompletedTask);

            _commandHandlerWithEventsAsync = new Mock <ICommandHandlerWithEventsAsync <CreateSomething> >();
            _commandHandlerWithEventsAsync
            .Setup(x => x.HandleAsync(_createSomething))
            .ReturnsAsync(_events);

            _commandHandlerWithDomainEventsAsync = new Mock <ICommandHandlerWithDomainEventsAsync <CreateAggregate> >();
            _commandHandlerWithDomainEventsAsync
            .Setup(x => x.HandleAsync(_createAggregate))
            .ReturnsAsync(_aggregate.Events);

            _handlerResolver = new Mock <IHandlerResolver>();
            _handlerResolver
            .Setup(x => x.ResolveHandler <ICommandHandlerAsync <CreateSomething> >())
            .Returns(_commandHandlerAsync.Object);
            _handlerResolver
            .Setup(x => x.ResolveHandler <ICommandHandlerWithEventsAsync <CreateSomething> >())
            .Returns(_commandHandlerWithEventsAsync.Object);
            _handlerResolver
            .Setup(x => x.ResolveHandler <ICommandHandlerWithDomainEventsAsync <CreateAggregate> >())
            .Returns(_commandHandlerWithDomainEventsAsync.Object);

            _sut = new CommandSender(_handlerResolver.Object, _eventPublisher.Object, _eventFactory.Object, _eventStore.Object, _commandStore.Object);
        }
예제 #7
0
        public void SetUp()
        {
            _createSomething          = new CreateSomething();
            _somethingCreated         = new SomethingCreated();
            _somethingCreatedConcrete = new SomethingCreated();
            _events = new List <IEvent> {
                _somethingCreated
            };

            _createAggregate          = new CreateAggregate();
            _aggregateCreatedConcrete = new AggregateCreated();
            _aggregate        = new Aggregate();
            _aggregateCreated = (AggregateCreated)_aggregate.Events[0];

            _commandResponse = new CommandResponse {
                Events = _events
            };
            _domainCommandResponse = new CommandResponse {
                Events = _aggregate.Events
            };

            _eventPublisher = new Mock <IEventPublisher>();
            _eventPublisher
            .Setup(x => x.Publish(_aggregateCreatedConcrete));

            _storeProvider = new Mock <IStoreProvider>();
            _storeProvider
            .Setup(x => x.Save(_aggregate.GetType(), _createAggregate.AggregateRootId, _createAggregate, new List <IDomainEvent>()
            {
                _aggregateCreated
            }));

            _eventFactory = new Mock <IEventFactory>();
            _eventFactory
            .Setup(x => x.CreateConcreteEvent(_somethingCreated))
            .Returns(_somethingCreatedConcrete);
            _eventFactory
            .Setup(x => x.CreateConcreteEvent(_aggregateCreated))
            .Returns(_aggregateCreatedConcrete);

            _validationService = new Mock <IValidationService>();
            _validationService
            .Setup(x => x.Validate(_createAggregate));

            _commandHandler = new Mock <ICommandHandler <CreateSomething> >();
            _commandHandler
            .Setup(x => x.Handle(_createSomething))
            .Returns(_commandResponse);

            _domainCommandHandler = new Mock <ICommandHandler <CreateAggregate> >();
            _domainCommandHandler
            .Setup(x => x.Handle(_createAggregate))
            .Returns(_domainCommandResponse);

            _handlerResolver = new Mock <IHandlerResolver>();
            _handlerResolver
            .Setup(x => x.ResolveHandler(_createSomething, typeof(ICommandHandler <>)))
            .Returns(_commandHandler.Object);
            _handlerResolver
            .Setup(x => x.ResolveHandler(_createAggregate, typeof(ICommandHandler <>)))
            .Returns(_domainCommandHandler.Object);

            _optionsMock = new Mock <IOptions <Options> >();
            _optionsMock
            .Setup(x => x.Value)
            .Returns(new Options());

            _sut = new CommandSender(_handlerResolver.Object,
                                     _eventPublisher.Object,
                                     _eventFactory.Object,
                                     _storeProvider.Object,
                                     _validationService.Object,
                                     _optionsMock.Object);
        }
예제 #8
0
 private void When(AggregateCreated <Guid> e)
 {
     Id        = e.Id;
     _products = new List <Product>();
 }
예제 #9
0
        public void SetUp()
        {
            _createSomething          = new CreateSomething();
            _somethingCreated         = new SomethingCreated();
            _somethingCreatedConcrete = new SomethingCreated();
            _events = new List <IEvent> {
                _somethingCreated
            };

            _createAggregate          = new CreateAggregate();
            _aggregateCreatedConcrete = new AggregateCreated();
            _aggregate        = new Aggregate();
            _aggregateCreated = (AggregateCreated)_aggregate.Events[0];

            _sampleCommandSequence = new sampleCommandSequence();

            _commandResponse = new CommandResponse {
                Events = _events, Result = "Result"
            };
            _domainCommandResponse = new CommandResponse {
                Events = _aggregate.Events, Result = "Result"
            };

            _eventPublisher = new Mock <IEventPublisher>();
            _eventPublisher
            .Setup(x => x.Publish(_aggregateCreatedConcrete));

            _storeProvider = new Mock <IStoreProvider>();
            _storeProvider
            .Setup(x => x.Save(It.IsAny <SaveStoreData>()))
            .Callback <SaveStoreData>(x => _storeDataSaved = x);

            _eventFactory = new Mock <IEventFactory>();
            _eventFactory
            .Setup(x => x.CreateConcreteEvent(_somethingCreated))
            .Returns(_somethingCreatedConcrete);
            _eventFactory
            .Setup(x => x.CreateConcreteEvent(_aggregateCreated))
            .Returns(_aggregateCreatedConcrete);

            _validationService = new Mock <IValidationService>();
            _validationService
            .Setup(x => x.Validate(_createAggregate));

            _commandHandler = new Mock <ICommandHandler <CreateSomething> >();
            _commandHandler
            .Setup(x => x.Handle(_createSomething))
            .Returns(_commandResponse);

            _domainCommandHandler = new Mock <ICommandHandler <CreateAggregate> >();
            _domainCommandHandler
            .Setup(x => x.Handle(_createAggregate))
            .Returns(_domainCommandResponse);

            _sequenceCommandHandler = new Mock <ISequenceCommandHandler <ICommand> >();
            _sequenceCommandHandler
            .Setup(x => x.Handle(It.IsAny <ICommand>(), It.IsAny <CommandResponse>()))
            .Returns(It.IsAny <CommandResponse>());

            _handlerResolver = new Mock <IHandlerResolver>();
            _handlerResolver
            .Setup(x => x.ResolveHandler(_createSomething, typeof(ICommandHandler <>)))
            .Returns(_commandHandler.Object);
            _handlerResolver
            .Setup(x => x.ResolveHandler(_createAggregate, typeof(ICommandHandler <>)))
            .Returns(_domainCommandHandler.Object);
            _handlerResolver
            .Setup(x => x.ResolveHandler(It.IsAny <ICommand>(), typeof(ISequenceCommandHandler <>)))
            .Returns(_sequenceCommandHandler.Object);

            _optionsMock = new Mock <IOptions <Options> >();
            _optionsMock
            .Setup(x => x.Value)
            .Returns(new Options());

            _sut = new CommandSender(_handlerResolver.Object,
                                     _eventPublisher.Object,
                                     _eventFactory.Object,
                                     _storeProvider.Object,
                                     _validationService.Object,
                                     _optionsMock.Object);
        }
예제 #10
0
        public void SetUp()
        {
            _createSomething          = new CreateSomething();
            _somethingCreated         = new SomethingCreated();
            _somethingCreatedConcrete = new SomethingCreated();
            _events = new List <IEvent> {
                _somethingCreated
            };

            _createAggregate          = new CreateAggregate();
            _aggregateCreatedConcrete = new AggregateCreated();
            _aggregate        = new Aggregate();
            _aggregateCreated = (AggregateCreated)_aggregate.Events[0];

            _eventPublisher = new Mock <IEventPublisher>();
            _eventPublisher
            .Setup(x => x.Publish(_somethingCreatedConcrete));
            _eventPublisher
            .Setup(x => x.Publish(_aggregateCreatedConcrete));

            _eventStore = new Mock <IEventStore>();
            _eventStore
            .Setup(x => x.SaveEvent <Aggregate>(_aggregateCreatedConcrete, null));

            _commandStore = new Mock <ICommandStore>();
            _commandStore
            .Setup(x => x.SaveCommand <Aggregate>(_createAggregate));

            _aggregateStore = new Mock <IAggregateStore>();
            _aggregateStore
            .Setup(x => x.SaveAggregate <Aggregate>(_createAggregate.AggregateRootId));

            _eventFactory = new Mock <IEventFactory>();
            _eventFactory
            .Setup(x => x.CreateConcreteEvent(_somethingCreated))
            .Returns(_somethingCreatedConcrete);
            _eventFactory
            .Setup(x => x.CreateConcreteEvent(_aggregateCreated))
            .Returns(_aggregateCreatedConcrete);

            _commandHandler = new Mock <ICommandHandler <CreateSomething> >();
            _commandHandler
            .Setup(x => x.Handle(_createSomething))
            .Returns(_events);

            _domainCommandHandler = new Mock <IDomainCommandHandler <CreateAggregate> >();
            _domainCommandHandler
            .Setup(x => x.Handle(_createAggregate))
            .Returns(_aggregate.Events);

            _handlerResolver = new Mock <IHandlerResolver>();
            _handlerResolver
            .Setup(x => x.ResolveHandler <ICommandHandler <CreateSomething> >())
            .Returns(_commandHandler.Object);
            _handlerResolver
            .Setup(x => x.ResolveHandler <IDomainCommandHandler <CreateAggregate> >())
            .Returns(_domainCommandHandler.Object);

            _optionsMock = new Mock <IOptions <Options> >();
            _optionsMock
            .Setup(x => x.Value)
            .Returns(new Options());

            _sut = new DomainCommandSender(_handlerResolver.Object,
                                           _eventPublisher.Object,
                                           _eventFactory.Object,
                                           _aggregateStore.Object,
                                           _commandStore.Object,
                                           _eventStore.Object,
                                           _optionsMock.Object);
        }
예제 #11
0
 private void Apply(AggregateCreated @event)
 {
 }
예제 #12
0
 void IPublish <AggregateCreated> .Apply(AggregateCreated @event)
 {
     Id   = @event.AggregateSutId;
     Name = @event.Name;
 }