public void event_handler_should_handle_event_via_router()
{
// arrange
var e = new AccountCreated(m_id);
// act
m_sender.SendOne(e);
// assert
}
public void Apply(AccountCreated e)
{
Created = true;
_account.AccountId = e.AccountId;
_account.EntityName = e.EntityName;
_account.TaxNumber = e.TaxNumber;
_account.AccountType = e.Type;
Version = e.Version;
}
public void file_record_storage_should_append_new()
{
// arrange
// act
var storage = m_factory.GetOrCreateStorage(m_accountID);
var account = new AccountCreated(m_accountID);
// assert
storage.TryAppend(new object[]{ account });
}
public void event_handler_should_handle_multiple_events_via_router()
{
// arrange
var e1 = new AccountCreated(m_id);
var e2 = new AccountCreated(m_id);
var e3 = new AccountCreated(m_id);
// act
m_sender.SendBatch(new object[] { e1, e2, e3 });
// assert
}
public void event_handler_should_handle_event()
{
// arrange
var e = new AccountCreated(m_id);
var handler = new MessageHandler();
handler.WireToLambda<AccountCreated>(new AccountCreatedHandler().Handle);
// act
handler.Handle(e);
// assert
}
public void file_record_storage_should_append_new_and_fetch()
{
// arrange
var storage = m_factory.GetOrCreateStorage(m_accountID);
var account = new AccountCreated(m_accountID);
storage.TryAppend(new object[] { account });
// act
var fetch = storage.GetRecords(0, int.MaxValue);
// assert
fetch.ShouldNotBeEmpty();
}
public async Task CannnotWithdrawCashIfOverdrafdIsExceeded(decimal deposit, decimal overdraft, decimal withdraw)
{
var accCreatedEv = new AccountCreated(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
Name = "Jake Sanders"
};
var depositSetEv = new CashDeposited(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
Amount = deposit
};
var overdraftSetEv = new OverdraftLimitSet(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
OverdraftLimit = overdraft
};
var cmd = new WithdrawCash()
{
AccountId = _accountId,
Amount = withdraw
};
var withdrawalFailedEv = new WithdrawalFailed(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
Amount = cmd.Amount
};
var accBlockedEv = new AccountBlocked(CorrelatedMessage.NewRoot())
{
AccountId = _accountId
};
await _runner.Run(
def => def
.Given(accCreatedEv, depositSetEv, overdraftSetEv)
.When(cmd)
.Then(withdrawalFailedEv, accBlockedEv));
}
/// <summary>
/// Attempts to insert a new company into the database
/// </summary>
/// <param name="accountInfo">Contains the info about the new company to be added to the database</param>
/// <returns>true if successful, false otherwise</returns>
public bool insertNewCompany(AccountCreated accountInfo)
{
if (openConnection() == true)
{
string query =
@"INSERT INTO company(companyname, phonenumber, email) " +
@"VALUES('" + accountInfo.username + @"', '" + accountInfo.phonenumber +
@"', '" + accountInfo.email + @"');" +
@"INSERT INTO location(address, companyname) " +
@"VALUES('" + accountInfo.address + @"', '" + accountInfo.username + @"');";
try
{
MySqlCommand command = new MySqlCommand(query, connection);
command.ExecuteNonQuery();
}
catch (MySqlException e)
{
Messages.Debug.consoleMsg("Unable to complete insert new company into database." +
" Error :" + e.Number + e.Message);
closeConnection();
return(false);
}
catch (Exception e)
{
closeConnection();
Messages.Debug.consoleMsg("Unable to Unable to complete insert new company into database." +
" Error:" + e.Message);
return(false);
}
finally
{
closeConnection();
}
}
else
{
return(false);
}
closeConnection();
return(true);
}
public async Task CannotWithrawNonPoitiveCashTests(decimal amount)
{
var accCreateEv = new AccountCreated(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
Name = "Jake Sanders"
};
var cmd = new WithdrawCash()
{
AccountId = _accountId,
Amount = amount
};
await _runner.Run(
def => def
.Given(accCreateEv)
.When(cmd)
.Throws(new SystemException("Withdrawn Cash amount should be greater than 0.")));
}
public async Task CashWithdrawAmountCannotBeNegative()
{
decimal withdrawAmount = -5000;
var accountCreated = new AccountCreated(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
AccountHolderName = "Tushar"
};
var cmd = new WithdrawCash()
{
AccountId = _accountId,
WithdrawAmount = withdrawAmount
};
await _runner.Run(
def => def.Given(accountCreated).When(cmd).Throws(new ValidationException("Cash withdrawal amount cannot be negative"))
);
}
private void BgwAccountUpdater_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
switch (e.UserState.ToString())
{
case "ACCOUNT_CREATED":
AccountCreated?.Invoke(this, new AccountEventArgs(accountData));
break;
case "ACCOUNT_DELETED":
AccountDeleted?.Invoke(this, new AccountEventArgs(accountData));
break;
case "ACCOUNT_INFO_UPDATED":
AccountInfoUpdated?.Invoke(this, new AccountEventArgs(accountData));
break;
default:
throw (new ArgumentException());
}
}
public async Task CannotConfigureNegativeWireTransferLimitOnAccount()
{
decimal dailyWireTransferLimit = -5000;
var accountCreated = new AccountCreated(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
AccountHolderName = "Tushar"
};
var cmd = new ConfigureDailyWireTransferLimit
{
AccountId = _accountId,
DailyWireTransferLimit = dailyWireTransferLimit
};
await _runner.Run(
def => def.Given(accountCreated).When(cmd).Throws(new ValidationException("Daily wire transfer limit cannot be negative"))
);
}
private static BankAccountEvent DeserializeEvent(string eventType, string dataString)
{
dynamic obj = JsonConvert.DeserializeObject(dataString);
switch (eventType)
{
case nameof(AccountCreated):
var a = JsonConvert.DeserializeObject <AccountCreated>(dataString);
var b = new AccountCreated(
new AccountId((Guid)obj.AppliesTo.Value),
new EventId((int)obj.Id.Value),
new EventDateTime((DateTimeOffset)obj.OccurredOn.Value)
);
return(b);
default: throw new Exception($"Unrecognized event type: {eventType}");
}
}
public Account_transactions_projection_tests()
{
// Given_account_created_and_projecting()
var msgCreated = new AccountCreated(Guid.NewGuid(), Guid.NewGuid(), 42);
var user = new User {
Id = msgCreated.UserId, Login = "******"
};
_msgReplenish = new AccountReplenish(msgCreated.SourceId, Guid.NewGuid(), new Money(100));
_msgWithdrawal = new AccountWithdrawal(msgCreated.SourceId, Guid.NewGuid(), new Money(30));
using (var context = CreateContext())
{
context.Users.Add(user);
context.SaveChanges();
}
ProjectionBuilder.Handle(msgCreated).Wait();
ProjectionBuilder.Handle(_msgReplenish).Wait();
ProjectionBuilder.Handle(_msgWithdrawal).Wait();
}
public async Task CannotSetOverdraftLimit(decimal limit)
{
var accCreatedEv = new AccountCreated(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
Name = "Jake Sanders"
};
var cmd = new SetOverdraftLimit
{
AccountId = _accountId,
OverdraftLimit = limit
};
await _runner.Run(
def => def
.Given(accCreatedEv)
.When(cmd)
.Throws(new SystemException("The overdraft limit cannot be negative."))
);
}
public async Task CannotDepositCheque(decimal amount)
{
var accCreatedEv = new AccountCreated(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
Name = "Jake Sanders"
};
var cmd = new DepositCheque()
{
AccountId = _accountId,
Amount = amount
};
await _runner.Run(
def => def
.Given(accCreatedEv)
.When(cmd)
.Throws(new SystemException("The deposited cheque amount should be greater than 0."))
);
}
private void InitiateAccount(CreateAccount command)
{
this.Monitor();
if (_accountState.AccountNumber == null)
{
/**
* we want to use behaviours here to make sure we don't allow the account to be created
* once it has been created -- Become AccountBoarded perhaps?
*/
var @event = new AccountCreated(command.AccountNumber);
Persist(@event, s =>
{
_accountState = _accountState.Event(@event);
_log.Debug($"Created account {command.AccountNumber}");
});
}
else
{
_log.Info($"You are trying to create {command.AccountNumber}, but has already been created. No action taken.");
}
}
public async Task CashDepositAmountCannotBeNegative()
{
decimal depositeAmount = -5000;
DateTime depositeDate = System.DateTime.Now;
var accountCreated = new AccountCreated(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
AccountHolderName = "Tushar"
};
var cmd = new DepositCash
{
AccountId = _accountId,
DepositAmount = depositeAmount
};
await _runner.Run(
def => def.Given(accountCreated).When(cmd).Throws(new ValidationException("Cash deposit amount cannot be negative"))
);
}
public async Task CannotWireTransferIfAccountIsBlocked()
{
var deposit = 5000m;
var transfer = 100m;
var accCreatedEv = new AccountCreated(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
Name = "Jake Sanders"
};
var cashDepositedEv = new CashDeposited(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
Amount = deposit
};
var accBlocked = new AccountBlocked(CorrelatedMessage.NewRoot())
{
AccountId = _accountId
};
var cmd = new TryWireTransfer()
{
AccountId = _accountId,
Amount = transfer
};
var transferFailedEv = new WireTransferFailed(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
Amount = cmd.Amount
};
await _runner.Run(
def => def
.Given(accCreatedEv, cashDepositedEv, accBlocked)
.When(cmd)
.Then(transferFailedEv));
}
public async Task CannnotWithdrawCashFromBlockedAccount()
{
var deposit = 1000m;
var withdraw = 500m;
var accCreatedEv = new AccountCreated(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
Name = "Jake Sanders"
};
var depositSetEv = new CashDeposited(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
Amount = deposit
};
var accBlockedEv = new AccountBlocked(CorrelatedMessage.NewRoot())
{
AccountId = _accountId
};
var cmd = new WithdrawCash()
{
AccountId = _accountId,
Amount = withdraw
};
var transferFailedEv = new WithdrawalFailed(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
Amount = cmd.Amount
};
await _runner.Run(
def => def
.Given(accCreatedEv, depositSetEv, accBlockedEv)
.When(cmd)
.Then(transferFailedEv));
}
private async Task <bool> Handle(AccountCreated ac)
{
Log.Information("Added Account: {ClientId}, {BranchCode}, {InitialBalance}",
ac.ClientId, ac.BranchBranchCode, ac.InitialBalance);
var account = new Account();
account.AccountId = ac.Id;
account.ClientId = ac.ClientId;
account.BranchCode = ac.BranchBranchCode;
account.Balance = ac.InitialBalance;
account.AccountNumber = ac.AccountNumber;
_dbContext.Add(account);
if (await _dbContext.SaveChangesAsync() == 0)
{
throw new ApplicationException();
}
return(true);
}
private void Handle(CreateAccount cmd)
{
var sender = Sender;
if (LastSequenceNr > 0)
{
throw new AlreadyCreatedException();
}
var created = new AccountCreated
{
AccountNumber = cmd.AccountNumber,
InitialFunds = cmd.InitialBalance
};
// when last event is persisted, send response
Persist(created, e =>
{
ApplyEvent(e);
Respond(sender, "Created", new[] { created });
});
}
public async Task CanWireTransferIfEnoughFundsAndNotExceededLimits(
decimal deposit, decimal limit, decimal transfer)
{
var accCreatedEv = new AccountCreated(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
Name = "Jake Sanders"
};
var cashDepositedEv = new CashDeposited(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
Amount = deposit
};
var dailyLimitSetEv = new DailyWireTransferLimitSet(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
DailyLimit = limit
};
var cmd = new TryWireTransfer()
{
AccountId = _accountId,
Amount = transfer
};
var transferedEv = new WireTransferHappened(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
Amount = cmd.Amount
};
await _runner.Run(
def => def
.Given(accCreatedEv, cashDepositedEv, dailyLimitSetEv)
.When(cmd)
.Then(transferedEv));
}
public async Task CashWithdrawalWhenAccountIsBlockedShouldRaiseAccountBlockedEvent()
{
decimal withdrawAmount = 10000;
decimal depositeAmount = 5000;
var accountCreated = new AccountCreated(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
AccountHolderName = "Tushar"
};
var evtCashDeposited = new CashDeposited(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
DepositAmount = depositeAmount
};
var evtCashWithdrawn = new CashWithdrawn(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
WithdrawAmount = withdrawAmount
};
var cmdWithdrawCash = new WithdrawCash()
{
AccountId = _accountId,
WithdrawAmount = withdrawAmount
};
var evAccountBlocked = new AccountBlocked(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
Amount = withdrawAmount
};
await _runner.Run(
def => def.Given(accountCreated, evtCashDeposited, evtCashWithdrawn).When(cmdWithdrawCash).Then(evAccountBlocked)
);
}
public async Task CanTransferFundFromValidAccount()
{
decimal WireTransferFund = 5000;
decimal depositeAmount = 5000;
var accountCreated = new AccountCreated(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
AccountHolderName = "Tushar"
};
var cmdDepositCash = new DepositCash
{
AccountId = _accountId,
DepositAmount = depositeAmount
};
var evtCashDeposited = new CashDeposited(cmdDepositCash)
{
AccountId = _accountId,
DepositAmount = depositeAmount
};
var cmd = new TransferWireFund()
{
AccountId = _accountId,
WireFund = WireTransferFund
};
var ev = new WireFundTransferred(cmd)
{
AccountId = _accountId,
WireFund = WireTransferFund
};
await _runner.Run(
def => def.Given(accountCreated, evtCashDeposited).When(cmd).Then(ev)
);
}
public async Task CanWithdrawCashFromValidAccount()
{
decimal withdrawAmount = 5000;
decimal depositeAmount = 5000;
var accountCreated = new AccountCreated(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
AccountHolderName = "Tushar"
};
var cmdDepositCash = new DepositCash
{
AccountId = _accountId,
DepositAmount = depositeAmount
};
var evtCashDeposited = new CashDeposited(cmdDepositCash)
{
AccountId = _accountId,
DepositAmount = depositeAmount
};
var cmd = new WithdrawCash()
{
AccountId = _accountId,
WithdrawAmount = withdrawAmount
};
var ev = new CashWithdrawn(cmd)
{
AccountId = _accountId,
WithdrawAmount = withdrawAmount
};
await _runner.Run(
def => def.Given(accountCreated, evtCashDeposited).When(cmd).Then(ev)
);
}
public async Task CanDepositCash(double amount)
{
var created = new AccountCreated(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
AccountHolderName = "Parth Sheth"
};
var cmd = new DepositCash
{
AccountId = _accountId,
Amount = Convert.ToDecimal(amount)
};
var limitSet = new CashDeposited(cmd)
{
AccountId = _accountId,
Amount = cmd.Amount
};
await _runner.Run(
def => def.Given(created).When(cmd).Then(limitSet)
);
}
public async Task CanUnblockAccount()
{
var accCreatedEv = new AccountCreated(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
Name = "Jake Sanders"
};
var accBlockedEv = new AccountBlocked(CorrelatedMessage.NewRoot())
{
AccountId = _accountId
};
var cmd = new DepositCash()
{
AccountId = _accountId,
Amount = 1000
};
var amountSetEv = new CashDeposited(CorrelatedMessage.NewRoot())
{
AccountId = cmd.AccountId,
Amount = cmd.Amount
};
var accUnblockedEv = new AccountUnblocked(CorrelatedMessage.NewRoot())
{
AccountId = _accountId
};
await _runner.Run(
def => def
.Given(accCreatedEv, accBlockedEv)
.When(cmd)
.Then(amountSetEv, accUnblockedEv));
}
public async Task CanSetOverdraftLimit(decimal limit)
{
var accCreatedEv = new AccountCreated(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
Name = "Jake Sanders"
};
var cmd = new SetOverdraftLimit
{
AccountId = _accountId,
OverdraftLimit = limit
};
var limitSetEv = new OverdraftLimitSet(CorrelatedMessage.NewRoot())
{
AccountId = cmd.AccountId,
OverdraftLimit = cmd.OverdraftLimit
};
await _runner.Run(
def => def.Given(accCreatedEv).When(cmd).Then(limitSetEv)
);
}
private AccountState ApplyEvent(AccountCreated occurred)
{
var newState = new AccountState(
occurred.AccountNumber,
accountStatus: AccountStatus.Boarded,
obligations: ImmutableDictionary.Create <string, MaintenanceFee>(),
simulation: LoadSimulation(),
log: AuditLog.Add(
new StateLog("AccountCreated",
occurred.Message + " Balance After: " + ((decimal)occurred.OpeningBalance).ToString("C"),
occurred.UniqueGuid(),
occurred.OccurredOn()
)
),
openingBalance: occurred.OpeningBalance,
currentBalance: 0, //best to affect currBal explicitly with an event
inventory: occurred.Inventory,
userName: occurred.UserName,
lastPaymentAmount: occurred.LastPaymentAmount,
lastPaymentDate: occurred.LastPaymentDate
);
return(newState);
}
public async Task CanSetDailyWireTransferLimit(double limit)
{
var created = new AccountCreated(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
AccountHolderName = "Parth Sheth"
};
var cmd = new SetDailyWireTransferLimit
{
AccountId = _accountId,
DailyWireTransferLimit = Convert.ToDecimal(limit)
};
var limitSet = new DailyWireTransferLimitSet(cmd)
{
AccountId = _accountId,
DailyWireTransferLimit = cmd.DailyWireTransferLimit
};
await _runner.Run(
def => def.Given(created).When(cmd).Then(limitSet)
);
}
public async Task CanDepositCheque(decimal amount)
{
var accCreatedEv = new AccountCreated(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
Name = "Jake Sanders"
};
var cmd = new DepositCheque()
{
AccountId = _accountId,
Amount = amount
};
var amountSetEv = new ChequeDeposited(CorrelatedMessage.NewRoot())
{
AccountId = cmd.AccountId,
Amount = cmd.Amount
};
await _runner.Run(
def => def.Given(accCreatedEv).When(cmd).Then(amountSetEv)
);
}
public async Task CanConfigureOverdraftLimitOnAccount()
{
decimal overdraftLimit = 500;
var accountCreated = new AccountCreated(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
AccountHolderName = "Tushar"
};
var cmd = new ConfigureOverdraftLimit
{
AccountId = _accountId,
OverdraftLimit = overdraftLimit
};
var ev = new OverdraftLimitConfigured(cmd)
{
AccountId = cmd.AccountId,
OverdraftLimit = cmd.OverdraftLimit
};
await _runner.Run(
def => def.Given(accountCreated).When(cmd).Then(ev)
);
}
public async Task CanConfigureDailyWireTransferLimitOnAccount()
{
decimal dailyWireTransferLimit = 5000;
var accountCreated = new AccountCreated(CorrelatedMessage.NewRoot())
{
AccountId = _accountId,
AccountHolderName = "Tushar"
};
var cmd = new ConfigureDailyWireTransferLimit
{
AccountId = _accountId,
DailyWireTransferLimit = dailyWireTransferLimit
};
var ev = new DailyWireTransferLimitConfigured(cmd)
{
AccountId = cmd.AccountId,
DailyWireTransferLimit = cmd.DailyWireTransferLimit
};
await _runner.Run(
def => def.Given(accountCreated).When(cmd).Then(ev)
);
}
public NewAccountCreatedEmailTemplate(AccountCreated accountCreatedEvent)
{
AccountCreatedEvent = accountCreatedEvent;
}
/// <summary>
/// Handles <see cref="AccountCreated"/> events
/// </summary>
/// <param name="e">Event to handle</param>
private void When(AccountCreated e)
{
this.Name = e.Name;
}
protected virtual void Handle(AccountCreated evnt)
{
_entityManager.BuildAndSave<LibraryAccountEntity>(evnt);
}
private void Handle(AccountCreated evnt)
{
_connection.Insert(evnt, "EventSourcing_Sample_LibraryAccount", _transaction);
}
private void Apply(AccountCreated @event)
{
Id = @event.AccountId;
}
public void When(AccountCreated e)
{
ID = e.Identity;
}
