class BankAcount(unittest.TestCase):
def setUp(self):
self.ba = BankAccount("rado", 500, "$")
def tearDown(self):
pass
def tets_create_new_BankAccount_class(self):
self.assertEqual(self.ba.history(),"Account was created")
self.assertTrue(isinstance(self.ba, BankAccount))
def test_create_int_value_from_BankAccount(self):
self.assertEqual(int(self.ba), 500)
def test__str__in_BankAccount(self):
self.assertEqual(str(self.ba),"Bank account for rado with balance of 500$")
def test_balance(self):
self.assertEqual(self.ba.balance(),500)
def test_transfer_to(self):
maria = BankAccount("Maria",200,"$")
self.assertEqual(self.ba.transfer_to(maria,"$"),True)
with self.assertRaises(TypeError) :
self.ba.transfer_to("maria","$")
def test_withdraw(self):
self.assertTrue(self.ba.withdraw(200))
self.assertFalse(self.ba.withdraw(900))
def test_deposit(self):
d = 1000
self.ba.deposit(500)
self.assertEqual(self.ba.balance(),1000)
class BankAccountTest(unittest.TestCase):
def setUp(self):
self.acc_name = "Ivan"
self.acc_balance = 200
self.acc_curr = "$"
self.bank_acc = BankAccount(self.acc_name, self.acc_balance, self.acc_curr)
self.test_dep_value = 1000
self.test_str_dun = "Bank account for Ivan with balance of 200$"
self.test_hist_str = ['Account was created', 'Deposited 1000$', 'Balance check -> 1200$', \
'__int__ check -> 1200$']
def test_create_new_bank_instance(self):
self.assertTrue(isinstance(self.bank_acc, BankAccount))
def test_method_deposit(self):
new_balance = self.bank_acc.balance() + self.test_dep_value
self.bank_acc.deposit(self.test_dep_value)
self.assertEqual(new_balance, self.bank_acc.balance())
def test_method_balance(self):
self.assertEqual(self.bank_acc.balance(), self.acc_balance)
def test_str_dunder(self):
self.assertEqual(self.test_str_dun, str(self.bank_acc))
def test_history(self):
self.bank_acc.deposit(self.test_dep_value)
self.bank_acc.balance()
int(self.bank_acc)
self.assertEqual(self.bank_acc.history(), self.test_hist_str)
class TestBankAccount(unittest.TestCase):
def setUp(self):
self.account = BankAccount("Vladko", 2000, "RON")
self.account1 = BankAccount("Phillip", 4114, "RON")
def test_init(self):
self.assertEqual(self.account.get_name(), "Vladko")
self.assertEqual(self.account1.get_name(), "Phillip")
self.assertEqual(self.account.get_currency(), "RON")
self.assertTrue(self.account.get_currency() == self.account1.get_currency())
def test_str(self):
self.assertEqual(str(self.account), "Bank account for Vladko with balance of 2000 RON")
self.assertEqual(str(self.account1), "Bank account for Phillip with balance of 4114 RON")
def test_get_name(self):
self.assertEqual(self.account.get_name(), "Vladko")
def test_get_currency(self):
self.assertEqual(self.account1.get_currency(), "RON")
def test_int(self):
self.assertEqual(int(self.account), 2000)
self.assertEqual(int(self.account1), 4114)
def test_history(self):
self.assertEqual(self.account.history(), ['Account was created.'])
def test_deposit(self):
self.account.deposit(213)
self.assertEqual(int(self.account), 2213)
self.account1.deposit(400)
self.assertEqual(int(self.account1), 4514)
def test_balance(self):
self.assertEqual(self.account.balance(), 2000)
def test_withdraw(self):
self.account.withdraw(1200)
self.assertEqual(self.account.balance(), 800)
self.account1.withdraw(10000)
self.assertEqual(self.account1.balance(), 4114)
def test_transfer(self):
self.account1.transfer_to(self.account, 114)
self.assertEqual(int(self.account), 2114)
self.assertEqual(int(self.account1), 4000)
def test_history(self):
self.assertEqual(self.account.history(), ['Account was created.'])
def test_transfer_to(self):
self.my_account.amount = 1000
# CHECK CURRENCY
ivo = BankAccount("Ivo", 0, "BGN")
self.assertFalse(self.my_account.transfer_to(ivo, 600))
ivo.currency = '$'
# CHECK IF MONEY IS ENOUGH
self.assertFalse(
self.my_account.transfer_to(ivo, self.transfered_money_false))
self.assertTrue(
self.my_account.transfer_to(ivo, self.transfered_money_true))
# CHECK IF MONEY HAS CHANGED, TRANSFERED
ivo.amount = 0
self.my_account.amount = 1000
self.my_account.transfer_to(ivo, 200)
self.assertEqual(self.my_account.balance(), 800)
self.assertEqual(ivo.balance(), 200)
class TestBankAccout(unittest.TestCase):
def setUp(self):
self.name = "Rado"
self.amount = 0
self.currency = '$'
self.my_account = BankAccount(self.name, self.amount, self.currency)
self.deposited_money = 1000
self.deposited_money_negative = -1000
self.withdrawed_money_true = 500
self.withdrawed_money_false = 1000
self.transfered_money_true = 500
self.transfered_money_false = 2000
def test_init(self):
self.assertTrue(isinstance(self.my_account, BankAccount))
self.assertEqual(self.my_account.name, self.name)
self.assertEqual(self.my_account.amount, self.amount)
self.assertEqual(self.my_account.currency, self.currency)
def test_deposit(self):
current_balance = self.my_account.balance()
self.my_account.deposit(self.deposited_money)
self.assertEqual(self.my_account.amount,
current_balance + self.deposited_money)
with self.assertRaises(ValueError):
self.my_account.deposit(self.deposited_money_negative)
def test_balance(self):
self.assertEqual(self.my_account.balance(), self.my_account.amount)
def test_withdraw(self):
self.my_account.amount = 1000
self.assertTrue(self.my_account.withdraw(self.withdrawed_money_true))
self.assertFalse(self.my_account.withdraw(self.withdrawed_money_false))
self.my_account.withdraw(self.withdrawed_money_false)
self.my_account.amount = 1000
current_balance = self.my_account.balance()
self.assertEqual(self.my_account.balance(), current_balance)
current_balance = self.my_account.balance()
self.my_account.withdraw(self.withdrawed_money_true)
self.assertEqual(self.my_account.balance(),
current_balance - self.withdrawed_money_true)
def test_str(self):
wanted_result = "Bank account for {} with balance of {}{}".format(
self.my_account.name, self.my_account.amount,
self.my_account.currency)
self.assertEqual(str(self.my_account), wanted_result)
def test_int(self):
self.assertEqual(int(self.my_account), self.my_account.balance())
def test_transfer_to(self):
self.my_account.amount = 1000
# CHECK CURRENCY
ivo = BankAccount("Ivo", 0, "BGN")
self.assertFalse(self.my_account.transfer_to(ivo, 600))
ivo.currency = '$'
# CHECK IF MONEY IS ENOUGH
self.assertFalse(
self.my_account.transfer_to(ivo, self.transfered_money_false))
self.assertTrue(
self.my_account.transfer_to(ivo, self.transfered_money_true))
# CHECK IF MONEY HAS CHANGED, TRANSFERED
ivo.amount = 0
self.my_account.amount = 1000
self.my_account.transfer_to(ivo, 200)
self.assertEqual(self.my_account.balance(), 800)
self.assertEqual(ivo.balance(), 200)
def test_history(self):
# Account Creation
self.assertEqual(self.my_account.history()[0], 'Account was created')
# Deposit
self.my_account.deposit(1000)
trueString = 'Deposited 1000' + self.my_account.currency
self.assertEqual(self.my_account.history()[-1], trueString)
# Balance
self.my_account.balance()
trueString = 'Balance check -> ' + \
str(self.my_account.balance()) + self.my_account.currency
self.assertEqual(self.my_account.history()[-1], trueString)
# Int transformation
trueString = '__int__ check -> ' + \
str(self.my_account.balance()) + self.my_account.currency
int(self.my_account)
self.assertEqual(self.my_account.history()[-1], trueString)
# Successfull withdraw
self.my_account.withdraw(500)
trueString = '500' + self.my_account.currency + \
' was withdrawed'
self.assertEqual(self.my_account.history()[-1], trueString)
# Failed withdraw
self.my_account.withdraw(1000)
trueString = 'Withdraw for {}{} failed.'.format(
1000, self.my_account.currency)
self.assertEqual(self.my_account.history()[-1], trueString)
# Transfer
ivo = BankAccount("Ivo", 0, "$")
self.my_account = BankAccount("Rado", 1000, "$")
self.my_account.transfer_to(ivo, 500)
trueString_Rado = 'Transfer to {} for {}{}'.format(
ivo.name, 500, self.my_account.currency)
trueString_Ivo = 'Transer from {} for {}{}'.format(
self.my_account.name, 500, ivo.currency)
self.assertEqual(self.my_account.history()[-1], trueString_Rado)
self.assertEqual(ivo.history()[-1], trueString_Ivo)
