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_withdraw_from_closed_account(self):
        account = BankAccount()
        account.open()
        account.close()

        with self.assertRaisesWithMessage(ValueError):
            account.withdraw(50)
    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_deposit_into_closed_account(self):
        account = BankAccount()
        account.open()
        account.close()

        with self.assertRaisesWithMessage(ValueError):
            account.deposit(50)
Beispiel #5
0
    def test_deposit_into_closed_account(self):
        account = BankAccount()
        account.open()
        account.close()

        with self.assertRaisesWithMessage(ValueError):
            account.deposit(50)
Beispiel #6
0
    def test_withdraw_from_closed_account(self):
        account = BankAccount()
        account.open()
        account.close()

        with self.assertRaisesWithMessage(ValueError):
            account.withdraw(50)
    def test_checking_balance_of_closed_account_throws_error(self):
        account = BankAccount()
        account.open()
        account.close()

        with self.assertRaisesWithMessage(ValueError):
            account.get_balance()
Beispiel #8
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)
Beispiel #9
0
    def test_deposit_into_closed_account(self):
        account = BankAccount()
        account.open()
        account.close()

        with self.assertRaises(ValueError) as err:
            account.deposit(50)
        self.assertEqual(type(err.exception), ValueError)
        self.assertEqual(err.exception.args[0], "account not open")
Beispiel #10
0
    def test_withdraw_from_closed_account(self):
        account = BankAccount()
        account.open()
        account.close()

        with self.assertRaises(ValueError) as err:
            account.withdraw(50)
        self.assertEqual(type(err.exception), ValueError)
        self.assertEqual(err.exception.args[0], "account not open")
Beispiel #11
0
    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")
Beispiel #12
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()
 def test_close_already_closed_account(self):
     account = BankAccount()
     with self.assertRaisesWithMessage(ValueError):
         account.close()
Beispiel #14
0
 def test_close_already_closed_account(self):
     account = BankAccount()
     with self.assertRaisesWithMessage(ValueError):
         account.close()
Beispiel #15
0
 def test_close_already_closed_account(self):
     account = BankAccount()
     with self.assertRaises(ValueError) as err:
         account.close()
     self.assertEqual(type(err.exception), ValueError)
     self.assertEqual(err.exception.args[0], "account not open")
Beispiel #16
0
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)
Beispiel #17
0
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)