public void TestAddAccountActionExecute_DuplicateName()
{
using (var testDbInfo = SetupUtil.CreateTestDb())
{
//Arrange
Mock <ILog> mockLog = new Mock <ILog>();
AccountRepository repo = new AccountRepository(testDbInfo.ConnectionString, mockLog.Object);
AccountStateRepository accountStateRepo = new AccountStateRepository(testDbInfo.ConnectionString, mockLog.Object);
RepositoryBag repositories = SetupUtil.CreateMockRepositoryBag(testDbInfo.ConnectionString, mockLog.Object, repo, accountStateRepo);
AccountDto dto = new AccountDto()
{
Name = "Test Account"
};
repo.Upsert(dto);
AddAccountCommand action = new AddAccountCommand("new account \"Test Account\"", repositories, "Test Account");
action.FundsOption.SetData(123.45);
action.DescriptionOption.SetData("Test Description");
//Act
bool successful = action.TryExecute(mockLog.Object);
//Assert
Assert.False(successful);
}
}
public void TestAddAccountActionExecute_DuplicateName_WithListeners()
{
using (var testDbInfo = SetupUtil.CreateTestDb())
{
//Arrange
Mock <ILog> mockLog = new Mock <ILog>();
AccountRepository repo = new AccountRepository(testDbInfo.ConnectionString, mockLog.Object);
AccountStateRepository accountStateRepo = new AccountStateRepository(testDbInfo.ConnectionString, mockLog.Object);
RepositoryBag repositories = SetupUtil.CreateMockRepositoryBag(testDbInfo.ConnectionString, mockLog.Object, repo, accountStateRepo);
AccountDto dto = new AccountDto()
{
Name = "Test Account"
};
repo.Upsert(dto);
AddAccountCommand action = new AddAccountCommand("new account \"Test Account\"", repositories, "Test Account");
action.FundsOption.SetData(123.45);
action.DescriptionOption.SetData("Test Description");
Mock <ICommandActionListener> mockListener = new Mock <ICommandActionListener>();
mockListener.Setup(x => x.OnCommand(It.Is <CreateCommandResult <Account> >(a => !a.IsSuccessful && a.CreatedItem == null))).Verifiable();
List <ICommandActionListener> listeners = new List <ICommandActionListener>();
listeners.Add(mockListener.Object);
//Act
bool successful = action.TryExecute(mockLog.Object, listeners);
//Assert
Assert.False(successful);
mockListener.VerifyAll();
}
}
public void TestAddAccountActionExecute()
{
using (var testDbInfo = SetupUtil.CreateTestDb())
{
//Arrange
Mock <ILog> mockLog = new Mock <ILog>();
AccountRepository repo = new AccountRepository(testDbInfo.ConnectionString, mockLog.Object);
AccountStateRepository accountStateRepo = new AccountStateRepository(testDbInfo.ConnectionString, mockLog.Object);
RepositoryBag repositories = SetupUtil.CreateMockRepositoryBag(testDbInfo.ConnectionString, mockLog.Object, repo, accountStateRepo);
AddAccountCommand action = new AddAccountCommand("new account \"Test Account\"", repositories, "Test Account");
action.FundsOption.SetData(123.45);
action.DescriptionOption.SetData("Test Description");
//Act
bool successful = action.TryExecute(mockLog.Object);
Account account = DtoToModelTranslator.FromDto(repo.GetById(1), DateTime.Today, repositories);
AccountState state = DtoToModelTranslator.FromDto(accountStateRepo.GetLatestByAccountId(1), repositories);
//Assert
Assert.True(successful);
Assert.Equal("Test Account", account.Name);
Assert.Null(account.CategoryId);
Assert.Equal(Account.DEFAULT_PRIORITY, account.Priority);
Assert.Equal(Data.Enums.AccountKind.Sink, account.AccountKind);
Assert.Equal("Test Description", account.Description);
Assert.NotNull(state);
Assert.Equal(123.45, state.Funds);
Assert.False(state.IsClosed);
}
}
public async Task Handle_BalanceDecreasing_AfterSendingFromThisAccount()
{
// Arrange
var ivanAccountCommand = new AddAccountCommand {
UserId = Guid.NewGuid(), Name = "Ivan"
};
var ivanAccountId = await new AddAccountCommandHandler(_context).Handle(ivanAccountCommand, CancellationToken.None);
var petrAccountCommand = new AddAccountCommand {
UserId = Guid.NewGuid(), Name = "Petr"
};
var petrAccountId = await new AddAccountCommandHandler(_context).Handle(petrAccountCommand, CancellationToken.None);
var transaction = new AddTransactionCommand {
Amount = 13, CreditAccount = ivanAccountId, DebitAccount = petrAccountId
};
await new AddTransactionCommandHandler(_context).Handle(transaction, CancellationToken.None);
// Act
var handler = new AccountBalanceQueryHandler(_context);
var balance = await handler.Handle(new AccountBalanceQuery { AccountId = ivanAccountId }, CancellationToken.None);
// Assert
Check.That(487).Equals(balance.Balance);
}
public async Task <MutationInfo> Add([Inject] IMediator mediator, [Inject] IRequestInfo requestInfo, NonNull <AddAccountParameters> parameters)
{
var command = new AddAccountCommand
{
Id = Guid.NewGuid(),
Name = parameters.Value.Name,
Type = parameters.Value.Type,
Headers = new CommandHeaders(correlationId: Guid.NewGuid(), identity: requestInfo.Identity, remoteIpAddress: requestInfo.IpAddress)
};
var result = await mediator.Send(command);
return(MutationInfo.FromCommand(command));
}
public async Task Handle_Returns500_ForInitialBalance()
{
// Arrange
var ivanAccountCommand = new AddAccountCommand {
UserId = Guid.NewGuid(), Name = "Ivan"
};
var ivanAccountId = await new AddAccountCommandHandler(_context).Handle(ivanAccountCommand, CancellationToken.None);
// Act
var handler = new AccountBalanceQueryHandler(_context);
var balance = await handler.Handle(new AccountBalanceQuery { AccountId = ivanAccountId }, CancellationToken.None);
// Assert
Check.That(500).Equals(balance.Balance);
}
private ICommandAction BuildNewAccountCommand(string input, CommandUsageMatchData matchData)
{
string accountName;
if (!matchData.TryGetArgValue(BudgetCliCommands.ARG_ACCOUNT_NAME, out accountName))
{
return(null);
}
AddAccountCommand cmd = new AddAccountCommand(input, Repositories, accountName);
string categoryName;
if (matchData.TryGetArgValue(BudgetCliCommands.OPT_CATEGORY.Arguments[0], out categoryName))
{
cmd.CategoryNameOption.SetData(categoryName);
}
string description;
if (matchData.TryGetArgValue(BudgetCliCommands.OPT_DESCRIPTION.Arguments[0], out description))
{
cmd.DescriptionOption.SetData(description);
}
Money funds;
if (matchData.TryGetArgValue(BudgetCliCommands.OPT_FUNDS.Arguments[0], out funds))
{
cmd.FundsOption.SetData(funds);
}
AccountKind accountKind;
if (matchData.TryGetArgValue(BudgetCliCommands.OPT_ACCOUNT_TYPE.Arguments[0], out accountKind))
{
cmd.AccountTypeOption.SetData(accountKind);
}
int priority;
if (matchData.TryGetArgValue(BudgetCliCommands.OPT_PRIORITY.Arguments[0], out priority))
{
cmd.PriorityOption.SetData(priority);
}
return(cmd);
}
public async Task LoadTwitterDataAsync(Action <bool> loadCompleted)
{
if (SaveData.IsTwitterDataInitializeCompleted())
{
var data = await SaveData.LoadTwitterDataAsync();
foreach (TwitterAccount account in data.AccountList)
{
await account.InitializeAsync();
AddAccountCommand.Execute(account);
}
var nowTabCount = data.TimelineTabList.Where(q => q.IsNowTab).Select(q => q).Count();
if (nowTabCount != 0)
{
var nowTab = data.TimelineTabList.Where(q => q.IsNowTab).Select(q => q).Single();
foreach (TimelineTab tab in data.TimelineTabList)
{
tab.Initialize(CallTabAction, CallTimelineAction, CallRowAction);
AddTimelineTabCommand.Execute(tab);
foreach (TimelineBase timeline in tab.TimelineList)
{
timeline.Initialize(
AccountList.Single(
q => q.UserInfomation.id_str == timeline.Account.UserInfomation.id_str), Setting,
CallTimelineAction, CallRowAction);
timeline.AddTimeLine();
}
ResetTimeline();
if (tab.IsNowTab)
{
ChangeTabCommand.Execute(tab);
}
}
ChangeTabCommand.Execute(nowTab);
}
IsFirstLaunch = false;
loadCompleted(true);
}
else
{
IsFirstLaunch = true;
loadCompleted(false);
}
}
public string AddTest()
{
CM_Account dataEntity = new CM_Account();
dataEntity.AccountCode = "asdfsd";
dataEntity.CreateTime = DateTime.Now;
AddAccountCommand cmd = new AddAccountCommand(dataEntity);
CommandBus.Send <AddAccountCommand>(cmd);
if (cmd.SimpleResult != null)
{
// BusinessID = DataTypeConvert.ToInt32(cmd.SimpleResult.Message);
}
return("");
}
public void AddAccountCommand()
{
using (var testDbInfo = SetupUtil.CreateTestDb())
{
Mock <ILog> mockLog = new Mock <ILog>();
CommandInterpreter interpreter = new CommandInterpreter(SetupUtil.CreateMockRepositoryBag(testDbInfo.ConnectionString, mockLog.Object), BudgetCliCommands.BuildCommandLibrary());
ICommandAction action;
bool success = interpreter.TryParseCommand("new account \"name\"", out action);
Assert.True(success);
Assert.IsType <AddAccountCommand>(action);
AddAccountCommand addAccount = (AddAccountCommand)action;
Assert.Equal("name", addAccount.AccountName.GetValue(null));
}
}
public void TestAddAccountActionExecute_WithListeners()
{
using (var testDbInfo = SetupUtil.CreateTestDb())
{
//Arrange
Mock <ILog> mockLog = new Mock <ILog>();
AccountRepository repo = new AccountRepository(testDbInfo.ConnectionString, mockLog.Object);
AccountStateRepository accountStateRepo = new AccountStateRepository(testDbInfo.ConnectionString, mockLog.Object);
RepositoryBag repositories = SetupUtil.CreateMockRepositoryBag(testDbInfo.ConnectionString, mockLog.Object, repo, accountStateRepo);
AddAccountCommand action = new AddAccountCommand("new account \"Test Account\"", repositories, "Test Account");
action.FundsOption.SetData(123.45);
action.DescriptionOption.SetData("Test Description");
Mock <ICommandActionListener> mockListener = new Mock <ICommandActionListener>();
mockListener.Setup(x => x.OnCommand(It.Is <CreateCommandResult <Account> >(a => a.IsSuccessful && a.CreatedItem.Name.Equals("Test Account")))).Verifiable();
List <ICommandActionListener> listeners = new List <ICommandActionListener>();
listeners.Add(mockListener.Object);
//Act
bool successful = action.TryExecute(mockLog.Object, listeners);
Account account = DtoToModelTranslator.FromDto(repo.GetById(1), DateTime.Today, repositories);
AccountState state = DtoToModelTranslator.FromDto(accountStateRepo.GetLatestByAccountId(1), repositories);
//Assert
Assert.True(successful);
Assert.Equal("Test Account", account.Name);
Assert.Null(account.CategoryId);
Assert.Equal(Account.DEFAULT_PRIORITY, account.Priority);
Assert.Equal(Data.Enums.AccountKind.Sink, account.AccountKind);
Assert.Equal("Test Description", account.Description);
Assert.NotNull(state);
Assert.Equal(123.45, state.Funds);
Assert.False(state.IsClosed);
mockListener.VerifyAll();
}
}
public void AddAccountCommand_WithOptions()
{
using (var testDbInfo = SetupUtil.CreateTestDb())
{
Mock <ILog> mockLog = new Mock <ILog>();
CommandInterpreter interpreter = new CommandInterpreter(SetupUtil.CreateMockRepositoryBag(testDbInfo.ConnectionString, mockLog.Object), BudgetCliCommands.BuildCommandLibrary());
ICommandAction action;
bool success = interpreter.TryParseCommand("new account name -p 4 -c category -d description -f 10 -y Sink", out action);
Assert.True(success);
Assert.IsType <AddAccountCommand>(action);
AddAccountCommand addAccount = (AddAccountCommand)action;
Assert.Equal("name", addAccount.AccountName.GetValue(null));
Assert.Equal(4L, addAccount.PriorityOption.GetValue(null));
Assert.Equal("category", addAccount.CategoryNameOption.GetValue(null));
Assert.Equal("description", addAccount.DescriptionOption.GetValue(null));
Assert.Equal(new Money(10), addAccount.FundsOption.GetValue(null));
Assert.Equal(AccountKind.Sink, addAccount.AccountTypeOption.GetValue(null));
}
}
// Chooses specific command to execute depending on the input given.
public string Dispatch(string input)
{
string[] inputArgs = input.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries).ToArray();
string commandName = input.Length != 0 ? inputArgs[0].ToLower() : string.Empty;
inputArgs = inputArgs.Skip(1).ToArray();
string output = string.Empty;
switch (commandName)
{
case "register":
RegisterCommand register = new RegisterCommand()
{
UserValidator = new UserValidator()
};
output = register.Execute(inputArgs);
break;
case "login":
LoginCommand login = new LoginCommand();
output = login.Execute(inputArgs);
break;
case "logout":
LogoutCommand logout = new LogoutCommand();
output = logout.Execute(inputArgs);
break;
case "exit":
ExitCommand exit = new ExitCommand();
output = exit.Execute(inputArgs);
break;
case "add":
AddAccountCommand add = new AddAccountCommand()
{
CheckingAccountValidator = new CheckingAccountValidator(),
SavingAccountValidator = new SavingAccountValidator()
};
output = add.Execute(inputArgs);
break;
case "deposit":
DepositCommand deposit = new DepositCommand();
output = deposit.Execute(inputArgs);
break;
case "withdraw":
WithdrawCommand withdraw = new WithdrawCommand();
output = withdraw.Execute(inputArgs);
break;
// List Accounts
case "listaccounts":
ListAccountsCommand list = new ListAccountsCommand();
output = list.Execute(inputArgs);
break;
// Deduct Fee
case "deductfee":
DeductFeeCommand deduct = new DeductFeeCommand();
output = deduct.Execute(inputArgs);
break;
// Add Interest
case "addinterest":
AddInterestCommand addInterest = new AddInterestCommand();
output = addInterest.Execute(inputArgs);
break;
default:
throw new ArgumentException($"Command \"{commandName}\" not supported!");
}
return(output);
}
public Task <AccountDto> AddAccount(AddAccountCommand command, CancellationToken token) => HandlerDispatcher.Invoke <AddAccountHandler, AddAccountCommand, AccountDto>(command, token);
string BuildAccount(long customerId)
{
var command = new AddAccountCommand(customerId, "account is opened");
return(JsonConvert.SerializeObject(command));
}
public async Task <ActionResult> AddAccount([FromBody] AddAccountCommand command)
{
var result = await _mediator.Send(command);
return(Ok(result));
}
