예제 #1
0
        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);
            }
        }
예제 #2
0
        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();
            }
        }
예제 #3
0
        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);
            }
        }
예제 #4
0
        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);
        }
예제 #5
0
        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));
        }
예제 #6
0
        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);
        }
예제 #7
0
        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);
        }
예제 #8
0
        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);
            }
        }
예제 #9
0
        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("");
        }
예제 #10
0
        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));
            }
        }
예제 #11
0
        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();
            }
        }
예제 #12
0
        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);
        }
예제 #14
0
 public Task <AccountDto> AddAccount(AddAccountCommand command, CancellationToken token)
 => HandlerDispatcher.Invoke <AddAccountHandler, AddAccountCommand, AccountDto>(command, token);
예제 #15
0
        string BuildAccount(long customerId)
        {
            var command = new AddAccountCommand(customerId, "account is opened");

            return(JsonConvert.SerializeObject(command));
        }
예제 #16
0
        public async Task <ActionResult> AddAccount([FromBody] AddAccountCommand command)
        {
            var result = await _mediator.Send(command);

            return(Ok(result));
        }