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 void TestDoesNameExist_False()
        {
            using (var testDbInfo = SetupUtil.CreateTestDb())
            {
                //Arrange
                Mock <ILog>       log  = new Mock <ILog>();
                AccountRepository repo = new AccountRepository(testDbInfo.ConnectionString, log.Object);

                AccountDto account = new AccountDto()
                {
                    AccountKind = Enums.AccountKind.Category,
                    Description = String.Empty,
                    Name        = "account",
                    Priority    = 5,
                    CategoryId  = null
                };

                repo.Upsert(account);

                //Act
                bool missingAccountExists = repo.DoesNameExist("doesNotExist");

                //Assert
                Assert.False(missingAccountExists);
            }
        }
Esempio n. 4
0
        public void TestAddAccountActionExecute_NameNotExist()
        {
            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);

                DetailAccountCommand action = new DetailAccountCommand("detail account missing", repositories);
                action.NameOption.SetData("missing");

                ReadDetailsCommandResult <Account> result       = null;
                Mock <ICommandActionListener>      mockListener = new Mock <ICommandActionListener>();
                mockListener.Setup(x => x.OnCommand(It.IsAny <ReadDetailsCommandResult <Account> >())).Callback <ReadDetailsCommandResult <Account> >((y) => { result = y; });

                //Act
                bool successful = action.TryExecute(mockLog.Object, new [] { mockListener.Object });

                //Assert
                Assert.False(successful);
                Assert.False(result.IsSuccessful);
                Assert.Null(result.Item);
            }
        }
Esempio n. 5
0
        public void FromDto_Account()
        {
            using (var testDbInfo = SetupUtil.CreateTestDb())
            {
                //Arrange
                Mock <ILog> mockLog    = new Mock <ILog>();
                AccountDto  accountDto = new AccountDto()
                {
                    Id          = 1,
                    Name        = "Test Account",
                    AccountKind = Data.Enums.AccountKind.Source,
                    CategoryId  = null,
                    Description = "",
                    Priority    = 7
                };

                RepositoryBag repositories = SetupUtil.CreateMockRepositoryBag(testDbInfo.ConnectionString, mockLog.Object);

                //Act
                Account account = DtoToModelTranslator.FromDto(accountDto, DateTime.Today, repositories);

                //Assert
                Assert.Equal("Test Account", account.Name);
                Assert.Null(account.CategoryId);
                Assert.Equal(7, account.Priority);
                Assert.Equal(Data.Enums.AccountKind.Source, account.AccountKind);
            }
        }
Esempio n. 6
0
        public void Account_ToDto()
        {
            using (var testDbInfo = SetupUtil.CreateTestDb())
            {
                //Arrange
                Mock <ILog>   mockLog      = new Mock <ILog>();
                RepositoryBag repositories = SetupUtil.CreateMockRepositoryBag(testDbInfo.ConnectionString, mockLog.Object);
                AccountDto    accountDto   = new AccountDto()
                {
                    Id          = 1,
                    Name        = "Test Account",
                    AccountKind = AccountKind.Source,
                    CategoryId  = null,
                    Description = "",
                    Priority    = 7
                };

                Account account = new Account(1, "Test Account", null, 7, AccountKind.Source, "", DateTime.Today, repositories);

                //Act
                AccountDto toDto = account.ToDto();

                //Assert
                Assert.Equal(accountDto, toDto);
            }
        }
Esempio n. 7
0
        public void TestRemoveAllStatesByAccountId_NoStates()
        {
            using (var testDbInfo = SetupUtil.CreateTestDb())
            {
                //Arrange
                Mock <ILog>            log         = new Mock <ILog>();
                AccountRepository      accountRepo = new AccountRepository(testDbInfo.ConnectionString, log.Object);
                AccountStateRepository repo        = new AccountStateRepository(testDbInfo.ConnectionString, log.Object);

                AccountDto account = new AccountDto()
                {
                    AccountKind = Enums.AccountKind.Category,
                    Description = String.Empty,
                    Name        = "account",
                    Priority    = 5,
                    CategoryId  = null
                };
                bool isInsertSuccessful = accountRepo.Upsert(account);

                //Act
                List <AccountStateDto> allStatesBeforeRemove = repo.GetAllByAccountId(account.Id.Value);
                bool isSuccessful = repo.RemoveAllByAccountId(account.Id.Value);
                List <AccountStateDto> allStatesAfterRemove = repo.GetAllByAccountId(account.Id.Value);

                //Assert
                Assert.True(isInsertSuccessful);
                Assert.False(isSuccessful);
                Assert.Empty(allStatesBeforeRemove);
                Assert.Empty(allStatesAfterRemove);
            }
        }
Esempio n. 8
0
        public void Transaction_ToDto()
        {
            using (var testDbInfo = SetupUtil.CreateTestDb())
            {
                //Arrange
                Mock <ILog>   mockLog      = new Mock <ILog>();
                RepositoryBag repositories = SetupUtil.CreateMockRepositoryBag(testDbInfo.ConnectionString, mockLog.Object);


                DateTime timestamp       = DateTime.Now;
                long?    sourceAccountId = 1;
                long?    destAccountId   = 3;
                Money    transferAmount  = 123.45;
                string   memo            = "memo";

                TransactionDto transactionDto = new TransactionDto()
                {
                    Id                   = 1,
                    Timestamp            = timestamp,
                    SourceAccountId      = sourceAccountId,
                    DestinationAccountId = destAccountId,
                    TransferAmount       = transferAmount.InternalValue,
                    Memo                 = memo
                };

                Transaction transaction = new Transaction(1, timestamp, sourceAccountId, destAccountId, transferAmount, memo, repositories);

                //Act
                TransactionDto toDto = transaction.ToDto();

                //Assert
                Assert.Equal(transactionDto, toDto);
            }
        }
        public void TestTransactionRepositoryInsertNew_NullSourceNullDest()
        {
            using (var testDbInfo = SetupUtil.CreateTestDb())
            {
                //Arrange
                Mock <ILog> log = new Mock <ILog>();

                Mock <TransactionDto> mockDto = new Mock <TransactionDto>();
                mockDto.SetupAllProperties();
                mockDto.SetupGet(t => t.SourceAccountId).Returns((long?)null);
                mockDto.SetupGet(t => t.DestinationAccountId).Returns((long?)null);
                //Skip set timestamp property

                var repo = new TransactionRepository(testDbInfo.ConnectionString, log.Object);

                //Act
                bool success = repo.Upsert(mockDto.Object);

                //Assert

                //Ensure update failed
                Assert.False(success);

                //Ensure failure was logged
                log.Verify(l => l.WriteLine(It.IsAny <string>(), LogLevel.Error));

                //Ensure ID was not set
                Assert.Null(mockDto.Object.Id);
            }
        }
        public void TestTransactionRepositoryUpdate_NullSourceNullDest()
        {
            using (var testDbInfo = SetupUtil.CreateTestDb())
            {
                //Arrange
                Mock <ILog>               log         = new Mock <ILog>();
                AccountRepository         accountRepo = new AccountRepository(testDbInfo.ConnectionString, log.Object);
                Dictionary <string, long> accountIds  = SetupAccounts(accountRepo, "A1", "A2");

                Mock <TransactionDto> mockDto = new Mock <TransactionDto>();
                mockDto.SetupAllProperties();
                mockDto.SetupGet(t => t.TransferAmount).Returns(123_45);
                mockDto.SetupGet(t => t.Timestamp).Returns(DateTime.Today);

                mockDto.Object.SourceAccountId      = accountIds["A1"];
                mockDto.Object.DestinationAccountId = accountIds["A2"];

                var repo = new TransactionRepository(testDbInfo.ConnectionString, log.Object);

                //First upsert will be an insert
                repo.Upsert(mockDto.Object);

                mockDto.Object.SourceAccountId      = null;
                mockDto.Object.DestinationAccountId = null;

                //Act
                bool successful = repo.Upsert(mockDto.Object);

                //Assert update failed
                Assert.False(successful);

                //Ensure failure was logged
                log.Verify(l => l.WriteLine(It.IsAny <string>(), LogLevel.Error));
            }
        }
        public void TestGetIdByName_NameDoesNotExist()
        {
            using (var testDbInfo = SetupUtil.CreateTestDb())
            {
                //Arrange
                Mock <ILog>       log  = new Mock <ILog>();
                AccountRepository repo = new AccountRepository(testDbInfo.ConnectionString, log.Object);

                AccountDto account = new AccountDto()
                {
                    AccountKind = Enums.AccountKind.Category,
                    Description = String.Empty,
                    Name        = "account",
                    Priority    = 5,
                    CategoryId  = null
                };

                repo.Upsert(account);

                //Act
                long missingAccountId = repo.GetIdByName("doesNotExist");

                //Assert
                Assert.Equal(-1, missingAccountId);
            }
        }
        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);
            }
        }
Esempio n. 13
0
        public void TestGetLatestStateByAccountId()
        {
            using (var testDbInfo = SetupUtil.CreateTestDb())
            {
                //Arrange
                Mock <ILog>            log         = new Mock <ILog>();
                AccountRepository      accountRepo = new AccountRepository(testDbInfo.ConnectionString, log.Object);
                AccountStateRepository repo        = new AccountStateRepository(testDbInfo.ConnectionString, log.Object);

                AccountDto account = new AccountDto()
                {
                    AccountKind = Enums.AccountKind.Category,
                    Description = String.Empty,
                    Name        = "account",
                    Priority    = 5,
                    CategoryId  = null
                };
                bool isInsertSuccessful = accountRepo.Upsert(account);

                DateTime        state1Timestamp = DateTime.Now;
                AccountStateDto accountState    = new AccountStateDto()
                {
                    AccountId = account.Id.Value,
                    Funds     = (new Money(100)).InternalValue,
                    IsClosed  = false,
                    Timestamp = state1Timestamp
                };
                isInsertSuccessful &= repo.Upsert(accountState);


                DateTime        state2Timestamp = state1Timestamp.AddDays(-1);
                AccountStateDto accountState2   = new AccountStateDto()
                {
                    AccountId = account.Id.Value,
                    Funds     = (new Money(500)).InternalValue,
                    IsClosed  = false,
                    Timestamp = state2Timestamp
                };
                isInsertSuccessful &= repo.Upsert(accountState2);

                DateTime        state3Timestamp = state1Timestamp.AddDays(-2);
                AccountStateDto accountState3   = new AccountStateDto()
                {
                    AccountId = account.Id.Value,
                    Funds     = (new Money(800)).InternalValue,
                    IsClosed  = false,
                    Timestamp = state3Timestamp
                };
                isInsertSuccessful &= repo.Upsert(accountState3);

                //Act
                AccountStateDto latest = repo.GetLatestByAccountId(account.Id.Value);

                //Assert
                Assert.True(isInsertSuccessful);

                Assert.Equal(100, new Money(latest.Funds, true));
            }
        }
        public void TestDoesNameExist_True()
        {
            using (var testDbInfo = SetupUtil.CreateTestDb())
            {
                //Arrange
                Mock <ILog>       log  = new Mock <ILog>();
                AccountRepository repo = new AccountRepository(testDbInfo.ConnectionString, log.Object);

                AccountDto parent = new AccountDto()
                {
                    AccountKind = Enums.AccountKind.Category,
                    Description = String.Empty,
                    Name        = "parent",
                    Priority    = 5,
                    CategoryId  = null
                };

                bool isParentInsertSuccessful = repo.Upsert(parent);

                AccountDto child1 = new AccountDto()
                {
                    AccountKind = Enums.AccountKind.Category,
                    Description = String.Empty,
                    Name        = "child1",
                    Priority    = 5,
                    CategoryId  = parent.Id
                };

                bool isChild1InsertSuccessful = repo.Upsert(child1);

                AccountDto child2 = new AccountDto()
                {
                    AccountKind = Enums.AccountKind.Category,
                    Description = String.Empty,
                    Name        = "child2",
                    Priority    = 5,
                    CategoryId  = parent.Id
                };

                bool isChild2InsertSuccessful = repo.Upsert(child2);

                //Act
                bool parentExists = repo.DoesNameExist("parent");
                bool child1Exists = repo.DoesNameExist("child1");
                bool child2Exists = repo.DoesNameExist("child2");

                //Assert
                Assert.True(isParentInsertSuccessful);
                Assert.True(isChild1InsertSuccessful);
                Assert.True(isChild2InsertSuccessful);

                Assert.True(parentExists);
                Assert.True(child1Exists);
                Assert.True(child2Exists);
            }
        }
        public void TestDeleteAccountActionExecute()
        {
            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 accountDto = new AccountDto()
                {
                    AccountKind = Data.Enums.AccountKind.Sink,
                    CategoryId  = null,
                    Description = "test account",
                    Name        = "Test Account",
                    Priority    = 5
                };
                bool isInsertSuccessful = repo.Upsert(accountDto);
                long accountId          = accountDto.Id.Value;

                int             accountCountBeforeDelete = repo.GetAll().Count();
                AccountStateDto stateDto = new AccountStateDto()
                {
                    AccountId = accountId,
                    Funds     = 0,
                    Timestamp = DateTime.Now,
                    IsClosed  = false
                };
                isInsertSuccessful &= accountStateRepo.Upsert(stateDto);
                int stateCountBeforeDelete = accountStateRepo.GetAll().Count();


                DeleteAccountCommand action = new DeleteAccountCommand("rm account \"Test Account\"", repositories);
                action.AccountName.SetData("Test Account");
                action.IsRecursiveOption.SetData(false);

                //Act
                bool successful = action.TryExecute(mockLog.Object);

                int accountCountAfterDelete = repo.GetAll().Count();
                int stateCountAfterDelete   = accountStateRepo.GetAll().Count();

                bool isClosed = accountStateRepo.GetLatestByAccountId(accountId).IsClosed;

                //Assert
                Assert.True(isInsertSuccessful);
                Assert.True(successful);
                Assert.Equal(1, accountCountBeforeDelete);
                Assert.Equal(1, accountCountAfterDelete);
                Assert.Equal(1, stateCountBeforeDelete);
                Assert.Equal(2, stateCountAfterDelete);
                Assert.True(isClosed);
            }
        }
Esempio n. 16
0
        public void ListAccountCommandExecute_PriorityOption()
        {
            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 account1 = new AccountDto()
                {
                    Id          = null,
                    AccountKind = AccountKind.Sink,
                    Name        = "account1",
                    Priority    = 5,
                    Description = "account1 description",
                    CategoryId  = null
                };
                AccountDto account2 = new AccountDto()
                {
                    Id          = null,
                    AccountKind = AccountKind.Sink,
                    Name        = "account2",
                    Priority    = 10,
                    Description = "account2 description",
                    CategoryId  = null
                };

                UpsertAccount(account1, repositories);
                UpsertAccount(account2, repositories);

                ListAccountCommand action = new ListAccountCommand("ls accounts", repositories);
                action.PriorityOption.SetData(new Range <long>(4, 6));

                FakeCommandActionListener listener = new FakeCommandActionListener();

                //Act
                bool successful = action.TryExecute(mockLog.Object, new ICommandActionListener[] { listener });

                IEnumerable <ReadCommandResult <Account> > results = listener.GetResults <ReadCommandResult <Account> >();

                IEnumerable <Account> accounts = results.First().FilteredItems;

                //Assert
                Assert.True(successful);
                Assert.True(listener.OnlyHasType <ReadCommandResult <Account> >());
                Assert.Equal(1, results.Count());
                Assert.Equal(1, accounts.Count());

                Assert.Contains(DtoToModelTranslator.FromDto(account1, DateTime.Today, repositories), accounts);
                Assert.DoesNotContain(DtoToModelTranslator.FromDto(account2, DateTime.Today, repositories), accounts);
            }
        }
Esempio n. 17
0
        public void TestAccountStatePropertyValues()
        {
            using (var testDbInfo = SetupUtil.CreateTestDb())
            {
                //Arrange
                Mock <ILog>            mockLog          = new Mock <ILog>();
                AccountRepository      accountRepo      = new AccountRepository(testDbInfo.ConnectionString, mockLog.Object);
                AccountStateRepository accountStateRepo = new AccountStateRepository(testDbInfo.ConnectionString, mockLog.Object);

                RepositoryBag repositories = SetupUtil.CreateMockRepositoryBag(testDbInfo.ConnectionString, mockLog.Object, accountRepo, accountStateRepo);

                var accountDto = new AccountDto()
                {
                    Name        = "account",
                    Priority    = 5,
                    AccountKind = AccountKind.Sink
                };
                accountRepo.Upsert(accountDto);

                long     accountId = accountDto.Id.Value;
                Money    funds     = 123.45;
                DateTime timestamp = DateTime.Now;
                bool     isClosed  = false;

                AccountStateDto accountStateDto = new AccountStateDto()
                {
                    AccountId = accountId,
                    IsClosed  = isClosed,
                    Funds     = funds.InternalValue,
                    Timestamp = timestamp
                };
                accountStateRepo.Upsert(accountStateDto);

                long id = accountStateDto.Id.Value;


                //Act
                Account      account        = DtoToModelTranslator.FromDto(accountDto, DateTime.Today, repositories);
                AccountState state          = DtoToModelTranslator.FromDto(accountStateDto, repositories);
                var          propertyValues = state.GetPropertyValues().ToList();

                //Assert
                Assert.Equal(5, propertyValues.Count);

                Assert.Equal(id, propertyValues.First(x => x.Property.Equals(AccountState.PROP_ID)).Value);
                Assert.Equal(account, propertyValues.First(x => x.Property.Equals(AccountState.PROP_ACCOUNT)).Value);
                Assert.Equal(funds, propertyValues.First(x => x.Property.Equals(AccountState.PROP_FUNDS)).Value);
                Assert.Equal(isClosed, propertyValues.First(x => x.Property.Equals(AccountState.PROP_STATUS)).Value);
                Assert.Equal(timestamp, propertyValues.First(x => x.Property.Equals(AccountState.PROP_TIMESTAMP)).Value);
            }
        }
Esempio n. 18
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);

                AccountDto account1 = new AccountDto()
                {
                    Id          = null,
                    AccountKind = AccountKind.Sink,
                    Name        = "account1",
                    Priority    = 123,
                    Description = "account1 description",
                    CategoryId  = null
                };
                AccountDto account2 = new AccountDto()
                {
                    Id          = null,
                    AccountKind = AccountKind.Sink,
                    Name        = "account2",
                    Priority    = 5,
                    Description = "account2 description",
                    CategoryId  = null
                };

                UpsertAccount(account1, repositories);
                UpsertAccount(account2, repositories);

                DetailAccountCommand action = new DetailAccountCommand("detail account account1", repositories);
                action.NameOption.SetData("account1");

                ReadDetailsCommandResult <Account> result       = null;
                Mock <ICommandActionListener>      mockListener = new Mock <ICommandActionListener>();
                mockListener.Setup(x => x.OnCommand(It.IsAny <ReadDetailsCommandResult <Account> >())).Callback <ReadDetailsCommandResult <Account> >((y) => { result = y; });

                //Act
                bool successful = action.TryExecute(mockLog.Object, new [] { mockListener.Object });

                Account account = DtoToModelTranslator.FromDto(repo.GetById(1), DateTime.Today, repositories);

                //Assert
                Assert.True(successful);
                Assert.NotNull(result);
                Assert.Equal(account1.Id, result.Item.Id);
            }
        }
        public void AddAccountCommand_NoName()
        {
            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", out action);

                Assert.False(success);
                Assert.Null(action);
            }
        }
Esempio n. 20
0
        public void TestOpenAccount_BadAccountId()
        {
            using (var testDbInfo = SetupUtil.CreateTestDb())
            {
                //Arrange
                Mock <ILog>            log  = new Mock <ILog>();
                AccountStateRepository repo = new AccountStateRepository(testDbInfo.ConnectionString, log.Object);

                //Act
                bool successful = repo.ReOpenAccount(1);

                //Assert
                Assert.False(successful);
            }
        }
Esempio n. 21
0
        public void TestRemoveAllStatesByAccountId_InvalidAccount()
        {
            using (var testDbInfo = SetupUtil.CreateTestDb())
            {
                //Arrange
                Mock <ILog>            log  = new Mock <ILog>();
                AccountStateRepository repo = new AccountStateRepository(testDbInfo.ConnectionString, log.Object);

                //Act
                bool isSuccessful = repo.RemoveAllByAccountId(1);

                //Assert
                Assert.False(isSuccessful);
            }
        }
Esempio n. 22
0
        public void TestAccountAddFromDtoConstructor()
        {
            using (var testDbInfo = SetupUtil.CreateTestDb())
            {
                //Arrange
                Mock <ILog>       mockLog = new Mock <ILog>();
                AccountRepository repo    = new AccountRepository(testDbInfo.ConnectionString, mockLog.Object);

                AccountDto categoryDto = new AccountDto()
                {
                    Name        = "Test Category",
                    AccountKind = Data.Enums.AccountKind.Category,
                    CategoryId  = null,
                    Description = "",
                    Priority    = 3
                };
                repo.Upsert(categoryDto);

                AccountDto accountDto = new AccountDto()
                {
                    Name        = "Test Account",
                    AccountKind = Data.Enums.AccountKind.Source,
                    CategoryId  = categoryDto.Id,
                    Description = "",
                    Priority    = 7
                };
                repo.Upsert(accountDto);

                RepositoryBag repositories = SetupUtil.CreateMockRepositoryBag(testDbInfo.ConnectionString, mockLog.Object, repo);

                //Act
                Account account = new Account(accountDto.Id.Value, accountDto.Name, accountDto.CategoryId, accountDto.Priority, accountDto.AccountKind, accountDto.Description, DateTime.Today, repositories);

                Account category = account.Category;

                //Assert
                Assert.Equal("Test Account", account.Name);
                Assert.Equal(categoryDto.Id, account.CategoryId);
                Assert.Equal(7, account.Priority);
                Assert.Equal(Data.Enums.AccountKind.Source, account.AccountKind);


                Assert.Equal("Test Category", category.Name);
                Assert.Null(category.CategoryId);
                Assert.Equal(3, category.Priority);
                Assert.Equal(Data.Enums.AccountKind.Category, category.AccountKind);
            }
        }
        public void SystemCommand(string input, CommandKind expectedKind)
        {
            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(input, out action);

                Assert.True(success);
                Assert.NotNull(action);
                Assert.IsType(typeof(SystemCommand), action);
                Assert.Equal(expectedKind, ((SystemCommand)action).CommandKind);
            }
        }
        public void DetailAccountCommand_WithDate()
        {
            using (var testDbInfo = SetupUtil.CreateTestDb())
            {
                Mock <ILog> mockLog = new Mock <ILog>();

                AccountRepository      repo      = new AccountRepository(testDbInfo.ConnectionString, mockLog.Object);
                AccountStateRepository stateRepo = new AccountStateRepository(testDbInfo.ConnectionString, mockLog.Object);

                //Id will be 1
                repo.Upsert(new Data.Models.AccountDto()
                {
                    AccountKind = AccountKind.Source,
                    CategoryId  = null,
                    Description = "Description",
                    Name        = "Name",
                    Priority    = 5
                });
                stateRepo.Upsert(new Data.Models.AccountStateDto()
                {
                    AccountId = 1,
                    Funds     = 10,
                    IsClosed  = false,
                    Timestamp = DateTime.Today.AddDays(-10)
                });
                stateRepo.Upsert(new Data.Models.AccountStateDto()
                {
                    AccountId = 1,
                    Funds     = 100,
                    IsClosed  = false,
                    Timestamp = DateTime.Today
                });

                CommandInterpreter interpreter = new CommandInterpreter(SetupUtil.CreateMockRepositoryBag(testDbInfo.ConnectionString, mockLog.Object, repo, stateRepo), BudgetCliCommands.BuildCommandLibrary());

                ICommandAction action;
                bool           success = interpreter.TryParseCommand("detail account \"Name\" -d yesterday", out action);

                Assert.True(success);
                Assert.IsType <DetailAccountCommand>(action);

                DetailAccountCommand command = (DetailAccountCommand)action;
                Assert.Equal("Name", command.NameOption.GetValue("N/A"));
                Assert.Equal(DateTime.Today.AddDays(-1), command.DateOption.GetValue(null));
            }
        }
Esempio n. 25
0
        public void ListAccountCommand_NullListeners()
        {
            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);

                ListAccountCommand action = new ListAccountCommand("ls accounts", repositories);

                //Act
                bool successful = action.TryExecute(mockLog.Object, null);

                //Passes automatically if no exceptions were thrown
            }
        }
        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 DeleteAccountCommand_Recursive()
        {
            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("rm account test -r", out action);

                Assert.True(success);
                Assert.IsType <DeleteAccountCommand>(action);

                DeleteAccountCommand deleteAccount = (DeleteAccountCommand)action;
                Assert.Equal("test", deleteAccount.AccountName.GetValue(null));
                Assert.True(deleteAccount.IsRecursiveOption.GetValue(false));
            }
        }
        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();
            }
        }
Esempio n. 29
0
        public void TestTryDoAction()
        {
            using (var testDbInfo = SetupUtil.CreateTestDb())
            {
                Mock <ILog>   mockLog      = new Mock <ILog>();
                RepositoryBag repositories = SetupUtil.CreateMockRepositoryBag(testDbInfo.ConnectionString, mockLog.Object);

                SystemCommand command = new SystemCommand("version", CommandKind.Version);

                List <ICommandActionListener> listeners = new List <ICommandActionListener>();

                Mock <ICommandActionListener> mockListener = new Mock <ICommandActionListener>();
                mockListener.Setup(x => x.OnCommand(It.Is <SystemCommandResult>(x => x.CommandKind == CommandKind.Version && x.IsSuccessful && x.CommandAction == command))).Verifiable();

                listeners.Add(mockListener.Object);

                command.TryExecute(mockLog.Object, listeners);

                mockListener.VerifyAll();
            }
        }
Esempio n. 30
0
        public void TestTryDoAction()
        {
            using (var testDbInfo = SetupUtil.CreateTestDb())
            {
                Mock <ILog>   mockLog      = new Mock <ILog>();
                RepositoryBag repositories = SetupUtil.CreateMockRepositoryBag(testDbInfo.ConnectionString, mockLog.Object);

                HelpCommand command = new HelpCommand("new account -h", repositories, BudgetCliCommands.CMD_NEW_ACCOUNT);

                List <ICommandActionListener> listeners = new List <ICommandActionListener>();

                Mock <ICommandActionListener> mockListener = new Mock <ICommandActionListener>();
                mockListener.Setup(x => x.OnCommand(It.IsAny <HelpCommandResult>())).Verifiable();

                listeners.Add(mockListener.Object);

                command.TryExecute(mockLog.Object, listeners);

                mockListener.VerifyAll();
            }
        }