Esempio n. 1
0
def main():
    account = Account(TransactionRepository(Clock()),
                      StatementPrinter(Console()))
    account.deposit(1000)
    account.withdraw(100)
    account.deposit(500)
    account.print_statement()
Esempio n. 2
0
    def test_add_account(self):
        bank = Bank()

        account_1 = Account("001", 50)
        account_2 = Account("002", 100)

        bank.add_account(account_1)
        bank.add_account(account_2)

        self.assertEqual(len(bank.accounts), 2)
Esempio n. 3
0
    def test_add_account(self):
        """Test add bank account """
        bank = Bank()

        account_1 = Account('001', 50)
        account_2 = Account('002', 30)

        bank.add_account(account_1)
        bank.add_account(account_2)

        self.assertEqual(len(bank.accounts), 2)
class AccountTest(TestCase):
    def setUp(self):
        self.transaction_repository = mock()
        self.account = Account(self.transaction_repository, None)

    def test_account_should_store_a_deposit_transaction(self):
        self.account.deposit(100)

        verify(self.transaction_repository).store(100)

    def test_account_should_store_a_withdraw_transaction(self):
        self.account.withdraw(50)

        verify(self.transaction_repository).store(-50)
    def create_account(self, account_id):
        if not self.account_exists(account_id):
            self.accounts[account_id] = Account(account_id)

            return self.get_account(account_id)

        return None
Esempio n. 6
0
    def test_get_account_balance(self):
        bank = Bank()

        account_1 = Account("001", 50)
        bank.add_account(account_1)

        self.assertEqual(bank.get_account_balance("001"), 50)
Esempio n. 7
0
class CardTest(unittest.TestCase):
    def setUp(self):
        self.acc = Account(name="John", surname="Doe")

    def test_basic(self):
        # given
        card = self.acc.create_new_card(4321)

        # when
        owner = card.owner

        # then
        self.assertEquals(owner, self.acc.owner)

    def test_check_pin(self):
        # given
        pin = 12345
        card = self.acc.create_new_card(pin)

        # when
        is_pin_ok = card.check_pin(pin)

        # then
        self.assertTrue(is_pin_ok)

    def test_get_account(self):
        # given
        pin = 12345
        card = self.acc.create_new_card(pin)

        # when
        account = card.get_account()

        # then
        self.assertEqual(account, self.acc)

    @unittest.expectedFailure
    def test_is_pin_number(self):
        # given
        pin = 'abc12345'
        card = self.acc.create_new_card(pin)

        # when
        is_pin_ok = card.is_pin_number()

        # then
        self.assertTrue(is_pin_ok)
Esempio n. 8
0
    def test_get_account_balance(self):
        """Test get account balance """
        bank = Bank()

        account_1 = Account('001', 50)
        bank.add_account(account_1)

        self.assertEqual(bank.get_account_balance('001'), 50)
Esempio n. 9
0
class TestAccount(unittest.TestCase):
    def setUp(self):
        self.account = Account(100)

    def test_deposit(self):
        self.account.deposit(10)
        assert self.account.balance == 10

    def test_withdraw_invalid(self):
        assert self.account.withdraw(1) == False

    def test_withdraw_success(self):
        self.account.deposit(1)
        assert self.account.withdraw(1) == True

    def test_get_balance(self):
        assert self.account.get_balance() == 0
        self.account.deposit(1)
        assert self.account.get_balance() == 1
Esempio n. 10
0
    def test_print_statement_containing_all_transactions(self):
        console = mock()
        clock = mock()

        when(clock).date_as_string().thenReturn('01/04/2015').thenReturn(
            '02/04/2015').thenReturn('10/04/2015')

        account = Account(TransactionRepository(clock),
                          StatementPrinter(console))
        account.deposit(1000)
        account.withdraw(100)
        account.deposit(500)

        account.print_statement()

        inorder.verify(console).print_line('DATE | AMOUNT | BALANCE')
        inorder.verify(console).print_line('10/04/2015 | 500.00 | 1400.00')
        inorder.verify(console).print_line('02/04/2015 | -100.00 | 900.00')
        inorder.verify(console).print_line('01/04/2015 | 1000.00 | 1000.00')
    def test_print_statement_containing_all_transactions(self):
        console = mock()
        clock = mock()

        when(clock).date_as_string().thenReturn('01/04/2015').thenReturn('02/04/2015').thenReturn('10/04/2015')

        account = Account(TransactionRepository(clock), StatementPrinter(console))
        account.deposit(1000)
        account.withdraw(100)
        account.deposit(500)

        account.print_statement()

        inorder.verify(console).print_line('DATE | AMOUNT | BALANCE')
        inorder.verify(console).print_line('10/04/2015 | 500.00 | 1400.00')
        inorder.verify(console).print_line('02/04/2015 | -100.00 | 900.00')
        inorder.verify(console).print_line('01/04/2015 | 1000.00 | 1000.00')
Esempio n. 12
0
class TestAccount(unittest.TestCase):
    
    def setUp(self):
        self.client = Client(1)
        self.account = Account(1, self.client)
    
    # def testOverdraft(self):
        # self.account.withdraw(600)
        # self.assertTrue(self.account.overdraft)
    
    def testBalance(self):
        self.assertEquals(500.00, self.account.getBalance())
Esempio n. 13
0
def test_create_account():
    # Given

    account_number = 9876
    initial_balance = 99

    # When

    account = Account(account_number, initial_balance)

    # Then

    assert account.account_number == account_number
    assert account.balance == initial_balance
 def test_account_if_existing(self):
    account = Account("001", 50)
    self.assertEqual(account.existing_account(001), None)
Esempio n. 15
0
 def Create_Account(self, account_number, balance):
     a = Account(account_number, balance)
     BANK.add_account(a)
Esempio n. 16
0
    print("1: Create an account")
    print("2: Log in to your account")
    print("3: Type \"stop\" to leave the bank")
    cmd = input()
    if cmd == "stop":
        stop = True
    elif cmd == "1":
        print("What is your name?")
        name = input()
        print("Choose your account number.")
        account = input()
        print("Choose your pin number.")
        pin_number = input()
        user = create_user(name, account, pin_number)
        print("Account created! Welcome, {}".format(user.name))

carter = User("Carter", 123, 1)
account = Account(123, 1000, "checking")

print("{} has account number {} with a pin number {}".format(
    carter.name, carter.account, carter.pin_number))
print("{} account with account number {} has balance {}".format(
    account.type, account.account_number, account.balance))

account.deposit(1000)
print(account.check_balance())
account.withdraw(500)
print(account.check_balance())
print("{} account with account number {} has balance {}".format(
    account.type, account.account_number, account.balance))
Esempio n. 17
0
def create_account(account_number, balance, type):
    return Account(account_number, balance, type)
Esempio n. 18
0
def closed_account():
    account = Account()
    account.open()
    account.close()
    return account
Esempio n. 19
0
def new_account():
    account = Account()
    return account
Esempio n. 20
0
def payee_account():
    return Account(PAYEE_ACCOUNT_NUMBER, 0)
Esempio n. 21
0
def opened_account():
    account = Account()
    account.open()
    return account
Esempio n. 22
0
def i_create_the_following_account(step):
    for row in step.hashes:
        a = Account(row['account_number'], row['balance'])
        BANK.add_account(a)
Esempio n. 23
0
def payer_account():
    return Account(PAYER_ACCOUNT_NUMBER, INITIAL_BALANCE)
Esempio n. 24
0
def alternative_account():
    return Account(ALTERNATIVE_ACCOUNT_NUMBER, INITIAL_BALANCE)
Esempio n. 25
0
from flask import Flask, render_template, request
from bank.bank import Bank
from bank.account import Account
app = Flask(__name__)
BANK = Bank()


@app.route('/')
def hello_world():
    # return 'Hello World!'
    account_number = request.args.get('account_number')
    balance = BANK.get_account_balance(account_number)
    return render_template('index.html', balance=balance)


if __name__ == '__main__':
    import cProfile

    account = Account('1111', 50)  #pylint: disable=C0103
    BANK.add_account(account)
    cProfile.run('app.run(debug=True)', sort='time')
    # app.run(debug=True)

 def setUp(self):
     self.transaction_repository = mock()
     self.account = Account(self.transaction_repository, None)
Esempio n. 27
0
 def test_account_object_returns_current_balance(self):
     account = Account("001", 50)
     self.assertEquals(account.account_number, "001")
     self.assertEquals(account.balance, 50)
def test_transactions(initial, added, withdrawn, remaining):
    account = Account(initial)
    account.add_cash(added)
    account.withdraw_cash(withdrawn)
    assert account.balance == remaining
Esempio n. 29
0
 def setUp(self):
     self.account = Account(100)
Esempio n. 30
0
 def test_account_object_can_be_created(self):
   account = Account()
Esempio n. 31
0
def i_create_account_with_balance_of_group1(step, account_number, balance):
    a = Account(account_number, balance)
    BANK.add_account(a)
Esempio n. 32
0
 def setUp(self):
     self.client = Client(1)
     self.account = Account(1, self.client)
Esempio n. 33
0
    def test_lacking_balance(self):
        account = Account("001", 50)
	
        account.get_balance()

        self.assertEqual(account.balance,50)
Esempio n. 34
0
def main():
    account = Account(TransactionRepository(Clock()), StatementPrinter(Console()))
    account.deposit(1000)
    account.withdraw(100)
    account.deposit(500)
    account.print_statement()