public async Task CanAddMultipleDomainEventsToSingleEventProviderConcurrentlyWithConcurrencyExceptionAsync(int i)
{
var command = new Create(SequentialAtEndGuidGenerator.NewGuid(), i);
var domainEvents = AccountAggregateRoot.Create(command);
domainEvents.AggregateRoot.State.ExternalStateTracker = GetStateTracker(domainEvents);
await Repository.CommitAsync(new CommandHandlerContext(command), domainEvents.AggregateRoot as AccountAggregateRoot);
var account = await Repository.GetByIdentityAsync(domainEvents.AggregateRoot.Identity);
Assert.IsNotNull(account);
var dispatcher = new CommandDispatcher(new CommandHandlerFactory(new CommandCatalog(new List <ICommandEntry> {
new StaticCommandEntry(typeof(Deposit), new AggregateRootCommandHandler <AccountAggregateRoot, Deposit>(Repository))
})), new CommandHandlerContextFactory(MetaFactories));
var tasks = new Task[30];
for (var j = 0; j < 30; j++)
{
tasks[j] = dispatcher.DispatchAsync(new Deposit(account.Identity, j));
}
;
try
{
Task.WaitAll(tasks);
}
catch (Exception e)
{
Assert.Fail(e.ToString());
}
}
public virtual void CanAddMultipleDomainEventsToSingleEventProviderConcurrentlyAsync(int i)
{
var command = new Create(SequentialAtEndGuidGenerator.NewGuid(), i);
var domainEvents = AccountAggregateRoot.Create(command);
domainEvents.AggregateRoot.State.ExternalStateTracker = GetStateTracker(domainEvents);
Repository.Commit(new CommandHandlerContext(command), domainEvents.AggregateRoot as AccountAggregateRoot);
var account = Repository.GetByIdentity(domainEvents.AggregateRoot.Identity);
Assert.IsNotNull(account);
var ch = new SynchronizedAggregateRootCommandHandler <AccountAggregateRoot, Deposit>(Repository, new AggregateRootSynchronizer(new AggregateRootSynchronizationCache()), new AggregateRootCache());
var tasks = new Task[10];
for (var j = 0; j < 10; j++)
{
tasks[j] = ch.HandleAsync(new CommandHandlerContext(new Deposit(account.Identity, j)));
}
try
{
Task.WaitAll(tasks);
}
catch (Exception e)
{
Assert.Fail(e.ToString());
}
}
public override ICommandHandlingResult Handle(ICommandHandlerContext <Deposit> context)
{
var command = context.Command;
Contract.Assume(command.Amount > decimal.Zero);
var domainEvents = AccountAggregateRoot.Create(new Create(Guid.NewGuid(), 50));
domainEvents.AggregateRoot.Execute(command);
return(new CommandHandlingResult(command.CommandId));
}
public virtual async Task CanGetAggregateRootAsync(int i)
{
var command = new Create(SequentialAtEndGuidGenerator.NewGuid(), i);
var domainEvents = AccountAggregateRoot.Create(command);
domainEvents.AggregateRoot.State.ExternalStateTracker = GetStateTracker(domainEvents);
await Repository.CommitAsync(new CommandHandlerContext(command), domainEvents.AggregateRoot as AccountAggregateRoot);
var account = await Repository.GetByIdentityAsync(domainEvents.AggregateRoot.Identity);
Assert.IsNotNull(account);
}
public override void Handle(Deposit command)
{
Contract.Assume(command != null);
Contract.Assume(command.Amount > decimal.Zero);
var accountAggregate = new AccountAggregateRoot();
var events = accountAggregate.Credit(command.Amount, new CanCreditAccount(CanCreditAccount));
Contract.Assume(Contract.ForAll(events, o => o != null));
_domainEventDispatcher.PublishAll(events);
}
public virtual ICommandHandlingResult CanGetAggregateRoot()
{
var command = new Create(SequentialAtEndGuidGenerator.NewGuid(), 100);
var domainEvents = AccountAggregateRoot.Create(command);
domainEvents.AggregateRoot.State.ExternalStateTracker = GetStateTracker(domainEvents);
var result = Repository.Commit(new CommandHandlerContext(command), domainEvents.AggregateRoot as AccountAggregateRoot);
var account = Repository.GetByIdentity(domainEvents.AggregateRoot.Identity);
Assert.IsNotNull(account);
return(result);
}
private bool CanCreditAccount(AccountAggregateRoot account, decimal amount, out string declinationReason)
{
Contract.Requires(account != null);
declinationReason = null;
if (amount <= 0)
{
declinationReason = "Cannot credit an acount for $0.00.";
return(false);
}
else if (account.Balance + amount > 100m)
{
declinationReason = "Account will be over $100 and fees will start to apply.";
return(false);
}
return(true);
}
private bool CanDebitAccount(AccountAggregateRoot account, decimal amount, out string declinationReason)
{
Contract.Requires(account != null);
declinationReason = null;
if (amount <= 0)
{
declinationReason = "Cannot debit an acount for $0.00.";
return(false);
}
else if (account.Overdrawn)
{
declinationReason = "Account is overdrawn.";
return(false);
}
return(true);
}
public virtual void CanAddMultipleDomainEventsToSingleEventProviderConcurrentlyWithConcurrencyException()
{
var command = new Create(SequentialAtEndGuidGenerator.NewGuid(), 100);
var domainEvents = AccountAggregateRoot.Create(command);
domainEvents.AggregateRoot.State.ExternalStateTracker = GetStateTracker(domainEvents);
Repository.Commit(new CommandHandlerContext(command), domainEvents.AggregateRoot as AccountAggregateRoot);
var account = Repository.GetByIdentity(domainEvents.AggregateRoot.Identity);
Assert.IsNotNull(account);
var dispatcher = new CommandDispatcher(new CommandHandlerFactory(new CommandCatalog(new List <ICommandEntry> {
new StaticCommandEntry(typeof(Deposit), new AggregateRootCommandHandler <AccountAggregateRoot, Deposit>(Repository))
})), new CommandHandlerContextFactory(MetaFactories));
Parallel.For(0, 30, (i) =>
{
dispatcher.Dispatch(new Deposit(account.Identity, i));
});
}
public virtual void CanAddMultipleDomainEventsToSingleEventProvider()
{
var command = new Create(SequentialAtEndGuidGenerator.NewGuid(), 100);
var domainEvents = AccountAggregateRoot.Create(command);
domainEvents.AggregateRoot.State.ExternalStateTracker = GetStateTracker(domainEvents);
Repository.Commit(new CommandHandlerContext(command), domainEvents.AggregateRoot as AccountAggregateRoot);
var account = Repository.GetByIdentity(domainEvents.AggregateRoot.Identity);
Assert.IsNotNull(account);
var ch = new AggregateRootCommandHandler <AccountAggregateRoot, Deposit>(Repository);
var ch1 = new AggregateRootCommandHandler <AccountAggregateRoot, Withdraw>(Repository);
var random = new Random();
for (var i = 0; i < 15; i++)
{
ch.Handle(new CommandHandlerContext(new Deposit(account.Identity, i)));
ch1.Handle(new CommandHandlerContext(new Withdraw(account.Identity, random.Next(1, 10) * i)));
}
}
public virtual void CanAddMultipleDomainEventsToSingleEventProviderConcurrently()
{
var accountId = SequentialAtEndGuidGenerator.NewGuid();
var command = new Create(accountId, 100);
var domainEvents = AccountAggregateRoot.Create(command);
domainEvents.AggregateRoot.State.ExternalStateTracker = GetStateTracker(domainEvents);
Repository.Commit(new CommandHandlerContext(command), domainEvents.AggregateRoot as AccountAggregateRoot);
var synchronizer = new AggregateRootSynchronizer(new AggregateRootSynchronizationCache());
var aggregateRootCache = new AggregateRootCache();
var ch = new SynchronizedAggregateRootCommandHandler <AccountAggregateRoot, Deposit>(Repository, synchronizer, aggregateRootCache);
var ch1 = new SynchronizedAggregateRootCommandHandler <AccountAggregateRoot, Withdraw2>(Repository, synchronizer, aggregateRootCache);
var random = new Random();
Parallel.For(0, 20, (i) =>
{
ch.Handle(new CommandHandlerContext(new Deposit(accountId, i)));
ch1.Handle(new CommandHandlerContext(new Withdraw2(accountId, random.Next(1, 10) * i)));
});
}
public override ICommandHandlingResult Handle(ICommandHandlerContext <Create> context)
{
var domainEvents = AccountAggregateRoot.Create(context.Command);
return(new CommandHandlingResult(context.Command.CommandId));
}
public GetCardAccountResponse(AccountAggregateRoot accountAggregateRoot)
{
Id = accountAggregateRoot.Id;
Balance = accountAggregateRoot.State.Balance;
Issuer = new IssuerReponseItem(accountAggregateRoot.State.IssuerId);
}
protected override void When() => Aggregate = Repository.GetByNaturalKey(AccountId);
