public void TestMakeTransfer_debit()
        {
            var operationsList = new List<Operation>();

            SIOperationRepository opRepository = new SIOperationRepository();
            opRepository.CreateOperationOperation = (x) =>
            {
                operationsList.Add(x);
            };

            SIAccountRepository acRepository = new SIAccountRepository();
            acRepository.UpdateAccountAccount = (x) =>
            {
                var acc1 = _accounts.SingleOrDefault(y => y.Id == x.Id);
                acc1.Operations = x.Operations;
            };

            AccountService service = new AccountService(acRepository, opRepository);
            service.MakeTransfer(_accounts[1], _accounts[0], 200);
            Assert.AreEqual(_accounts[1].Balance, 200);
            Assert.AreEqual(_accounts[0].Balance, 100);
            Assert.AreEqual(operationsList.Count, 2);
            Assert.AreEqual(_accounts[1].Operations.Count, 2);
            Assert.AreEqual(_accounts[0].Operations.Count, 3);
        }
Example #2
0
        public string Transfer(
            Account debitAccount,
            Account creditAccount,
            decimal amount,
            string motif
            )
        {
            MGuid.NewGuid = () => new Guid("64d80a10-4f21-4acb-9d3d-0332e68c4394");

            PexAssume.IsNotNull(debitAccount);
            PexAssume.IsNotNull(creditAccount);
            PexAssume.IsTrue(creditAccount != debitAccount);
            var repository          = new SIRepository();
            var operationRepository = new SIOperationRepository();
            var operationCreator    = new OperationDtoCreator();

            //act
            var operationServices = new OperationServices(operationRepository, repository, operationCreator);

            operationServices.Transfer(debitAccount, creditAccount, amount, motif);

            string result = operationServices.Transfer(debitAccount, creditAccount, amount, motif);

            PexAssert.IsNotNullOrEmpty(result);
            return(result);
        }
Example #3
0
        public List <Operation> GetOperationsForAccount(int accountID)
        {
            List <Operation> operations1 = new List <Operation>();

            operations1.Add(new Operation {
                Amount = 100, Direction = Domain.Direction.Credit
            });
            operations1.Add(new Operation {
                Amount = 200, Direction = Domain.Direction.Debit
            });


            List <Account> accounts = new List <Account>();

            accounts.Add(new Account {
                Balance = 300, Operations = operations1, AutorizeOverdraft = true, Id = 1
            });
            accounts.Add(new Account {
                Balance = 0, Operations = null, AutorizeOverdraft = false, Id = 2
            });

            SIAccountRepository accountRepository = new SIAccountRepository();

            accountRepository.GetAccountInt32 = (x) =>
            {
                return(accounts.SingleOrDefault(a => a.Id == x));
            };

            SIOperationRepository operationRepository = new SIOperationRepository();
            AccountService        service             = new AccountService(accountRepository, operationRepository);

            List <Operation> result = service.GetOperationsForAccount(accountID);

            return(result);
        }
Example #4
0
        public void TestMakeTransfer_debit()
        {
            var operationsList = new List <Operation>();

            SIOperationRepository opRepository = new SIOperationRepository();

            opRepository.CreateOperationOperation = (x) =>
            {
                operationsList.Add(x);
            };

            SIAccountRepository acRepository = new SIAccountRepository();

            acRepository.UpdateAccountAccount = (x) =>
            {
                var acc1 = _accounts.SingleOrDefault(y => y.Id == x.Id);
                acc1.Operations = x.Operations;
            };

            AccountService service = new AccountService(acRepository, opRepository);

            service.MakeTransfer(_accounts[1], _accounts[0], 200);
            Assert.AreEqual(_accounts[1].Balance, 200);
            Assert.AreEqual(_accounts[0].Balance, 100);
            Assert.AreEqual(operationsList.Count, 2);
            Assert.AreEqual(_accounts[1].Operations.Count, 2);
            Assert.AreEqual(_accounts[0].Operations.Count, 3);
        }
 public void MakeTransfer(Account creditAccount,Account debitAccount,decimal amount)
 {
     SIAccountRepository accountRepository = new SIAccountRepository();
     SIOperationRepository operationRepository = new SIOperationRepository();
     AccountService service = new AccountService(accountRepository, operationRepository);
     service.MakeTransfer(creditAccount, debitAccount, amount);
 }
Example #6
0
        public void MakeTransfer(Account creditAccount, Account debitAccount, decimal amount)
        {
            SIAccountRepository   accountRepository   = new SIAccountRepository();
            SIOperationRepository operationRepository = new SIOperationRepository();
            AccountService        service             = new AccountService(accountRepository, operationRepository);

            service.MakeTransfer(creditAccount, debitAccount, amount);
        }
        public void GetOperationsForAccount_AccountFound()
        {
            SIAccountRepository accountRepository = new SIAccountRepository();
            accountRepository.GetAccountInt32 = (x) =>
            {
                return _accounts.SingleOrDefault(a => a.Id == x);
            };

            SIOperationRepository operationRepository = new SIOperationRepository();
            AccountService service = new AccountService(accountRepository, operationRepository);

            List<Operation> result = service.GetOperationsForAccount(1);
            Assert.AreEqual(result.Count, 2);
        }
        public void MakeTransfer(int debitAccountId, int creditAccountId, decimal amount, string motif)
        {
            PexAssume.IsTrue(amount > 100);

            var repository = new SIRepository();
            repository.GetObject<Account>((x) => _accounts.SingleOrDefault(a => a.Id == (int)x));

            var operationRepository = new SIOperationRepository();
            var operationCreator = new OperationDtoCreator();

            //act
            var operationServices = new OperationServices(operationRepository, repository, operationCreator);
            operationServices.MakeTransfer(debitAccountId, creditAccountId, amount, motif);
        }
Example #9
0
        public decimal ComputeInterest(Account account, double annualRate, int months)
        {
            PexAssume.Implies(account != null, () => account.Balance = 1000);
            PexAssume.IsTrue(annualRate != 0);
            PexAssume.IsTrue(months != 0);

            SIAccountRepository   accountRepository   = new SIAccountRepository();
            SIOperationRepository operationRepository = new SIOperationRepository();

            AccountService service = new AccountService(accountRepository, operationRepository);

            decimal result = service.ComputeInterest(account, annualRate, months);

            return(result);
        }
        public decimal ComputeInterest(Account account,double annualRate,int months)
        {
            PexAssume.Implies(account != null, () => account.Balance = 1000);
            PexAssume.IsTrue(annualRate != 0);
            PexAssume.IsTrue(months != 0);

            SIAccountRepository accountRepository = new SIAccountRepository();
            SIOperationRepository operationRepository = new SIOperationRepository();

            AccountService service = new AccountService(accountRepository, operationRepository);

            decimal result = service.ComputeInterest(account, annualRate, months);

            return result;
        }
Example #11
0
        public void MakeTransfer(int debitAccountId, int creditAccountId, decimal amount, string motif)
        {
            PexAssume.IsTrue(amount > 100);

            var repository = new SIRepository();

            repository.GetObject <Account>((x) => _accounts.SingleOrDefault(a => a.Id == (int)x));

            var operationRepository = new SIOperationRepository();
            var operationCreator    = new OperationDtoCreator();

            //act
            var operationServices = new OperationServices(operationRepository, repository, operationCreator);

            operationServices.MakeTransfer(debitAccountId, creditAccountId, amount, motif);
        }
Example #12
0
        public void GetOperationsForAccount_AccountFound()
        {
            SIAccountRepository accountRepository = new SIAccountRepository();

            accountRepository.GetAccountInt32 = (x) =>
            {
                return(_accounts.SingleOrDefault(a => a.Id == x));
            };

            SIOperationRepository operationRepository = new SIOperationRepository();
            AccountService        service             = new AccountService(accountRepository, operationRepository);

            List <Operation> result = service.GetOperationsForAccount(1);

            Assert.AreEqual(result.Count, 2);
        }
        public List<Operation> GetOperationsForAccount(int accountID)
        {
            List<Operation> operations1 = new List<Operation>();
            operations1.Add(new Operation { Amount = 100, Direction = Domain.Direction.Credit });
            operations1.Add(new Operation { Amount = 200, Direction = Domain.Direction.Debit });

            List<Account> accounts = new List<Account>();
            accounts.Add(new Account { Balance = 300, Operations = operations1, AutorizeOverdraft = true, Id = 1 });
            accounts.Add(new Account { Balance = 0, Operations = null, AutorizeOverdraft = false, Id = 2 });

            SIAccountRepository accountRepository = new SIAccountRepository();
            accountRepository.GetAccountInt32 = (x) =>
            {
                return accounts.SingleOrDefault(a => a.Id == x);
            };

            SIOperationRepository operationRepository = new SIOperationRepository();
            AccountService service = new AccountService(accountRepository, operationRepository);

            List<Operation> result = service.GetOperationsForAccount(accountID);
            return result;
        }
        public string Transfer(
            Account debitAccount,
            Account creditAccount,
            decimal amount,
            string motif
        )
        {
            MGuid.NewGuid = () => new Guid("64d80a10-4f21-4acb-9d3d-0332e68c4394");

            PexAssume.IsNotNull(debitAccount);
            PexAssume.IsNotNull(creditAccount);
            PexAssume.IsTrue(creditAccount != debitAccount);
            var repository = new SIRepository();
            var operationRepository = new SIOperationRepository();
            var operationCreator = new OperationDtoCreator();

            //act
            var operationServices = new OperationServices(operationRepository, repository, operationCreator);
            operationServices.Transfer(debitAccount, creditAccount, amount, motif);

            string result = operationServices.Transfer(debitAccount, creditAccount, amount, motif);
            PexAssert.IsNotNullOrEmpty(result);
            return result;
        }