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 AccountBalanceTestCases(unittest.TestCase): def setUp(self): self.my_account = BankAccount(90) def test_balance(self): self.assertEqual(self.my_account.balance, 90, msg='Account Balance Invalid') def test_deposit(self): self.my_account.deposit(90) self.assertEqual(self.my_account.balance, 180, msg='Deposit method inaccurate') def test_withdraw(self): self.my_account.withdraw(40) self.assertEqual(self.my_account.balance, 50, msg='Withdraw method inaccurate') def test_invalid_operation(self): self.assertEqual(self.my_account.withdraw(1000), "invalid transaction", msg='Invalid transaction') def test_sub_class(self): self.assertTrue(issubclass(MinimumBalanceAccount, BankAccount), msg='No true subclass of BankAccount')
def test_deposit(self): dep_1 = BankAccount("gigi").deposit(2000) dep_2 = BankAccount("gigi").deposit(3000) dep_3 = BankAccount("gigi").deposit(-6000) self.assertEqual(dep_1, "The amount you want to deposit is $2000.00") self.assertEqual(dep_2, "The amount you want to deposit is $3000.00") self.assertEqual(dep_3, "The amount you entered is incorrect!")
def test_withdraw(self): widraw_1 = BankAccount("gigi").withdraw(1000) widraw_2 = BankAccount("gigi").withdraw(3000) self.assertEqual( widraw_1, "The amount of $1000.00 had been withdrawed from your account! \n" "Your Balance is $1000.00") self.assertEqual(widraw_2, "The amount you entered is grater than the balance!") with self.assertRaises(ValueError): BankAccount("gigi").withdraw(-6000)
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 __init__(self,db_file): ''' (Bank,str)-> NoneType initialize the Bank database from a file given as argument ''' self._database = set() handle = open(db_file,"r") lines = handle.readlines() for line in lines: data = line.split(",") p = Person(data[0],data[1],data[2]) a = BankAccount(p) a.credit(int(data[3])) self._database.add(a)
class TestBankAccount(unittest.TestCase): # test case """ Unit Test for the BankAccount Class """ def setUp(self): # test fixture # print('setup called') self.ing = BankAccount('mila', 500) self.bnp = BankAccount('alex', 2000) def test_deposit(self): """ testing the deposit method """ self.ing.deposit(200) self.bnp.deposit(500) self.assertEqual(self.ing.balance, 700) self.assertEqual(self.bnp.balance, 2500) def test_withdraw(self): """ testing the withdraw method """ self.ing.withdraw(400) self.bnp.withdraw(1200) self.assertEqual(self.ing.balance, 100) self.assertEqual(self.bnp.balance, 800) self.assertRaises(ValueError, self.ing.withdraw, 500)
class User: # here's what we have so far def __init__(self, name, email): self.name = name self.email = email self.account = BankAccount(4.0) # adding the deposit method def make_deposit( self, amount): # takes an argument that is the amount of the deposit self.account.deposit(amount) return self def make_withdrawl(self, amount): self.account.withdraw(amount) return self def display_user_balance(self): self.account.display_account_info() return self def transfer_money(self, other_user, amount): other_user.account.deposit(amount) self.account.withdraw(amount) return self
def createBankAccount(self, name, acctType, balance=0): accountNum = self.__getNextAccountNum() if accountNum in self.__bankAccounts: return DUPLICATE_NUMBER newBankAccount = BankAccount(accountNum, name, acctType, name) self.__bankAccounts[accountNum] = newBankAccount return accountNum
def load_records(database_file): """\ Opens the specified local database file with the bank account records and store the records in-memory for usage with the aid of the dictionary data structure. Checks that the argument 'database_file' passed in is of type 'str' else an 'Exception' is raised. If the specified database file doesn't exist an 'Exception' is raised. :param database_file: Name of the database file to load records from :return: Dictionary data structure with the bank account records """ if type(database_file) != str: raise Exception( "Invalid argument: database_file of type {} should be: <class 'str'>" .format(type(database_file))) database = DatabaseConnection(database_file) records = dict() result_set = database.sql_statement(database.READ, "SELECT * FROM accounts") for record in result_set: # grab each record from the result-set records[record[4]] = BankAccount(record[0], record[1], record[2], record[3]) database.close() return records
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 create_account(self, first_name: str, last_name: str, initial_deposit: float, preferred_tz) -> BankAccount: self._last_account_number += 1 new_account = BankAccount(first_name, last_name, self._last_account_number, initial_deposit, preferred_tz) self._active_accounts.append(new_account) return new_account
class User: def __init__(self, name, email): self.name = name self.email = email self.account = BankAccount() def deposit(self, amount): self.account.deposit(amount) def make_withdrawal(self, amount): return self.account.withdraw(amount) def display_user_balance(self): self.account.display_account_info() print(f"{self.name} balance is:{self.balance}") def transfer_money(self,other_user,amount): if self.withdrawal(amount): other_user.deposit(amount) return True return False
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$']
class user: def _int_(self, name, year_of_birth, balance=0): self.name = name self.year_of_birth = year_of_birth self.account = BankAccount() def make_withdrawal(self, amount): return self.account.withdraw(amount) def display_user_balance(self): print(f"{self.name} Balance is:", end=" ") def deposit(self, amount): self.account.deposit(amount) def transfer_money(self, other_user, amount): if self.make_withdrawal(amount): other_user.deposit(amount) return True return False
def bankAccountCreate(bankAccount): b = bankAccount dbAcnt = BankAccount(name=b['name'], description=b['description'], bankName=b['bankName'], ifscCode=b['ifscCode'], accountNumber=b['accountNumber'], interestRate=b['interestRate'], mab=b['mab']).save() print("BankAccount", colored(dbAcnt.name), "created")
def create_account(user_name, initial_deposit, password): """ :param user_name: User name to create a Bank Account for :param initial_deposit: The initial amount user wants to deposit into account :return: None """ bank_acc = BankAccount(user_name, initial_deposit, password) accounts[user_name] = bank_acc print("\nThank you! Here is your Bank info: ") print("Name: {}".format(bank_acc.name.title())) print("Acccount Number: {}".format(bank_acc.accnum)) print("Balance: ${:.2f}\n\n".format(int(bank_acc.balance)))
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)
def main(): populate_database() while True: try: # To Test please use 123,5678 or 6788 customer_id = input( "Please enter customer ID, Use Cust_id=123 or 5678 or 6788: ") if not customer_id: break choice = int(input("Please enter 1-Deposit or 2-Withdraw: ")) if choice == 1: b = BankAccount(cust_id=customer_id) amt = int(input("Please enter the amount to deposit: ")) b.deposit(cust_id=customer_id, amount=amt) elif choice == 2: b = BankAccount(cust_id=customer_id) amt = int(input("Please enter the amount to withdraw: ")) b.withdraw(cust_id=customer_id, amount=amt) except ValueError: print("Oops! Invalid values Try again...")
def _account_selection(account_names, accounts): choice = raw_input('Welcome to the Family Banking App. Who is this?') if choice not in account_names: print( 'This person does not have an account. The people with accounts are: ' + ', '.join(account_names) + '.') new_account = _request_user_input( 'Do you wish to make an account for ' + choice + '? (Y/N)', ['Y', 'N'], 'Invalid response. Try again.') if new_account == 'Y': amount_to_deposit = raw_input( 'How much would you like to deposit in this (' + choice + '\'s) account?') accounts.append(BankAccount(choice, float(amount_to_deposit))) account_names.append(choice) return choice else: print('Try again, then. Who is this?') choice = _account_selection(account_names, accounts) return choice return choice
def parse_text_file(self, text_file): bank_account = BankAccount() for row_index, row in enumerate(text_file): if (row_index + 1) % 4 == 0: self.accounts.append(bank_account) bank_account = BankAccount() else: strip_row = row.rstrip() for digit_index, index in enumerate(range( 0, len(strip_row), 3)): value = list(strip_row[index:index + 3]) if len(value) < 3: value.append(' ') bank_account.set_row(digit_index=digit_index, row_index=row_index % 4, value=value)
class user: def __init__(self, name, email): self.name = name self.email = email self.account = BankAccount() def make_deposite(self, amount): self.account.deposit(amount) def make_withdrawal(self, amount=0): self.account.withdraw(amount) def display_user_balance(self): print("User Name: " + self.name + ", User Balance: ", end=" ") self.account.display_account_info() def transfer_money(self, other_user, amount): if self.make_withdrawal(amount): other_user.make_deposite(amount) return True return False
def add_account(self, customer_id, name, init_balance): self.account_list.append(BankAccount(customer_id, name, init_balance))
def populate_database(): """Populate the database.""" emp = Employees(123456, 'Sammy', 'Retail Applications', 'IT Analyst') emp1 = Employees(5678, 'Nancy', 'Capital Market', 'Teller') emp.create_employees() emp1.create_employees() cust = Customer(123, 'John', '*****@*****.**', '1-233-2234') cust1 = Customer(5678, 'Katherine', '*****@*****.**', '1-456-4578') cust2 = Customer(6788, 'Vijay', '*****@*****.**', '1-678-5555') cust.create_customer() cust1.create_customer() cust2.create_customer() bank_Acc = BankAccount(1234444, 123, 'Chequing', 100) bank_Acc.create_Bank_Account() bank_Acc1 = BankAccount(567888, 5678, 'Saving', 200) bank_Acc1.create_Bank_Account() bank_Acc2 = BankAccount(1677777, 6788, 'Chequing', 400) bank_Acc2.create_Bank_Account() creditCard = CreditCard('Ms', 'Nancy', 'Smith', '15 Bloor St, Toronto', 14566666, 'May', 2023, '677', 'Visa', 'CAD') creditCard.create_Credit_Account() creditCard1 = CreditCard('Mr', 'Sam', 'Rogers', '15 Upland St, Toronto', 8999666, 'Aug', 2021, '127', 'Visa', 'CAD') creditCard1.create_Credit_Account()
from BankEmpire import BankEmpire from Bank import Bank from Customer import Customer from HighNetWorthCustomer import HighNetWorthCustomer from BankAccount import BankAccount from datetime import datetime as dt ianbotzEmpire = BankEmpire('The Ianbotz Bank Empire') '''''' '''''' '''''' '''''' '''''' '''''' '''''' iBank1 = Bank('Lavender Side Bank') georgeCustomer = Customer('George Curious', 23, 60_000, BankAccount(balance=130)) stevenCustomer = HighNetWorthCustomer('Steven Hillborough', 78, 3_200_000, BankAccount(balance=36_000_000), 'Exchange Traded Funds', dt(1942, 3, 26)) iBank1.addCustomer(georgeCustomer) iBank1.addCustomer(stevenCustomer) ianbotzEmpire.addBank(iBank1) '''''' '''''' '''''' '''''' '''''' '''''' '''''' iBank2 = Bank('Mason Hill Bank') williamCustomer = Customer('William Blake', 18, 40_000, BankAccount(balance=200)) joshCustomer = Customer('Josh Maven', 35, 80_000, BankAccount(balance=30_000)) ronaldCustomer = HighNetWorthCustomer('Ronald McDonald', 68, 128_200_000, BankAccount(balance=1_200_000_000), 'Foreign Exchange Market', dt(1950, 8, 2))
def setUp(self): self.my_account = BankAccount(90)
def __init__(self, name, email): self.name = name self.email = email self.account = BankAccount()
# Test driver for BankAccount, JointBankAccount, and # CreditBankAccount classes ######################################################### # A sample comment. All comments start with #. # Importing the classes we will use # Format is: from <file name without .py> import <class name> from BankAccount import BankAccount from JointBankAccount import JointBankAccount from CreditBankAccount import CreditBankAccount # Create a BankAccount object and do a few transactions # Notice "try/except" statement to handle exceptions raised basicAccount = BankAccount("Sam Smith", 0) print("At creation : " + basicAccount.toString()) basicAccount.deposit(100) print("After deposit 100: " + basicAccount.toString()) basicAccount.withdraw(50) print("After withdraw 50: " + basicAccount.toString()) try: basicAccount.withdraw(75) print("After withdraw 75: " + basicAccount.toString()) except Exception as ex: print("Failed to withdraw 75: " + str(ex))
else: print('out of stock') @property def price(self): return self._price @price.setter def price(self, x): if 50 < x < 1000: self._price = x else: raise ValueError('asdasd') a = BankAccount('fayed', 200) a.display() book1 = Book('957-4-36-547417-1', 'Learn Physics', 'Stephen', 'CBC', 350, 200, 10) book2 = Book('652-6-86-748413-3', 'Learn Chemistry', 'Jack', 'CBC', 400, 220, 20) book3 = Book('957-7-39-347216-2', 'Learn Maths', 'John', 'XYZ', 500, 300, 5) book4 = Book('957-7-39-347216-2', 'Learn Biology', 'Jack', 'XYZ', 400, 200, 6) book1.display() book1.sell() books = [book1, book2, book3, book4] for i in range(4): books[i].display() book_title_list = [books[i].title for i in range(4)] print(book_title_list) a = Fraction(-2)
# Class: 1321L # Sec: 02 # Lab: Python # Term: Fall 2018 # Instructor: Malcolm # Name: Ly Pham from BankAccount import BankAccount myObject = BankAccount() myObject.setID(123456) myObject.setbalance(10000) myObject.withdraw(3500) myObject.deposit(500) myObject.setannualInterestRate(2.50) print(myObject.toString())
from AccountException import AccountException from Bank import Bank from BankAccount import BankAccount from BankAccount_INT import BankAccount_INT from BankAccount_COVID19 import BankAccount_COVID19 from BankAccount_COVID19_company import BankAccount_COVID19_company bank = Bank() pl_01 = BankAccount('PL_01', 10000) int_01 = BankAccount_INT('INT_01', 10000) covid_01 = BankAccount_COVID19('COVID_01', 10000) company_01 = BankAccount_COVID19_company('COMPANY_01', 10000) for account in [pl_01, int_01, covid_01, company_01]: bank.add(account) print(bank) # BankAccount print() pl_01.deposit(200) pl_01.withdraw(300) print(pl_01) try: pl_01.withdraw(50000) except AccountException as e: print('Error:', e) print() print(pl_01)
from BankAccount import BankAccount # Create a new instance of BankAccount newAccount = BankAccount() # open a new file bankFile = open("AccountSummary_AlanVenneman.txt", "w") bankFile.write("### Welcome to Acme Bank ###\n") # Ask user for initial deposit newAccount.setBalance(eval(input("Enter opening balance: "))) bankFile.write("Opening balance for February: ${:.2f}\n".format( newAccount.getBalance())) # Ask user for additional deposits deposits = 0.0 print("Enter deposits first, type the number 0 after final entry.") while (deposits != -1): deposits = newAccount.setDeposit(float(input("Enter deposit: "))) if (deposits != -1): bankFile.write(str(deposits) + '\n') else: bankFile.write("Your Deposits: ${:.2f}\n".format( newAccount.getDeposit())) # Ask user for a withdrawal withdrawals = 0 print("Enter withdrawals second, type the number 0 after final entry.") while withdrawals > -1: withdrawals = newAccount.setWithdraw(float(input("Enter withdrawal: "))) if withdrawals != -1: bankFile.write("Your Withdrawals: ${:.2f}\n".format( newAccount.getWithdraw())) # Print closing Amount bankFile.write("Your final balance today is: ${:.2f}\n".format(
def setUp(self): self.account = BankAccount("Vladko", 2000, "RON") self.account1 = BankAccount("Phillip", 4114, "RON")
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 setUp(self): self.ba = BankAccount("rado", 500, "$")
from BankAccount import BankAccount # ||===========================================|| # || Main Function || # ||===========================================|| # user input of their current balance currentBalance = float(input('Enter your current Balance:')) # initializing the bank account with the courrent balance my_account = BankAccount(currentBalance) # if the initial balance is nonzero if float(my_account.balance) > 0.00: # Option for user to select what they want to do print(' OPTIONS:\n' '1. Check Balance \n' '2. Deposit \n' '3. Withdraw \n' '4. Spend \n') choice = input("what is your choice from the above options: ") print("you chose OPTION #: ", choice) # User chooses to view balance if choice is '1': # prints the current balance of the Account print("You have: $", my_account.balance, "in your bank Account") # end the transaction or keep going keepGo = input("Are you done with your transaction?:\n"