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 @@ +7V3ZbuM4Fv2aAOmHBKJ2PzpLTReQqg46GdTMo2IxthBZNCQ5S3/9kCKphaRs2aaUoIaNAjqiKWo55y68pO49c67X7//Ko83qB4phemZb8fuZc3Nm27bnuvh/pOWDtgDPDmjLMk9i1tY0PCT/QNZosdZtEsOi07FEKC2TTbdxgbIMLspOW5Tn6K3b7Rml3atuoiWUGh4WUSq3/kricsVagWU1P/wJk+WKXTr02A9P0eJlmaNtxq53ZjvP1X/053XEx2L9i1UUo7dWk3N75lznCJX0r/X7NUzJy+WvjZ73refX+r5zmJVDTrDpCa9RumWPPl8s8O2X7PbKD/5KirdknUYZPrp6Rln5wH4B+DhKk2WG/17gi8IcN7zCvEzw25yzH0q0wa2LVZLGd9EH2pJbK0r8qvjR1QrlyT942ChlY+Kf85IRw/Y7PR7ImbjZwq05LHCfe/68QGj6Eb13Ot5FRckaFihNo02RPNWPsY7yZZJdobJEa9aJP/S3JE2vUYry6l1wSJ0r9vbw48L3XgRAjSsWGIjWsMw/cBd+gu/RU5isuJZPj98a4jkBo8uqxTnckxGekX1Zj11f7m8sHFG2xI/YXG9mda7n+JZ0vVB1Ob97tSjFWGdRCa8I24s2y/AfrSdtmiruqXnoSDy8INeiXPx+c+bMSWdCS3wbDiDYtDpgBkbZAtJeMdoSTJUd/13AvKDd7pKCjJYS9pHmS3wrtr8sK1RV52LalVt2Mm6ih7fZdq3u/phHWREtygRlf+JLIfImxOu2+uy9/OPHBtYX5w308lb1xqxsS16pILaYmGUlTjl6gZzCGaJy3GI1a+KinMLnsleQi020SLLlXdXnxm1a/mZ0IU0In/ucVrptlcQxzIgQIvzSIipx5PE2CENa8cm7wv8w666tS+/Mwzd+jY9Bc4z/ke55eY0y/CxRUgkXxOL8BotyqCTaakn86DJ8n+DN3H6564jADr67Et8l5NKkQoQix60QOAq2NQYghQ1OjwTGmwsgYenIWDoK3NLoCab3qEgIc3FbTvsKeE4AGbBl5aXELDwdMk8B2VV16XIV59HbPIt/RC+wJdPnVBX9QcW29UNLwukYMdyQt3nKECX57RnmvWMQmbItZt6xuhkw5hJy1Xr+R49ypR03OUa3o+YeSty0VI14vDakQ0RPhE3Y6atGmzfKkN+jpB+NSjxevsJh8gWAfbqEASCJGLHMxhWdyBWtdRxD/wLI4AOVa+js8EQHgy9PRYj3s8UE4P7fc5JFqdIPJL1+RmvYo3t4l/uoKN5QHu/pxnSKwlFstGejnox22cG3HsLt8LhUBAs0eFxAnmIYl+sY0OogyD7UNPhcQOUnX3Us//fsGXHL3+N0FLC8/3VOf2Q9X1ElwoJnEcfzDJUrmBOz84hu37Ho43PYlc4l30k5yiKHeFb8E77x0wR/hJ1bx1nE01NUwMOuiJ+PKD/VExrldALPFb6PiueAa5KTmC5PLwgJv2FHF7GRjAs0gQsUhoIL5LkSC2zXU2g7XwMJ/L0+EEYCg8mdICPeO4D2DvU9lLiKcc+jcA2M76EFNM8eKIwaMAt7XA9q34lyPuf+hpWRuUcVX6mbNmyuwcyxciJr5HU49IplivHkdaY0xr/w3a4Q1sbGHE9kjgPQXaxSxXuBr4xHaQhJ8IspzHEVFFCuI5nAwCDYZ4caZyXMOoTdlqOOxjgfA5rCOCtB02CcOUSquEBlmaWJMxNNaTVinqbVojAJIVwZcR6HGQrbrWSGp0Npy3G+6xVcvDRxHGO9P2lriz/zZB/OUVlvS0PAV7HGrtxOQVcVru2zudVSEH2bLBaMS0Yf7FxVdA4170oeuDpooFq3N+b9cNACxQRMBZoO8y7HwcSwv1nwHwllOeitRFmL5y2Hxb5nr/hZ1vhujbGeOPLtdI11CCY11nK0TYOxTmo2GZ2wUycEX8dcy6E3Y66PAW1Cc+3IcTJjridCeUJz7ciBsofoFb/DwtjqaW21Y3Vt9cyZ0lY7cvBNg60uKJWMNthFC+fg/XSjGWrH7KfTA9qUhnr/djpjqEdCeUpDLYe8bt9LyL/Sa0OIG+fke1l89JQiYiKvcBOzocCnh8SSsbe6Ktfc2uInzz/+Q9rxa2SH/2Xd6HVgLH1lK1g428ImG5OPv5CdVu/CugSuBTqW72LXSmEO06hMXrv3sONryXtUbapq9oJ1F599V8CmQNt8AdlZDTzSQK5grn1fGIi+hB0D8Y7o+bmAnT7HfGspR9dGoMdQCuyCO/BmXbQVfo4utF1bF9rCQKH4aczEaMtBti+KduiHgnA7smnUBbcnyqQbHAe3OFDti38O3K7snM/3mPGeWZp18vRL4QP8rjMyryvzwOJUblPXHWtG5vaveUtoG6etBSqVloO2IalA1OG0ubJv3iyGGBRPQFG1L2k0FGXX+8EENk6GUDF7Gg9C2T3+nm22Jro52bYhzwKXTvu/roMVBhIZlN9l8UQ3J5FB9p5JrDOpCEE/yFlEWWb29u8Rb/9QO6v+0FyHeKu+6zBxy8NBU5jVsT4DdlWLwixuyXSzdf7wUZRwfZlkwsfARi6Phlixb1cJsY78D3wGJU9c25m2zNRVu7m9EDb+uDPZviqdrUBHUiV5TfmvDRYNI7U78PQsNaCfMGvlRqAdeSAJDGKD4AkITjlj9eS4QysRlwkajjnRsWZC7NhSrG+MFjX05FjFL5bLLjKJJHfLr/t1NLAcrrih2QQNhCdAOKkKloMMjyybo8HwBAynjBp6clihZUZNGp+J8wYIa/AB/xiwRQVPnctJx1RWDleQoGHZ8MFk8zlY1MNDLa4SXx2i7suRCgk7E0EcAJrCxipB0xBn8FVJHtrZm6OU5+mrkntaRE5fYb2xnaT2idb0b+vQtM4jjMyzPe8fuv17ldvw0CsbrXQ0wRXxUyXBfQ1Gx5cjMbtgNJ7HOJ5H6Hc9D0+xh81WTul1BNF9dR2NshvQoUJeqqI8nVzIrR5zqif6C2wonJv+dM3tgQ/Ktdw3SpWppc7zcmkyn+6mMNUVB31GolwA0BCE8k0lDD2gqdIyK1HT4U311cJYwnbdmz2pmY2EngC24nMSZWjD1oC2HJ5iutmENSZeqgVCXGPmDizRoGMvlL8zR4MJaRws4wdnXRhtU5Rvsi7oAW3CTVGBKgzVJCjmJQS23CFuRQOEUgRRz+f7RlqHAz/lVqlADmbNt+UK3yp+39ggG3s81QI+8L0dO5WBYu6vriChI/FlIAeALuqYYHeCLFWYbIcNu9VJjEroJ0egp7qRjmwMgcnGoAc0RTaG0Qx4XzaGFGFdRuXUamoMdAx5X5mBrSrNMR4Pa+oqL/KeMkK12MvXFX0F8RowqlXIuSlBpImMAysQcdV/EhvlmM59jjZ3KIpNCcav8u0TAKrq4EqXwtLhUqjrEW0wL1jAnv5ponoDxf3gkkTqGb8Oh8GUJNIDmjehw9BXkijFSvqeSqLFja8smZWNx1Za7GnM9KkUGGimeW6OkzggR+p+wGx7l2Qv8ifmxkqPZKXdWTdTjT/pTD+UI3/ELKMNUYa8MpGYd5H0iJNik0Yfj5Vsm28kBwr/waWKRpvlh3LgzxjtY0CbcJYfymE5tjmQCuNfldQW+0sYs47EcOObWKF9JYFvGmEfUPu4pRrEWzHK4XieTTiBD+UQIPEMfkavydKsCky6KsDVC2OBM3SOoMc7UNc9SjLckMS3JE3nbZ4juhzQcQ/WmC7zPI8+FLvx1szJNPXQhhAkPLj+0Xg+g6l/pAe0KX2G3vpH6BFRKSROAJXIXVZ9CUvS5ZwmmqyyFrHujTwbOT6eElOa995deKYs8WeXJXb8WSdoP7R8rZYqxeHObXnqQsX1Op8x5gOUwMH79EarVRyafXp6QJuwVvFMjtaJRRdMueIvJdFTliueybP2BbGYSbYzPzvaVC+yU46hztRuc1vMe8dJtEZZ/LhKMsFMA5c3tPK6kzTu3FfAr3qFliiL0tumdR89npg9voLvSUlKRIBLy/LYcVUj4jIIfXZ8D/MEvzbihNCr13UlztpVJaoiE/SVDKkrQdO3M5xoU7vUhL+31IQFgo6N57vfT807P+u6Dr6YcGBo3vnA2zPQtHnnZ3LUIYflNpe/PG1xtp83EtPjqFjBWOJ62CHMpRvM2qQBl8DxeYPEM8ZNVr6EM/N4loUKmvUsHJ5IImCJ4Ivfdwxl0SzYM1APi45hiByIUM1ZxqRH6An0IEI+FT1cBT16phkn00NAdQbc4+ghjRR6zmj8kIMen6BBAHAEigS9FBlOhE6Vo56cq6eCLhiWmXukSqh3rdeQh6NBLsc0poe862VYTqgXbqcn1eNXgdsW4RaTUWiEW45UfIKEW5YrQO7phnwkta4NcleAPBgPcjlgMbXRDxoFzjS6P5nR5zu+2uwIxlEItjBfAVZwZEUrW4hugnoqpJ8f9TblTyMImepZHZtv7WMH6MxkT5iXKnTHSBMGsbjdsfMFwK9dl02zx6OGvNvpdwqN6C+fqaYOQ866dOq8HbVgn+kIaTh8eYsHxB37OHIFQsFNR1weOSGkUe1raPVgIcfBD8Xvpe/eHU997w3/6R0cLw32/4U0gI4s1GaYu25+S/USS+72BBGPU8ihIoSzO1Bokfmh35WqQI9UhYJUiZp2qFQ5QkYyF3xq9Vlg/d4R7wFEvpCYrJXF3Na3WQx6MiU3xkGkm62FxYHgL7iOED8aXGbVFaqU8KXQT7ANvjBlBsxW9N271J+tJeizDZ8YfG9mTKCrm51QK6uBQjeDcSbanqAxLwKBa0NJ6wu1gS+APaw48H4S4MMcobLdPY82qx8ohqTH/wA= \ No newline at end of file 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..bee3549 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/RandomUtils.java @@ -0,0 +1,44 @@ +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 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(); + } + + 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(); + } + + 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 new file mode 100644 index 0000000..3a693b9 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/Account.java @@ -0,0 +1,117 @@ +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.transaction.TransactionType; +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 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; + } + + 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 this.accountID; + } + + public void addUser(User user) { + accountUsers.add(user); + } + + public AccountStatus getAccountStatus() { + return accountStatus; + } + + + public void addTransactionToHistory(Transaction transaction){ + this.getTransactionHistory().add(transaction); + } + + public Transaction withdrawAndMakeTransaction(double amount) throws TransactionAmountIsZeroException, BalanceTooLowException { + + if(amount >= 0.001) { + if (this.accountBalance >= amount) { + this.accountBalance -= amount; + Transaction newTransaction = TransactionFactory.createNewWithdrawal(amount, this); + addTransactionToHistory(newTransaction); + return newTransaction; + } else { throw new BalanceTooLowException(); } + } else { throw new TransactionAmountIsZeroException(); } + + } + + public Transaction depositAndMakeTransaction(double amount) throws TransactionAmountIsZeroException { + + if(amount >= 0.001) { + this.accountBalance += amount; + Transaction newTransaction = TransactionFactory.createNewDeposit(amount, this); + addTransactionToHistory(newTransaction); + return newTransaction; + } else { throw new TransactionAmountIsZeroException(); } + + } + + 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 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 new file mode 100644 index 0000000..ad0921c --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/AccountFactory.java @@ -0,0 +1,43 @@ +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; + static final int ACCOUNT_ID_LENGTH = 9; + + static int nextAccountID() throws NoMoreAccountsException { + if((""+ iteratedAccountID).length() <= ACCOUNT_ID_LENGTH) { + return iteratedAccountID++; + } else { throw new NoMoreAccountsException(); } + } + + private static Account accountCreatorHelper(Account account, User user){ + try { + account.setAccountID(nextAccountID()); + } catch (NoMoreAccountsException e) { + e.printStackTrace(); + } + 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 account = new SavingsAccount(); + return (SavingsAccount) accountCreatorHelper(account, user); + } + + public static InvestmentAccount createNewInvestmentAccount(User user) { + InvestmentAccount account = new InvestmentAccount(); + return (InvestmentAccount) accountCreatorHelper(account, user); + } + +} 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/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 new file mode 100644 index 0000000..4273e72 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/CheckingAccount.java @@ -0,0 +1,11 @@ +package com.zipcode.macrolabs.atm.bankaccount; + +public class CheckingAccount extends Account { + + public CheckingAccount(){ } + + @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..4e7609a --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/InvestmentAccount.java @@ -0,0 +1,12 @@ +package com.zipcode.macrolabs.atm.bankaccount; + +public class InvestmentAccount extends Account { + + public InvestmentAccount(){ } + + @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..8ffbceb --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/bankaccount/SavingsAccount.java @@ -0,0 +1,12 @@ +package com.zipcode.macrolabs.atm.bankaccount; + +public class SavingsAccount extends Account { + + public SavingsAccount(){ } + + @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..58d4543 --- /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 our 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..8d6845e --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/transaction/Transaction.java @@ -0,0 +1,55 @@ +package com.zipcode.macrolabs.atm.transaction; + +import com.zipcode.macrolabs.atm.bankaccount.Account; + +import java.util.Date; + +public class Transaction { + + Date date; + double amount; + final TransactionType transactionType; + String transactionID; + Account originAccount; + + @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 double getAmount(){ + return this.amount; + } + + 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 new file mode 100644 index 0000000..051ba19 --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/transaction/TransactionFactory.java @@ -0,0 +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 { + + static int iteratedTransactionID = 0; + public static final int TRANSACTION_ID_LENGTH = 9; + + 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/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/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 new file mode 100644 index 0000000..787a41e --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/user/User.java @@ -0,0 +1,103 @@ +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){ + this.getAccounts().get(accountIndex).addUser(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.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 new file mode 100644 index 0000000..103153a --- /dev/null +++ b/src/main/java/com/zipcode/macrolabs/atm/user/UserFactory.java @@ -0,0 +1,37 @@ +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; + +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', 10); + String password = RandomUtils.createString('a', 'z', 8); + User randomUser = new User(name, password); + return randomUser; + } + +} 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/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/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..57de714 --- /dev/null +++ b/src/test/com/zipcode/macrolabs/atm/bankaccount/AccountFactoryTest.java @@ -0,0 +1,105 @@ +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 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..f04f857 --- /dev/null +++ b/src/test/com/zipcode/macrolabs/atm/bankaccount/AccountTestSuite.java @@ -0,0 +1,16 @@ +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, + 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 new file mode 100644 index 0000000..9a30db0 --- /dev/null +++ b/src/test/com/zipcode/macrolabs/atm/bankaccount/CheckingAccountTest.java @@ -0,0 +1,189 @@ +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.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; +import org.junit.Before; +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 = 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 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; + 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() 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 new file mode 100644 index 0000000..f84bb0a --- /dev/null +++ b/src/test/com/zipcode/macrolabs/atm/bankaccount/InvestmentAccountTest.java @@ -0,0 +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 { + + 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 new file mode 100644 index 0000000..85d0ba1 --- /dev/null +++ b/src/test/com/zipcode/macrolabs/atm/bankaccount/SavingsAccountTest.java @@ -0,0 +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 new file mode 100644 index 0000000..d48a33f --- /dev/null +++ b/src/test/com/zipcode/macrolabs/atm/user/UserFactoryTest.java @@ -0,0 +1,67 @@ +package com.zipcode.macrolabs.atm.user; + +import com.zipcode.macrolabs.atm.exceptions.NoMoreUsersException; +import org.junit.*; + +public class UserFactoryTest { + + public static User createBob(){ + String name = "Uncle Bob"; + String password = "cleancode"; + + return UserFactory.createNewUser(name, password); + + } + + User user; + + @Before + public void setUp(){ + user = createBob(); + 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++) { + createBob(); + } + Assert.assertEquals(iterations, UserFactory.iteratedUserID); + } + + @Test + public void setUserNameTestShouldBeUncleBob(){ + Assert.assertEquals("Uncle Bob", user.getUserName()); + } + + @Test + public void setUserPasswordShouldBeCleanCode(){ + Assert.assertEquals("cleancode", 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..523e909 --- /dev/null +++ b/src/test/com/zipcode/macrolabs/atm/user/UserTest.java @@ -0,0 +1,127 @@ +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; +import org.junit.Test; + +public class UserTest { + + User user; + + @Before + public void setUp(){ + user = UserFactoryTest.createBob(); + } + + @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); + } + + @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); + } + +} 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..33251e4 --- /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(); + UserFactoryTest.createBob(); + 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++) { + UserFactoryTest.createBob(); + } + User user = UserWarehouse.findUserByID(id); + + Assert.assertEquals(id, user.getUserID()); + } + +}