def test_checking_balance_of_closed_account_throws_error(self):
account = BankAccount()
account.open()
account.close()
with self.assertRaisesWithMessage(ValueError):
account.get_balance()
class TestBankAccount(unittest.TestCase):
def setUp(self):
self.acc = BankAccount("Sasho", 100, "dollars")
self.acc2 = BankAccount("Misho", 200, "dollars")
def test_init(self):
self.assertEqual(self.acc.get_name(), "Sasho")
self.assertEqual(self.acc.get_balance(), 100)
self.assertEqual(self.acc.get_currency(), "dollars")
def test_deposits(self):
self.acc.deposit(200)
self.assertEqual(self.acc.get_balance(), 300)
def test_withdraw(self):
self.acc.withdraw(100)
self.assertEqual(self.acc.get_balance(), 0)
def test_transfer(self):
self.acc.transfer_to(self.acc2, 100)
self.assertEqual(self.acc2.get_balance(), 300)
def test_history(self):
arr2 = self.acc.history(self.acc2, 50)
arr = ["Account was created", "Balance : "+str(self.acc.get_balance()), "Sasho transfered 50 dollars to Misho", "Balance : 100"]
self.assertEqual(arr, arr2)
def test_checking_balance_of_closed_account_throws_error(self):
account = BankAccount()
account.open()
account.close()
with self.assertRaisesWithMessage(ValueError):
account.get_balance()
def test_checking_balance_of_closed_account_throws_error(self):
account = BankAccount()
account.open()
account.close()
with self.assertRaises(ValueError) as err:
account.get_balance()
self.assertEqual(type(err.exception), ValueError)
self.assertEqual(err.exception.args[0], "account not open")
def test_can_withdraw_money(self):
account = BankAccount()
account.open()
account.deposit(100)
account.withdraw(50)
self.assertEqual(account.get_balance(), 50)
def test_can_deposit_money_sequentially(self):
account = BankAccount()
account.open()
account.deposit(100)
account.deposit(50)
self.assertEqual(account.get_balance(), 150)
def test_can_withdraw_money(self):
account = BankAccount()
account.open()
account.deposit(100)
account.withdraw(50)
self.assertEqual(account.get_balance(), 50)
def test_can_withdraw_money_sequentially(self):
account = BankAccount()
account.open()
account.deposit(100)
account.withdraw(20)
account.withdraw(80)
self.assertEqual(account.get_balance(), 0)
def test_reopened_account_does_not_retain_balance(self):
account = BankAccount()
account.open()
account.deposit(50)
account.close()
account.open()
self.assertEqual(account.get_balance(), 0)
def test_can_deposit_money_sequentially(self):
account = BankAccount()
account.open()
account.deposit(100)
account.deposit(50)
self.assertEqual(account.get_balance(), 150)
def test_reopened_account_does_not_retain_balance(self):
account = BankAccount()
account.open()
account.deposit(50)
account.close()
account.open()
self.assertEqual(account.get_balance(), 0)
def test_can_handle_concurrent_transactions(self):
account = BankAccount()
account.open()
account.deposit(1000)
self.adjust_balance_concurrently(account)
self.assertEqual(account.get_balance(), 1000)
def test_can_handle_concurrent_transactions(self):
account = BankAccount()
account.open()
account.deposit(1000)
self.adjust_balance_concurrently(account)
self.assertEqual(account.get_balance(), 1000)
def test_can_withdraw_money_sequentially(self):
account = BankAccount()
account.open()
account.deposit(100)
account.withdraw(20)
account.withdraw(80)
self.assertEqual(account.get_balance(), 0)
class BankAccountTest(unittest.TestCase):
"""
The main bank account testing class. Here we define various methods which specifically test our module for bugs and errors.
"""
def setUp(self):
self.account = BankAccount()
def test_newly_opened_account_has_zero_balance(self):
self.account.open()
self.assertEqual(self.account.get_balance(), 0)
def test_can_deposit_money(self):
self.account.open()
self.account.deposit(99)
self.assertEqual(self.account.get_balance(), 99)
def test_can_deposit_money_sequentially(self):
self.account.open()
self.account.deposit(20)
self.account.deposit(30)
self.assertEqual(self.account.get_balance(), 50)
def test_can_withdraw_money(self):
self.account.open()
self.account.deposit(10)
self.account.deposit(80)
self.account.withdraw(30)
self.account.withdraw(20)
self.assertEqual(self.account.get_balance(), 40)
def test_checking_balance_of_closed_account_throws_error(self):
self.account.open()
self.account.close()
with self.assertRaises(ValueError):
self.account.get_balance()
reply = 'OK reset'
elif cmd == 'w':
try:
amount = float(parameter)
bank_account.withdraw(amount)
reply = "OK withdrawl made"
except ValueError as ve:
reply = 'Error: ' + str(ve)
elif cmd == 'd':
try:
amount = float(parameter)
bank_account.deposit(amount)
reply = "OK deposit made"
except ValueError as ve:
reply = 'Error: ' + str(ve)
elif cmd == 'b':
bal = bank_account.get_balance()
reply = 'OK{:.2}'.format(bal)
else:
reply = 'Error: invalid command code'
conn.sendall(reply.encode('UTF-8'))
conn.shutdown(1)
conn.shutdown(0)
conn.close()
listener.close()
import person
from bank_account import BankAccount
joe = person.Person('Joe', '222-22-2222')
print(joe)
account = BankAccount(joe, 1200)
print(account.get_balance())
print(account)
class TestBankAccount(unittest.TestCase):
def setUp(self):
self.name = 'viki'
self.name2 = 'stenly'
self.balance = 1000000
self.currency = 'pound'
self.account = BankAccount(self.name, self.balance, self.currency)
self.account2 = BankAccount(self.name2, self.balance, self.currency)
def test_account_init(self):
self.assertEqual(self.account.name, self.name)
self.assertEqual(self.account.balance, self.balance)
self.assertEqual(self.account.currency, self.currency)
def test_account_str(self):
self.assertEqual(
str(self.account),
"Bank account for {} with balance of {}{}".format(
self.name,
self.balance,
self.currency
)
)
def test_account_int(self):
self.assertEqual(int(self.account), self.balance)
def test_get_balance(self):
self.assertEqual(self.account.balance, self.account.get_balance())
def test_account_deposit(self):
deposit_amount = 10000000
self.account.deposit(deposit_amount)
self.assertEqual(self.account.balance, self.balance + deposit_amount)
def test_account_withdraw_success(self):
initial_balance = self.account.balance
withdraw_amount = 1
result = self.account.withdraw(withdraw_amount)
self.assertTrue(result)
self.assertEqual(initial_balance - withdraw_amount, self.account.balance)
def test_account_withdraw_fail(self):
initial_balance = self.account.balance
withdraw_amount = 10000000000
result = self.account.withdraw(withdraw_amount)
self.assertFalse(result)
self.assertEqual(initial_balance, self.account.balance)
def test_account_transfer_to_success(self):
old_balance1 = self.account.balance
old_balance2 = self.account2.balance
transfer_amount = 10000
result = self.account.transfer_to(self.account2, transfer_amount)
self.assertTrue(result)
self.assertEqual(old_balance1 - transfer_amount, self.account.balance)
self.assertEqual(old_balance2 + transfer_amount, self.account2.balance)
def test_account_transfer_to_fails_currency(self):
self.account2.currency = 'BGN'
transfer_amount = 10000
result = self.account.transfer_to(self.account2, transfer_amount)
self.assertFalse(result)
def test_account_transfer_to_fails_amount(self):
self.account.balance = 1
transfer_amount = 10000
result = self.account.transfer_to(self.account2, transfer_amount)
self.assertFalse(result)
class BankAccountTest(unittest.TestCase):
def setUp(self):
self.account = BankAccount()
# @unittest.skip
def test_newly_opened_account_has_zero_balance(self):
self.account.open()
self.assertEqual(self.account.get_balance(), 0)
# @unittest.skip
def test_can_deposit_money(self):
self.account.open()
self.account.deposit(100)
self.assertEqual(self.account.get_balance(), 100)
# @unittest.skip
def test_can_deposit_money_sequentially(self):
self.account.open()
self.account.deposit(100)
self.account.deposit(50)
self.assertEqual(self.account.get_balance(), 150)
# @unittest.skip
def test_can_withdraw_money(self):
self.account.open()
self.account.deposit(100)
self.account.withdraw(50)
self.assertEqual(self.account.get_balance(), 50)
# @unittest.skip
def test_can_withdraw_money_sequentially(self):
self.account.open()
self.account.deposit(100)
self.account.withdraw(20)
self.account.withdraw(80)
self.assertEqual(self.account.get_balance(), 0)
# @unittest.skip
def test_checking_balance_of_closed_account_throws_error(self):
self.account.open()
self.account.close()
with self.assertRaises(ValueError):
self.account.get_balance()
# @unittest.skip
def test_deposit_into_closed_account(self):
self.account.open()
self.account.close()
with self.assertRaises(ValueError):
self.account.deposit(50)
# @unittest.skip
def test_withdraw_from_closed_account(self):
self.account.open()
self.account.close()
with self.assertRaises(ValueError):
self.account.withdraw(50)
# @unittest.skip
def test_cannot_withdraw_more_than_deposited(self):
self.account.open()
self.account.deposit(25)
with self.assertRaises(ValueError):
self.account.withdraw(50)
# @unittest.skip
def test_cannot_withdraw_negative(self):
self.account.open()
self.account.deposit(100)
with self.assertRaises(ValueError):
self.account.withdraw(-50)
# @unittest.skip
def test_cannot_deposit_negative(self):
self.account.open()
with self.assertRaises(ValueError):
self.account.deposit(-50)
# @unittest.skip
def test_can_handle_concurrent_transactions(self):
self.account.open()
self.account.deposit(1000)
for _ in range(10):
self.adjust_balance_concurrently()
# @unittest.skip
def adjust_balance_concurrently(self):
def transact():
self.account.deposit(5)
time.sleep(0.001)
self.account.withdraw(5)
# Greatly improve the chance of an operation being interrupted
# by thread switch, thus testing synchronization effectively
try:
sys.setswitchinterval(1e-12)
except AttributeError:
# For Python 2 compatibility
sys.setcheckinterval(1)
threads = []
for _ in range(1000):
t = threading.Thread(target=transact)
threads.append(t)
t.start()
for thread in threads:
thread.join()
self.assertEqual(self.account.get_balance(), 1000)
def test_zero_on_new_account(bank_account):
bank_account = BankAccount()
assert bank_account.get_balance() == 0
class TestBankAccount(unittest.TestCase):
def setUp(self):
self.my_account = BankAccount("Rado", 100, "$")
def test_create_new_account_instance(self):
# self.assertTrue(isinstance(self.my_account, BankAccount))
self.assertEqual(self.my_account.name, "Rado")
self.assertEqual(self.my_account.balance, 100)
self.assertEqual(self.my_account.currency, "$")
def test_int_cast(self):
self.assertEqual(int(self.my_account), 100)
def test_str_cast(self):
helper_str = "Bank account for Rado with balance of 100$"
self.assertEqual(str(self.my_account), helper_str)
def testing_the_current_balance(self):
self.assertEqual(100, self.my_account.get_balance())
def test_deposit_amount(self):
self.my_account.deposit(1000)
self.assertEqual(1100, self.my_account.balance)
def test_deposit_with_negative_amount(self):
with self.assertRaises(ValueError):
self.my_account.deposit(-110)
self.assertEqual(self.my_account.balance, 100)
def test_withdraw_amount(self):
self.assertTrue(self.my_account.withdraw(0))
def test_value_error_raises_from_greater_amount(self):
self.assertFalse(self.my_account.withdraw(110))
def test_value_error_raises_from_negative_balance(self):
with self.assertRaises(ValueError):
current_account = BankAccount("Ivo", -10, "$")
def test_type_error_raises_from_float_balance(self):
with self.assertRaises(TypeError):
current_account = BankAccount("Az", 0.25, "$")
def test_transfer_to_different_currency(self):
your_account = BankAccount("Ivo", 200, "&")
with self.assertRaises(ValueError):
self.my_account.transfer_to(your_account, 200)
self.assertEqual(self.my_account.balance, 1000)
self.assertEqual(your_account.balance, 200)
def test_transfert_more_money_than_we_have(self):
your_account = BankAccount("Ivo", 200, "$")
self.assertFalse(your_account.transfer_to(self.my_account, 300))
self.assertEqual(self.my_account.balance, 1000)
self.assertEqual(your_account.balance, 200)
def test_tranfer_to(self):
your_account = BankAccount("Ivo", 200, "$")
self.assertTrue(self.my_account.transfer_to(your_account, 50))
self.assertEqual(your_account.balance, 250)
self.assertEqual(my_account.balance, 50)
def test_newly_opened_account_has_zero_balance(self):
account = BankAccount()
account.open()
self.assertEqual(account.get_balance(), 0)
class BankAccountWindow(object):
def __init__(self, master):
self._master = master
self._master.title("BankAccount")
self._deposit_account_name = Entry(master, text='amount of money')
self._deposit_account_name.pack()
self._deposit_account_name.place(bordermode=OUTSIDE,
height=20,
width=200,
relx=0.035,
rely=0.05)
self._deposit_button = Button(master,
text='deposit money to your account',
command=self.deposit)
self._deposit_button.pack()
self._deposit_button.place(bordermode=OUTSIDE,
height=20,
width=200,
relx=0.035,
rely=0.115)
self._text_box = Text(master)
self._text_box.pack()
self._text_box.place(bordermode=OUTSIDE,
height=20,
width=200,
relx=0.035,
rely=0.185)
self._withdraw_account_name = Entry(master, text='amount of money2')
self._withdraw_account_name.pack()
self._withdraw_account_name.place(bordermode=OUTSIDE,
height=20,
width=200,
relx=0.365,
rely=0.05)
self._withdraw_button = Button(master,
text='withdraw money from your account',
command=self.withdraw)
self._withdraw_button.pack()
self._withdraw_button.place(bordermode=OUTSIDE,
height=20,
width=200,
relx=0.365,
rely=0.115)
self._text_box2 = Text(master)
self._text_box2.pack()
self._text_box2.place(bordermode=OUTSIDE,
height=20,
width=200,
relx=0.365,
rely=0.185)
self._get_name_button = Button(master,
text='click here to see your name',
command=self.get_name)
self._get_name_button.pack()
self._get_name_button.place(bordermode=OUTSIDE,
height=20,
width=200,
relx=0.695,
rely=0.05)
self._text_box3 = Text(master)
self._text_box3.pack()
self._text_box3.place(bordermode=OUTSIDE,
height=20,
width=200,
relx=0.695,
rely=0.115)
self._get_balance_button = Button(
master,
text='click here to see your balance',
command=self.get_balance)
self._get_balance_button.pack()
self._get_balance_button.place(bordermode=OUTSIDE,
height=20,
width=200,
relx=0.1925,
rely=0.325)
self._text_box4 = Text(master)
self._text_box4.pack()
self._text_box4.place(bordermode=OUTSIDE,
height=20,
width=200,
relx=0.1925,
rely=0.397)
self._get_number_button = Button(master,
text='click here to see your number')
self._get_number_button.pack()
self._get_number_button.place(bordermode=OUTSIDE,
height=20,
width=200,
relx=0.53,
rely=0.325)
self._text_box5 = Text(master)
self._text_box5.pack()
self._text_box5.place(bordermode=OUTSIDE,
height=20,
width=200,
relx=0.53,
rely=0.397)
self._new_account = BankAccount("yoav")
def deposit(self):
self._bank_account = self._new_account.deposit(
int(self._deposit_account_name.get()))
self._text_box.insert(END,
"your deposit is %d \n" % self._bank_account)
def withdraw(self):
self._bank_account = self._new_account.withdraw(
int(self._withdraw_account_name.get()))
self._text_box2.insert(END,
"your deposit is %d \n" % self._bank_account)
def get_name(self):
self._bank_account = self._new_account.get_name()
self._text_box3.insert(END, "your name is %s \n" % self._bank_account)
def get_balance(self):
self._bank_account = self._new_account.get_balance()
self._text_box4.insert(END,
"your balance is %d \n" % self._bank_account)
class BankAccountTest(unittest.TestCase):
def setUp(self):
self.account = BankAccount()
def test_newly_opened_account_has_zero_balance(self):
self.account.open()
self.assertEqual(self.account.get_balance(), 0)
def test_can_deposit_money(self):
self.account.open()
self.account.deposit(100)
self.assertEqual(self.account.get_balance(), 100)
def test_can_deposit_money_sequentially(self):
self.account.open()
self.account.deposit(100)
self.account.deposit(50)
self.assertEqual(self.account.get_balance(), 150)
def test_can_withdraw_money(self):
self.account.open()
self.account.deposit(100)
self.account.withdraw(50)
self.assertEqual(self.account.get_balance(), 50)
def test_can_withdraw_money_sequentially(self):
self.account.open()
self.account.deposit(100)
self.account.withdraw(20)
self.account.withdraw(80)
self.assertEqual(self.account.get_balance(), 0)
def test_checking_balance_of_closed_account_throws_error(self):
self.account.open()
self.account.close()
with self.assertRaises(ValueError):
self.account.get_balance()
def test_deposit_into_closed_account(self):
self.account.open()
self.account.close()
with self.assertRaises(ValueError):
self.account.deposit(50)
def test_withdraw_from_closed_account(self):
self.account.open()
self.account.close()
with self.assertRaises(ValueError):
self.account.withdraw(50)
def test_cannot_withdraw_more_than_deposited(self):
self.account.open()
self.account.deposit(25)
with self.assertRaises(ValueError):
self.account.withdraw(50)
def test_cannot_withdraw_negative(self):
self.account.open()
self.account.deposit(100)
with self.assertRaises(ValueError):
self.account.withdraw(-50)
def test_cannot_deposit_negative(self):
self.account.open()
with self.assertRaises(ValueError):
self.account.deposit(-50)
def test_can_handle_concurrent_transactions(self):
self.account.open()
self.account.deposit(1000)
for _ in range(10):
self.adjust_balance_concurrently()
def adjust_balance_concurrently(self):
def transact():
self.account.deposit(5)
time.sleep(0.001)
self.account.withdraw(5)
# Greatly improve the chance of an operation being interrupted
# by thread switch, thus testing synchronization effectively
try:
sys.setswitchinterval(1e-12)
except AttributeError:
# For Python 2 compatibility
sys.setcheckinterval(1)
threads = []
for _ in range(1000):
t = threading.Thread(target=transact)
threads.append(t)
t.start()
for thread in threads:
thread.join()
self.assertEqual(self.account.get_balance(), 1000)
def test_newly_opened_account_has_zero_balance(self):
account = BankAccount()
account.open()
self.assertEqual(account.get_balance(), 0)
class BankAccountTest(unittest.TestCase):
def setUp(self):
self.account = BankAccount("Joro", 10, "BGN")
def test_create_bank_account_class(self):
self.assertTrue(isinstance(self.account, BankAccount))
def test_is_name_valid_type(self):
with self.assertRaises(TypeError):
BankAccount(1000, 10, "BGN")
def test_is_balance_valid_type(self):
with self.assertRaises(TypeError):
BankAccount("Joro", "gosho", "BGN")
def test_is_currency_valid_type(self):
with self.assertRaises(TypeError):
BankAccount("Joro", 100, 1000)
def test_is_balance_positive_number(self):
with self.assertRaises(ValueError):
BankAccount("Joro", -10, "BGN")
def test_is_balance_private(self):
with self.assertRaises(AttributeError):
self.account.balance += 10
def test_is_amount_being_deposited(self):
old_balance = self.account.get_balance()
self.account.deposit(10)
new_balance = self.account.get_balance()
self.assertEqual(10, new_balance - old_balance)
def test_is_withdraw_possible_with_negative_number(self):
self.assertFalse(self.account.withdraw(-10))
def test_is_withdraw_possible_if_balance_not_enough(self):
self.assertFalse(self.account.withdraw(20))
def test_is_amount_multiple_by_10(self):
with self.assertRaises(ValueError):
self.account.withdraw(5)
def test_account_str_print(self):
self.assertEqual(str(self.account), "Bank account for Joro with balance of 10BGN")
def test_account_int_return(self):
self.assertEqual(int(self.account), 10)
def test_is_trasfer_possible_if_accounts_have_different_currencies(self):
kiro = BankAccount("Kiro", 50, "$")
self.assertFalse(self.account.transfer_to(kiro, 100))
def test_history_of_account_that_is_just_created(self):
self.assertEqual(["Account was created"], self.account.history())
def test_history_after_some_actions(self):
self.account.deposit(20)
self.account.get_balance()
int(self.account)
self.account.withdraw(20)
self.account.get_balance()
self.account.withdraw(50)
self.assertEqual(['Account was created', 'Deposited 20BGN', 'Balance check -> 30BGN', '__int__ check -> 30BGN', '20BGN was withdrawed', 'Balance check -> 10BGN', 'Withdraw for 50BGN failed.'], self.account.history())
