From 4c5929fced3795b0a3faec6875aa273e29e053a9 Mon Sep 17 00:00:00 2001 From: pavel Date: Tue, 24 Oct 2017 20:13:59 -0400 Subject: [PATCH 1/4] Initial commit: working on backend --- pom.xml | 9 + src/main/java/Main.java | 9 - .../java/com/zipcode/macrolabs/atm/Main.java | 13 ++ .../zipcode/macrolabs/atm/RandomUtils.java | 29 +++ .../macrolabs/atm/bankaccount/Account.java | 105 +++++++++++ .../atm/bankaccount/AccountFactory.java | 50 ++++++ .../atm/bankaccount/AccountStatus.java | 8 + .../atm/bankaccount/AccountType.java | 10 ++ .../atm/bankaccount/CheckingAccount.java | 18 ++ .../atm/bankaccount/InvestmentAccount.java | 19 ++ .../atm/bankaccount/SavingsAccount.java | 19 ++ .../exceptions/AccountNotEmptyException.java | 7 + .../exceptions/BalanceTooLowException.java | 7 + .../exceptions/NoMoreAccountsException.java | 7 + .../NoMoreTransactionsException.java | 7 + .../atm/exceptions/NoMoreUsersException.java | 7 + .../TransactionAmountIsZeroException.java | 9 + .../atm/navigation/Authenticator.java | 4 + .../atm/navigation/BankAccountManager.java | 15 ++ .../macrolabs/atm/navigation/Input.java | 14 ++ .../macrolabs/atm/navigation/MenuLinks.java | 4 + .../atm/navigation/MenuNavigator.java | 4 + .../atm/transaction/Transaction.java | 18 ++ .../atm/transaction/TransactionFactory.java | 11 ++ .../atm/transaction/TransactionType.java | 9 + .../com/zipcode/macrolabs/atm/user/User.java | 104 +++++++++++ .../macrolabs/atm/user/UserFactory.java | 38 ++++ .../macrolabs/atm/user/UserWarehouse.java | 29 +++ .../macrolabs/atm/RandomUtilsTest.java | 24 +++ .../atm/bankaccount/AccountFactoryTest.java | 116 ++++++++++++ .../atm/bankaccount/AccountTestSuite.java | 14 ++ .../atm/bankaccount/CheckingAccountTest.java | 168 ++++++++++++++++++ .../bankaccount/InvestmentAccountTest.java | 9 + .../atm/bankaccount/SavingsAccountTest.java | 6 + .../macrolabs/atm/user/UserFactoryTest.java | 61 +++++++ .../zipcode/macrolabs/atm/user/UserTest.java | 79 ++++++++ .../macrolabs/atm/user/UserTestSuite.java | 13 ++ .../macrolabs/atm/user/UserWarehouseTest.java | 35 ++++ 38 files changed, 1099 insertions(+), 9 deletions(-) delete mode 100644 src/main/java/Main.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/Main.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/RandomUtils.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/bankaccount/Account.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/bankaccount/AccountFactory.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/bankaccount/AccountStatus.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/bankaccount/AccountType.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/bankaccount/CheckingAccount.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/bankaccount/InvestmentAccount.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/bankaccount/SavingsAccount.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/exceptions/AccountNotEmptyException.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/exceptions/BalanceTooLowException.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/exceptions/NoMoreAccountsException.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/exceptions/NoMoreTransactionsException.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/exceptions/NoMoreUsersException.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/exceptions/TransactionAmountIsZeroException.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/navigation/Authenticator.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/navigation/BankAccountManager.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/navigation/Input.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/navigation/MenuLinks.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/navigation/MenuNavigator.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/transaction/Transaction.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/transaction/TransactionFactory.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/transaction/TransactionType.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/user/User.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/user/UserFactory.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/user/UserWarehouse.java create mode 100644 src/test/com/zipcode/macrolabs/atm/RandomUtilsTest.java create mode 100644 src/test/com/zipcode/macrolabs/atm/bankaccount/AccountFactoryTest.java create mode 100644 src/test/com/zipcode/macrolabs/atm/bankaccount/AccountTestSuite.java create mode 100644 src/test/com/zipcode/macrolabs/atm/bankaccount/CheckingAccountTest.java create mode 100644 src/test/com/zipcode/macrolabs/atm/bankaccount/InvestmentAccountTest.java create mode 100644 src/test/com/zipcode/macrolabs/atm/bankaccount/SavingsAccountTest.java create mode 100644 src/test/com/zipcode/macrolabs/atm/user/UserFactoryTest.java create mode 100644 src/test/com/zipcode/macrolabs/atm/user/UserTest.java create mode 100644 src/test/com/zipcode/macrolabs/atm/user/UserTestSuite.java create mode 100644 src/test/com/zipcode/macrolabs/atm/user/UserWarehouseTest.java diff --git a/pom.xml b/pom.xml index 9901415..1012f0d 100644 --- a/pom.xml +++ b/pom.xml @@ -8,5 +8,14 @@ project-2-atm 1.0-SNAPSHOT + + + + junit + junit + 4.12 + + + \ No newline at end of file diff --git a/src/main/java/Main.java b/src/main/java/Main.java deleted file mode 100644 index 05e41a9..0000000 --- a/src/main/java/Main.java +++ /dev/null @@ -1,9 +0,0 @@ -/** - * Created by iyasuwatts on 10/17/17. - */ -public class Main { - - public static void main(String[] args){ - - } -} diff --git a/src/main/java/com/zipcode/macrolabs/atm/Main.java b/src/main/java/com/zipcode/macrolabs/atm/Main.java new file mode 100644 index 0000000..9af0ab2 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/Main.java @@ -0,0 +1,13 @@ +package com.zipcode.macrolabs.atm; + +import com.zipcode.macrolabs.atm.navigation.BankAccountManager; + +public class Main { + + public static void main(String[] args) { + + BankAccountManager bankAccountManager = new BankAccountManager(); + bankAccountManager.run(); + + } +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/RandomUtils.java b/src/main/java/com/zipcode/macrolabs/atm/RandomUtils.java new file mode 100644 index 0000000..e090775 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/RandomUtils.java @@ -0,0 +1,29 @@ +package com.zipcode.macrolabs.atm; + +import java.util.Random; + +public class RandomUtils { + + private static final Random random = new Random(); + + public static Float createFloat(float min, float max) { + return random.nextFloat() * (max - min) + min; + } + + public static Integer createInteger(Integer min, Integer max) { + return createFloat(min, max).intValue(); + } + + public static Character createCharacter(char min, char max) { + return (char) createInteger((int) min, (int) max).intValue(); + } + + public static String createString(char min, char max, int stringLength) { + StringBuffer sb = new StringBuffer(); + for (int i = 0; i < stringLength; i++) { + sb.append(createCharacter(min, max)); + } + return sb.toString(); + } + +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/bankaccount/Account.java b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/Account.java new file mode 100644 index 0000000..cee84ec --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/Account.java @@ -0,0 +1,105 @@ +package com.zipcode.macrolabs.atm.bankaccount; + +import com.zipcode.macrolabs.atm.exceptions.BalanceTooLowException; +import com.zipcode.macrolabs.atm.exceptions.TransactionAmountIsZeroException; +import com.zipcode.macrolabs.atm.transaction.Transaction; +import com.zipcode.macrolabs.atm.transaction.TransactionFactory; +import com.zipcode.macrolabs.atm.user.User; + +import java.nio.file.attribute.UserDefinedFileAttributeView; +import java.util.ArrayList; +import java.util.List; + +public abstract class Account { + + protected int accountID = 0; + protected AccountType accountType; + private double accountBalance = 0.00d; + private List accountUsers = new ArrayList(); + private AccountStatus accountStatus = AccountStatus.ACTIVE; + private List accountTransactionHistory = new ArrayList(); + + + public double getBalance() { + return this.accountBalance; + } + + public void setBalance(double accountBalance) { + this.accountBalance = accountBalance; + } + + public String getAccountID() { + return String.format( "%0" + AccountFactory.ACCOUNT_ID_LENGTH + "d", accountID); + } + + public void addUser(User user) { + accountUsers.add(user); + } + + public AccountStatus getAccountStatus() { + return accountStatus; + } + + public void setAccountID(int accountID) { + this.accountID = accountID; + } + + public String getAccountInfo(){ + String accountInfo = String.format("Account - ID: %s | Type: %s | Balance: %,.2f | Status: %s | Users: %s\n", + this.getAccountID(), this.getAccountType(), this.getBalance(), + this.getAccountStatus(), this.getAccountUsers()); + return accountInfo; + } + + public Transaction withdrawAndMakeTransaction(double amount) throws TransactionAmountIsZeroException, BalanceTooLowException { + + if(amount >= 0.001) { + if (this.accountBalance >= amount) { + this.accountBalance -= amount; + Transaction newTransaction = TransactionFactory.createNewTransaction(); + return newTransaction; + } else { System.out.println("Sorry, your balance is too low! Requested: " + amount + ". Available: " + this.accountBalance + "."); + throw new BalanceTooLowException(); } + } else { throw new TransactionAmountIsZeroException(); } + + } + + public Transaction depositAndMakeTransaction(double amount) throws TransactionAmountIsZeroException { + + if(amount >= 0.001) { + this.accountBalance += amount; + Transaction newTransaction = TransactionFactory.createNewTransaction(); + return newTransaction; + } else { throw new TransactionAmountIsZeroException(); } + + } + + public Transaction transferAndMakeTransaction(double amount, String destinationAccountID){ + return null; + } + + public String printHistory(){ + return null; + } + + public Transaction[] getHistory(){ + return null; + } + + public abstract void setAccountType(); + + public abstract AccountType getAccountType(); + + public void setAccountStatus(AccountStatus accountStatus){ + } + + + public ArrayList getAccountUsers() { + return (ArrayList) accountUsers; + } + + + public ArrayList getTransactionHistory() { + return (ArrayList) accountTransactionHistory; + } +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/bankaccount/AccountFactory.java b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/AccountFactory.java new file mode 100644 index 0000000..ad569df --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/AccountFactory.java @@ -0,0 +1,50 @@ +package com.zipcode.macrolabs.atm.bankaccount; + +import com.zipcode.macrolabs.atm.exceptions.NoMoreAccountsException; +import com.zipcode.macrolabs.atm.user.User; + +public class AccountFactory { + + static int iteratedAccountID = 0; + public static final int ACCOUNT_ID_LENGTH = 9; + + public static int nextAccountID() throws NoMoreAccountsException { + if((""+ iteratedAccountID).length() <= ACCOUNT_ID_LENGTH) { + return iteratedAccountID++; + } else { throw new NoMoreAccountsException(); } + } + + public static CheckingAccount createNewCheckingAccount(User user) { + CheckingAccount newCheckingAccount = new CheckingAccount(); + newCheckingAccount.addUser(user); + try { + newCheckingAccount.setAccountID(nextAccountID()); + } catch (NoMoreAccountsException e) { + e.printStackTrace(); + } + return newCheckingAccount; + } + + public static SavingsAccount createNewSavingsAccount(User user) { + SavingsAccount newSavingsAccount = new SavingsAccount(); + newSavingsAccount.addUser(user); + try { + newSavingsAccount.setAccountID(nextAccountID()); + } catch (NoMoreAccountsException e) { + e.printStackTrace(); + } + return newSavingsAccount; + } + + public static InvestmentAccount createNewInvestmentAccount(User user) { + InvestmentAccount newInvestmentAccount = new InvestmentAccount(); + newInvestmentAccount.addUser(user); + try { + newInvestmentAccount.setAccountID(nextAccountID());; + } catch (NoMoreAccountsException e) { + e.printStackTrace(); + } + return newInvestmentAccount; + } + +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/bankaccount/AccountStatus.java b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/AccountStatus.java new file mode 100644 index 0000000..5453bb2 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/AccountStatus.java @@ -0,0 +1,8 @@ +package com.zipcode.macrolabs.atm.bankaccount; + +public enum AccountStatus { + + ACTIVE, + CLOSED + +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/bankaccount/AccountType.java b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/AccountType.java new file mode 100644 index 0000000..1cdb486 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/AccountType.java @@ -0,0 +1,10 @@ +package com.zipcode.macrolabs.atm.bankaccount; + +public enum AccountType { + + CHECKING, + SAVINGS, + INVESTMENT, + TEST + +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/bankaccount/CheckingAccount.java b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/CheckingAccount.java new file mode 100644 index 0000000..8247170 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/CheckingAccount.java @@ -0,0 +1,18 @@ +package com.zipcode.macrolabs.atm.bankaccount; + +public class CheckingAccount extends Account { + + public CheckingAccount(){ + setAccountType(); + } + + @Override + public void setAccountType() { + this.accountType = AccountType.CHECKING; + } + + @Override + public AccountType getAccountType() { + return AccountType.CHECKING; + } +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/bankaccount/InvestmentAccount.java b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/InvestmentAccount.java new file mode 100644 index 0000000..f2b9d62 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/InvestmentAccount.java @@ -0,0 +1,19 @@ +package com.zipcode.macrolabs.atm.bankaccount; + +public class InvestmentAccount extends Account { + + public InvestmentAccount(){ + setAccountType(); + } + + @Override + public void setAccountType() { + this.accountType = AccountType.INVESTMENT; + } + + @Override + public AccountType getAccountType() { + return AccountType.INVESTMENT; + } + +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/bankaccount/SavingsAccount.java b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/SavingsAccount.java new file mode 100644 index 0000000..6906576 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/SavingsAccount.java @@ -0,0 +1,19 @@ +package com.zipcode.macrolabs.atm.bankaccount; + +public class SavingsAccount extends Account { + + public SavingsAccount(){ + setAccountType(); + } + + @Override + public void setAccountType() { + this.accountType = AccountType.SAVINGS; + } + + @Override + public AccountType getAccountType() { + return AccountType.SAVINGS; + } + +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/exceptions/AccountNotEmptyException.java b/src/main/java/com/zipcode/macrolabs/atm/exceptions/AccountNotEmptyException.java new file mode 100644 index 0000000..7802a80 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/exceptions/AccountNotEmptyException.java @@ -0,0 +1,7 @@ +package com.zipcode.macrolabs.atm.exceptions; + +public class AccountNotEmptyException extends Exception{ + + public AccountNotEmptyException(){} + +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/exceptions/BalanceTooLowException.java b/src/main/java/com/zipcode/macrolabs/atm/exceptions/BalanceTooLowException.java new file mode 100644 index 0000000..684f71a --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/exceptions/BalanceTooLowException.java @@ -0,0 +1,7 @@ +package com.zipcode.macrolabs.atm.exceptions; + +public class BalanceTooLowException extends Exception { + + public BalanceTooLowException(){} + +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/exceptions/NoMoreAccountsException.java b/src/main/java/com/zipcode/macrolabs/atm/exceptions/NoMoreAccountsException.java new file mode 100644 index 0000000..9a2a1b6 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/exceptions/NoMoreAccountsException.java @@ -0,0 +1,7 @@ +package com.zipcode.macrolabs.atm.exceptions; + +public class NoMoreAccountsException extends Exception { + + public NoMoreAccountsException(){} + +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/exceptions/NoMoreTransactionsException.java b/src/main/java/com/zipcode/macrolabs/atm/exceptions/NoMoreTransactionsException.java new file mode 100644 index 0000000..7867663 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/exceptions/NoMoreTransactionsException.java @@ -0,0 +1,7 @@ +package com.zipcode.macrolabs.atm.exceptions; + +public class NoMoreTransactionsException extends Exception { + + public NoMoreTransactionsException(){} + +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/exceptions/NoMoreUsersException.java b/src/main/java/com/zipcode/macrolabs/atm/exceptions/NoMoreUsersException.java new file mode 100644 index 0000000..51e54cd --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/exceptions/NoMoreUsersException.java @@ -0,0 +1,7 @@ +package com.zipcode.macrolabs.atm.exceptions; + +public class NoMoreUsersException extends Exception{ + + public NoMoreUsersException(){} + +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/exceptions/TransactionAmountIsZeroException.java b/src/main/java/com/zipcode/macrolabs/atm/exceptions/TransactionAmountIsZeroException.java new file mode 100644 index 0000000..0776c05 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/exceptions/TransactionAmountIsZeroException.java @@ -0,0 +1,9 @@ +package com.zipcode.macrolabs.atm.exceptions; + +public class TransactionAmountIsZeroException extends Exception{ + + public TransactionAmountIsZeroException(){ + System.out.println("Please don't waste out time with $0.00 transactions."); + } + +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/navigation/Authenticator.java b/src/main/java/com/zipcode/macrolabs/atm/navigation/Authenticator.java new file mode 100644 index 0000000..9fbe09a --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/navigation/Authenticator.java @@ -0,0 +1,4 @@ +package com.zipcode.macrolabs.atm.navigation; + +public class Authenticator { +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/navigation/BankAccountManager.java b/src/main/java/com/zipcode/macrolabs/atm/navigation/BankAccountManager.java new file mode 100644 index 0000000..74062a0 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/navigation/BankAccountManager.java @@ -0,0 +1,15 @@ +package com.zipcode.macrolabs.atm.navigation; + +public class BankAccountManager { + + public void run() { + + //print splash screen + + //give options + + //take input + + + } +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/navigation/Input.java b/src/main/java/com/zipcode/macrolabs/atm/navigation/Input.java new file mode 100644 index 0000000..9bb9840 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/navigation/Input.java @@ -0,0 +1,14 @@ +package com.zipcode.macrolabs.atm.navigation; + +import java.util.Scanner; + +public class Input { + + public static String stringInput(){ + + Scanner scanner = new Scanner(System.in); + return scanner.nextLine(); + + } + +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/navigation/MenuLinks.java b/src/main/java/com/zipcode/macrolabs/atm/navigation/MenuLinks.java new file mode 100644 index 0000000..b2d9e84 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/navigation/MenuLinks.java @@ -0,0 +1,4 @@ +package com.zipcode.macrolabs.atm.navigation; + +public class MenuLinks { +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/navigation/MenuNavigator.java b/src/main/java/com/zipcode/macrolabs/atm/navigation/MenuNavigator.java new file mode 100644 index 0000000..e367192 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/navigation/MenuNavigator.java @@ -0,0 +1,4 @@ +package com.zipcode.macrolabs.atm.navigation; + +public class MenuNavigator { +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/transaction/Transaction.java b/src/main/java/com/zipcode/macrolabs/atm/transaction/Transaction.java new file mode 100644 index 0000000..92c4425 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/transaction/Transaction.java @@ -0,0 +1,18 @@ +package com.zipcode.macrolabs.atm.transaction; + +public class Transaction { + + TransactionType transactionType; + + public TransactionType getTransactionType() { + + return this.transactionType; + + } + + public void setTransactionType(TransactionType transactionType){ + + this.transactionType = transactionType; + + } +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/transaction/TransactionFactory.java b/src/main/java/com/zipcode/macrolabs/atm/transaction/TransactionFactory.java new file mode 100644 index 0000000..9041687 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/transaction/TransactionFactory.java @@ -0,0 +1,11 @@ +package com.zipcode.macrolabs.atm.transaction; + +public class TransactionFactory { + + private static int transactionID = 0; + public static final int TRANSACTION_ID_LENGTH = 9; + + public static Transaction createNewTransaction() { + return null; + } +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/transaction/TransactionType.java b/src/main/java/com/zipcode/macrolabs/atm/transaction/TransactionType.java new file mode 100644 index 0000000..4ed08ec --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/transaction/TransactionType.java @@ -0,0 +1,9 @@ +package com.zipcode.macrolabs.atm.transaction; + +public enum TransactionType { + + WITHDRAWAL, + DEPOSIT, + TRANSFER + +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/user/User.java b/src/main/java/com/zipcode/macrolabs/atm/user/User.java new file mode 100644 index 0000000..38c491a --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/user/User.java @@ -0,0 +1,104 @@ +package com.zipcode.macrolabs.atm.user; + +import com.zipcode.macrolabs.atm.bankaccount.Account; +import com.zipcode.macrolabs.atm.bankaccount.AccountFactory; +import com.zipcode.macrolabs.atm.bankaccount.AccountStatus; +import com.zipcode.macrolabs.atm.bankaccount.AccountType; +import com.zipcode.macrolabs.atm.exceptions.AccountNotEmptyException; + +import java.util.ArrayList; +import java.util.List; + +public class User { + + String userID; + String userName; + String userPassword; + List userAccounts = new ArrayList(); + + @Override + public String toString(){ + String userString = String.format("UserID: %s | User Name: %s", this.getUserID(), this.getUserName()); + return userString; + } + + public User(String userName, String userPassword) { + this.userName = userName; + this.userPassword = userPassword; + } + + public List getAccounts(){ + return userAccounts; + } + + public void setUserName(String newUserName){ + this.userName = newUserName; + } + + public void setUserPassword(String userPassword) { + this.userPassword = userPassword; + } + + public void addAnotherUserToExistingAccount(int accountIndex, User anotherUser){ + + } + + public void addAccount(Account newAccount){ + this.userAccounts.add(newAccount); + } + + public void createNewAccount(AccountType accountType){ + Account newAccount; + switch(accountType) { + case CHECKING: + this.addAccount(AccountFactory.createNewCheckingAccount(this)); + break; + case SAVINGS: + this.addAccount(AccountFactory.createNewSavingsAccount(this)); + break; + case INVESTMENT: + this.addAccount(AccountFactory.createNewInvestmentAccount(this)); + break; + + } + } + + public void removeAccount(int accountIndex) throws AccountNotEmptyException { + Account thisAccount = userAccounts.get(accountIndex); + if(thisAccount.getBalance() < 0.001d){ + userAccounts.remove(thisAccount); + } else {throw new AccountNotEmptyException();} + } + + public void closeAccount(int accountIndex) throws AccountNotEmptyException { + Account thisAccount = userAccounts.get(accountIndex); + if(thisAccount.getBalance() < 0.001d){ + thisAccount.setAccountStatus(AccountStatus.CLOSED); + } else {throw new AccountNotEmptyException();} + + } + + public void setUserID(int userID) { + this.userID = String.format("%0" + UserFactory.USER_ID_LENGTH + "d", userID); + } + + public String getUserID() { + return this.userID; + } + + public String getUserName() { + return userName; + } + + public String getUserPassword() { + return userPassword; + } + + public String getAllUserAccountInfo() { + String allAcountInfo = ""; + for (Account account: this.getAccounts()) { + allAcountInfo += account.getAccountInfo(); + } + return allAcountInfo; + } +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/user/UserFactory.java b/src/main/java/com/zipcode/macrolabs/atm/user/UserFactory.java new file mode 100644 index 0000000..5ff1d0b --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/user/UserFactory.java @@ -0,0 +1,38 @@ +package com.zipcode.macrolabs.atm.user; + +import com.zipcode.macrolabs.atm.exceptions.NoMoreAccountsException; +import com.zipcode.macrolabs.atm.exceptions.NoMoreUsersException; + +public class UserFactory { + + static int iteratedUserID = 0; + public static final int USER_ID_LENGTH = 9; + + public static int nextUserID() throws NoMoreUsersException { + if((""+iteratedUserID).length() <= USER_ID_LENGTH) { + return iteratedUserID++; + } else { throw new NoMoreUsersException(); } + } + + public static User createNewUser(String name, String password) { + User newUser = new User(name, password); + try { + newUser.setUserID(nextUserID()); + } catch (NoMoreUsersException e) { + e.printStackTrace(); + } + UserWarehouse.addPerson(newUser); + return newUser; + + } + +// public static User createRandomUser() { +// String name = RandomUtils.createString('a', 'z', 5); +// int age = RandomUtils.createInteger(0, 100); +// boolean isMale = RandomUtils.createBoolean(50); +// +// Person randomPerson = new Person(name, age, isMale); +// return randomPerson; +// } + +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/user/UserWarehouse.java b/src/main/java/com/zipcode/macrolabs/atm/user/UserWarehouse.java new file mode 100644 index 0000000..adb4a9a --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/user/UserWarehouse.java @@ -0,0 +1,29 @@ +package com.zipcode.macrolabs.atm.user; + +import java.util.ArrayList; +import java.util.List; + +public class UserWarehouse { + + private static final List users = new ArrayList(); + + public static void addPerson(User user) { + users.add(user); + } + + public static List getUsers() { + return users; + } + + public static User findUserByID(String userID){ + User userOut = null; + for (User user: users){ + if(userID.equals(user.getUserID())){ + userOut = user; + break; + } + } + return userOut; + } + +} diff --git a/src/test/com/zipcode/macrolabs/atm/RandomUtilsTest.java b/src/test/com/zipcode/macrolabs/atm/RandomUtilsTest.java new file mode 100644 index 0000000..fa9b416 --- /dev/null +++ b/src/test/com/zipcode/macrolabs/atm/RandomUtilsTest.java @@ -0,0 +1,24 @@ +package com.zipcode.macrolabs.atm; + +import org.junit.Test; + +import static org.junit.Assert.*; + +public class RandomUtilsTest { + @Test + public void createFloat() throws Exception { + } + + @Test + public void createInteger() throws Exception { + } + + @Test + public void createCharacter() throws Exception { + } + + @Test + public void createString() throws Exception { + } + +} diff --git a/src/test/com/zipcode/macrolabs/atm/bankaccount/AccountFactoryTest.java b/src/test/com/zipcode/macrolabs/atm/bankaccount/AccountFactoryTest.java new file mode 100644 index 0000000..e0d0c5e --- /dev/null +++ b/src/test/com/zipcode/macrolabs/atm/bankaccount/AccountFactoryTest.java @@ -0,0 +1,116 @@ +package com.zipcode.macrolabs.atm.bankaccount; + +import com.zipcode.macrolabs.atm.exceptions.*; +import com.zipcode.macrolabs.atm.transaction.*; +import com.zipcode.macrolabs.atm.user.*; + +import org.junit.*; + +import java.util.ArrayList; + +public class AccountFactoryTest { + + Account[] accounts = new Account[3]; + User user; + Account checkingAccount; + Account savingsAccount; + Account investmentAccount; + + @Before + public void setUp(){ + user = UserFactory.createNewUser("Uncle Bob", "cleancode"); + checkingAccount = AccountFactory.createNewCheckingAccount(user); + accounts[0] = checkingAccount; + savingsAccount = AccountFactory.createNewSavingsAccount(user); + accounts[1] = savingsAccount; + investmentAccount = AccountFactory.createNewInvestmentAccount(user); + accounts[2] = investmentAccount; + AccountFactory.iteratedAccountID = 0; + } + + @After + public void tearDown(){ + AccountFactory.iteratedAccountID = 0; + } + + @Test(expected = NoMoreAccountsException.class) + public void noMoreAccountsTest() throws NoMoreAccountsException { + AccountFactory.iteratedAccountID += (int) Math.pow(10, AccountFactory.ACCOUNT_ID_LENGTH); + int nextID = AccountFactory.nextAccountID(); + } + + + @Test + public void setIDTest() { + int expectedID = 5; + for(Account account: accounts) { + account.setAccountID(5); + int actualID = Integer.valueOf(account.getAccountID()); + Assert.assertEquals(expectedID, actualID); + } + } + + @Test + public void iteratingIDTest(){ + int iterations = 5; + for (int i = 0; i < iterations; i++) { + AccountFactory.createNewCheckingAccount(user); + } + Assert.assertEquals(iterations, AccountFactory.iteratedAccountID); + } + + @Test + public void setAccountBalanceTest(){ + for(Account account: accounts) { + double expectedBalance = 0.00d; + Assert.assertEquals(expectedBalance, account.getBalance(), 0.001d); + } + } + + @Test + public void setAccountTypeTest(){ + + AccountType expectedType1 = AccountType.CHECKING; + AccountType accountType1 = checkingAccount.getAccountType(); + System.out.println(accountType1); + Assert.assertEquals(expectedType1, accountType1); + + AccountType expectedType2 = AccountType.SAVINGS; + AccountType accountType2 = savingsAccount.getAccountType(); + System.out.println(accountType2); + Assert.assertEquals(expectedType2, accountType2); + + AccountType expectedType3 = AccountType.INVESTMENT; + AccountType accountType3 = investmentAccount.getAccountType(); + System.out.println(accountType3); + Assert.assertEquals(expectedType3, accountType3); + } + + @Test + public void setUserTest(){ + for(Account account: accounts) { + int expectedUserCount = 1; + ArrayList users = account.getAccountUsers(); + Assert.assertEquals(expectedUserCount, users.size()); + } + } + + @Test + public void setAccountStatusTest(){ + for(Account account: accounts) { + AccountStatus expectedStatus = AccountStatus.ACTIVE; + Assert.assertEquals(expectedStatus, account.getAccountStatus()); + } + } + + @Test + public void setTransactionTest(){ + for(Account account: accounts) { + int expectedTransactionCount = 0; + ArrayList transactions = account.getTransactionHistory(); + Assert.assertEquals(expectedTransactionCount, transactions.size()); + } + } + + +} diff --git a/src/test/com/zipcode/macrolabs/atm/bankaccount/AccountTestSuite.java b/src/test/com/zipcode/macrolabs/atm/bankaccount/AccountTestSuite.java new file mode 100644 index 0000000..32cb8a6 --- /dev/null +++ b/src/test/com/zipcode/macrolabs/atm/bankaccount/AccountTestSuite.java @@ -0,0 +1,14 @@ +package com.zipcode.macrolabs.atm.bankaccount; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; + +@RunWith(Suite.class) + +@Suite.SuiteClasses({ + CheckingAccountTest.class, + SavingsAccountTest.class, + InvestmentAccountTest.class +}) + +public class AccountTestSuite {} diff --git a/src/test/com/zipcode/macrolabs/atm/bankaccount/CheckingAccountTest.java b/src/test/com/zipcode/macrolabs/atm/bankaccount/CheckingAccountTest.java new file mode 100644 index 0000000..c9d5ec8 --- /dev/null +++ b/src/test/com/zipcode/macrolabs/atm/bankaccount/CheckingAccountTest.java @@ -0,0 +1,168 @@ +package com.zipcode.macrolabs.atm.bankaccount; + +import com.zipcode.macrolabs.atm.bankaccount.Account; +import com.zipcode.macrolabs.atm.bankaccount.CheckingAccount; +import com.zipcode.macrolabs.atm.exceptions.*; +import com.zipcode.macrolabs.atm.transaction.Transaction; +import com.zipcode.macrolabs.atm.transaction.TransactionType; +import com.zipcode.macrolabs.atm.user.User; +import com.zipcode.macrolabs.atm.user.UserFactory; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.junit.rules.ExpectedException; + +public class CheckingAccountTest { + + Account account; + + @Before + public void initialize() { + User user = UserFactory.createNewUser("Uncle Bob", "cleancode"); + account = AccountFactory.createNewCheckingAccount(user); + } + + @Test + public void setAndGetBalanceTest(){ + account.setBalance(1000.00d); + + double expected = 1000.00d; + double actual = account.getBalance(); + + Assert.assertEquals(expected, actual, 0.001d); + } + + @Test + public void getAccountTypeTest(){ + AccountType expected = AccountType.CHECKING; + AccountType actual = account.getAccountType(); + + Assert.assertEquals(expected, actual); + } + + @Test + public void getAccountIDTest(){ + Assert.assertTrue(account.getAccountID().length() == AccountFactory.ACCOUNT_ID_LENGTH); + Assert.assertTrue(Integer.valueOf(account.getAccountID()) > 0); + } + + @Test + public void withdrawBalanceShouldDecreaseTest() throws BalanceTooLowException, TransactionAmountIsZeroException { + + account.setBalance(1000.00d); + + account.withdrawAndMakeTransaction(500.00d); + + double expected = 500.00d; + double actual = account.getBalance(); + + Assert.assertEquals(expected, actual, 0.001d); + + } + + @Test(expected = TransactionAmountIsZeroException.class) + public void withdrawShouldBeMoreThanAPennyTest() throws TransactionAmountIsZeroException, BalanceTooLowException { + + account.setBalance(1000.00d); + account.withdrawAndMakeTransaction(0.00d); + + } + + @Test(expected = BalanceTooLowException.class) + public void cantWithdrawIfBalanceLessThanAmount() throws BalanceTooLowException, TransactionAmountIsZeroException{ + + account.setBalance(50); + account.withdrawAndMakeTransaction(1000); + + } + + @Test + public void withdrawShouldMakeWithdrawalTransactionTest() throws BalanceTooLowException, TransactionAmountIsZeroException { + + Transaction transaction; + account.setBalance(1000.00d); + transaction = account.withdrawAndMakeTransaction(500.00d); + + Assert.assertTrue(transaction instanceof Transaction && transaction.getTransactionType().equals(TransactionType.WITHDRAWAL)); + } + + @Test + public void depositBalanceShouldIncreaseTest() throws TransactionAmountIsZeroException { + + account.setBalance(1000.00d); + + account.depositAndMakeTransaction(500.00d); + + double expected = 1500.00d; + double actual = account.getBalance(); + + Assert.assertEquals(expected, actual, 0.001d); + + } +// + @Test(expected = TransactionAmountIsZeroException.class) + public void depositShouldBeMoreThanAPennyTest() throws TransactionAmountIsZeroException { + + account.setBalance(1000.00d); + account.depositAndMakeTransaction(0.00d); + + } + + @Test + public void depositShouldMakeDepositTransactionTest() throws TransactionAmountIsZeroException { + + Transaction transaction; + account.setBalance(1000.00d); + + transaction = account.depositAndMakeTransaction(500.00d); + + Assert.assertTrue(transaction instanceof Transaction && transaction.getTransactionType().equals(TransactionType.DEPOSIT)); + + } + +// @Test +// public void transferBalanceShouldMove() { +// +// Account accountOther = new CheckingAccount(); +// account.setBalance(1000.00d); +// accountOther.setBalance(1000.00d); +// +// account.transferAndMakeTransaction(500.00d, accountOther); +// +// double expected = 500.00d; +// double expectedOther = 1500.00d; +// double actual = account.getBalance(); +// double actualOther = accountOther.getBalance(); +// +// Assert.assertEquals(expected, actual, 0.001d); +// Assert.assertEquals(expectedOther, actualOther, 0.001d); +// } +// +// +// public String printHistory(){ +// +// return null; +// +// } +// +// public Transaction[] getHistory(){ +// +// return null; +// +// } +// +// public abstract accountTypeEnum getAccountType(){ +// +// return null; +// +// } +// +// public CheckingAccountTest(){ +// +// } +// +// @Override +// public accountTypeEnum getAccountType() { +// return null; +// } +} diff --git a/src/test/com/zipcode/macrolabs/atm/bankaccount/InvestmentAccountTest.java b/src/test/com/zipcode/macrolabs/atm/bankaccount/InvestmentAccountTest.java new file mode 100644 index 0000000..d6e3efb --- /dev/null +++ b/src/test/com/zipcode/macrolabs/atm/bankaccount/InvestmentAccountTest.java @@ -0,0 +1,9 @@ +package com.zipcode.macrolabs.atm.bankaccount; + +public class InvestmentAccountTest { + + public InvestmentAccountTest(){ + + } + +} diff --git a/src/test/com/zipcode/macrolabs/atm/bankaccount/SavingsAccountTest.java b/src/test/com/zipcode/macrolabs/atm/bankaccount/SavingsAccountTest.java new file mode 100644 index 0000000..aa8efa5 --- /dev/null +++ b/src/test/com/zipcode/macrolabs/atm/bankaccount/SavingsAccountTest.java @@ -0,0 +1,6 @@ +package com.zipcode.macrolabs.atm.bankaccount; + +public class SavingsAccountTest { + + +} diff --git a/src/test/com/zipcode/macrolabs/atm/user/UserFactoryTest.java b/src/test/com/zipcode/macrolabs/atm/user/UserFactoryTest.java new file mode 100644 index 0000000..7ca3aa2 --- /dev/null +++ b/src/test/com/zipcode/macrolabs/atm/user/UserFactoryTest.java @@ -0,0 +1,61 @@ +package com.zipcode.macrolabs.atm.user; + +import com.zipcode.macrolabs.atm.exceptions.NoMoreUsersException; +import org.junit.*; + +public class UserFactoryTest { + + User user; + String name = "Uncle Bob"; + String password = "cleancode"; + + @Before + public void setUp(){ + user = UserFactory.createNewUser(name, password); + UserFactory.iteratedUserID = 0; + } + + @After + public void tearDown(){ + UserFactory.iteratedUserID = 0; + } + + @Test(expected = NoMoreUsersException.class) + public void noMoreUserIDsTest() throws NoMoreUsersException { + UserFactory.iteratedUserID += (int) Math.pow(10, UserFactory.USER_ID_LENGTH); + int nextID = UserFactory.nextUserID(); + } + + @Test + public void setAndGetUserIDTestShouldBe7(){ + user.setUserID(7); + int expectedID = 7; + int actualID = Integer.valueOf(user.getUserID()); + Assert.assertEquals(expectedID, actualID); + } + + @Test + public void iteratingIDTest(){ + int iterations = 5; + for (int i = 0; i < iterations; i++) { + UserFactory.createNewUser("Uncle Bob", "clean code"); + } + Assert.assertEquals(iterations, UserFactory.iteratedUserID); + } + + @Test + public void setUserNameTestShouldBeUncleBob(){ + Assert.assertEquals(name, user.getUserName()); + } + + @Test + public void setUserPasswordShouldBeCleanCode(){ + Assert.assertEquals(password, user.getUserPassword()); + } + + @Test + public void setUserAccountsTestShouldBeEmpty(){ + Assert.assertEquals(0, user.getAccounts().size()); + } + +} diff --git a/src/test/com/zipcode/macrolabs/atm/user/UserTest.java b/src/test/com/zipcode/macrolabs/atm/user/UserTest.java new file mode 100644 index 0000000..29a9b34 --- /dev/null +++ b/src/test/com/zipcode/macrolabs/atm/user/UserTest.java @@ -0,0 +1,79 @@ +package com.zipcode.macrolabs.atm.user; + +import com.zipcode.macrolabs.atm.bankaccount.AccountType; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Ignore; +import org.junit.Test; + +public class UserTest { + + User user; + + @Before + public void setUp(){ + user = UserFactory.createNewUser("Uncle Bob", "cleancode"); + } + + @Test + public void getAndSetUserNameTest(){ + user.setUserName("Code Man"); + String expectedName = "Code Man"; + String actualName = user.getUserName(); + Assert.assertEquals(expectedName, actualName); + } + + @Test + public void getAndSetUserPasswordTest(){ + user.setUserPassword("dirtydancing"); + String expectedPassword = "dirtydancing"; + String actualPassword = user.getUserPassword(); + Assert.assertEquals(expectedPassword, actualPassword); + } + + @Test + public void getAndSetUserIDTest(){ + user.setUserID(55555); + String expectedUserID = "000055555"; + String actualUserID = user.getUserID(); + Assert.assertEquals(expectedUserID, actualUserID); + } + + @Test + public void getAccountInfoTest(){ + user.createNewAccount(AccountType.CHECKING); + user.createNewAccount(AccountType.SAVINGS); + user.createNewAccount(AccountType.INVESTMENT); + System.out.println(user.getAllUserAccountInfo()); + } + + @Test + public void createAndAddNewAccountTest(){ + int initialAccountCount = user.getAccounts().size(); + user.createNewAccount(AccountType.CHECKING); + user.createNewAccount(AccountType.SAVINGS); + user.createNewAccount(AccountType.INVESTMENT); + int afterAccountCount = user.getAccounts().size(); + int actualCountDifference = afterAccountCount - initialAccountCount; + int expectedCountDifference = 3; + Assert.assertEquals(expectedCountDifference, actualCountDifference); + } + + @Test + public void addUserToAccountTest(){ + for (int i = 0; i < 5; i++) { + UserFactory.createNewUser("Uncle Bob", "cleancode"); + } + user.createNewAccount(AccountType.CHECKING); + user.createNewAccount(AccountType.SAVINGS); + user.createNewAccount(AccountType.INVESTMENT); + int accountIndex = 1; + int initialAccountUserNumber = user.getAccounts().get(accountIndex).getAccountUsers().size(); + user.addAnotherUserToExistingAccount(accountIndex, UserWarehouse.findUserByID("000000003")); + int afterAccountUserNumber = user.getAccounts().get(accountIndex).getAccountUsers().size(); + int actualCountDifference = afterAccountUserNumber - initialAccountUserNumber; + int expectedCountDifference = 1; + Assert.assertEquals(expectedCountDifference, actualCountDifference); + } + +} diff --git a/src/test/com/zipcode/macrolabs/atm/user/UserTestSuite.java b/src/test/com/zipcode/macrolabs/atm/user/UserTestSuite.java new file mode 100644 index 0000000..f8f9a0c --- /dev/null +++ b/src/test/com/zipcode/macrolabs/atm/user/UserTestSuite.java @@ -0,0 +1,13 @@ +package com.zipcode.macrolabs.atm.user; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; + +@RunWith(Suite.class) +@Suite.SuiteClasses({ + UserTest.class, + UserFactoryTest.class, + UserWarehouseTest.class +}) +public class UserTestSuite { +} diff --git a/src/test/com/zipcode/macrolabs/atm/user/UserWarehouseTest.java b/src/test/com/zipcode/macrolabs/atm/user/UserWarehouseTest.java new file mode 100644 index 0000000..e66ffce --- /dev/null +++ b/src/test/com/zipcode/macrolabs/atm/user/UserWarehouseTest.java @@ -0,0 +1,35 @@ +package com.zipcode.macrolabs.atm.user; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +public class UserWarehouseTest { + + @Before + public void setUp(){ + UserFactory.iteratedUserID = 0; + } + + @Test + public void addOnePersonTest(){ + int initial = UserWarehouse.getUsers().size(); + UserFactory.createNewUser("Uncle Bob", "cleancode"); + int after = UserWarehouse.getUsers().size(); + int expectedSizeChange = 1; + int actualSizeChange = after - initial; + Assert.assertEquals(expectedSizeChange, actualSizeChange); + } + + @Test + public void findUserByIDTest(){ + String id = "000000003"; + for (int i = 0; i < 5; i++) { + UserFactory.createNewUser("Uncle Bob", "cleancode"); + } + User user = UserWarehouse.findUserByID(id); + + Assert.assertEquals(id, user.getUserID()); + } + +} From d68f34b3a4e6777df68f208f40c3780f35add6cc Mon Sep 17 00:00:00 2001 From: pavel Date: Tue, 24 Oct 2017 21:17:14 -0400 Subject: [PATCH 2/4] User package implementation and testing should be finished --- .../macrolabs/atm/bankaccount/Account.java | 1 + .../com/zipcode/macrolabs/atm/user/User.java | 3 +- .../zipcode/macrolabs/atm/user/UserTest.java | 48 +++++++++++++++++++ 3 files changed, 50 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/zipcode/macrolabs/atm/bankaccount/Account.java b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/Account.java index cee84ec..00472b2 100644 --- a/src/main/java/com/zipcode/macrolabs/atm/bankaccount/Account.java +++ b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/Account.java @@ -91,6 +91,7 @@ public Transaction[] getHistory(){ public abstract AccountType getAccountType(); public void setAccountStatus(AccountStatus accountStatus){ + this.accountStatus = accountStatus; } diff --git a/src/main/java/com/zipcode/macrolabs/atm/user/User.java b/src/main/java/com/zipcode/macrolabs/atm/user/User.java index 38c491a..f2556e9 100644 --- a/src/main/java/com/zipcode/macrolabs/atm/user/User.java +++ b/src/main/java/com/zipcode/macrolabs/atm/user/User.java @@ -40,7 +40,7 @@ public void setUserPassword(String userPassword) { } public void addAnotherUserToExistingAccount(int accountIndex, User anotherUser){ - + this.getAccounts().get(accountIndex).addUser(anotherUser); } public void addAccount(Account newAccount){ @@ -75,7 +75,6 @@ public void closeAccount(int accountIndex) throws AccountNotEmptyException { if(thisAccount.getBalance() < 0.001d){ thisAccount.setAccountStatus(AccountStatus.CLOSED); } else {throw new AccountNotEmptyException();} - } public void setUserID(int userID) { diff --git a/src/test/com/zipcode/macrolabs/atm/user/UserTest.java b/src/test/com/zipcode/macrolabs/atm/user/UserTest.java index 29a9b34..7517334 100644 --- a/src/test/com/zipcode/macrolabs/atm/user/UserTest.java +++ b/src/test/com/zipcode/macrolabs/atm/user/UserTest.java @@ -1,6 +1,10 @@ package com.zipcode.macrolabs.atm.user; +import com.zipcode.macrolabs.atm.bankaccount.Account; +import com.zipcode.macrolabs.atm.bankaccount.AccountStatus; import com.zipcode.macrolabs.atm.bankaccount.AccountType; +import com.zipcode.macrolabs.atm.exceptions.AccountNotEmptyException; +import com.zipcode.macrolabs.atm.exceptions.TransactionAmountIsZeroException; import org.junit.Assert; import org.junit.Before; import org.junit.Ignore; @@ -67,6 +71,7 @@ public void addUserToAccountTest(){ user.createNewAccount(AccountType.CHECKING); user.createNewAccount(AccountType.SAVINGS); user.createNewAccount(AccountType.INVESTMENT); + int accountIndex = 1; int initialAccountUserNumber = user.getAccounts().get(accountIndex).getAccountUsers().size(); user.addAnotherUserToExistingAccount(accountIndex, UserWarehouse.findUserByID("000000003")); @@ -76,4 +81,47 @@ public void addUserToAccountTest(){ Assert.assertEquals(expectedCountDifference, actualCountDifference); } + @Test + public void removeAccountExecutionTest() throws AccountNotEmptyException { + + user.createNewAccount(AccountType.CHECKING); + user.createNewAccount(AccountType.SAVINGS); + user.createNewAccount(AccountType.INVESTMENT); + + int initialAccountCount = user.getAccounts().size(); + user.removeAccount(0); + int afterAccountCount = user.getAccounts().size(); + int expectedCountDifference = -1; + int actualCountDifference = afterAccountCount - initialAccountCount; + Assert.assertEquals(expectedCountDifference, actualCountDifference); + } + + @Test(expected = AccountNotEmptyException.class) + public void removeAccountBalanceExceptionTest() throws TransactionAmountIsZeroException, AccountNotEmptyException { + user.createNewAccount(AccountType.CHECKING); + Account activeAccount = user.getAccounts().get(0); + + activeAccount.depositAndMakeTransaction(50); + user.removeAccount(0); + } + + @Test + public void closeAccountStatusTest() throws AccountNotEmptyException { + + user.createNewAccount(AccountType.CHECKING); + user.closeAccount(0); + + AccountStatus expectedStatus = AccountStatus.CLOSED; + AccountStatus actualStatus = user.getAccounts().get(0).getAccountStatus(); + Assert.assertEquals(expectedStatus, actualStatus); + } + + @Test(expected = AccountNotEmptyException.class) + public void closeAccountBalanceExceptionTest() throws AccountNotEmptyException, TransactionAmountIsZeroException { + user.createNewAccount(AccountType.CHECKING); + Account activeAccount = user.getAccounts().get(0); + activeAccount.depositAndMakeTransaction(50); + user.closeAccount(0); + } + } From 4b4d6e0486a801d7271f20f1e7ab4abc62a436bf Mon Sep 17 00:00:00 2001 From: pavel Date: Wed, 25 Oct 2017 15:09:58 -0400 Subject: [PATCH 3/4] Backend Alpha Version --- .../zipcode/macrolabs/atm/RandomUtils.java | 15 +++ .../macrolabs/atm/bankaccount/Account.java | 67 +++++----- .../atm/bankaccount/AccountFactory.java | 39 +++--- .../atm/bankaccount/AccountWarehouse.java | 28 +++++ .../atm/bankaccount/CheckingAccount.java | 9 +- .../atm/bankaccount/InvestmentAccount.java | 9 +- .../atm/bankaccount/SavingsAccount.java | 9 +- .../TransactionAmountIsZeroException.java | 2 +- .../atm/transaction/Transaction.java | 45 ++++++- .../atm/transaction/TransactionFactory.java | 38 +++++- .../atm/transaction/TransferTransaction.java | 24 ++++ .../com/zipcode/macrolabs/atm/user/User.java | 2 +- .../macrolabs/atm/user/UserFactory.java | 15 ++- .../zipcode/macrolabs/atm/AllTestsSuite.java | 18 +++ .../atm/bankaccount/AccountFactoryTest.java | 11 -- .../atm/bankaccount/AccountTestSuite.java | 4 +- .../atm/bankaccount/AccountWarehouseTest.java | 40 ++++++ .../atm/bankaccount/CheckingAccountTest.java | 115 +++++++++++------- .../bankaccount/InvestmentAccountTest.java | 21 +++- .../atm/bankaccount/SavingsAccountTest.java | 22 ++++ .../atm/navigation/NavigationTestSuite.java | 11 ++ .../transaction/TransactionFactoryTest.java | 76 ++++++++++++ .../atm/transaction/TransactionTestSuite.java | 11 ++ .../macrolabs/atm/user/UserFactoryTest.java | 18 ++- .../zipcode/macrolabs/atm/user/UserTest.java | 2 +- .../macrolabs/atm/user/UserWarehouseTest.java | 4 +- 26 files changed, 494 insertions(+), 161 deletions(-) create mode 100644 src/main/java/com/zipcode/macrolabs/atm/bankaccount/AccountWarehouse.java create mode 100644 src/main/java/com/zipcode/macrolabs/atm/transaction/TransferTransaction.java create mode 100644 src/test/com/zipcode/macrolabs/atm/AllTestsSuite.java create mode 100644 src/test/com/zipcode/macrolabs/atm/bankaccount/AccountWarehouseTest.java create mode 100644 src/test/com/zipcode/macrolabs/atm/navigation/NavigationTestSuite.java create mode 100644 src/test/com/zipcode/macrolabs/atm/transaction/TransactionFactoryTest.java create mode 100644 src/test/com/zipcode/macrolabs/atm/transaction/TransactionTestSuite.java diff --git a/src/main/java/com/zipcode/macrolabs/atm/RandomUtils.java b/src/main/java/com/zipcode/macrolabs/atm/RandomUtils.java index e090775..bee3549 100644 --- a/src/main/java/com/zipcode/macrolabs/atm/RandomUtils.java +++ b/src/main/java/com/zipcode/macrolabs/atm/RandomUtils.java @@ -14,6 +14,13 @@ public static Integer createInteger(Integer min, Integer max) { return createFloat(min, max).intValue(); } + public static Boolean createBoolean(Integer skew){ + int seed = createInteger(0, 100); + if (skew > seed){ + return true; + } else { return false; } + } + public static Character createCharacter(char min, char max) { return (char) createInteger((int) min, (int) max).intValue(); } @@ -26,4 +33,12 @@ public static String createString(char min, char max, int stringLength) { return sb.toString(); } + public static String createID(int idLength){ + String id = ""; + for (int i = 0; i < idLength; i++) { + id += i; + } + return id; + } + } diff --git a/src/main/java/com/zipcode/macrolabs/atm/bankaccount/Account.java b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/Account.java index 00472b2..3a693b9 100644 --- a/src/main/java/com/zipcode/macrolabs/atm/bankaccount/Account.java +++ b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/Account.java @@ -4,6 +4,7 @@ import com.zipcode.macrolabs.atm.exceptions.TransactionAmountIsZeroException; import com.zipcode.macrolabs.atm.transaction.Transaction; import com.zipcode.macrolabs.atm.transaction.TransactionFactory; +import com.zipcode.macrolabs.atm.transaction.TransactionType; import com.zipcode.macrolabs.atm.user.User; import java.nio.file.attribute.UserDefinedFileAttributeView; @@ -12,13 +13,20 @@ public abstract class Account { - protected int accountID = 0; + protected String accountID; protected AccountType accountType; private double accountBalance = 0.00d; private List accountUsers = new ArrayList(); private AccountStatus accountStatus = AccountStatus.ACTIVE; private List accountTransactionHistory = new ArrayList(); + @Override + public String toString(){ + String accountInfo = String.format("Account - ID: %s | Type: %s | Balance: %,.2f | Status: %s | Users: %s ", + this.getAccountID(), this.getAccountType(), this.getBalance(), + this.getAccountStatus(), this.getAccountUsers()); + return accountInfo; + } public double getBalance() { return this.accountBalance; @@ -28,8 +36,12 @@ public void setBalance(double accountBalance) { this.accountBalance = accountBalance; } + public void setAccountID(int accountID) { + this.accountID = String.format( "%0" + AccountFactory.ACCOUNT_ID_LENGTH + "d", accountID); + } + public String getAccountID() { - return String.format( "%0" + AccountFactory.ACCOUNT_ID_LENGTH + "d", accountID); + return this.accountID; } public void addUser(User user) { @@ -40,15 +52,9 @@ public AccountStatus getAccountStatus() { return accountStatus; } - public void setAccountID(int accountID) { - this.accountID = accountID; - } - public String getAccountInfo(){ - String accountInfo = String.format("Account - ID: %s | Type: %s | Balance: %,.2f | Status: %s | Users: %s\n", - this.getAccountID(), this.getAccountType(), this.getBalance(), - this.getAccountStatus(), this.getAccountUsers()); - return accountInfo; + public void addTransactionToHistory(Transaction transaction){ + this.getTransactionHistory().add(transaction); } public Transaction withdrawAndMakeTransaction(double amount) throws TransactionAmountIsZeroException, BalanceTooLowException { @@ -56,10 +62,10 @@ public Transaction withdrawAndMakeTransaction(double amount) throws TransactionA if(amount >= 0.001) { if (this.accountBalance >= amount) { this.accountBalance -= amount; - Transaction newTransaction = TransactionFactory.createNewTransaction(); + Transaction newTransaction = TransactionFactory.createNewWithdrawal(amount, this); + addTransactionToHistory(newTransaction); return newTransaction; - } else { System.out.println("Sorry, your balance is too low! Requested: " + amount + ". Available: " + this.accountBalance + "."); - throw new BalanceTooLowException(); } + } else { throw new BalanceTooLowException(); } } else { throw new TransactionAmountIsZeroException(); } } @@ -68,39 +74,44 @@ public Transaction depositAndMakeTransaction(double amount) throws TransactionAm if(amount >= 0.001) { this.accountBalance += amount; - Transaction newTransaction = TransactionFactory.createNewTransaction(); + Transaction newTransaction = TransactionFactory.createNewDeposit(amount, this); + addTransactionToHistory(newTransaction); return newTransaction; } else { throw new TransactionAmountIsZeroException(); } } - public Transaction transferAndMakeTransaction(double amount, String destinationAccountID){ - return null; - } - - public String printHistory(){ - return null; - } - - public Transaction[] getHistory(){ - return null; + public Transaction transferAndMakeTransaction(double amount, Account destinationAccount) throws TransactionAmountIsZeroException, BalanceTooLowException { + if(amount >= 0.001) { + if (this.accountBalance >= amount) { + this.accountBalance -= amount; + destinationAccount.accountBalance += amount; + Transaction newTransaction = TransactionFactory.createNewTransfer(amount, this, destinationAccount); + addTransactionToHistory(newTransaction); + return newTransaction; + } else { throw new BalanceTooLowException(); } + } else { throw new TransactionAmountIsZeroException(); } } - public abstract void setAccountType(); - public abstract AccountType getAccountType(); public void setAccountStatus(AccountStatus accountStatus){ this.accountStatus = accountStatus; } - public ArrayList getAccountUsers() { return (ArrayList) accountUsers; } - public ArrayList getTransactionHistory() { return (ArrayList) accountTransactionHistory; } + + public String printTransactionHistory(){ + String history = ""; + for (Transaction transaction: this.getTransactionHistory()) { + history += transaction.toString() + "\n"; + } + return history; + } } diff --git a/src/main/java/com/zipcode/macrolabs/atm/bankaccount/AccountFactory.java b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/AccountFactory.java index ad569df..ad0921c 100644 --- a/src/main/java/com/zipcode/macrolabs/atm/bankaccount/AccountFactory.java +++ b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/AccountFactory.java @@ -6,45 +6,38 @@ public class AccountFactory { static int iteratedAccountID = 0; - public static final int ACCOUNT_ID_LENGTH = 9; + static final int ACCOUNT_ID_LENGTH = 9; - public static int nextAccountID() throws NoMoreAccountsException { + static int nextAccountID() throws NoMoreAccountsException { if((""+ iteratedAccountID).length() <= ACCOUNT_ID_LENGTH) { return iteratedAccountID++; } else { throw new NoMoreAccountsException(); } } - public static CheckingAccount createNewCheckingAccount(User user) { - CheckingAccount newCheckingAccount = new CheckingAccount(); - newCheckingAccount.addUser(user); + private static Account accountCreatorHelper(Account account, User user){ try { - newCheckingAccount.setAccountID(nextAccountID()); + account.setAccountID(nextAccountID()); } catch (NoMoreAccountsException e) { e.printStackTrace(); } - return newCheckingAccount; + account.addUser(user); + AccountWarehouse.addAccount(account); + return account; + } + + public static CheckingAccount createNewCheckingAccount(User user) { + CheckingAccount account = new CheckingAccount(); + return (CheckingAccount) accountCreatorHelper(account, user); } public static SavingsAccount createNewSavingsAccount(User user) { - SavingsAccount newSavingsAccount = new SavingsAccount(); - newSavingsAccount.addUser(user); - try { - newSavingsAccount.setAccountID(nextAccountID()); - } catch (NoMoreAccountsException e) { - e.printStackTrace(); - } - return newSavingsAccount; + SavingsAccount account = new SavingsAccount(); + return (SavingsAccount) accountCreatorHelper(account, user); } public static InvestmentAccount createNewInvestmentAccount(User user) { - InvestmentAccount newInvestmentAccount = new InvestmentAccount(); - newInvestmentAccount.addUser(user); - try { - newInvestmentAccount.setAccountID(nextAccountID());; - } catch (NoMoreAccountsException e) { - e.printStackTrace(); - } - return newInvestmentAccount; + InvestmentAccount account = new InvestmentAccount(); + return (InvestmentAccount) accountCreatorHelper(account, user); } } diff --git a/src/main/java/com/zipcode/macrolabs/atm/bankaccount/AccountWarehouse.java b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/AccountWarehouse.java new file mode 100644 index 0000000..659e8a4 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/AccountWarehouse.java @@ -0,0 +1,28 @@ +package com.zipcode.macrolabs.atm.bankaccount; + +import java.util.ArrayList; +import java.util.List; + +public class AccountWarehouse { + + private static final List accounts = new ArrayList(); + + public static void addAccount(Account account) { + accounts.add(account); + } + + public static List getAccounts() { + return accounts; + } + + public static Account findAccountByID(String accountID){ + Account accountOut = null; + for (Account account: accounts){ + if(accountID.equals(account.getAccountID())){ + accountOut = account; + break; + } + } + return accountOut; + } +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/bankaccount/CheckingAccount.java b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/CheckingAccount.java index 8247170..4273e72 100644 --- a/src/main/java/com/zipcode/macrolabs/atm/bankaccount/CheckingAccount.java +++ b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/CheckingAccount.java @@ -2,14 +2,7 @@ public class CheckingAccount extends Account { - public CheckingAccount(){ - setAccountType(); - } - - @Override - public void setAccountType() { - this.accountType = AccountType.CHECKING; - } + public CheckingAccount(){ } @Override public AccountType getAccountType() { diff --git a/src/main/java/com/zipcode/macrolabs/atm/bankaccount/InvestmentAccount.java b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/InvestmentAccount.java index f2b9d62..4e7609a 100644 --- a/src/main/java/com/zipcode/macrolabs/atm/bankaccount/InvestmentAccount.java +++ b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/InvestmentAccount.java @@ -2,14 +2,7 @@ public class InvestmentAccount extends Account { - public InvestmentAccount(){ - setAccountType(); - } - - @Override - public void setAccountType() { - this.accountType = AccountType.INVESTMENT; - } + public InvestmentAccount(){ } @Override public AccountType getAccountType() { diff --git a/src/main/java/com/zipcode/macrolabs/atm/bankaccount/SavingsAccount.java b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/SavingsAccount.java index 6906576..8ffbceb 100644 --- a/src/main/java/com/zipcode/macrolabs/atm/bankaccount/SavingsAccount.java +++ b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/SavingsAccount.java @@ -2,14 +2,7 @@ public class SavingsAccount extends Account { - public SavingsAccount(){ - setAccountType(); - } - - @Override - public void setAccountType() { - this.accountType = AccountType.SAVINGS; - } + public SavingsAccount(){ } @Override public AccountType getAccountType() { diff --git a/src/main/java/com/zipcode/macrolabs/atm/exceptions/TransactionAmountIsZeroException.java b/src/main/java/com/zipcode/macrolabs/atm/exceptions/TransactionAmountIsZeroException.java index 0776c05..58d4543 100644 --- a/src/main/java/com/zipcode/macrolabs/atm/exceptions/TransactionAmountIsZeroException.java +++ b/src/main/java/com/zipcode/macrolabs/atm/exceptions/TransactionAmountIsZeroException.java @@ -3,7 +3,7 @@ public class TransactionAmountIsZeroException extends Exception{ public TransactionAmountIsZeroException(){ - System.out.println("Please don't waste out time with $0.00 transactions."); + System.out.println("Please don't waste our time with $0.00 transactions."); } } diff --git a/src/main/java/com/zipcode/macrolabs/atm/transaction/Transaction.java b/src/main/java/com/zipcode/macrolabs/atm/transaction/Transaction.java index 92c4425..8d6845e 100644 --- a/src/main/java/com/zipcode/macrolabs/atm/transaction/Transaction.java +++ b/src/main/java/com/zipcode/macrolabs/atm/transaction/Transaction.java @@ -1,18 +1,55 @@ package com.zipcode.macrolabs.atm.transaction; +import com.zipcode.macrolabs.atm.bankaccount.Account; + +import java.util.Date; + public class Transaction { - TransactionType transactionType; + Date date; + double amount; + final TransactionType transactionType; + String transactionID; + Account originAccount; - public TransactionType getTransactionType() { + @Override + public String toString(){ + return String.format("Date: %s | ID: %s | Type: %s | Amount: $%,.2f | Account: %s ", + this.date, this.transactionID, this.transactionType, this.amount, this.originAccount.getAccountID()); + } + public Transaction(TransactionType transactionType, double amount){ + this.transactionType = transactionType; + this.amount = amount; + this.date = new Date(); + } + + public TransactionType getTransactionType() { return this.transactionType; + } + public Date getDate(){ + return this.date; } - public void setTransactionType(TransactionType transactionType){ + public double getAmount(){ + return this.amount; + } - this.transactionType = transactionType; + public void setTransactionID(int iteratedTransactionID) { + this.transactionID = String.format( "%0" + TransactionFactory.TRANSACTION_ID_LENGTH + "d", iteratedTransactionID); + } + + public String getTransactionID(){ + return this.transactionID; + } + + public Account getOriginAccount(){ + return this.originAccount; + } + public void setOriginAccount(Account originAccount){ + this.originAccount = originAccount; } + } diff --git a/src/main/java/com/zipcode/macrolabs/atm/transaction/TransactionFactory.java b/src/main/java/com/zipcode/macrolabs/atm/transaction/TransactionFactory.java index 9041687..051ba19 100644 --- a/src/main/java/com/zipcode/macrolabs/atm/transaction/TransactionFactory.java +++ b/src/main/java/com/zipcode/macrolabs/atm/transaction/TransactionFactory.java @@ -1,11 +1,43 @@ package com.zipcode.macrolabs.atm.transaction; +import com.zipcode.macrolabs.atm.bankaccount.Account; +import com.zipcode.macrolabs.atm.exceptions.NoMoreTransactionsException; + public class TransactionFactory { - private static int transactionID = 0; + static int iteratedTransactionID = 0; public static final int TRANSACTION_ID_LENGTH = 9; - public static Transaction createNewTransaction() { - return null; + static int nextTransactionID() throws NoMoreTransactionsException { + if (("" + iteratedTransactionID).length() <= TRANSACTION_ID_LENGTH) { + return iteratedTransactionID++; + } else { + throw new NoMoreTransactionsException(); + } + } + + private static Transaction transactionCreatorHelper(Transaction transaction, Account originAccount) { + try { + transaction.setTransactionID(nextTransactionID()); + } catch (NoMoreTransactionsException e) { + e.printStackTrace(); + } + transaction.setOriginAccount(originAccount); + return transaction; + } + + public static Transaction createNewWithdrawal(double amount, Account originAccount) { + Transaction transaction = new Transaction(TransactionType.WITHDRAWAL, amount); + return transactionCreatorHelper(transaction, originAccount); + } + + public static Transaction createNewDeposit(double amount, Account originAccount) { + Transaction transaction = new Transaction(TransactionType.DEPOSIT, amount); + return transactionCreatorHelper(transaction, originAccount); + } + + public static TransferTransaction createNewTransfer(double amount, Account originAccount, Account destinationAccount) { + TransferTransaction transaction = new TransferTransaction(amount, destinationAccount); + return (TransferTransaction) transactionCreatorHelper(transaction, originAccount); } } diff --git a/src/main/java/com/zipcode/macrolabs/atm/transaction/TransferTransaction.java b/src/main/java/com/zipcode/macrolabs/atm/transaction/TransferTransaction.java new file mode 100644 index 0000000..7b79ea1 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/transaction/TransferTransaction.java @@ -0,0 +1,24 @@ +package com.zipcode.macrolabs.atm.transaction; + +import com.zipcode.macrolabs.atm.bankaccount.Account; + +public class TransferTransaction extends Transaction{ + + private Account destinationAccount; + + public TransferTransaction(double amount, Account destinationAccount){ + super(TransactionType.TRANSFER, amount); + this.destinationAccount = destinationAccount; + } + + @Override + public String toString(){ + return String.format("Date: %s | ID: %s | Type: %s | Amount: $%,.2f | From Account: %s | To Account: %s ", + this.date, this.transactionID, this.transactionType, this.amount, this.originAccount.getAccountID(), this.destinationAccount.getAccountID()); + } + + public Account getDestinationAccount() { + return destinationAccount; + } + +} diff --git a/src/main/java/com/zipcode/macrolabs/atm/user/User.java b/src/main/java/com/zipcode/macrolabs/atm/user/User.java index f2556e9..787a41e 100644 --- a/src/main/java/com/zipcode/macrolabs/atm/user/User.java +++ b/src/main/java/com/zipcode/macrolabs/atm/user/User.java @@ -96,7 +96,7 @@ public String getUserPassword() { public String getAllUserAccountInfo() { String allAcountInfo = ""; for (Account account: this.getAccounts()) { - allAcountInfo += account.getAccountInfo(); + allAcountInfo += account.toString(); } return allAcountInfo; } diff --git a/src/main/java/com/zipcode/macrolabs/atm/user/UserFactory.java b/src/main/java/com/zipcode/macrolabs/atm/user/UserFactory.java index 5ff1d0b..103153a 100644 --- a/src/main/java/com/zipcode/macrolabs/atm/user/UserFactory.java +++ b/src/main/java/com/zipcode/macrolabs/atm/user/UserFactory.java @@ -1,5 +1,6 @@ package com.zipcode.macrolabs.atm.user; +import com.zipcode.macrolabs.atm.RandomUtils; import com.zipcode.macrolabs.atm.exceptions.NoMoreAccountsException; import com.zipcode.macrolabs.atm.exceptions.NoMoreUsersException; @@ -26,13 +27,11 @@ public static User createNewUser(String name, String password) { } -// public static User createRandomUser() { -// String name = RandomUtils.createString('a', 'z', 5); -// int age = RandomUtils.createInteger(0, 100); -// boolean isMale = RandomUtils.createBoolean(50); -// -// Person randomPerson = new Person(name, age, isMale); -// return randomPerson; -// } + public static User createRandomUser() { + String name = RandomUtils.createString('a', 'z', 10); + String password = RandomUtils.createString('a', 'z', 8); + User randomUser = new User(name, password); + return randomUser; + } } diff --git a/src/test/com/zipcode/macrolabs/atm/AllTestsSuite.java b/src/test/com/zipcode/macrolabs/atm/AllTestsSuite.java new file mode 100644 index 0000000..b87f00c --- /dev/null +++ b/src/test/com/zipcode/macrolabs/atm/AllTestsSuite.java @@ -0,0 +1,18 @@ +package com.zipcode.macrolabs.atm; + +import com.zipcode.macrolabs.atm.bankaccount.AccountTestSuite; +import com.zipcode.macrolabs.atm.navigation.NavigationTestSuite; +import com.zipcode.macrolabs.atm.transaction.TransactionTestSuite; +import com.zipcode.macrolabs.atm.user.UserTestSuite; +import org.junit.runner.RunWith; +import org.junit.runners.Suite; + +@RunWith(Suite.class) +@Suite.SuiteClasses({ + AccountTestSuite.class, + UserTestSuite.class, + TransactionTestSuite.class, + NavigationTestSuite.class +}) +public class AllTestsSuite { +} diff --git a/src/test/com/zipcode/macrolabs/atm/bankaccount/AccountFactoryTest.java b/src/test/com/zipcode/macrolabs/atm/bankaccount/AccountFactoryTest.java index e0d0c5e..57de714 100644 --- a/src/test/com/zipcode/macrolabs/atm/bankaccount/AccountFactoryTest.java +++ b/src/test/com/zipcode/macrolabs/atm/bankaccount/AccountFactoryTest.java @@ -39,17 +39,6 @@ public void noMoreAccountsTest() throws NoMoreAccountsException { int nextID = AccountFactory.nextAccountID(); } - - @Test - public void setIDTest() { - int expectedID = 5; - for(Account account: accounts) { - account.setAccountID(5); - int actualID = Integer.valueOf(account.getAccountID()); - Assert.assertEquals(expectedID, actualID); - } - } - @Test public void iteratingIDTest(){ int iterations = 5; diff --git a/src/test/com/zipcode/macrolabs/atm/bankaccount/AccountTestSuite.java b/src/test/com/zipcode/macrolabs/atm/bankaccount/AccountTestSuite.java index 32cb8a6..f04f857 100644 --- a/src/test/com/zipcode/macrolabs/atm/bankaccount/AccountTestSuite.java +++ b/src/test/com/zipcode/macrolabs/atm/bankaccount/AccountTestSuite.java @@ -8,7 +8,9 @@ @Suite.SuiteClasses({ CheckingAccountTest.class, SavingsAccountTest.class, - InvestmentAccountTest.class + InvestmentAccountTest.class, + AccountFactoryTest.class, + AccountWarehouseTest.class }) public class AccountTestSuite {} diff --git a/src/test/com/zipcode/macrolabs/atm/bankaccount/AccountWarehouseTest.java b/src/test/com/zipcode/macrolabs/atm/bankaccount/AccountWarehouseTest.java new file mode 100644 index 0000000..791a2e1 --- /dev/null +++ b/src/test/com/zipcode/macrolabs/atm/bankaccount/AccountWarehouseTest.java @@ -0,0 +1,40 @@ +package com.zipcode.macrolabs.atm.bankaccount; + +import com.zipcode.macrolabs.atm.user.User; +import com.zipcode.macrolabs.atm.user.UserFactoryTest; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +public class AccountWarehouseTest { + + @Before + public void setUp(){ + AccountFactory.iteratedAccountID = 0; + } + + @Test + public void addOneAccountTest(){ + int initial = AccountWarehouse.getAccounts().size(); + AccountFactory.createNewCheckingAccount(UserFactoryTest.createBob()); + int after = AccountWarehouse.getAccounts().size(); + int expectedSizeChange = 1; + int actualSizeChange = after - initial; + Assert.assertEquals(expectedSizeChange, actualSizeChange); + } + + @Test + public void findAccountByIDTest(){ + String id = "000000003"; + User user = UserFactoryTest.createBob(); + for (int i = 0; i < 5; i++) { + AccountFactory.createNewCheckingAccount(user); + } + Account account = AccountWarehouse.findAccountByID(id); + + Assert.assertEquals(id, account.getAccountID()); + } + +} + + diff --git a/src/test/com/zipcode/macrolabs/atm/bankaccount/CheckingAccountTest.java b/src/test/com/zipcode/macrolabs/atm/bankaccount/CheckingAccountTest.java index c9d5ec8..9a30db0 100644 --- a/src/test/com/zipcode/macrolabs/atm/bankaccount/CheckingAccountTest.java +++ b/src/test/com/zipcode/macrolabs/atm/bankaccount/CheckingAccountTest.java @@ -4,7 +4,9 @@ import com.zipcode.macrolabs.atm.bankaccount.CheckingAccount; import com.zipcode.macrolabs.atm.exceptions.*; import com.zipcode.macrolabs.atm.transaction.Transaction; +import com.zipcode.macrolabs.atm.transaction.TransactionFactory; import com.zipcode.macrolabs.atm.transaction.TransactionType; +import com.zipcode.macrolabs.atm.transaction.TransferTransaction; import com.zipcode.macrolabs.atm.user.User; import com.zipcode.macrolabs.atm.user.UserFactory; import org.junit.Assert; @@ -12,13 +14,16 @@ import org.junit.Test; import org.junit.rules.ExpectedException; +import java.util.ArrayList; + public class CheckingAccountTest { Account account; + User user; @Before public void initialize() { - User user = UserFactory.createNewUser("Uncle Bob", "cleancode"); + user = UserFactory.createNewUser("Uncle Bob", "cleancode"); account = AccountFactory.createNewCheckingAccount(user); } @@ -32,6 +37,14 @@ public void setAndGetBalanceTest(){ Assert.assertEquals(expected, actual, 0.001d); } + @Test + public void IDSetterGetterTest() { + int expectedID = 5; + account.setAccountID(5); + int actualID = Integer.valueOf(account.getAccountID()); + Assert.assertEquals(expectedID, actualID); + } + @Test public void getAccountTypeTest(){ AccountType expected = AccountType.CHECKING; @@ -99,7 +112,7 @@ public void depositBalanceShouldIncreaseTest() throws TransactionAmountIsZeroExc Assert.assertEquals(expected, actual, 0.001d); } -// + @Test(expected = TransactionAmountIsZeroException.class) public void depositShouldBeMoreThanAPennyTest() throws TransactionAmountIsZeroException { @@ -120,49 +133,57 @@ public void depositShouldMakeDepositTransactionTest() throws TransactionAmountIs } -// @Test -// public void transferBalanceShouldMove() { -// -// Account accountOther = new CheckingAccount(); -// account.setBalance(1000.00d); -// accountOther.setBalance(1000.00d); -// -// account.transferAndMakeTransaction(500.00d, accountOther); -// -// double expected = 500.00d; -// double expectedOther = 1500.00d; -// double actual = account.getBalance(); -// double actualOther = accountOther.getBalance(); -// -// Assert.assertEquals(expected, actual, 0.001d); -// Assert.assertEquals(expectedOther, actualOther, 0.001d); -// } -// -// -// public String printHistory(){ -// -// return null; -// -// } -// -// public Transaction[] getHistory(){ -// -// return null; -// -// } -// -// public abstract accountTypeEnum getAccountType(){ -// -// return null; -// -// } -// -// public CheckingAccountTest(){ -// -// } -// -// @Override -// public accountTypeEnum getAccountType() { -// return null; -// } + @Test + public void transferBalanceShouldMove() throws BalanceTooLowException, TransactionAmountIsZeroException { + Account destAccount = AccountFactory.createNewCheckingAccount(user); + account.setBalance(1000.00d); + destAccount.setBalance(1000.00d); + + account.transferAndMakeTransaction(500.00d, destAccount); + + double expected = 500.00d; + double expectedDest = 1500.00d; + double actual = account.getBalance(); + double actualDest = destAccount.getBalance(); + + Assert.assertEquals(expected, actual, 0.001d); + Assert.assertEquals(expectedDest, actualDest, 0.001d); + } + + @Test(expected = TransactionAmountIsZeroException.class) + public void transferShouldBeMoreThanAPennyTest() throws TransactionAmountIsZeroException, BalanceTooLowException { + Account destAccount = AccountFactory.createNewCheckingAccount(user); + account.setBalance(1000.00d); + account.transferAndMakeTransaction(0.00d, destAccount); + } + + @Test + public void transferShouldMakeTransferTransactionTest() throws TransactionAmountIsZeroException, BalanceTooLowException { + Transaction transaction; + Account destAccount = AccountFactory.createNewCheckingAccount(user); + account.setBalance(1000.00d); + + transaction = account.transferAndMakeTransaction(500.00d, destAccount); + + Assert.assertTrue(transaction instanceof TransferTransaction && transaction.getTransactionType().equals(TransactionType.TRANSFER)); + + } + + @Test + public void getUsersNotNull(){ + Assert.assertTrue(account.getAccountUsers().size() > 0); + } + + @Test + public void getHistoryIsNotNullTest(){ + Assert.assertNotNull(account.getTransactionHistory()); + } + + @Test + public void printHistoryIsStringTest() throws BalanceTooLowException, TransactionAmountIsZeroException { + for (int i = 0; i < 5; i++) { + account.depositAndMakeTransaction(500); + } + Assert.assertTrue(account.printTransactionHistory().length() > 0); + } } diff --git a/src/test/com/zipcode/macrolabs/atm/bankaccount/InvestmentAccountTest.java b/src/test/com/zipcode/macrolabs/atm/bankaccount/InvestmentAccountTest.java index d6e3efb..f84bb0a 100644 --- a/src/test/com/zipcode/macrolabs/atm/bankaccount/InvestmentAccountTest.java +++ b/src/test/com/zipcode/macrolabs/atm/bankaccount/InvestmentAccountTest.java @@ -1,9 +1,28 @@ package com.zipcode.macrolabs.atm.bankaccount; +import com.zipcode.macrolabs.atm.user.User; +import com.zipcode.macrolabs.atm.user.UserFactory; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + public class InvestmentAccountTest { - public InvestmentAccountTest(){ + Account account; + + @Before + public void initialize() { + User user = UserFactory.createNewUser("Uncle Bob", "cleancode"); + account = AccountFactory.createNewInvestmentAccount(user); + } + + @Test + public void getAccountTypeTest(){ + + AccountType expected = AccountType.INVESTMENT; + AccountType actual = account.getAccountType(); + Assert.assertEquals(expected, actual); } } diff --git a/src/test/com/zipcode/macrolabs/atm/bankaccount/SavingsAccountTest.java b/src/test/com/zipcode/macrolabs/atm/bankaccount/SavingsAccountTest.java index aa8efa5..85d0ba1 100644 --- a/src/test/com/zipcode/macrolabs/atm/bankaccount/SavingsAccountTest.java +++ b/src/test/com/zipcode/macrolabs/atm/bankaccount/SavingsAccountTest.java @@ -1,6 +1,28 @@ package com.zipcode.macrolabs.atm.bankaccount; +import com.zipcode.macrolabs.atm.user.User; +import com.zipcode.macrolabs.atm.user.UserFactory; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + public class SavingsAccountTest { + Account account; + + @Before + public void initialize() { + User user = UserFactory.createNewUser("Uncle Bob", "cleancode"); + account = AccountFactory.createNewSavingsAccount(user); + } + + @Test + public void getAccountTypeTest(){ + + AccountType expected = AccountType.SAVINGS; + AccountType actual = account.getAccountType(); + + Assert.assertEquals(expected, actual); + } } diff --git a/src/test/com/zipcode/macrolabs/atm/navigation/NavigationTestSuite.java b/src/test/com/zipcode/macrolabs/atm/navigation/NavigationTestSuite.java new file mode 100644 index 0000000..ecc678a --- /dev/null +++ b/src/test/com/zipcode/macrolabs/atm/navigation/NavigationTestSuite.java @@ -0,0 +1,11 @@ +package com.zipcode.macrolabs.atm.navigation; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; + +@RunWith(Suite.class) +@Suite.SuiteClasses({ + +}) +public class NavigationTestSuite { +} diff --git a/src/test/com/zipcode/macrolabs/atm/transaction/TransactionFactoryTest.java b/src/test/com/zipcode/macrolabs/atm/transaction/TransactionFactoryTest.java new file mode 100644 index 0000000..31d82a1 --- /dev/null +++ b/src/test/com/zipcode/macrolabs/atm/transaction/TransactionFactoryTest.java @@ -0,0 +1,76 @@ +package com.zipcode.macrolabs.atm.transaction; + +import com.zipcode.macrolabs.atm.bankaccount.Account; +import com.zipcode.macrolabs.atm.bankaccount.AccountFactory; +import com.zipcode.macrolabs.atm.exceptions.NoMoreTransactionsException; +import com.zipcode.macrolabs.atm.user.User; +import com.zipcode.macrolabs.atm.user.UserFactoryTest; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import java.util.Date; + +public class TransactionFactoryTest { + + Transaction transaction; + User user; + Account account; + + @Before + public void setUp(){ + user = UserFactoryTest.createBob(); + account = AccountFactory.createNewCheckingAccount(user); + TransactionFactory.iteratedTransactionID = 0; + } + + @Test(expected = NoMoreTransactionsException.class) + public void noMoreTransactionsTest() throws NoMoreTransactionsException{ + TransactionFactory.iteratedTransactionID += (int) Math.pow(10, TransactionFactory.TRANSACTION_ID_LENGTH); + int nextID = TransactionFactory.nextTransactionID(); + } + + @Test + public void createWithdrawalTest(){ + transaction = TransactionFactory.createNewWithdrawal(500, account); + + Assert.assertEquals(account, transaction.getOriginAccount()); + Assert.assertTrue(transaction.getDate() instanceof Date); + Assert.assertTrue(transaction.getTransactionID().length() == TransactionFactory.TRANSACTION_ID_LENGTH); + Assert.assertEquals(TransactionType.WITHDRAWAL, transaction.getTransactionType()); + Assert.assertEquals(500d, transaction.getAmount(), 0.001); + } + + @Test + public void createDepositTest(){ + transaction = TransactionFactory.createNewDeposit(500, account); + + Assert.assertEquals(account, transaction.getOriginAccount()); + Assert.assertTrue(transaction.getDate() instanceof Date); + Assert.assertTrue(transaction.getTransactionID().length() == TransactionFactory.TRANSACTION_ID_LENGTH); + Assert.assertEquals(TransactionType.DEPOSIT, transaction.getTransactionType()); + Assert.assertEquals(500d, transaction.getAmount(), 0.001); + } + + @Test + public void createTransferTest(){ + Account destAccount = AccountFactory.createNewCheckingAccount(user); + TransferTransaction transferTransaction = TransactionFactory.createNewTransfer(500, account, destAccount); + + Assert.assertEquals(account, transferTransaction.getOriginAccount()); + Assert.assertEquals(destAccount, transferTransaction.getDestinationAccount()); + Assert.assertTrue(transferTransaction.getDate() instanceof Date); + Assert.assertTrue(transferTransaction.getTransactionID().length() == TransactionFactory.TRANSACTION_ID_LENGTH); + Assert.assertEquals(TransactionType.TRANSFER, transferTransaction.getTransactionType()); + Assert.assertEquals(500d, transferTransaction.getAmount(), 0.001); + } + + @Test + public void transactionIDIteratorTest(){ + int iterations = 5; + for (int i = 0; i < iterations; i++) { + TransactionFactory.createNewWithdrawal(500, account); + } + Assert.assertEquals(iterations, TransactionFactory.iteratedTransactionID); + } +} diff --git a/src/test/com/zipcode/macrolabs/atm/transaction/TransactionTestSuite.java b/src/test/com/zipcode/macrolabs/atm/transaction/TransactionTestSuite.java new file mode 100644 index 0000000..a520341 --- /dev/null +++ b/src/test/com/zipcode/macrolabs/atm/transaction/TransactionTestSuite.java @@ -0,0 +1,11 @@ +package com.zipcode.macrolabs.atm.transaction; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; + +@RunWith(Suite.class) +@Suite.SuiteClasses({ + TransactionFactoryTest.class +}) +public class TransactionTestSuite { +} diff --git a/src/test/com/zipcode/macrolabs/atm/user/UserFactoryTest.java b/src/test/com/zipcode/macrolabs/atm/user/UserFactoryTest.java index 7ca3aa2..d48a33f 100644 --- a/src/test/com/zipcode/macrolabs/atm/user/UserFactoryTest.java +++ b/src/test/com/zipcode/macrolabs/atm/user/UserFactoryTest.java @@ -5,13 +5,19 @@ public class UserFactoryTest { + public static User createBob(){ + String name = "Uncle Bob"; + String password = "cleancode"; + + return UserFactory.createNewUser(name, password); + + } + User user; - String name = "Uncle Bob"; - String password = "cleancode"; @Before public void setUp(){ - user = UserFactory.createNewUser(name, password); + user = createBob(); UserFactory.iteratedUserID = 0; } @@ -38,19 +44,19 @@ public void setAndGetUserIDTestShouldBe7(){ public void iteratingIDTest(){ int iterations = 5; for (int i = 0; i < iterations; i++) { - UserFactory.createNewUser("Uncle Bob", "clean code"); + createBob(); } Assert.assertEquals(iterations, UserFactory.iteratedUserID); } @Test public void setUserNameTestShouldBeUncleBob(){ - Assert.assertEquals(name, user.getUserName()); + Assert.assertEquals("Uncle Bob", user.getUserName()); } @Test public void setUserPasswordShouldBeCleanCode(){ - Assert.assertEquals(password, user.getUserPassword()); + Assert.assertEquals("cleancode", user.getUserPassword()); } @Test diff --git a/src/test/com/zipcode/macrolabs/atm/user/UserTest.java b/src/test/com/zipcode/macrolabs/atm/user/UserTest.java index 7517334..523e909 100644 --- a/src/test/com/zipcode/macrolabs/atm/user/UserTest.java +++ b/src/test/com/zipcode/macrolabs/atm/user/UserTest.java @@ -16,7 +16,7 @@ public class UserTest { @Before public void setUp(){ - user = UserFactory.createNewUser("Uncle Bob", "cleancode"); + user = UserFactoryTest.createBob(); } @Test diff --git a/src/test/com/zipcode/macrolabs/atm/user/UserWarehouseTest.java b/src/test/com/zipcode/macrolabs/atm/user/UserWarehouseTest.java index e66ffce..33251e4 100644 --- a/src/test/com/zipcode/macrolabs/atm/user/UserWarehouseTest.java +++ b/src/test/com/zipcode/macrolabs/atm/user/UserWarehouseTest.java @@ -14,7 +14,7 @@ public void setUp(){ @Test public void addOnePersonTest(){ int initial = UserWarehouse.getUsers().size(); - UserFactory.createNewUser("Uncle Bob", "cleancode"); + UserFactoryTest.createBob(); int after = UserWarehouse.getUsers().size(); int expectedSizeChange = 1; int actualSizeChange = after - initial; @@ -25,7 +25,7 @@ public void addOnePersonTest(){ public void findUserByIDTest(){ String id = "000000003"; for (int i = 0; i < 5; i++) { - UserFactory.createNewUser("Uncle Bob", "cleancode"); + UserFactoryTest.createBob(); } User user = UserWarehouse.findUserByID(id); From dd1d5d114ea9b45f823480ab2036de003347dcb0 Mon Sep 17 00:00:00 2001 From: PParfenov <32852881+PParfenov@users.noreply.github.com> Date: Wed, 25 Oct 2017 15:58:52 -0400 Subject: [PATCH 4/4] UML Diagram ATM --- Untitled Diagram.xml | 1 + 1 file changed, 1 insertion(+) create mode 100644 Untitled Diagram.xml diff --git a/Untitled Diagram.xml b/Untitled Diagram.xml new file mode 100644 index 0000000..58fdb1a --- /dev/null +++ b/Untitled Diagram.xml @@ -0,0 +1 @@ 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 \ No newline at end of file