[WIP] Implement exercise bank-account

config.json

@@ -499,6 +499,18 @@
 
       ]
     },
+    {
+      "uuid": "83a3ff95-c043-401c-bc2c-547d52344b02",
+      "slug": "bank-account",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 4,
+      "topics": [
+        "classes",
+        "concurrency",
+        "conditionals"
+      ]
+    },
     {
       "uuid": "d41238ce-359c-4a9a-81ea-ca5d2c4bb50d",
       "slug": "twelve-days",

exercises/bank-account/README.md

@@ -0,0 +1,22 @@
+# Bank Account
+
+Simulate a bank account supporting opening/closing, withdrawals, and deposits of money. Watch out for concurrent transactions!
+
+A bank account can be accessed in multiple ways. Clients can make deposits and withdrawals using the internet, mobile phones, etc. Shops can charge against the account.
+
+Create an account that can be accessed from multiple threads/processes (terminology depends on your programming language).
+
+It should be possible to close an account; operations against a closed account must fail.
+
+### Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the solution is in the `exercism/python/<exerciseName>` directory.
+
+For example, if you're submitting `bob.py` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/python/bob/bob.py`.
+
+
+For more detailed information about running tests, code style and linting,
+please see the [help page](http://exercism.io/languages/python).
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

exercises/bank-account/bank_account.py

@@ -0,0 +1,21 @@
+
+
+class BankAccount(object):
+
+    def __init__(self):
+        pass
+
+    def getBalance(self):
+        pass
+
+    def open(self):
+        pass
+
+    def deposit(self, amount):
+        pass
+
+    def withdraw(self, amount):
+        pass
+
+    def close(self):
+        pass

exercises/bank-account/bank_account_test.py

@@ -0,0 +1,125 @@
+import unittest
+import threading
+
+from bank_account import BankAccount
+
+
+class BankAccountTests(unittest.TestCase):
+
+    def test_newly_opened_account_has_zero_balance(self):
+        self.account = BankAccount()
+        self.account.open()
+
+        self.assertEqual(self.account.getBalance(), 0)
+
+    def test_get_balance_0(self):
+        self.account = BankAccount()
+        self.account.open()
+
+        self.assertEqual(self.account.getBalance(), 0)
+
+    def test_get_balance_with_amount(self):
+        self.account = BankAccount()
+        self.account.open()
+        self.account.deposit(100)
+
+        self.assertEqual(self.account.getBalance(), 100)
+
+    def test_deposit_into_account(self):
+        self.account = BankAccount()
+        self.account.open()
+        self.account.deposit(100)
+
+        self.assertEqual(self.account.getBalance(), 100)
+
+    def test_two_deposits_in_a_row(self):
+        self.account = BankAccount()
+        self.account.open()
+        self.account.deposit(100)
+        self.account.deposit(50)
+
+        self.assertEqual(self.account.getBalance(), 150)
+
+    def test_can_withdraw(self):
+        self.account = BankAccount()
+        self.account.open()
+        self.account.deposit(100)
+        self.account.withdraw(50)
+
+        self.assertEqual(self.account.getBalance(), 50)
+
+    def test_checking_balance_of_closed_account_throws_error(self):
+        self.account = BankAccount()
+        self.account.open()
+        self.account.close()
+
+        with self.assertRaises(ValueError):
+            self.account.getBalance()
+
+    def test_deposit_into_closed_account(self):
+        self.account = BankAccount()
+        self.account.open()
+        self.account.close()
+
+        with self.assertRaises(ValueError):
+            self.account.deposit(50)
+
+    def test_withdraw_from_closed_account(self):
+        self.account = BankAccount()
+        self.account.open()
+        self.account.close()
+
+        with self.assertRaises(ValueError):
+            self.account.withdraw(50)
+
+    def test_cannot_withdraw_more_than_deposited(self):
+        self.account = BankAccount()
+        self.account.open()
+        self.account.deposit(25)
+
+        with self.assertRaises(ValueError):
+            self.account.withdraw(50)
+
+    def test_cannot_withdraw_negative(self):
+        self.account = BankAccount()
+        self.account.open()
+        self.account.deposit(100)
+
+        with self.assertRaises(ValueError):
+            self.account.withdraw(-50)
+
+    def test_cannot_deposit_negative(self):
+        self.account = BankAccount()
+        self.account.open()
+
+        with self.assertRaises(ValueError):
+            self.account.deposit(-50)
+
+    def test_can_handle_concurrent_transactions(self):
+        def increment_and_decrement(self):
+            self.account.deposit(10)
+            self.account.withdraw(1)
+
+        self.account = BankAccount()
+        self.account.open()
+
+        threadlist = []
+        threads = 100
+        i = 0
+        while (i < threads):
+            thread = threading.Thread(target=increment_and_decrement,
+                                      args=(self, ))
+            threadlist.append(thread)
+            i += 1
+
+        for thread in threadlist:
+            thread.start()
+
+        for thread in threadlist:
+            thread.join()
+
+        self.assertEqual(self.account.getBalance(), 900)
+
+
+if __name__ == '__main__':
+    unittest.main()

exercises/bank-account/example.py

@@ -0,0 +1,45 @@
+import threading
+
+
+class BankAccount(object):
+    def __init__(self):
+        self.isOpen = False
+        self.lock = threading.Lock()
+
+    def getBalance(self):
+        self.lock.acquire()
+        if (self.isOpen):
+            self.lock.release()
+            return self.balance
+        else:
+            self.lock.release()
+            raise ValueError
+
+    def open(self):
+        self.lock.acquire()
+        self.balance = 0
+        self.isOpen = True
+        self.lock.release()
+
+    def deposit(self, amount):
+        self.lock.acquire()
+        if (self.isOpen and amount > 0):
+            self.balance += amount
+            self.lock.release()
+        else:
+            self.lock.release()
+            raise ValueError
+
+    def withdraw(self, amount):
+        self.lock.acquire()
+        if (self.isOpen and self.balance >= amount and amount > 0):
+            self.balance -= amount
+            self.lock.release()
+        else:
+            self.lock.release()
+            raise ValueError
+
+    def close(self):
+        self.lock.acquire()
+        self.isOpen = False
+        self.lock.release()