public void ShouldResolveSplitEventStream()
{
var eventStore = new EventStore();
var events = new IDomainEvent[]
{
new DraftCreatedEvent(organizationId, null),
};
var draftEvents = new IDomainEvent[]
{
new DraftCreatedEvent(draftId, organizationId),
};
var afterDraftEvents = new IDomainEvent[]
{
new LevelCreatedEvent(structureId, new LevelId(), "Level"),
};
foreach (var domainEvent in events)
{
eventStore.Add(organizationId, domainEvent);
}
foreach (var domainEvent in draftEvents)
{
eventStore.Add(draftId, domainEvent);
}
foreach (var domainEvent in afterDraftEvents)
{
eventStore.Add(organizationId, domainEvent);
}
eventStore.GetEvents(draftId).Should().Equal(events.Concat(draftEvents));
}
public static EventStore getDefault()
{
EventStore es = new EventStore();
es.targetObjIdList.Add(0);
es.targetObjIdList.Add(1);
es.targetObjIdList.Add(2);
Dictionary <int, SingleEvent> kv1 = new Dictionary <int, SingleEvent>();
kv1.Add(0, new SingleEvent());
kv1[0].Add("Um?");
kv1[0].Add("What's this?");
kv1.Add(1, new SingleEvent());
kv1[1].Add("......");
kv1.Add(2, new SingleEvent());
kv1[2].Add("I can't open it ...");
es.Add(0, kv1);
Dictionary <int, SingleEvent> kv2 = new Dictionary <int, SingleEvent>();
kv2.Add(0, new SingleEvent());
kv2[0].Add("......");
kv2.Add(1, new SingleEvent());
kv2[1].Add("This is ... ");
kv2[1].Add("cart ... ??");
kv2.Add(2, new SingleEvent());
kv2[2].Add("I can't open it ...");
es.Add(1, kv2);
Dictionary <int, SingleEvent> kv3 = new Dictionary <int, SingleEvent>();
kv3.Add(0, new SingleEvent());
kv3[0].Add("......");
kv3.Add(1, new SingleEvent());
kv3[1].Add("......");
kv3.Add(2, new SingleEvent(SingleEvent.CallbackAction.Door));
kv3[2].Add("It is open !!");
es.Add(2, kv3);
return(es);
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
var tValue = (DelegateAddRemove <PropertyChangedEventHandler>)value;
string tGuid;
if (tValue.IsAdding)
{
if (!_uniqueEvents.TryGetValue(tValue.Delegate, out tGuid))
{
tGuid = Guid.NewGuid().ToString();
_uniqueEvents.Add(tValue.Delegate, tGuid);
EventStore.Add(tGuid, tValue.Delegate);
}
_parent.DependencyLink(tGuid, binder.Name);
}
else
{
if (_uniqueEvents.TryGetValue(tValue.Delegate, out tGuid))
{
_parent.DependencyUnlink(tGuid, binder.Name);
}
}
return(true);
}
/// <summary>
/// 订阅指定事件数据的事件处理对象
/// </summary>
/// <param name="eventType">事件数据类型</param>
/// <param name="eventHandler">事件处理对象</param>
public virtual void Subscribe(Type eventType, IEventHandler eventHandler)
{
eventType.CheckNotNull(nameof(eventType));
eventHandler.CheckNotNull(nameof(eventHandler));
EventStore.Add(eventType, eventHandler);
}
/// <summary>
/// 订阅指定事件数据的事件处理对象
/// </summary>
/// <param name="eventType">事件数据类型</param>
/// <param name="eventHandler">事件处理对象</param>
public virtual void Subscribe(Type eventType, IEventHandler eventHandler)
{
Check.NotNull(eventType, nameof(eventType));
Check.NotNull(eventHandler, nameof(eventHandler));
EventStore.Add(eventType, eventHandler);
}
public Scenario Given(Event anEvent)
{
_steps.Add(
new Step
{
Title = anEvent.GetType().FullName,
Type = "Event",
Data = anEvent
.GetType()
.GetProperties()
.ToDictionary(x => x.Name, x => x.GetValue(anEvent).ToString())
});
_eventStore.Add(anEvent.AggregateId(), new List <Event> {
anEvent
});
return(this);
}
/// <summary>
/// 订阅指定事件数据的事件处理对象
/// </summary>
/// <param name="eventType">事件数据类型</param>
/// <param name="eventHandler">事件处理对象</param>
public virtual void Subscribe(Type eventType, IEventHandler eventHandler)
{
Check.NotNull(eventType, nameof(eventType));
Check.NotNull(eventHandler, nameof(eventHandler));
EventStore.Add(eventType, eventHandler);
Logger.LogDebug($"创建事件“{eventType}”到处理器“{eventHandler.GetType()}”的订阅配对");
}
public void AddingInvalidEventThrowsException()
{
var eventStore = new EventStore();
var @event = new TestEvent();
/* Do not set aggregate id etc. */
Assert.Throws <DomainEventIncompleteException>(() => eventStore.Add(@event));
}
public void Events_ForOrder_ShouldBeSaved()
{
var manager = new Manager("Manager");
var user = new User("alex", "T", "*****@*****.**");
var customer = new Customer(user.Id, user.Name);
customer.Fund(100);
var newOrderId = customer.CreateOrder();
var order = customer.Orders.First(x => x.Id == newOrderId);
order.SetManager(manager);
order.AddProduct(new Product()
{
Price = 11,
Type = "Cheeseburger"
});
customer.PayOrder(newOrderId);
var es = new EventStore(new DefaultEventSerializer(), new EventDataStorage());
es.Add(customer);
es.Commit();
es.Add(manager);
es.Commit();
var orderEvents = es.GetEventsForAggregate(order.Id);
var orderFromEvents = new Order(order.Id);
foreach (var @event in orderEvents)
{
orderFromEvents.Handle(@event);
}
Assert.Equal(11, orderFromEvents.Products.First().Price);
Assert.True(orderFromEvents.IsClosed);
Assert.True(orderFromEvents.IsPayed);
}
public void ReconstitutedNewAccountHasCorrectName()
{
var accountId = new Guid("A34C7724-F9FE-4A14-89A2-C8F1D662EE2A");
var eventStore = new EventStore();
var prevouslyCreatedAccount = new Account(accountId, "Test2");
eventStore.Add(prevouslyCreatedAccount.Events);
var account = new Account(accountId, eventStore.GetEvents());
Assert.AreEqual("Test2", account.Name);
}
public void AddedEventsAreInStore()
{
var eventStore = new EventStore();
var @event = new TestEvent();
@event.AggregateId = new TestEventId(new Guid("FFF291EF-1911-4C7C-BB30-89C29F0D6D3E"));
@event.DeviceId = new Guid("6BAAB117-6D9B-404A-AB6A-4AE7A8DA856C");
@event.VectorClock = new VectorClock();
eventStore.Add(@event);
Assert.Contains(@event, eventStore.GetEvents().ToList());
}
public void When_CreatingNewEvent_Then_SQLRepositoryAddEventShouldBeCalled()
{
//Arrange
var mock = new Mock <IEventRepository>();
mock.Setup(x => x.Add(It.IsAny <Event>()));
var sut = new EventStore(mock.Object);
//Act
sut.Add(new Event());
//Assert
mock.VerifyAll();
}
public void OnlyAddedEventsAreInStore()
{
var eventStore = new EventStore();
var @event = new TestEvent();
@event.AggregateId = new TestEventId(new Guid("FFF291EF-1911-4C7C-BB30-89C29F0D6D3E"));
@event.DeviceId = new Guid("6BAAB117-6D9B-404A-AB6A-4AE7A8DA856C");
@event.VectorClock = new VectorClock();
eventStore.Add(@event);
var events = eventStore.GetEvents().ToList();
Assert.That(() => events.All(x => ReferenceEquals(x, @event) && events.Count == 1));
}
public void Handle(BecomeCustomerCommand command)
{
var state = AccountState.FromStorage(AccountStore.AccountStates.SingleOrDefault(x => x.Email == command.Email)) ?? new AccountState();
var agg = Account.Create(state);
agg.BecomeCustomer(command.Email, command.Username);
foreach (var change in agg.Changes())
{
EventStore.Add(change);
}
AccountStore.AccountStates.Add(state.ToStorage());
}
public void ShouldReconstituteLevelFromCreatedEvent()
{
var organizationId = new OrganizationId();
var events = new EventStore();
DomainEvents.Register((IDomainEvent evt) => events.Add(organizationId, evt));
var levelId = new LevelId();
var level = new Level(levelId, new StructureId(), "Level Name");
var repo = new DomainRepository(organizationId, events);
var clonedLevel = repo.GetLevel(levelId);
clonedLevel.ShouldBeEquivalentTo(level);
}
public void ShouldResolveSimpleEventStream()
{
var eventStore = new EventStore();
var events = new IDomainEvent[]
{
new DraftCreatedEvent(organizationId, null),
new StructureCreatedEvent(structureId),
new LevelCreatedEvent(structureId, new LevelId(), "Level"),
};
foreach (var domainEvent in events)
{
eventStore.Add(organizationId, domainEvent);
}
eventStore.GetEvents(organizationId).Should().Equal(events);
}
/// <summary>
/// 自动订阅所有事件数据及其处理类型
/// </summary>
/// <param name="eventHandlerTypes">事件处理器类型集合</param>
public virtual void SubscribeAll(Type[] eventHandlerTypes)
{
Check.NotNull(eventHandlerTypes, nameof(eventHandlerTypes));
foreach (Type eventHandlerType in eventHandlerTypes)
{
Type handlerInterface = eventHandlerType.GetInterface("IEventHandler`1"); //获取该类实现的泛型接口
if (handlerInterface == null)
{
continue;
}
Type eventDataType = handlerInterface.GetGenericArguments()[0]; //泛型的EventData类型
IEventHandlerFactory factory = new IocEventHandlerFactory(_serviceProvider, eventHandlerType);
EventStore.Add(eventDataType, factory);
Logger.LogDebug($"创建事件“{eventDataType}”到处理器“{eventHandlerType}”的订阅配对");
}
Logger.LogInformation($"共从程序集创建了 {eventHandlerTypes.Length} 个事件处理器的事件订阅");
}
public void Handle(AddCreditCardCommand command)
{
var state = AccountState.FromStorage(AccountStore.AccountStates.SingleOrDefault(x => x.Email == command.Email));
if (state == null)
{
throw new Exception("Not found");
}
var agg = Domain.Account.Create(state);
agg.AddCreditCard(command.CreditCard);
foreach (var change in agg.Changes())
{
EventStore.Add(change);
}
AccountStore.Update(state.ToStorage());
}
public void EventsSurviveSerialisationRoundtrip()
{
var eventStore = new EventStore();
var @event = new TestEvent();
@event.AggregateId = new TestEventId(new Guid("FFF291EF-1911-4C7C-BB30-89C29F0D6D3E"));
@event.DeviceId = new Guid("6BAAB117-6D9B-404A-AB6A-4AE7A8DA856C");
@event.VectorClock = new VectorClock();
eventStore.Add(@event);
Serialiser.KnownTypes = new Type[]
{
typeof(TestEvent),
typeof(TestEventId),
};
var clonedState = Serialiser.CloneSerialisable(eventStore.State);
Assert.That(() => eventStore.State.Events.SequenceEqual(clonedState.Events));
}
/// <summary>
/// 订阅指定事件数据的事件处理类型
/// </summary>
/// <typeparam name="TEventData">事件数据类型</typeparam>
/// <typeparam name="TEventHandler">事件处理器类型</typeparam>
public virtual void Subscribe <TEventData, TEventHandler>() where TEventData : IEventData where TEventHandler : IEventHandler, new()
{
EventStore.Add <TEventData, TEventHandler>();
}
public EventStoreBuilder Add <TAggregateRoot>(TAggregateRoot aggregateRoot)
where TAggregateRoot : AggregateRoot
{
_store.Add(aggregateRoot);
return(this);
}