def test_should_transfer_a_amount_between_two_accounts(self): senderinitialamount = Amount(1000) sender = BankAccount("123", senderinitialamount, AccountType.CHECKING, 10) receiverinitialamount = Amount(2000) receiver = BankAccount("123", receiverinitialamount, AccountType.SAVINGS, 12) transferamount = Amount(750) banktransfer = BankTransfer(sender, receiver, transferamount) transferrecord = banktransfer.transfer() expectedamountsender = (senderinitialamount - transferamount) senderbalance = sender.getbalance() expectedamountreceiver = (receiverinitialamount + transferamount) receiverbalance = receiver.getbalance() transferrecordsender = transferrecord[0] transferrecordreceiver = transferrecord[1] self.assertEqual(expectedamountsender, senderbalance) self.assertEqual(expectedamountreceiver, receiverbalance) self.assertEqual(transferrecordsender.getamount(), -int(transferamount)) self.assertEqual(transferrecordsender.getoperation(), BankOperationType.TRANSFER) self.assertEqual(transferrecordreceiver.getamount(), int(transferamount)) self.assertEqual(transferrecordreceiver.getoperation(), BankOperationType.TRANSFER)
def test_should_not_withdraw_an_amount_when_the_balance_amount_is_less_that_amount( self): initialbalance = Amount(100) account = BankAccount("123", initialbalance, AccountType.SAVINGS) withdrawamount = Amount(1000000) with self.assertRaises(ValueError): account.withdraw(withdrawamount)
def test_not_should_start_a_bank_transfer_when_the_sender_is_an_invalid_account( self): sender = "receiver" receiveramount = Amount(2000) receiver = BankAccount("123", receiveramount, AccountType.SAVINGS) transferamount = Amount(750) with self.assertRaises(TypeError): BankTransfer(sender, receiver, transferamount)
def test_not_should_start_a_bank_transfer_when_the_transfer_amount_is_an_invalid( self): senderamount = Amount(1000) sender = BankAccount("123", senderamount, AccountType.CHECKING) receiveramount = Amount(2000) receiver = BankAccount("123", receiveramount, AccountType.SAVINGS) transferamount = 750 with self.assertRaises(TypeError): BankTransfer(sender, receiver, transferamount)
def test_should_receive_an_amount_and_increase_the_current_amount(self): initialbalance = Amount(0) account = BankAccount("123", initialbalance, AccountType.SAVINGS) receiveAmount = Amount(100) account.receive(receiveAmount) newbalance = account.getbalance() expectedbalance = (initialbalance + receiveAmount) self.assertEqual(newbalance, expectedbalance)
def test_should_withdraw_an_amount_and_decrease_the_current_amount(self): initialbalance = Amount(100) account = BankAccount("123", initialbalance, AccountType.SAVINGS) withdrawamount = Amount(10) account.withdraw(withdrawamount) newbalance = account.getbalance() expectedbalance = (initialbalance - withdrawamount) self.assertEqual(newbalance, expectedbalance)
def test_should_be_created_bank_account_in_valid_state(self): balance = Amount(0) account = BankAccount("123", balance, AccountType.SAVINGS) self.assertIsInstance(account, BankAccount) self.assertIsNotNone(account)
def test_not_should_start_a_bank_draft_when_the_target_is_an_invalid_account(self): target = "Hype" transferamount = Amount(100) with self.assertRaises(TypeError): BankDraft(target, transferamount)
def test_should_not_be_created_bank_account_with_invalid_account_type( self): balance = Amount(0) with self.assertRaises(TypeError): BankAccount("123", balance, 22)
def test_should_to_withdraw_a_amount_in_a_account(self): initialbalance = Amount(1000) target = BankAccount("123", initialbalance, AccountType.SAVINGS, 10) transferamount = Amount(100) bankdraft = BankDraft(target, transferamount) withdrawrecord = bankdraft.towithdraw() newbalance = target.getbalance() expectedbalance = (initialbalance - transferamount) self.assertEqual(newbalance, expectedbalance) self.assertEqual(withdrawrecord.getamount(), -int(transferamount)) self.assertEqual(withdrawrecord.getoperation(), BankOperationType.WITHDRAW)
def test_not_should_start_a_bank_deposit_when_the_receiver_is_an_invalid_account( self): receiver = "ibrain" transferamount = Amount(100) with self.assertRaises(TypeError): BankDeposit(receiver, transferamount)
def test_should_deposit_a_amount_in_a_account(self): initialbalance = Amount(1000) receiver = BankAccount("123", initialbalance, AccountType.CHECKING, 10) transferamount = Amount(100) bankdeposit = BankDeposit(receiver, transferamount) depositrecord = bankdeposit.todeposit() newbalance = receiver.getbalance() expectedbalance = (initialbalance + transferamount) self.assertEqual(newbalance, expectedbalance) self.assertEqual(depositrecord.getamount(), int(transferamount)) self.assertEqual(depositrecord.getoperation(), BankOperationType.DEPOSIT)
def execute(self, balance, accounttype): number = str(random.randint(1, 999999999999999999)) balance = Amount(balance) accounttype = AccountType(accounttype) newbankaccount = BankAccount(number, balance, accounttype) self.__bankaccountrepository.add(newbankaccount) self.__session.commit()
def test_not_should_start_a_bank_draft_when_the_transfer_amount_is_an_invalid(self): balance = Amount(1000) target = BankAccount("123", balance, AccountType.SAVINGS) transferamount = 100 with self.assertRaises(TypeError): BankDraft(target, transferamount)
def test_not_should_start_a_bank_deposit_when_the_transfer_amount_is_an_invalid( self): balance = Amount(1000) receiver = BankAccount("123", balance, AccountType.CHECKING) transferamount = 100 with self.assertRaises(TypeError): BankDeposit(receiver, transferamount)
def test_should_not_withdraw_an_amount_when_amount_is_invalid(self): initialbalance = Amount(100) account = BankAccount("123", initialbalance, AccountType.SAVINGS) withdrawamount = 10 with self.assertRaises(TypeError): account.withdraw(withdrawamount)
def test_should_not_receive_an_amount_when_amount_is_invalid(self): initialbalance = Amount(0) account = BankAccount("123", initialbalance, AccountType.SAVINGS) receiveAmount = 100 with self.assertRaises(TypeError): account.receive(receiveAmount)
def test_not_should_register_a_bank_transaction_when_the_amount_is_invalid( self): whenoccurred = datetime.now() amount = Amount(100) description = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" with self.assertRaises(TypeError): BankTransactionRecord(BankOperationType.DEPOSIT, "123", whenoccurred, amount, description, 1)
def findperaccountnumber(self, targetaccountnumber): bankcccountmap = self.__session.query(BankAccountMap).filter_by( number=targetaccountnumber).first() # TODO: Possible encapsulation number = targetaccountnumber balance = Amount(bankcccountmap.balance) accounttype = AccountType(bankcccountmap.type) id = bankcccountmap.id return BankAccount(number, balance, accounttype, id)
def execute(self, targetaccountnumber, withdrawamount): #Validar targetaccountnumber withdrawamount = Amount(withdrawamount) targetaccount = self.__bankaccountrepository.findperaccountnumber( targetaccountnumber) bankdraft = BankDraft(targetaccount, withdrawamount) banktransactionrecord = bankdraft.towithdraw() self.__bankaccountrepository.update(targetaccount) self.__banktransactionrecordrepository.add(banktransactionrecord) self.__session.commit()
def execute(self, receiveraccountnumber, depositamount): #Validar targetaccountnumber depositamount = Amount(depositamount) receiveraccount = self.__bankaccountrepository.findperaccountnumber( receiveraccountnumber) bankdeposit = BankDeposit(receiveraccount, depositamount) banktransactionrecord = bankdeposit.todeposit() self.__bankaccountrepository.update(receiveraccount) self.__banktransactionrecordrepository.add(banktransactionrecord) self.__session.commit()
def execute(self, senderaccountnumber, receiveraccountnumber, transferamount): #Validar targetaccountnumber transferamount = Amount(transferamount) senderaccount = self.__bankaccountrepository.findperaccountnumber( senderaccountnumber) receiveraccount = self.__bankaccountrepository.findperaccountnumber( receiveraccountnumber) banktransfer = BankTransfer(senderaccount, receiveraccount, transferamount) banktransactionrecords = banktransfer.transfer() self.__bankaccountrepository.update(senderaccount) self.__bankaccountrepository.update(receiveraccount) self.__banktransactionrecordrepository.addmultiple( banktransactionrecords) self.__session.commit()
def __init__(self): self.__CHECKING_LIMIT_WITHDRAWAL = Amount(6000) self.__CHECKING_LIMIT_RECEIVE = Amount(8000)
def __init__(self): self.__SAVINGS_LIMIT_WITHDRAWAL = Amount(2500) self.__SAVINGS_LIMIT_RECEIVE = Amount(5000)