From bff946d58df5a2a56228bb7b159bdd65983ea4c2 Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Wed, 22 Jan 2020 14:30:31 -0500 Subject: [PATCH 01/45] added to isEmailValidTest --- .gitignore | 1 + .idea/SoftwareEngineeringPractice.iml | 2 ++ .idea/misc.xml | 5 ++++- .idea/vcs.xml | 6 ++++++ .../java/edu/ithaca/dragon/bank/BankAccountTest.java | 12 ++++++++++++ 5 files changed, 25 insertions(+), 1 deletion(-) create mode 100644 .idea/SoftwareEngineeringPractice.iml create mode 100644 .idea/vcs.xml diff --git a/.gitignore b/.gitignore index 3c8b8dd5..44927002 100644 --- a/.gitignore +++ b/.gitignore @@ -2,6 +2,7 @@ # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 # User-specific stuff +target/ .idea/**/workspace.xml .idea/**/tasks.xml .idea/**/usage.statistics.xml diff --git a/.idea/SoftwareEngineeringPractice.iml b/.idea/SoftwareEngineeringPractice.iml new file mode 100644 index 00000000..78b2cc53 --- /dev/null +++ b/.idea/SoftwareEngineeringPractice.iml @@ -0,0 +1,2 @@ + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml index d87af9ac..effd0327 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -1,6 +1,9 @@ + + - + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 00000000..35eb1ddf --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index d19ecb02..8dedaf36 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -25,6 +25,18 @@ void withdrawTest() { void isEmailValidTest(){ assertTrue(BankAccount.isEmailValid( "a@b.com")); assertFalse( BankAccount.isEmailValid("")); + //prefix + assertFalse(BankAccount.isEmailValid("abc-@mail.com")); + assertFalse(BankAccount.isEmailValid("abc..@mail.com")); + assertFalse(BankAccount.isEmailValid(".abc@mail.com")); + assertFalse(BankAccount.isEmailValid("abc#def@mail.com")); + //suffix + assertFalse(BankAccount.isEmailValid("abc.def@mail.c")); + assertFalse(BankAccount.isEmailValid("abc.def@mail#archive.com")); + assertFalse(BankAccount.isEmailValid("abc.def@mail")); + assertFalse(BankAccount.isEmailValid("abc.def@mail..com")); + //more than one @ + assertFalse(BankAccount.isEmailValid("abc@def@mail.com")); } @Test From 13c72ce02637d611f6e947b7b22e5067b91c8a7c Mon Sep 17 00:00:00 2001 From: sradms0 Date: Wed, 22 Jan 2020 19:26:50 -0500 Subject: [PATCH 02/45] fix isEmailValid method to contain more thorough validation --- .idea/encodings.xml | 1 + .idea/misc.xml | 2 +- src/main/java/edu/ithaca/dragon/bank/BankAccount.java | 7 +------ 3 files changed, 3 insertions(+), 7 deletions(-) diff --git a/.idea/encodings.xml b/.idea/encodings.xml index b26911bd..fade66b8 100644 --- a/.idea/encodings.xml +++ b/.idea/encodings.xml @@ -2,5 +2,6 @@ + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml index effd0327..5d282d4d 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -11,7 +11,7 @@ - + \ No newline at end of file diff --git a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java index e340e0ea..e1c59729 100644 --- a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java +++ b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java @@ -36,11 +36,6 @@ public void withdraw (double amount) { public static boolean isEmailValid(String email){ - if (email.indexOf('@') == -1){ - return false; - } - else { - return true; - } + return email.matches("(\\w)+((_|\\.|-)+\\w+)?@(\\w)+.(com|org|cc)"); } } From 9d1d1b95bd0459a00d8904a1cc287b2131723775 Mon Sep 17 00:00:00 2001 From: sradms0 Date: Thu, 23 Jan 2020 18:11:33 -0500 Subject: [PATCH 03/45] update regex string to accomodate any domain suffix (with min. of 2 chars) --- src/main/java/edu/ithaca/dragon/bank/BankAccount.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java index e1c59729..6cd97cee 100644 --- a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java +++ b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java @@ -36,6 +36,6 @@ public void withdraw (double amount) { public static boolean isEmailValid(String email){ - return email.matches("(\\w)+((_|\\.|-)+\\w+)?@(\\w)+.(com|org|cc)"); + return email.matches("(\\w)+((_|\\.|-)+\\w+)?@(\\w)+\\.\\w{2,}$"); } } From 763434917ea4438dc710b9b06102d3e48725b6d5 Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Sun, 26 Jan 2020 17:01:03 -0500 Subject: [PATCH 04/45] Added tests for Widthdraw and getBalance methods, edited javadoc for widthdraw --- .idea/misc.xml | 2 +- .../edu/ithaca/dragon/bank/BankAccount.java | 5 +- .../ithaca/dragon/bank/BankAccountTest.java | 72 ++++++++++++++++--- 3 files changed, 65 insertions(+), 14 deletions(-) diff --git a/.idea/misc.xml b/.idea/misc.xml index 5d282d4d..effd0327 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -11,7 +11,7 @@ - + \ No newline at end of file diff --git a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java index 6cd97cee..6617bb17 100644 --- a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java +++ b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java @@ -28,9 +28,10 @@ public String getEmail(){ /** * @post reduces the balance by amount if amount is non-negative and smaller than balance + * throws InsufficientFundsException if the amount is larger than the balance + * If balance is negative, do nothing */ - public void withdraw (double amount) { - balance -= amount; + public void withdraw (double amount) throws InsufficientFundsException { } diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index 8dedaf36..3cc64a92 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -7,36 +7,86 @@ class BankAccountTest { @Test - void getBalanceTest() { - BankAccount bankAccount = new BankAccount("a@b.com", 200); + void getBalanceTest() throws InsufficientFundsException { + //classes - fresh account, after withdrawal, after unsuccessful withdrawal + BankAccount bankAccount = new BankAccount("a@b.com", 1000); - assertEquals(200, bankAccount.getBalance()); + //fresh account + assertEquals(1000, bankAccount.getBalance()); + //after withdrawal + bankAccount.withdraw(100); + assertEquals(900, bankAccount.getBalance()); + bankAccount.withdraw(500); + assertEquals(400, bankAccount.getBalance()); + bankAccount.withdraw(400); + assertEquals(0, bankAccount.getBalance()); + + //after unsuccessful withdrawal + BankAccount unsuccessful = new BankAccount("a@b.com",1000); + assertThrows(InsufficientFundsException.class, () -> bankAccount.withdraw(1100)); + assertEquals(1000, bankAccount.getBalance()); + assertThrows(InsufficientFundsException.class, () -> bankAccount.withdraw(2000)); + assertEquals(1000, bankAccount.getBalance()); + assertThrows(InsufficientFundsException.class, () -> bankAccount.withdraw(Integer.MAX_VALUE)); + assertEquals(1000, bankAccount.getBalance()); } @Test - void withdrawTest() { - BankAccount bankAccount = new BankAccount("a@b.com", 200); + void withdrawTest() throws InsufficientFundsException{ + //classes - sufficient funds, insufficient funds, negative funds + BankAccount bankAccount = new BankAccount("a@b.com", 1000); + //sufficient funds bankAccount.withdraw(100); + assertEquals(900, bankAccount.getBalance()); + bankAccount.withdraw(500); + assertEquals(400, bankAccount.getBalance()); + bankAccount.withdraw(400); + assertEquals(0, bankAccount.getBalance()); + //insufficient funds + int min = Integer.MIN_VALUE; + int max = Integer.MAX_VALUE; + assertThrows(InsufficientFundsException.class, () -> bankAccount.withdraw(300)); + assertThrows(InsufficientFundsException.class, () -> bankAccount.withdraw(max)); + assertThrows(InsufficientFundsException.class, () -> bankAccount.withdraw(1)); + //negative numbers, does nothing for now + BankAccount negative = new BankAccount("a@b.com", 1000); + negative.withdraw(-1); + assertEquals(1000, negative.getBalance()); + negative.withdraw(-500); + assertEquals(1000, negative.getBalance()); + negative.withdraw(min); + assertEquals(1000, negative.getBalance()); - assertEquals(100, bankAccount.getBalance()); } @Test void isEmailValidTest(){ + //one @ symbol class assertTrue(BankAccount.isEmailValid( "a@b.com")); + assertFalse(BankAccount.isEmailValid("abc@def@mail.com")); + assertFalse(BankAccount.isEmailValid("abc@d@ef@mail.com")); + assertFalse(BankAccount.isEmailValid("abc@d@ef@ma@il.com")); assertFalse( BankAccount.isEmailValid("")); - //prefix + //valid special characters in prefix assertFalse(BankAccount.isEmailValid("abc-@mail.com")); assertFalse(BankAccount.isEmailValid("abc..@mail.com")); assertFalse(BankAccount.isEmailValid(".abc@mail.com")); + //invalid characters in prefix assertFalse(BankAccount.isEmailValid("abc#def@mail.com")); - //suffix - assertFalse(BankAccount.isEmailValid("abc.def@mail.c")); + assertFalse(BankAccount.isEmailValid("abc#de!f@mail.com")); + assertTrue(BankAccount.isEmailValid("abc.def@mail.com")); + //invalid suffix characters assertFalse(BankAccount.isEmailValid("abc.def@mail#archive.com")); + assertFalse(BankAccount.isEmailValid("abc.def@mail!ar%chive.com")); + assertFalse(BankAccount.isEmailValid("abc.def@mail!ar%chi.ve.com")); + assertFalse(BankAccount.isEmailValid("abc.def@mail--archive.com")); + assertFalse(BankAccount.isEmailValid("abc.def@mail-arc!h.ive.com")); + //valid domain + assertFalse(BankAccount.isEmailValid("abc.def@mail.c")); assertFalse(BankAccount.isEmailValid("abc.def@mail")); assertFalse(BankAccount.isEmailValid("abc.def@mail..com")); - //more than one @ - assertFalse(BankAccount.isEmailValid("abc@def@mail.com")); + assertTrue(BankAccount.isEmailValid("abc.def@mail.cc")); + } @Test From 18bf9e5099f3ad37007c97e7b67105a3b004efb7 Mon Sep 17 00:00:00 2001 From: Isha Sharma <1999sharma19@gmail.com> Date: Sun, 26 Jan 2020 23:18:04 -0500 Subject: [PATCH 05/45] Comments for BankAcctest --- .idea/modules.xml | 8 +++ SoftwareEngineeringPractice.iml | 26 ++++++++- .../ithaca/dragon/bank/BankAccountTest.java | 54 +++++++++---------- 3 files changed, 60 insertions(+), 28 deletions(-) create mode 100644 .idea/modules.xml diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 00000000..785c424e --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/SoftwareEngineeringPractice.iml b/SoftwareEngineeringPractice.iml index 78b2cc53..53139ab2 100644 --- a/SoftwareEngineeringPractice.iml +++ b/SoftwareEngineeringPractice.iml @@ -1,2 +1,26 @@ - \ No newline at end of file + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index 3cc64a92..e9669d09 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -37,11 +37,11 @@ void withdrawTest() throws InsufficientFundsException{ BankAccount bankAccount = new BankAccount("a@b.com", 1000); //sufficient funds bankAccount.withdraw(100); - assertEquals(900, bankAccount.getBalance()); + assertEquals(900, bankAccount.getBalance()); //equivalence class of less than and not border case bankAccount.withdraw(500); - assertEquals(400, bankAccount.getBalance()); + assertEquals(400, bankAccount.getBalance()); //equivalence class of more than and not border case bankAccount.withdraw(400); - assertEquals(0, bankAccount.getBalance()); + assertEquals(0, bankAccount.getBalance()); //equivalence class of zero and border case //insufficient funds int min = Integer.MIN_VALUE; int max = Integer.MAX_VALUE; @@ -51,42 +51,42 @@ void withdrawTest() throws InsufficientFundsException{ //negative numbers, does nothing for now BankAccount negative = new BankAccount("a@b.com", 1000); negative.withdraw(-1); - assertEquals(1000, negative.getBalance()); + assertEquals(1000, negative.getBalance()); //equivalence class of negative balance and border case negative.withdraw(-500); - assertEquals(1000, negative.getBalance()); + assertEquals(1000, negative.getBalance()); //equivalence class of negative balance and not border case negative.withdraw(min); - assertEquals(1000, negative.getBalance()); - + assertEquals(1000, negative.getBalance()); //equivalence class of negative balance and border case } @Test void isEmailValidTest(){ //one @ symbol class - assertTrue(BankAccount.isEmailValid( "a@b.com")); - assertFalse(BankAccount.isEmailValid("abc@def@mail.com")); - assertFalse(BankAccount.isEmailValid("abc@d@ef@mail.com")); - assertFalse(BankAccount.isEmailValid("abc@d@ef@ma@il.com")); - assertFalse( BankAccount.isEmailValid("")); + assertTrue(BankAccount.isEmailValid( "a@b.com")); //equivalence class of one @ and not border case + assertFalse(BankAccount.isEmailValid("abc@def@mail.com")); //equivalence class of one multiple @ and border case + assertFalse(BankAccount.isEmailValid("abc@d@ef@mail.com")); //equivalence class of one multiple @ and border case + assertFalse(BankAccount.isEmailValid("abc@d@ef@ma@il.com")); //equivalence class of one multiple @ and border case + assertFalse( BankAccount.isEmailValid("")); //equivalence class of one no @ and border case //valid special characters in prefix - assertFalse(BankAccount.isEmailValid("abc-@mail.com")); - assertFalse(BankAccount.isEmailValid("abc..@mail.com")); - assertFalse(BankAccount.isEmailValid(".abc@mail.com")); + assertFalse(BankAccount.isEmailValid("abc-@mail.com")); //equivalence class of one valid special characters and not border case + assertFalse(BankAccount.isEmailValid("abc..@mail.com")); //equivalence class of two valid special characters and not border case + assertFalse(BankAccount.isEmailValid(".abc@mail.com")); //equivalence class of valid special characters and not border case //invalid characters in prefix - assertFalse(BankAccount.isEmailValid("abc#def@mail.com")); - assertFalse(BankAccount.isEmailValid("abc#de!f@mail.com")); - assertTrue(BankAccount.isEmailValid("abc.def@mail.com")); + assertFalse(BankAccount.isEmailValid("abc#def@mail.com")); //equivalence class of one invalid characters and border case + assertFalse(BankAccount.isEmailValid("abc#de!f@mail.com")); //equivalence class of two invalid characters and border case + assertTrue(BankAccount.isEmailValid("abc.def@mail.com")); //equivalence class of one invalid characters and not border case //invalid suffix characters - assertFalse(BankAccount.isEmailValid("abc.def@mail#archive.com")); - assertFalse(BankAccount.isEmailValid("abc.def@mail!ar%chive.com")); - assertFalse(BankAccount.isEmailValid("abc.def@mail!ar%chi.ve.com")); - assertFalse(BankAccount.isEmailValid("abc.def@mail--archive.com")); - assertFalse(BankAccount.isEmailValid("abc.def@mail-arc!h.ive.com")); + assertFalse(BankAccount.isEmailValid("abc.def@mail#archive.com")); //equivalence class of invalid suffix characters and border case + assertFalse(BankAccount.isEmailValid("abc.def@mail!ar%chive.com")); //equivalence class of invalid suffix characters and border case + assertFalse(BankAccount.isEmailValid("abc.def@mail!ar%chi.ve.com")); //equivalence class of invalid suffix characters and border case + assertFalse(BankAccount.isEmailValid("abc.def@mail--archive.com")); //equivalence class of invalid suffix characters and border case + assertFalse(BankAccount.isEmailValid("abc.def@mail-arc!h.ive.com")); //equivalence class of invalid suffix characters and border case //valid domain - assertFalse(BankAccount.isEmailValid("abc.def@mail.c")); - assertFalse(BankAccount.isEmailValid("abc.def@mail")); - assertFalse(BankAccount.isEmailValid("abc.def@mail..com")); - assertTrue(BankAccount.isEmailValid("abc.def@mail.cc")); + assertFalse(BankAccount.isEmailValid("abc.def@mail.c")); //equivalence class of invalid domain and not border case + assertFalse(BankAccount.isEmailValid("abc.def@mail")); //equivalence class of no domain and border case + assertFalse(BankAccount.isEmailValid("abc.def@mail..com")); //equivalence class of two . in domain and border case + assertTrue(BankAccount.isEmailValid("abc.def@mail.cc")); //equivalence class of invalid domain and not border case + /* equivalence class of Domain present twice and border case */ } @Test From 37b0d78b8af6dff2e232a5bebbd4b5b80f1ef889 Mon Sep 17 00:00:00 2001 From: Isha Sharma <1999sharma19@gmail.com> Date: Mon, 27 Jan 2020 16:20:39 -0500 Subject: [PATCH 06/45] withdraw function --- .../ithaca/dragon/bank/BankAccountTest.java | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index e9669d09..78bccfb1 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -12,22 +12,22 @@ void getBalanceTest() throws InsufficientFundsException { BankAccount bankAccount = new BankAccount("a@b.com", 1000); //fresh account - assertEquals(1000, bankAccount.getBalance()); + assertEquals(1000, bankAccount.getBalance()); //equivalence class starting balance and not border cas //after withdrawal bankAccount.withdraw(100); - assertEquals(900, bankAccount.getBalance()); + assertEquals(900, bankAccount.getBalance()); //equivalence class of less than and not border case bankAccount.withdraw(500); - assertEquals(400, bankAccount.getBalance()); + assertEquals(400, bankAccount.getBalance()); //equivalence class of more than and not border case bankAccount.withdraw(400); - assertEquals(0, bankAccount.getBalance()); + assertEquals(0, bankAccount.getBalance()); //equivalence class of zero and border case //after unsuccessful withdrawal BankAccount unsuccessful = new BankAccount("a@b.com",1000); - assertThrows(InsufficientFundsException.class, () -> bankAccount.withdraw(1100)); + assertThrows(InsufficientFundsException.class, () -> bankAccount.withdraw(1100)); //equivalence class of greater than and border case assertEquals(1000, bankAccount.getBalance()); - assertThrows(InsufficientFundsException.class, () -> bankAccount.withdraw(2000)); + assertThrows(InsufficientFundsException.class, () -> bankAccount.withdraw(2000)); //equivalence class of middle value and not border case assertEquals(1000, bankAccount.getBalance()); - assertThrows(InsufficientFundsException.class, () -> bankAccount.withdraw(Integer.MAX_VALUE)); + assertThrows(InsufficientFundsException.class, () -> bankAccount.withdraw(Integer.MAX_VALUE)); //equivalence class of Max Value and border case assertEquals(1000, bankAccount.getBalance()); } @@ -62,9 +62,9 @@ void withdrawTest() throws InsufficientFundsException{ void isEmailValidTest(){ //one @ symbol class assertTrue(BankAccount.isEmailValid( "a@b.com")); //equivalence class of one @ and not border case - assertFalse(BankAccount.isEmailValid("abc@def@mail.com")); //equivalence class of one multiple @ and border case - assertFalse(BankAccount.isEmailValid("abc@d@ef@mail.com")); //equivalence class of one multiple @ and border case - assertFalse(BankAccount.isEmailValid("abc@d@ef@ma@il.com")); //equivalence class of one multiple @ and border case + assertFalse(BankAccount.isEmailValid("abc@def@mail.com")); //equivalence class of multiple @ and border case + assertFalse(BankAccount.isEmailValid("abc@d@ef@mail.com")); //equivalence class of multiple @ and border case + assertFalse(BankAccount.isEmailValid("abc@d@ef@ma@il.com")); //equivalence class of multiple @ and border case assertFalse( BankAccount.isEmailValid("")); //equivalence class of one no @ and border case //valid special characters in prefix assertFalse(BankAccount.isEmailValid("abc-@mail.com")); //equivalence class of one valid special characters and not border case From 2c4417851012a04de46086c0c7fb57139435162d Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Tue, 28 Jan 2020 14:40:20 -0500 Subject: [PATCH 07/45] Updated Withdraw method --- .idea/compiler.xml | 1 - .idea/misc.xml | 7 ------- src/main/java/edu/ithaca/dragon/bank/BankAccount.java | 6 ++++++ 3 files changed, 6 insertions(+), 8 deletions(-) diff --git a/.idea/compiler.xml b/.idea/compiler.xml index 28c6362f..65cb3c4b 100644 --- a/.idea/compiler.xml +++ b/.idea/compiler.xml @@ -6,7 +6,6 @@ - diff --git a/.idea/misc.xml b/.idea/misc.xml index effd0327..d85cd037 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -4,13 +4,6 @@ - - - diff --git a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java index 6617bb17..6546e4a0 100644 --- a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java +++ b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java @@ -32,6 +32,12 @@ public String getEmail(){ * If balance is negative, do nothing */ public void withdraw (double amount) throws InsufficientFundsException { + if (balance >= amount && amount > 0) { + balance -= amount; + } + else if(balance < amount){ + throw new InsufficientFundsException("Amount requested is more than in your account by " + (amount - balance)); + } } From 91ce52b4f657dfa154349f5185616a1a19c871cf Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Tue, 28 Jan 2020 15:50:38 -0500 Subject: [PATCH 08/45] Updated Regex function and tests and made withdraw more concise --- .../edu/ithaca/dragon/bank/BankAccount.java | 22 +++++++++++---- .../ithaca/dragon/bank/BankAccountTest.java | 28 +++++++++++-------- 2 files changed, 34 insertions(+), 16 deletions(-) diff --git a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java index 6546e4a0..456640f5 100644 --- a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java +++ b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java @@ -29,20 +29,32 @@ public String getEmail(){ /** * @post reduces the balance by amount if amount is non-negative and smaller than balance * throws InsufficientFundsException if the amount is larger than the balance - * If balance is negative, do nothing + * If balance is negative or has more than 2 decimal places, throws IllegalArgumentException */ - public void withdraw (double amount) throws InsufficientFundsException { - if (balance >= amount && amount > 0) { + public void withdraw (double amount) throws InsufficientFundsException, IllegalArgumentException { + if(!isAmountValid(amount)){ + throw new IllegalArgumentException("Amount must have 2 decimal places and must be positive "); + } + if (balance >= amount) { balance -= amount; } - else if(balance < amount){ + else{ throw new InsufficientFundsException("Amount requested is more than in your account by " + (amount - balance)); } } + /** + * @post TODO + */ + public boolean isAmountValid(double amount){ + String doubleCheck = Double.toString(Math.abs(amount)); + int integerPlaces = doubleCheck.indexOf('.'); + int decimalPlaces = doubleCheck.length() - integerPlaces - 1; + return (decimalPlaces <= 2 || doubleCheck.indexOf('E') != -1) && !(amount < 0); + } public static boolean isEmailValid(String email){ - return email.matches("(\\w)+((_|\\.|-)+\\w+)?@(\\w)+\\.\\w{2,}$"); + return email.matches("(\\w)+((_|\\.|-)+\\w+)*@(\\w)+((-)?\\w+)*\\.\\w{2,}$"); } } diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index 78bccfb1..103ea6bc 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -7,7 +7,7 @@ class BankAccountTest { @Test - void getBalanceTest() throws InsufficientFundsException { + void getBalanceTest() throws InsufficientFundsException, IllegalArgumentException { //classes - fresh account, after withdrawal, after unsuccessful withdrawal BankAccount bankAccount = new BankAccount("a@b.com", 1000); @@ -24,18 +24,20 @@ void getBalanceTest() throws InsufficientFundsException { //after unsuccessful withdrawal BankAccount unsuccessful = new BankAccount("a@b.com",1000); assertThrows(InsufficientFundsException.class, () -> bankAccount.withdraw(1100)); //equivalence class of greater than and border case - assertEquals(1000, bankAccount.getBalance()); + assertEquals(1000, unsuccessful.getBalance()); assertThrows(InsufficientFundsException.class, () -> bankAccount.withdraw(2000)); //equivalence class of middle value and not border case - assertEquals(1000, bankAccount.getBalance()); + assertEquals(1000, unsuccessful.getBalance()); assertThrows(InsufficientFundsException.class, () -> bankAccount.withdraw(Integer.MAX_VALUE)); //equivalence class of Max Value and border case - assertEquals(1000, bankAccount.getBalance()); + assertEquals(1000, unsuccessful.getBalance()); } @Test - void withdrawTest() throws InsufficientFundsException{ + void withdrawTest() throws InsufficientFundsException, IllegalArgumentException{ //classes - sufficient funds, insufficient funds, negative funds BankAccount bankAccount = new BankAccount("a@b.com", 1000); //sufficient funds + bankAccount.withdraw(0); + assertEquals(1000, bankAccount.getBalance()); bankAccount.withdraw(100); assertEquals(900, bankAccount.getBalance()); //equivalence class of less than and not border case bankAccount.withdraw(500); @@ -48,20 +50,20 @@ void withdrawTest() throws InsufficientFundsException{ assertThrows(InsufficientFundsException.class, () -> bankAccount.withdraw(300)); assertThrows(InsufficientFundsException.class, () -> bankAccount.withdraw(max)); assertThrows(InsufficientFundsException.class, () -> bankAccount.withdraw(1)); - //negative numbers, does nothing for now + //negative numbers BankAccount negative = new BankAccount("a@b.com", 1000); - negative.withdraw(-1); + assertThrows(IllegalArgumentException.class, () -> bankAccount.withdraw(-100)); assertEquals(1000, negative.getBalance()); //equivalence class of negative balance and border case - negative.withdraw(-500); + assertThrows(IllegalArgumentException.class, () -> bankAccount.withdraw(-500)); assertEquals(1000, negative.getBalance()); //equivalence class of negative balance and not border case - negative.withdraw(min); + assertThrows(IllegalArgumentException.class, () -> bankAccount.withdraw(min)); assertEquals(1000, negative.getBalance()); //equivalence class of negative balance and border case } @Test void isEmailValidTest(){ //one @ symbol class - assertTrue(BankAccount.isEmailValid( "a@b.com")); //equivalence class of one @ and not border case + assertTrue(BankAccount.isEmailValid( "a.b.c@b.com")); //equivalence class of one @ and not border case assertFalse(BankAccount.isEmailValid("abc@def@mail.com")); //equivalence class of multiple @ and border case assertFalse(BankAccount.isEmailValid("abc@d@ef@mail.com")); //equivalence class of multiple @ and border case assertFalse(BankAccount.isEmailValid("abc@d@ef@ma@il.com")); //equivalence class of multiple @ and border case @@ -86,7 +88,6 @@ void isEmailValidTest(){ assertFalse(BankAccount.isEmailValid("abc.def@mail..com")); //equivalence class of two . in domain and border case assertTrue(BankAccount.isEmailValid("abc.def@mail.cc")); //equivalence class of invalid domain and not border case - /* equivalence class of Domain present twice and border case */ } @Test @@ -99,4 +100,9 @@ void constructorTest() { assertThrows(IllegalArgumentException.class, ()-> new BankAccount("", 100)); } + @Test + void isAmountValidTest(){ + + } + } \ No newline at end of file From 7191579f5807b2e254e728119434e5f778ce3a1d Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Thu, 30 Jan 2020 00:26:11 -0500 Subject: [PATCH 09/45] Added tests for IsValidAmount method --- .../edu/ithaca/dragon/bank/BankAccount.java | 17 ++++--- .../ithaca/dragon/bank/BankAccountTest.java | 44 +++++++++++++++++++ 2 files changed, 52 insertions(+), 9 deletions(-) diff --git a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java index 456640f5..6ac68080 100644 --- a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java +++ b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java @@ -32,10 +32,10 @@ public String getEmail(){ * If balance is negative or has more than 2 decimal places, throws IllegalArgumentException */ public void withdraw (double amount) throws InsufficientFundsException, IllegalArgumentException { - if(!isAmountValid(amount)){ + /*if(!isAmountValid(amount)){ throw new IllegalArgumentException("Amount must have 2 decimal places and must be positive "); - } - if (balance >= amount) { + }*/ + if (balance >= amount && amount >= 0) { balance -= amount; } else{ @@ -45,13 +45,12 @@ public void withdraw (double amount) throws InsufficientFundsException, IllegalA } /** - * @post TODO + * @post checks to see if a double is a valid input to be withdrawn + * Returns false if double has more than 2 decimal places, or is negative */ - public boolean isAmountValid(double amount){ - String doubleCheck = Double.toString(Math.abs(amount)); - int integerPlaces = doubleCheck.indexOf('.'); - int decimalPlaces = doubleCheck.length() - integerPlaces - 1; - return (decimalPlaces <= 2 || doubleCheck.indexOf('E') != -1) && !(amount < 0); + public static boolean isAmountValid(double amount){ + + return false; } public static boolean isEmailValid(String email){ diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index 103ea6bc..7f4718de 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -102,6 +102,50 @@ void constructorTest() { @Test void isAmountValidTest(){ + //valid number, no decimals + assertTrue(BankAccount.isAmountValid(0)); + assertTrue(BankAccount.isAmountValid(1)); + assertTrue(BankAccount.isAmountValid(500)); + assertTrue(BankAccount.isAmountValid(678)); + assertTrue(BankAccount.isAmountValid(Integer.MAX_VALUE)); + //valid number, 1 decimal + assertTrue(BankAccount.isAmountValid(500.0)); + assertTrue(BankAccount.isAmountValid(500.1)); + assertTrue(BankAccount.isAmountValid(500.5)); + assertTrue(BankAccount.isAmountValid(500.9)); + //valid number, 2 decimals + assertTrue(BankAccount.isAmountValid(500.00)); + assertTrue(BankAccount.isAmountValid(500.01)); + assertTrue(BankAccount.isAmountValid(500.10)); + assertTrue(BankAccount.isAmountValid(500.62)); + assertTrue(BankAccount.isAmountValid(500.99)); + //invalid number, more than 2 decimals + assertFalse(BankAccount.isAmountValid(500.001)); + assertFalse(BankAccount.isAmountValid(500.597)); + assertFalse(BankAccount.isAmountValid(500.56690930452)); + assertFalse(BankAccount.isAmountValid(500.999)); + assertFalse(BankAccount.isAmountValid(500.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999)); + //invalid number, negative with 0 decimals + assertFalse(BankAccount.isAmountValid(-1)); + assertFalse(BankAccount.isAmountValid(-100)); + assertFalse(BankAccount.isAmountValid(Integer.MIN_VALUE)); + //invalid number, negative with 1 decimal + assertFalse(BankAccount.isAmountValid(-1.0)); + assertFalse(BankAccount.isAmountValid(-100.7)); + assertFalse(BankAccount.isAmountValid(-999999.9)); + //invalid number, negative with 2 decimals + assertFalse(BankAccount.isAmountValid(-1.00)); + assertFalse(BankAccount.isAmountValid(-100.59)); + assertFalse(BankAccount.isAmountValid(-999999999999.99)); + //invalid number, negative with more than 2 decimals + assertFalse(BankAccount.isAmountValid(-100.001)); + assertFalse(BankAccount.isAmountValid(-100.5689)); + assertFalse(BankAccount.isAmountValid(-100.5784939576859)); + assertFalse(BankAccount.isAmountValid(-999.99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999)); + + + + } From e2a7ce1f620d46ac8e01fae8ef4e189a28aca814 Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Thu, 30 Jan 2020 00:32:31 -0500 Subject: [PATCH 10/45] Added code for IsAmountValid --- src/main/java/edu/ithaca/dragon/bank/BankAccount.java | 10 ++++++---- .../java/edu/ithaca/dragon/bank/BankAccountTest.java | 4 ++-- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java index 6ac68080..aeee24cb 100644 --- a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java +++ b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java @@ -32,9 +32,9 @@ public String getEmail(){ * If balance is negative or has more than 2 decimal places, throws IllegalArgumentException */ public void withdraw (double amount) throws InsufficientFundsException, IllegalArgumentException { - /*if(!isAmountValid(amount)){ + if(!isAmountValid(amount)){ throw new IllegalArgumentException("Amount must have 2 decimal places and must be positive "); - }*/ + } if (balance >= amount && amount >= 0) { balance -= amount; } @@ -49,8 +49,10 @@ public void withdraw (double amount) throws InsufficientFundsException, IllegalA * Returns false if double has more than 2 decimal places, or is negative */ public static boolean isAmountValid(double amount){ - - return false; + String doubleCheck = Double.toString(Math.abs(amount)); + int integerPlaces = doubleCheck.indexOf('.'); + int decimalPlaces = doubleCheck.length() - integerPlaces - 1; + return (decimalPlaces <= 2 || doubleCheck.indexOf('E') != -1) && !(amount < 0); } public static boolean isEmailValid(String email){ diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index 7f4718de..831005a0 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -124,7 +124,7 @@ void isAmountValidTest(){ assertFalse(BankAccount.isAmountValid(500.597)); assertFalse(BankAccount.isAmountValid(500.56690930452)); assertFalse(BankAccount.isAmountValid(500.999)); - assertFalse(BankAccount.isAmountValid(500.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999)); + assertFalse(BankAccount.isAmountValid(500.2048675849586746)); //invalid number, negative with 0 decimals assertFalse(BankAccount.isAmountValid(-1)); assertFalse(BankAccount.isAmountValid(-100)); @@ -141,7 +141,7 @@ void isAmountValidTest(){ assertFalse(BankAccount.isAmountValid(-100.001)); assertFalse(BankAccount.isAmountValid(-100.5689)); assertFalse(BankAccount.isAmountValid(-100.5784939576859)); - assertFalse(BankAccount.isAmountValid(-999.99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999)); + assertFalse(BankAccount.isAmountValid(-999.9999999999999999)); From 6f8e11c33b72b6491b1136c125d621f073ce4d90 Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Thu, 30 Jan 2020 10:10:40 -0500 Subject: [PATCH 11/45] Added Tests to Withdraw and Constructor --- .../ithaca/dragon/bank/BankAccountTest.java | 32 ++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-) diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index 831005a0..030d1c92 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -58,6 +58,24 @@ void withdrawTest() throws InsufficientFundsException, IllegalArgumentException{ assertEquals(1000, negative.getBalance()); //equivalence class of negative balance and not border case assertThrows(IllegalArgumentException.class, () -> bankAccount.withdraw(min)); assertEquals(1000, negative.getBalance()); //equivalence class of negative balance and border case + //numbers with more than 2 decimals + assertThrows(IllegalArgumentException.class, () -> bankAccount.withdraw(300.001)); + assertEquals(1000, negative.getBalance()); //equivalence class of negative balance and border case + assertThrows(IllegalArgumentException.class, () -> bankAccount.withdraw(1000.04940)); + assertEquals(1000, negative.getBalance()); //equivalence class of negative balance and not border case + assertThrows(IllegalArgumentException.class, () -> bankAccount.withdraw(50.1029384958674950)); + assertEquals(1000, negative.getBalance()); //equivalence class of negative balance and border case + //negative numbers with more than 2 decimals + assertThrows(IllegalArgumentException.class, () -> bankAccount.withdraw(-100.001)); + assertEquals(1000, negative.getBalance()); //equivalence class of negative balance and border case + assertThrows(IllegalArgumentException.class, () -> bankAccount.withdraw(-100.10239485)); + assertEquals(1000, negative.getBalance()); //equivalence class of negative balance and not border case + assertThrows(IllegalArgumentException.class, () -> bankAccount.withdraw(-100.1029384758493815)); + assertEquals(1000, negative.getBalance()); //equivalence class of negative balance and border case + + + + } @Test @@ -96,8 +114,20 @@ void constructorTest() { assertEquals("a@b.com", bankAccount.getEmail()); assertEquals(200, bankAccount.getBalance()); - //check for exception thrown correctly + //check for exception thrown correctly for email assertThrows(IllegalArgumentException.class, ()-> new BankAccount("", 100)); + //checks if it throws an argument for negative numbers + assertThrows(IllegalArgumentException.class, ()-> new BankAccount("a@b.com", -1)); + assertThrows(IllegalArgumentException.class, ()-> new BankAccount("a@b.com", -150)); + assertThrows(IllegalArgumentException.class, ()-> new BankAccount("a@b.com", -10000000)); + //checks if it throws an argument for numbers with more than 2 decimal places + assertThrows(IllegalArgumentException.class, ()-> new BankAccount("a@b.com", 100.001)); + assertThrows(IllegalArgumentException.class, ()-> new BankAccount("a@b.com", 150.01020495)); + assertThrows(IllegalArgumentException.class, ()-> new BankAccount("a@b.com", -123.1029384758495837)); + //checks if it throws an argument for numbers that are negative and have more than 2 decimal places + assertThrows(IllegalArgumentException.class, ()-> new BankAccount("a@b.com", -1.001)); + assertThrows(IllegalArgumentException.class, ()-> new BankAccount("a@b.com", -120.123453)); + assertThrows(IllegalArgumentException.class, ()-> new BankAccount("a@b.com", -100.102938456744854)); } @Test From 87768df8282cc5059b2a294ec3e9cf8f87b327ac Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Thu, 30 Jan 2020 10:14:41 -0500 Subject: [PATCH 12/45] Added code to have constructor and withdraw rely on isAmountValid --- src/main/java/edu/ithaca/dragon/bank/BankAccount.java | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java index aeee24cb..406c06bd 100644 --- a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java +++ b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java @@ -10,8 +10,13 @@ public class BankAccount { */ public BankAccount(String email, double startingBalance){ if (isEmailValid(email)){ - this.email = email; - this.balance = startingBalance; + if(isAmountValid(startingBalance)){ + this.email = email; + this.balance = startingBalance; + } + else{ + throw new IllegalArgumentException("starting Balance of " + startingBalance + "is an invalid amount to add"); + } } else { throw new IllegalArgumentException("Email address: " + email + " is invalid, cannot create account"); From dc0da89b8c6852c6b80fc67990ee2710929c9c90 Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Thu, 30 Jan 2020 19:55:38 -0500 Subject: [PATCH 13/45] Added headers for deposit and transfer methods, and tests --- .../edu/ithaca/dragon/bank/BankAccount.java | 17 +++ .../ithaca/dragon/bank/BankAccountTest.java | 126 ++++++++++++++++++ 2 files changed, 143 insertions(+) diff --git a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java index 406c06bd..bacf3b0d 100644 --- a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java +++ b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java @@ -49,6 +49,23 @@ public void withdraw (double amount) throws InsufficientFundsException, IllegalA } + /** + * @post adds to the balance by amount if amount is non-negative and has 2 or less decimal places + * @throws IllegalArgumentException if amount is negative or has more than 2 decimal places + */ + public void deposit(double amount) throws IllegalArgumentException{ + + } + + /** + * @post transfers funds from one bank account to the one passed in, as long as amount is non-negative and has 2 or less decimal places + * @throws IllegalArgumentException if amount is negative or has more than 2 decimal places, or if bankAccount to transfer to is the current one + * @throws InsufficientFundsException if amount is larger than current bank account balance + */ + public void transfer(double amount, BankAccount toTransfer) throws InsufficientFundsException, IllegalArgumentException{ + + } + /** * @post checks to see if a double is a valid input to be withdrawn * Returns false if double has more than 2 decimal places, or is negative diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index 030d1c92..beafb5e3 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -173,9 +173,135 @@ void isAmountValidTest(){ assertFalse(BankAccount.isAmountValid(-100.5784939576859)); assertFalse(BankAccount.isAmountValid(-999.9999999999999999)); + } + + @Test + void depositTest(){ + BankAccount bankAccount = new BankAccount("a@b.com", 1000); + //deposit valid integer + bankAccount.deposit(1); + assertEquals(1001, bankAccount.getBalance()); + bankAccount.deposit(100); + assertEquals(1101, bankAccount.getBalance()); + bankAccount.deposit(10000); + assertEquals(10101, bankAccount.getBalance()); + //deposit valid double with < 1 decimal + bankAccount.deposit(1.1); + assertEquals(10102.1, bankAccount.getBalance()); + bankAccount.deposit(10.5); + assertEquals(10112.6, bankAccount.getBalance()); + bankAccount.deposit(10.9); + assertEquals(101123.5, bankAccount.getBalance()); + //deposit valid with 2 decimals + bankAccount.deposit(1.00); + assertEquals(101123.50, bankAccount.getBalance()); + bankAccount.deposit(1.11); + assertEquals(101124.51, bankAccount.getBalance()); + bankAccount.deposit(1.57); + assertEquals(101126.08, bankAccount.getBalance()); + bankAccount.deposit(1.99); + assertEquals(101128.07, bankAccount.getBalance()); + //invalid number, negative + assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(-1)); + assertEquals(101128.07, bankAccount.getBalance()); + assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(-500)); + assertEquals(101128.07, bankAccount.getBalance()); + assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(Integer.MIN_VALUE)); + assertEquals(101128.07, bankAccount.getBalance()); + //invalid number, negative, one decimal + assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(-1.1)); + assertEquals(101128.07, bankAccount.getBalance()); + assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(-1.5)); + assertEquals(101128.07, bankAccount.getBalance()); + assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(-1.9)); + assertEquals(101128.07, bankAccount.getBalance()); + //invalid number, negative, 2 decimals + assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(-1.00)); + assertEquals(101128.07, bankAccount.getBalance()); + assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(-1.57)); + assertEquals(101128.07, bankAccount.getBalance()); + assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(-1.99)); + assertEquals(101128.07, bankAccount.getBalance()); + //invalid number, more than 2 decimals + assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(1.001)); + assertEquals(101128.07, bankAccount.getBalance()); + assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(-1.585976)); + assertEquals(101128.07, bankAccount.getBalance()); + assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(50.102938475960794)); + assertEquals(101128.07, bankAccount.getBalance()); + + } + @Test + void transferTest() throws InsufficientFundsException,IllegalArgumentException{ + BankAccount bankAccount1 = new BankAccount("a@b.com", 1000); + BankAccount bankAccount2 = new BankAccount("b@a.com", 0); + //checking initial balances + assertEquals(1000, bankAccount1.getBalance()); + assertEquals(0, bankAccount2.getBalance()); + //transfer from 1 to 2, integers, valid amount + bankAccount1.transfer(1, bankAccount2); + assertEquals(999, bankAccount1.getBalance()); + assertEquals(1, bankAccount2.getBalance()); + bankAccount1.transfer(99, bankAccount2); + assertEquals(900, bankAccount1.getBalance()); + assertEquals(100, bankAccount2.getBalance()); + bankAccount1.transfer(900, bankAccount2); + assertEquals(0, bankAccount1.getBalance()); + assertEquals(1000, bankAccount2.getBalance()); + //transfer from 2 to 1, 1 decimal, valid amount + bankAccount2.transfer(0.1, bankAccount1); + assertEquals(0.1, bankAccount1.getBalance()); + assertEquals(999.9, bankAccount2.getBalance()); + bankAccount2.transfer(99.5, bankAccount1); + assertEquals(99.6, bankAccount1.getBalance()); + assertEquals(900.4, bankAccount2.getBalance()); + //transfer from 2 to 1, 2 decimals, valid amount + bankAccount2.transfer(50.41, bankAccount1); + assertEquals(150.01, bankAccount1.getBalance()); + assertEquals(849.99, bankAccount2.getBalance()); + bankAccount2.transfer(50.11, bankAccount1); + assertEquals(200.12, bankAccount1.getBalance()); + assertEquals(799.88, bankAccount2.getBalance()); + bankAccount2.transfer(50.99, bankAccount1); + assertEquals(251.11, bankAccount1.getBalance()); + assertEquals(748.89, bankAccount2.getBalance()); + //invalid transfer, same bank + assertThrows(IllegalArgumentException.class, ()-> bankAccount1.transfer(50, bankAccount1)); + assertThrows(IllegalArgumentException.class, ()-> bankAccount2.transfer(50, bankAccount2)); + //invalid transfer, negative numbers + assertThrows(IllegalArgumentException.class, ()-> bankAccount1.transfer(-1, bankAccount2)); + assertEquals(251.11, bankAccount1.getBalance()); + assertEquals(748.89, bankAccount2.getBalance()); + assertThrows(IllegalArgumentException.class, ()-> bankAccount1.transfer(-50.8, bankAccount2)); + assertEquals(251.11, bankAccount1.getBalance()); + assertEquals(748.89, bankAccount2.getBalance()); + assertThrows(IllegalArgumentException.class, ()-> bankAccount1.transfer(-500.99, bankAccount2)); + assertEquals(251.11, bankAccount1.getBalance()); + assertEquals(748.89, bankAccount2.getBalance()); + //invalid transfer, 3 or more decimals + assertThrows(IllegalArgumentException.class, ()-> bankAccount1.transfer(50.001, bankAccount2)); + assertEquals(251.11, bankAccount1.getBalance()); + assertEquals(748.89, bankAccount2.getBalance()); + assertThrows(IllegalArgumentException.class, ()-> bankAccount1.transfer(50.9484930, bankAccount2)); + assertEquals(251.11, bankAccount1.getBalance()); + assertEquals(748.89, bankAccount2.getBalance()); + assertThrows(IllegalArgumentException.class, ()-> bankAccount1.transfer(-50.102938495869503, bankAccount2)); + assertEquals(251.11, bankAccount1.getBalance()); + assertEquals(748.89, bankAccount2.getBalance()); + //invalid transfer, insufficient funds + bankAccount1.transfer(251.11, bankAccount2); + assertThrows(InsufficientFundsException.class, ()-> bankAccount1.transfer(1, bankAccount2)); + assertEquals(0, bankAccount1.getBalance()); + assertEquals(1000, bankAccount2.getBalance()); + assertThrows(InsufficientFundsException.class, ()-> bankAccount1.transfer(246, bankAccount2)); + assertEquals(0, bankAccount1.getBalance()); + assertEquals(1000, bankAccount2.getBalance()); + assertThrows(InsufficientFundsException.class, ()-> bankAccount1.transfer(Integer.MAX_VALUE, bankAccount2)); + assertEquals(0, bankAccount1.getBalance()); + assertEquals(1000, bankAccount2.getBalance()); } From a563950cb0cac542dac660e7eb93b52ceacdf78b Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Thu, 30 Jan 2020 20:08:13 -0500 Subject: [PATCH 14/45] Added Implementation for Deposit and Transfer --- .../edu/ithaca/dragon/bank/BankAccount.java | 11 ++++- .../ithaca/dragon/bank/BankAccountTest.java | 40 +++++++++---------- 2 files changed, 29 insertions(+), 22 deletions(-) diff --git a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java index bacf3b0d..f0c57e56 100644 --- a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java +++ b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java @@ -54,7 +54,10 @@ public void withdraw (double amount) throws InsufficientFundsException, IllegalA * @throws IllegalArgumentException if amount is negative or has more than 2 decimal places */ public void deposit(double amount) throws IllegalArgumentException{ - + if(!isAmountValid(amount)){ + throw new IllegalArgumentException("Amount must have 2 or less decimal places and must be positive"); + } + balance += amount; } /** @@ -63,7 +66,11 @@ public void deposit(double amount) throws IllegalArgumentException{ * @throws InsufficientFundsException if amount is larger than current bank account balance */ public void transfer(double amount, BankAccount toTransfer) throws InsufficientFundsException, IllegalArgumentException{ - + if(!isAmountValid(amount) || toTransfer == this){ + throw new IllegalArgumentException("Amount must be positive, have 2 decimals or less, and transfer to a new bank account"); + } + this.withdraw(amount); + toTransfer.deposit(amount); } /** diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index beafb5e3..43e5963a 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -184,51 +184,51 @@ void depositTest(){ bankAccount.deposit(100); assertEquals(1101, bankAccount.getBalance()); bankAccount.deposit(10000); - assertEquals(10101, bankAccount.getBalance()); + assertEquals(11101, bankAccount.getBalance()); //deposit valid double with < 1 decimal bankAccount.deposit(1.1); - assertEquals(10102.1, bankAccount.getBalance()); + assertEquals(11102.1, bankAccount.getBalance()); bankAccount.deposit(10.5); - assertEquals(10112.6, bankAccount.getBalance()); + assertEquals(11112.6, bankAccount.getBalance()); bankAccount.deposit(10.9); - assertEquals(101123.5, bankAccount.getBalance()); + assertEquals(11123.5, bankAccount.getBalance()); //deposit valid with 2 decimals bankAccount.deposit(1.00); - assertEquals(101123.50, bankAccount.getBalance()); + assertEquals(11124.50, bankAccount.getBalance()); bankAccount.deposit(1.11); - assertEquals(101124.51, bankAccount.getBalance()); + assertEquals(11125.61, bankAccount.getBalance()); bankAccount.deposit(1.57); - assertEquals(101126.08, bankAccount.getBalance()); + assertEquals(11127.18, bankAccount.getBalance()); bankAccount.deposit(1.99); - assertEquals(101128.07, bankAccount.getBalance()); + assertEquals(11129.17, bankAccount.getBalance()); //invalid number, negative assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(-1)); - assertEquals(101128.07, bankAccount.getBalance()); + assertEquals(11129.17, bankAccount.getBalance()); assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(-500)); - assertEquals(101128.07, bankAccount.getBalance()); + assertEquals(11129.17, bankAccount.getBalance()); assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(Integer.MIN_VALUE)); - assertEquals(101128.07, bankAccount.getBalance()); + assertEquals(11129.17, bankAccount.getBalance()); //invalid number, negative, one decimal assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(-1.1)); - assertEquals(101128.07, bankAccount.getBalance()); + assertEquals(11129.17, bankAccount.getBalance()); assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(-1.5)); - assertEquals(101128.07, bankAccount.getBalance()); + assertEquals(11129.17, bankAccount.getBalance()); assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(-1.9)); - assertEquals(101128.07, bankAccount.getBalance()); + assertEquals(11129.17, bankAccount.getBalance()); //invalid number, negative, 2 decimals assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(-1.00)); - assertEquals(101128.07, bankAccount.getBalance()); + assertEquals(11129.17, bankAccount.getBalance()); assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(-1.57)); - assertEquals(101128.07, bankAccount.getBalance()); + assertEquals(11129.17, bankAccount.getBalance()); assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(-1.99)); - assertEquals(101128.07, bankAccount.getBalance()); + assertEquals(11129.17, bankAccount.getBalance()); //invalid number, more than 2 decimals assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(1.001)); - assertEquals(101128.07, bankAccount.getBalance()); + assertEquals(11129.17, bankAccount.getBalance()); assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(-1.585976)); - assertEquals(101128.07, bankAccount.getBalance()); + assertEquals(11129.17, bankAccount.getBalance()); assertThrows(IllegalArgumentException.class, ()-> bankAccount.deposit(50.102938475960794)); - assertEquals(101128.07, bankAccount.getBalance()); + assertEquals(11129.17, bankAccount.getBalance()); } From 7a796578d42e1854fa3edc16cdb8e9cac64b6bdb Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Thu, 30 Jan 2020 20:17:11 -0500 Subject: [PATCH 15/45] Added functionality to isAmountValid --- .../java/edu/ithaca/dragon/bank/BankAccount.java | 13 +++++++++---- .../edu/ithaca/dragon/bank/BankAccountTest.java | 1 + 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java index f0c57e56..fab3ae6e 100644 --- a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java +++ b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java @@ -78,10 +78,15 @@ public void transfer(double amount, BankAccount toTransfer) throws InsufficientF * Returns false if double has more than 2 decimal places, or is negative */ public static boolean isAmountValid(double amount){ - String doubleCheck = Double.toString(Math.abs(amount)); - int integerPlaces = doubleCheck.indexOf('.'); - int decimalPlaces = doubleCheck.length() - integerPlaces - 1; - return (decimalPlaces <= 2 || doubleCheck.indexOf('E') != -1) && !(amount < 0); + double positiveRoundOff = Math.abs(Math.round(amount * 100.0) / 100.0); + if(amount != positiveRoundOff){ + + String doubleCheck = Double.toString(Math.abs(amount)); + int integerPlaces = doubleCheck.indexOf('.'); + int decimalPlaces = doubleCheck.length() - integerPlaces - 1; + return (decimalPlaces <= 2 || doubleCheck.indexOf('E') != -1) && !(amount < 0); + } + return true; } public static boolean isEmailValid(String email){ diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index 43e5963a..87f56beb 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -150,6 +150,7 @@ void isAmountValidTest(){ assertTrue(BankAccount.isAmountValid(500.62)); assertTrue(BankAccount.isAmountValid(500.99)); //invalid number, more than 2 decimals + assertTrue(BankAccount.isAmountValid(500.00000000)); assertFalse(BankAccount.isAmountValid(500.001)); assertFalse(BankAccount.isAmountValid(500.597)); assertFalse(BankAccount.isAmountValid(500.56690930452)); From 7fdcf9b50c9daa1d17b69b59ad632a2685e6b01f Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Mon, 3 Feb 2020 14:46:33 -0500 Subject: [PATCH 16/45] Added Bank API Files --- .../java/edu/ithaca/dragon/bank/AdminAPI.java | 15 ++++ .../edu/ithaca/dragon/bank/AdvancedAPI.java | 9 +++ .../java/edu/ithaca/dragon/bank/BasicAPI.java | 18 +++++ .../edu/ithaca/dragon/bank/CentralBank.java | 68 +++++++++++++++++++ 4 files changed, 110 insertions(+) create mode 100644 src/main/java/edu/ithaca/dragon/bank/AdminAPI.java create mode 100644 src/main/java/edu/ithaca/dragon/bank/AdvancedAPI.java create mode 100644 src/main/java/edu/ithaca/dragon/bank/BasicAPI.java create mode 100644 src/main/java/edu/ithaca/dragon/bank/CentralBank.java diff --git a/src/main/java/edu/ithaca/dragon/bank/AdminAPI.java b/src/main/java/edu/ithaca/dragon/bank/AdminAPI.java new file mode 100644 index 00000000..b11e2b4e --- /dev/null +++ b/src/main/java/edu/ithaca/dragon/bank/AdminAPI.java @@ -0,0 +1,15 @@ +package edu.ithaca.dragon.bank; + +import java.util.Collection; + +public interface AdminAPI { + + public double calcTotalAssets(); + + public Collection findAcctIdsWithSuspiciousActivity(); + + public void freezeAccount(String acctId); + + public void unfreezeAcct(String acctId); + +} diff --git a/src/main/java/edu/ithaca/dragon/bank/AdvancedAPI.java b/src/main/java/edu/ithaca/dragon/bank/AdvancedAPI.java new file mode 100644 index 00000000..26253541 --- /dev/null +++ b/src/main/java/edu/ithaca/dragon/bank/AdvancedAPI.java @@ -0,0 +1,9 @@ +package edu.ithaca.dragon.bank; + +//API to be used by Teller systems +public interface AdvancedAPI extends BasicAPI { + + public void createAccount(String acctId, double startingBalance); + + public void closeAccount(String acctId); +} diff --git a/src/main/java/edu/ithaca/dragon/bank/BasicAPI.java b/src/main/java/edu/ithaca/dragon/bank/BasicAPI.java new file mode 100644 index 00000000..bd65b941 --- /dev/null +++ b/src/main/java/edu/ithaca/dragon/bank/BasicAPI.java @@ -0,0 +1,18 @@ +package edu.ithaca.dragon.bank; + +//API to be used by ATMs +public interface BasicAPI { + + boolean confirmCredentials(String acctId, String password); + + double checkBalance(String acctId); + + void withdraw(String acctId, double amount) throws InsufficientFundsException; + + void deposit(String acctId, double amount); + + void transfer(String acctIdToWithdrawFrom, String acctIdToDepositTo, double amount) throws InsufficientFundsException; + + String transactionHistory(String acctId); + +} diff --git a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java new file mode 100644 index 00000000..1aeab213 --- /dev/null +++ b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java @@ -0,0 +1,68 @@ +package edu.ithaca.dragon.bank; + +import java.util.Collection; + +public class CentralBank implements AdvancedAPI, AdminAPI { + + //----------------- BasicAPI methods -------------------------// + + public boolean confirmCredentials(String acctId, String password) { + return false; + } + + public double checkBalance(String acctId) { + return 0; + } + + public void withdraw(String acctId, double amount) throws InsufficientFundsException { + + } + + @Override + public double calcTotalAssets() { + return 0; + } + + public void deposit(String acctId, double amount) { + + } + + public void transfer(String acctIdToWithdrawFrom, String acctIdToDepositTo, double amount) throws InsufficientFundsException { + + } + + public String transactionHistory(String acctId) { + return null; + } + + + //----------------- AdvancedAPI methods -------------------------// + + public void createAccount(String acctId, double startingBalance) { + + } + + public void closeAccount(String acctId) { + + } + + + //------------------ AdminAPI methods -------------------------// + + public double checkTotalAssets() { + return 0; + } + + public Collection findAcctIdsWithSuspiciousActivity() { + return null; + } + + public void freezeAccount(String acctId) { + + } + + public void unfreezeAcct(String acctId) { + + } + +} From 7520f3e073ebc49c30e34fcdd1896ee8767b08de Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Mon, 3 Feb 2020 14:49:58 -0500 Subject: [PATCH 17/45] Updated Central Bank File --- src/main/java/edu/ithaca/dragon/bank/CentralBank.java | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java index 1aeab213..ba9efd61 100644 --- a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java +++ b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java @@ -18,10 +18,6 @@ public void withdraw(String acctId, double amount) throws InsufficientFundsExcep } - @Override - public double calcTotalAssets() { - return 0; - } public void deposit(String acctId, double amount) { @@ -49,7 +45,7 @@ public void closeAccount(String acctId) { //------------------ AdminAPI methods -------------------------// - public double checkTotalAssets() { + public double calcTotalAssets() { return 0; } From 8aeda1bf98f4307a6d1d850049cf2bf9bcc2b241 Mon Sep 17 00:00:00 2001 From: thegoat Date: Tue, 4 Feb 2020 16:21:27 -0500 Subject: [PATCH 18/45] testing branch --- .idea/misc.xml | 2 +- SoftwareEngineeringPractice.iml | 16 ++++++++++++++++ .../java/edu/ithaca/dragon/bank/CentralBank.java | 3 ++- 3 files changed, 19 insertions(+), 2 deletions(-) diff --git a/.idea/misc.xml b/.idea/misc.xml index d85cd037..8073cbd7 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -4,7 +4,7 @@ - + \ No newline at end of file diff --git a/SoftwareEngineeringPractice.iml b/SoftwareEngineeringPractice.iml index 53139ab2..59e7e833 100644 --- a/SoftwareEngineeringPractice.iml +++ b/SoftwareEngineeringPractice.iml @@ -22,5 +22,21 @@ + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java index 1aeab213..65c11a7d 100644 --- a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java +++ b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java @@ -38,7 +38,8 @@ public String transactionHistory(String acctId) { //----------------- AdvancedAPI methods -------------------------// - public void createAccount(String acctId, double startingBalance) { + public void createAccount(String acctId, double startingBalance) { + } From 342338108b652cc32dd77b761b02589bb5e8ff09 Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Tue, 4 Feb 2020 17:54:17 -0500 Subject: [PATCH 19/45] Added tests for Savings Account --- .../ithaca/dragon/bank/CheckingAccount.java | 12 +++++ .../ithaca/dragon/bank/SavingsAccount.java | 44 +++++++++++++++++++ .../ithaca/dragon/bank/BankAccountTest.java | 18 ++++++++ 3 files changed, 74 insertions(+) create mode 100644 src/main/java/edu/ithaca/dragon/bank/CheckingAccount.java create mode 100644 src/main/java/edu/ithaca/dragon/bank/SavingsAccount.java diff --git a/src/main/java/edu/ithaca/dragon/bank/CheckingAccount.java b/src/main/java/edu/ithaca/dragon/bank/CheckingAccount.java new file mode 100644 index 00000000..c400f1d6 --- /dev/null +++ b/src/main/java/edu/ithaca/dragon/bank/CheckingAccount.java @@ -0,0 +1,12 @@ +package edu.ithaca.dragon.bank; + +public class CheckingAccount extends BankAccount { + /** + * @param email + * @param startingBalance + * @throws IllegalArgumentException if email is invalid + */ + public CheckingAccount(String email, double startingBalance) { + super(email, startingBalance); + } +} diff --git a/src/main/java/edu/ithaca/dragon/bank/SavingsAccount.java b/src/main/java/edu/ithaca/dragon/bank/SavingsAccount.java new file mode 100644 index 00000000..44d46254 --- /dev/null +++ b/src/main/java/edu/ithaca/dragon/bank/SavingsAccount.java @@ -0,0 +1,44 @@ +package edu.ithaca.dragon.bank; + +public class SavingsAccount extends BankAccount { + private double interest; + private double maxWithdraw; + /** + * @param email + * @param startingBalance + * @throws IllegalArgumentException if email is invalid + */ + public SavingsAccount(String email, double startingBalance, double interest, double maxWithdraw) { + super(email, startingBalance); + this.interest = interest; + this.maxWithdraw = maxWithdraw; + } + + /** + * Compounds interest of the day and adds it to balance + */ + public void compoundInterest(){ + double compounded = interest * this.getBalance(); + this.deposit(compounded); + } + + /** + * @post reduces the balance by amount if amount is non-negative and smaller than balance + * throws InsufficientFundsException if the amount is larger than the balance + * If balance is negative or has more than 2 decimal places, throws IllegalArgumentException + * If amount to withdraw is more than withdraw limit, it throws an InsufficientFundsException + */ + /*@Override + public void withdraw (double amount) throws InsufficientFundsException, IllegalArgumentException { + if(!isAmountValid(amount)){ + throw new IllegalArgumentException("Amount must have 2 decimal places and must be positive "); + } + if (this.getBalance() >= amount && amount >= 0) { + withdraw(amount); + } + else{ + throw new InsufficientFundsException("Amount requested is more than in your account by " + (amount - balance)); + } + + }*/ +} diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index 87f56beb..4ce08939 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -306,4 +306,22 @@ void transferTest() throws InsufficientFundsException,IllegalArgumentException{ } + @Test + void SavingsAccountTest(){ + //constructor test + SavingsAccount bankAccount = new SavingsAccount("a@b.com", 1000, 4.9, 500); + + //invalid interest + assertThrows(IllegalArgumentException.class, ()-> new SavingsAccount("a@b.com", 1000, 101, 500)); + assertThrows(IllegalArgumentException.class, ()-> new SavingsAccount("a@b.com", 1000, -0.1, 500)); + assertThrows(IllegalArgumentException.class, ()-> new SavingsAccount("a@b.com", 1000, 150, 500)); + assertThrows(IllegalArgumentException.class, ()-> new SavingsAccount("a@b.com", 1000, -50.6, 500)); + + //invalid maxWithdraw + assertThrows(IllegalArgumentException.class, ()-> new SavingsAccount("a@b.com", 1000, 5.0, 0)); + assertThrows(IllegalArgumentException.class, ()-> new SavingsAccount("a@b.com", 1000, 5.0, -1)); + assertThrows(IllegalArgumentException.class, ()-> new SavingsAccount("a@b.com", 1000, 5.0, -500.495)); + } + + } \ No newline at end of file From b160ebedb6b63ef87fb11148a3e33fbff766b4ef Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Tue, 4 Feb 2020 18:11:40 -0500 Subject: [PATCH 20/45] Added more tests for Savings Account --- .../edu/ithaca/dragon/bank/SavingsAccount.java | 5 ++++- .../ithaca/dragon/bank/BankAccountTest.java | 18 ++++++++++++++++-- 2 files changed, 20 insertions(+), 3 deletions(-) diff --git a/src/main/java/edu/ithaca/dragon/bank/SavingsAccount.java b/src/main/java/edu/ithaca/dragon/bank/SavingsAccount.java index 44d46254..4826421e 100644 --- a/src/main/java/edu/ithaca/dragon/bank/SavingsAccount.java +++ b/src/main/java/edu/ithaca/dragon/bank/SavingsAccount.java @@ -8,8 +8,11 @@ public class SavingsAccount extends BankAccount { * @param startingBalance * @throws IllegalArgumentException if email is invalid */ - public SavingsAccount(String email, double startingBalance, double interest, double maxWithdraw) { + public SavingsAccount(String email, double startingBalance, double interest, double maxWithdraw) throws IllegalArgumentException { super(email, startingBalance); + if(interest < 0){ + throw new IllegalArgumentException("Interest must be at least 0%"); + } this.interest = interest; this.maxWithdraw = maxWithdraw; } diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index 4ce08939..05c1876b 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -307,9 +307,9 @@ void transferTest() throws InsufficientFundsException,IllegalArgumentException{ } @Test - void SavingsAccountTest(){ + void SavingsAccountTest() throws IllegalArgumentException, InsufficientFundsException{ //constructor test - SavingsAccount bankAccount = new SavingsAccount("a@b.com", 1000, 4.9, 500); + SavingsAccount savingsAccount = new SavingsAccount("a@b.com", 1000, 5, 500); //invalid interest assertThrows(IllegalArgumentException.class, ()-> new SavingsAccount("a@b.com", 1000, 101, 500)); @@ -321,6 +321,20 @@ void SavingsAccountTest(){ assertThrows(IllegalArgumentException.class, ()-> new SavingsAccount("a@b.com", 1000, 5.0, 0)); assertThrows(IllegalArgumentException.class, ()-> new SavingsAccount("a@b.com", 1000, 5.0, -1)); assertThrows(IllegalArgumentException.class, ()-> new SavingsAccount("a@b.com", 1000, 5.0, -500.495)); + + //Compound interest + savingsAccount.compoundInterest(); + assertEquals(1050, savingsAccount.getBalance()); + savingsAccount.compoundInterest(); + assertEquals(1152.5, savingsAccount.getBalance()); + + //Overridden Withdraw + savingsAccount.withdraw(152.5); + assertEquals(1000, savingsAccount.getBalance()); + + assertThrows(IllegalArgumentException.class, () -> savingsAccount.withdraw(501)); + assertThrows(IllegalArgumentException.class, () -> savingsAccount.withdraw(750.59)); + assertThrows(IllegalArgumentException.class, () -> savingsAccount.withdraw(1000.75)); } From e9ac20e2055b71b193dfaeabaf520d81a0111982 Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Tue, 4 Feb 2020 18:36:10 -0500 Subject: [PATCH 21/45] Added fleshed out Savings Account --- .../ithaca/dragon/bank/SavingsAccount.java | 33 +++++++++---------- .../ithaca/dragon/bank/BankAccountTest.java | 7 ++-- 2 files changed, 18 insertions(+), 22 deletions(-) diff --git a/src/main/java/edu/ithaca/dragon/bank/SavingsAccount.java b/src/main/java/edu/ithaca/dragon/bank/SavingsAccount.java index 4826421e..a2c39017 100644 --- a/src/main/java/edu/ithaca/dragon/bank/SavingsAccount.java +++ b/src/main/java/edu/ithaca/dragon/bank/SavingsAccount.java @@ -2,19 +2,18 @@ public class SavingsAccount extends BankAccount { private double interest; - private double maxWithdraw; + private double withdrawLimit; /** - * @param email - * @param startingBalance + * @throws IllegalArgumentException if email is invalid */ - public SavingsAccount(String email, double startingBalance, double interest, double maxWithdraw) throws IllegalArgumentException { + public SavingsAccount(String email, double startingBalance, double interest, double withdrawLimit) throws IllegalArgumentException { super(email, startingBalance); - if(interest < 0){ - throw new IllegalArgumentException("Interest must be at least 0%"); + if(interest < 0 || withdrawLimit <= 0){ + throw new IllegalArgumentException("Interest must be at least 0% and you must be able to withdraw from the account"); } - this.interest = interest; - this.maxWithdraw = maxWithdraw; + this.interest = interest / 100; + this.withdrawLimit = withdrawLimit; } /** @@ -31,17 +30,15 @@ public void compoundInterest(){ * If balance is negative or has more than 2 decimal places, throws IllegalArgumentException * If amount to withdraw is more than withdraw limit, it throws an InsufficientFundsException */ - /*@Override + @Override public void withdraw (double amount) throws InsufficientFundsException, IllegalArgumentException { - if(!isAmountValid(amount)){ - throw new IllegalArgumentException("Amount must have 2 decimal places and must be positive "); - } - if (this.getBalance() >= amount && amount >= 0) { - withdraw(amount); - } - else{ - throw new InsufficientFundsException("Amount requested is more than in your account by " + (amount - balance)); + + if(withdrawLimit - amount < 0) + { + throw new IllegalArgumentException("Cannot withdraw more than the daily limit"); } - }*/ + super.withdraw(amount); + withdrawLimit -= amount; + } } diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index 05c1876b..766017f8 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -312,10 +312,9 @@ void SavingsAccountTest() throws IllegalArgumentException, InsufficientFundsExce SavingsAccount savingsAccount = new SavingsAccount("a@b.com", 1000, 5, 500); //invalid interest - assertThrows(IllegalArgumentException.class, ()-> new SavingsAccount("a@b.com", 1000, 101, 500)); assertThrows(IllegalArgumentException.class, ()-> new SavingsAccount("a@b.com", 1000, -0.1, 500)); - assertThrows(IllegalArgumentException.class, ()-> new SavingsAccount("a@b.com", 1000, 150, 500)); assertThrows(IllegalArgumentException.class, ()-> new SavingsAccount("a@b.com", 1000, -50.6, 500)); + assertThrows(IllegalArgumentException.class, ()-> new SavingsAccount("a@b.com", 1000, -150.6, 500)); //invalid maxWithdraw assertThrows(IllegalArgumentException.class, ()-> new SavingsAccount("a@b.com", 1000, 5.0, 0)); @@ -326,10 +325,10 @@ void SavingsAccountTest() throws IllegalArgumentException, InsufficientFundsExce savingsAccount.compoundInterest(); assertEquals(1050, savingsAccount.getBalance()); savingsAccount.compoundInterest(); - assertEquals(1152.5, savingsAccount.getBalance()); + assertEquals(1102.5, savingsAccount.getBalance()); //Overridden Withdraw - savingsAccount.withdraw(152.5); + savingsAccount.withdraw(102.5); assertEquals(1000, savingsAccount.getBalance()); assertThrows(IllegalArgumentException.class, () -> savingsAccount.withdraw(501)); From accad2f871c1f6364d5b313c3195fbba48246f22 Mon Sep 17 00:00:00 2001 From: thegoat Date: Tue, 4 Feb 2020 18:55:05 -0500 Subject: [PATCH 22/45] Confirm Credentials and Create Account functions and Test --- .idea/compiler.xml | 1 + .idea/misc.xml | 7 +++ .idea/modules.xml | 8 --- SoftwareEngineeringPractice.iml | 42 ---------------- SoftwareEngineeringPracticeBank.iml | 2 + .../edu/ithaca/dragon/bank/AdvancedAPI.java | 2 +- .../edu/ithaca/dragon/bank/BankAccount.java | 18 ++++++- .../java/edu/ithaca/dragon/bank/BasicAPI.java | 2 + .../edu/ithaca/dragon/bank/CentralBank.java | 25 ++++++++-- .../ithaca/dragon/bank/BankAccountTest.java | 50 +++++++++++++++++++ 10 files changed, 102 insertions(+), 55 deletions(-) delete mode 100644 .idea/modules.xml delete mode 100644 SoftwareEngineeringPractice.iml create mode 100644 SoftwareEngineeringPracticeBank.iml diff --git a/.idea/compiler.xml b/.idea/compiler.xml index 65cb3c4b..8e6ce1f3 100644 --- a/.idea/compiler.xml +++ b/.idea/compiler.xml @@ -6,6 +6,7 @@ + diff --git a/.idea/misc.xml b/.idea/misc.xml index 8073cbd7..5d282d4d 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -4,6 +4,13 @@ + + + diff --git a/.idea/modules.xml b/.idea/modules.xml deleted file mode 100644 index 785c424e..00000000 --- a/.idea/modules.xml +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - - \ No newline at end of file diff --git a/SoftwareEngineeringPractice.iml b/SoftwareEngineeringPractice.iml deleted file mode 100644 index 59e7e833..00000000 --- a/SoftwareEngineeringPractice.iml +++ /dev/null @@ -1,42 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/SoftwareEngineeringPracticeBank.iml b/SoftwareEngineeringPracticeBank.iml new file mode 100644 index 00000000..74f3f131 --- /dev/null +++ b/SoftwareEngineeringPracticeBank.iml @@ -0,0 +1,2 @@ + + \ No newline at end of file diff --git a/src/main/java/edu/ithaca/dragon/bank/AdvancedAPI.java b/src/main/java/edu/ithaca/dragon/bank/AdvancedAPI.java index 26253541..858eb254 100644 --- a/src/main/java/edu/ithaca/dragon/bank/AdvancedAPI.java +++ b/src/main/java/edu/ithaca/dragon/bank/AdvancedAPI.java @@ -3,7 +3,7 @@ //API to be used by Teller systems public interface AdvancedAPI extends BasicAPI { - public void createAccount(String acctId, double startingBalance); + public void createAccount(String acctId, String email, String password, double startingBalance); public void closeAccount(String acctId); } diff --git a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java index fab3ae6e..7c2a19dc 100644 --- a/src/main/java/edu/ithaca/dragon/bank/BankAccount.java +++ b/src/main/java/edu/ithaca/dragon/bank/BankAccount.java @@ -1,18 +1,30 @@ package edu.ithaca.dragon.bank; +import java.util.regex.Pattern; + public class BankAccount { private String email; private double balance; + private String password; + private String acctId; + + + + public BankAccount(String email, double startingBalance) { + this("", email, "", startingBalance); + } /** * @throws IllegalArgumentException if email is invalid */ - public BankAccount(String email, double startingBalance){ + public BankAccount(String acctId, String email, String password, double startingBalance){ if (isEmailValid(email)){ if(isAmountValid(startingBalance)){ + this.acctId = acctId; this.email = email; this.balance = startingBalance; + this.password = password; } else{ throw new IllegalArgumentException("starting Balance of " + startingBalance + "is an invalid amount to add"); @@ -92,4 +104,8 @@ public static boolean isAmountValid(double amount){ public static boolean isEmailValid(String email){ return email.matches("(\\w)+((_|\\.|-)+\\w+)*@(\\w)+((-)?\\w+)*\\.\\w{2,}$"); } + + public String getPassword() { + return password; + } } diff --git a/src/main/java/edu/ithaca/dragon/bank/BasicAPI.java b/src/main/java/edu/ithaca/dragon/bank/BasicAPI.java index bd65b941..bde440c0 100644 --- a/src/main/java/edu/ithaca/dragon/bank/BasicAPI.java +++ b/src/main/java/edu/ithaca/dragon/bank/BasicAPI.java @@ -15,4 +15,6 @@ public interface BasicAPI { String transactionHistory(String acctId); + + } diff --git a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java index 65c11a7d..f285f900 100644 --- a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java +++ b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java @@ -1,15 +1,30 @@ package edu.ithaca.dragon.bank; import java.util.Collection; +import java.util.HashMap; +import java.util.Map; public class CentralBank implements AdvancedAPI, AdminAPI { //----------------- BasicAPI methods -------------------------// - public boolean confirmCredentials(String acctId, String password) { + + public MapaccountMap = new HashMap<>(); + + + + + public boolean confirmCredentials(String acctId, String password){ + if(accountMap.containsKey(acctId)){ + return accountMap.get(acctId).getPassword().equals(password); + } + + + return false; } + public double checkBalance(String acctId) { return 0; } @@ -38,11 +53,15 @@ public String transactionHistory(String acctId) { //----------------- AdvancedAPI methods -------------------------// - public void createAccount(String acctId, double startingBalance) { - + public void createAccount(String acctId, String email, String password, double startingBalance) { + BankAccount account = new BankAccount(acctId, email, password, startingBalance); + accountMap.put(acctId, account); } + + + public void closeAccount(String acctId) { } diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index 87f56beb..49fef3b4 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -6,6 +6,56 @@ class BankAccountTest { + + + @Test + void createAccountTest(){ + CentralBank bankAccount = new CentralBank(); + bankAccount.createAccount("1245", "a1@hello.com", "testpassword", 500); + assertNull( bankAccount.accountMap.get("12466")); + assertEquals(500, bankAccount.accountMap.get("1245").getBalance()); + assertEquals("a1@hello.com", bankAccount.accountMap.get("1245").getEmail()); + assertEquals("testpassword", bankAccount.accountMap.get("1245").getPassword()); + + CentralBank bankAccount2 = new CentralBank(); + bankAccount2.createAccount("BH8525", "atest3@gmail.com", "funny", 1000); + assertNull(bankAccount2.accountMap.get("BH85425")); + assertEquals(1000, bankAccount2.accountMap.get("BH8525").getBalance()); + assertEquals("atest3@gmail.com", bankAccount2.accountMap.get("BH8525").getEmail()); + assertEquals("funny", bankAccount2.accountMap.get("BH8525").getPassword()); + + + + + + + + + + + } + + @Test + void confirmCredentialsTest(){ + + CentralBank bankAccount = new CentralBank(); + CentralBank bankAccount2 = new CentralBank(); + bankAccount.createAccount("11212", "a@b.com", "testingPassword", 500); + bankAccount2.createAccount("11BFWGG", "tester@gmail.com", "singleLetter", 1000); + + assertFalse(bankAccount.confirmCredentials("11212", "test")); + assertFalse( bankAccount.confirmCredentials("112", "testingPassword")); + assertTrue( bankAccount.confirmCredentials("11212", "testingPassword")); + + assertFalse(bankAccount2.confirmCredentials("11bfwgg", "singleLetter")); + assertFalse(bankAccount2.confirmCredentials("11bfwgg", "SingleLetter")); + assertTrue(bankAccount2.confirmCredentials("11BFWGG", "singleLetter")); + + + + + } + @Test void getBalanceTest() throws InsufficientFundsException, IllegalArgumentException { //classes - fresh account, after withdrawal, after unsuccessful withdrawal From 3c672f91bcb6ade65adb844a934036b1e85ae852 Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Wed, 5 Feb 2020 14:02:57 -0500 Subject: [PATCH 23/45] Fixed Comments --- src/main/java/edu/ithaca/dragon/bank/CheckingAccount.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/main/java/edu/ithaca/dragon/bank/CheckingAccount.java b/src/main/java/edu/ithaca/dragon/bank/CheckingAccount.java index c400f1d6..8c494bb0 100644 --- a/src/main/java/edu/ithaca/dragon/bank/CheckingAccount.java +++ b/src/main/java/edu/ithaca/dragon/bank/CheckingAccount.java @@ -2,8 +2,6 @@ public class CheckingAccount extends BankAccount { /** - * @param email - * @param startingBalance * @throws IllegalArgumentException if email is invalid */ public CheckingAccount(String email, double startingBalance) { From 90785b2319525ff83d593e61471a1241ac3bbc20 Mon Sep 17 00:00:00 2001 From: thegoat Date: Wed, 5 Feb 2020 14:05:50 -0500 Subject: [PATCH 24/45] Started some close account tests --- .../java/edu/ithaca/dragon/bank/CentralBank.java | 7 +++++++ .../java/edu/ithaca/dragon/bank/BankAccountTest.java | 12 ++++++++++-- 2 files changed, 17 insertions(+), 2 deletions(-) diff --git a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java index f285f900..c4aa13bd 100644 --- a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java +++ b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java @@ -63,6 +63,13 @@ public void createAccount(String acctId, String email, String password, double s public void closeAccount(String acctId) { +// CentralBank bank = new CentralBank(); +// +// bank.accountMap.remove(acctId); + + + + } diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index 49fef3b4..4cbece9d 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -24,11 +24,19 @@ void createAccountTest(){ assertEquals("atest3@gmail.com", bankAccount2.accountMap.get("BH8525").getEmail()); assertEquals("funny", bankAccount2.accountMap.get("BH8525").getPassword()); + } + @Test + void closeAccountTest(){ + CentralBank bankAccount = new CentralBank(); + bankAccount.createAccount("1245", "a1@hello.com", "testpassword", 500); + assertEquals("a1@hello.com",bankAccount.accountMap.get("1245").getEmail()); + bankAccount.closeAccount("1245"); + assertEquals(null, bankAccount.accountMap.get("1245").getEmail()); - - + CentralBank bankAccount2 = new CentralBank(); + bankAccount2.createAccount("BH8525", "atest3@gmail.com", "funny", 1000); From 1b3e98b0abe55edd9d48f3307de5efaff7b85d10 Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Wed, 5 Feb 2020 14:20:24 -0500 Subject: [PATCH 25/45] Made Tests --- src/main/java/edu/ithaca/dragon/bank/AdvancedAPI.java | 2 +- src/main/java/edu/ithaca/dragon/bank/CentralBank.java | 4 ++-- src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java | 7 +++++++ 3 files changed, 10 insertions(+), 3 deletions(-) diff --git a/src/main/java/edu/ithaca/dragon/bank/AdvancedAPI.java b/src/main/java/edu/ithaca/dragon/bank/AdvancedAPI.java index 26253541..e46d0fd4 100644 --- a/src/main/java/edu/ithaca/dragon/bank/AdvancedAPI.java +++ b/src/main/java/edu/ithaca/dragon/bank/AdvancedAPI.java @@ -3,7 +3,7 @@ //API to be used by Teller systems public interface AdvancedAPI extends BasicAPI { - public void createAccount(String acctId, double startingBalance); + public BankAccount createAccount(String acctId, double startingBalance); public void closeAccount(String acctId); } diff --git a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java index ba9efd61..7ae28c2c 100644 --- a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java +++ b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java @@ -34,8 +34,8 @@ public String transactionHistory(String acctId) { //----------------- AdvancedAPI methods -------------------------// - public void createAccount(String acctId, double startingBalance) { - + public BankAccount createAccount(String acctId, double startingBalance) { + return null; } public void closeAccount(String acctId) { diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index 87f56beb..ac64a773 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -306,4 +306,11 @@ void transferTest() throws InsufficientFundsException,IllegalArgumentException{ } + @Test + void createAccountTest(){ + CentralBank centralBank = new CentralBank(); + assertEquals(1000, centralBank.createAccount("a@b.com", 1000).getBalance()); + assertEquals("a@b.com", centralBank.createAccount("a@b.com", 1000).getEmail()); + } + } \ No newline at end of file From 8853b3b51c75cb6ad44f8e7bd5a6f0f18eb5aae0 Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Wed, 5 Feb 2020 14:21:16 -0500 Subject: [PATCH 26/45] Made Function to complete tests --- src/main/java/edu/ithaca/dragon/bank/CentralBank.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java index 7ae28c2c..3e3cd9db 100644 --- a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java +++ b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java @@ -35,7 +35,7 @@ public String transactionHistory(String acctId) { //----------------- AdvancedAPI methods -------------------------// public BankAccount createAccount(String acctId, double startingBalance) { - return null; + return new BankAccount(acctId, startingBalance); } public void closeAccount(String acctId) { From 6402d7f105341049b43f72310010ba890dfff1d0 Mon Sep 17 00:00:00 2001 From: thegoat Date: Wed, 5 Feb 2020 14:26:54 -0500 Subject: [PATCH 27/45] CreateAccount Tests --- .idea/misc.xml | 2 +- .../edu/ithaca/dragon/bank/AdvancedAPI.java | 2 +- .../edu/ithaca/dragon/bank/CentralBank.java | 8 +++++-- .../ithaca/dragon/bank/BankAccountTest.java | 21 +++++++++++++++++++ 4 files changed, 29 insertions(+), 4 deletions(-) diff --git a/.idea/misc.xml b/.idea/misc.xml index d85cd037..8073cbd7 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -4,7 +4,7 @@ - + \ No newline at end of file diff --git a/src/main/java/edu/ithaca/dragon/bank/AdvancedAPI.java b/src/main/java/edu/ithaca/dragon/bank/AdvancedAPI.java index 26253541..e46d0fd4 100644 --- a/src/main/java/edu/ithaca/dragon/bank/AdvancedAPI.java +++ b/src/main/java/edu/ithaca/dragon/bank/AdvancedAPI.java @@ -3,7 +3,7 @@ //API to be used by Teller systems public interface AdvancedAPI extends BasicAPI { - public void createAccount(String acctId, double startingBalance); + public BankAccount createAccount(String acctId, double startingBalance); public void closeAccount(String acctId); } diff --git a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java index 1aeab213..c156d753 100644 --- a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java +++ b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java @@ -10,7 +10,8 @@ public boolean confirmCredentials(String acctId, String password) { return false; } - public double checkBalance(String acctId) { + public double checkBalance(String email) { + return 0; } @@ -38,8 +39,11 @@ public String transactionHistory(String acctId) { //----------------- AdvancedAPI methods -------------------------// - public void createAccount(String acctId, double startingBalance) { + public BankAccount createAccount(String email, double startingBalance) { + BankAccount account = new BankAccount("a@b.com", startingBalance); + + return account; } public void closeAccount(String acctId) { diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index 87f56beb..663b5be8 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -6,6 +6,27 @@ class BankAccountTest { + + + @Test + void createAccountTest(){ + CentralBank bank = new CentralBank(); + + assertEquals(1000, bank.createAccount("ag@bgmail.com",1000).getBalance()); + + assertEquals(500, bank.createAccount("a@bgmail.com",500).getBalance()); + + + + + + + + + + + } + @Test void getBalanceTest() throws InsufficientFundsException, IllegalArgumentException { //classes - fresh account, after withdrawal, after unsuccessful withdrawal From aa51b585236c60bd53b04521e1bb4220a48db0c9 Mon Sep 17 00:00:00 2001 From: Matthew Becker Date: Wed, 5 Feb 2020 14:28:15 -0500 Subject: [PATCH 28/45] Implementing checkBalance --- .idea/misc.xml | 2 +- SoftwareEngineeringPractice.iml | 10 ++++++++++ .../java/edu/ithaca/dragon/bank/CentralBank.java | 2 ++ .../edu/ithaca/dragon/bank/BankAccountTest.java | 15 +++++++++++++++ 4 files changed, 28 insertions(+), 1 deletion(-) diff --git a/.idea/misc.xml b/.idea/misc.xml index d85cd037..c5af4629 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -4,7 +4,7 @@ - + \ No newline at end of file diff --git a/SoftwareEngineeringPractice.iml b/SoftwareEngineeringPractice.iml index 53139ab2..5225168b 100644 --- a/SoftwareEngineeringPractice.iml +++ b/SoftwareEngineeringPractice.iml @@ -22,5 +22,15 @@ + + + + + + + + + + \ No newline at end of file diff --git a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java index ba9efd61..2dd0feb1 100644 --- a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java +++ b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java @@ -11,6 +11,8 @@ public boolean confirmCredentials(String acctId, String password) { } public double checkBalance(String acctId) { + BankAccount accountToCheck = new BankAccount(acctId, 1000); + return accountToCheck.getBalance(); return 0; } diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index 87f56beb..553d9434 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -1,10 +1,25 @@ package edu.ithaca.dragon.bank; +import jdk.internal.vm.annotation.ReservedStackAccess; +import org.junit.Test; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.*; class BankAccountTest { + @Test + CentralBank createAccount(){ + CentralBank client = new CentralBank(); + client.createAccount("1234",1000); + return client; + } + @Test + void checkBalanceTest(){ + CentralBank newBank = createAccount(); + assertEquals(1000,newBank.checkBalance()); + } + + @Test void getBalanceTest() throws InsufficientFundsException, IllegalArgumentException { From 4ed74159bbec33f21bb994b95e042aa6d6cb6101 Mon Sep 17 00:00:00 2001 From: Matthew Becker Date: Wed, 5 Feb 2020 14:33:37 -0500 Subject: [PATCH 29/45] Implementing checkBalance --- src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index 553d9434..39172f1e 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -16,7 +16,7 @@ CentralBank createAccount(){ @Test void checkBalanceTest(){ CentralBank newBank = createAccount(); - assertEquals(1000,newBank.checkBalance()); + //assertEquals(1000,newBank.checkBalance()); } From dfbf89e79387a13b884f3a066c8a86497893fd90 Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Wed, 5 Feb 2020 14:41:09 -0500 Subject: [PATCH 30/45] updated git ignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 44927002..de73317e 100644 --- a/.gitignore +++ b/.gitignore @@ -8,6 +8,7 @@ target/ .idea/**/usage.statistics.xml .idea/**/dictionaries .idea/**/shelf +.idea/misc.xml # Generated files .idea/**/contentModel.xml From 84eb27952b02cd5f0fa6eb9c3abdeff562ce8af3 Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Wed, 5 Feb 2020 14:53:00 -0500 Subject: [PATCH 31/45] Updated Git Ignore --- .gitignore | 1 + .idea/misc.xml | 2 +- .../java/edu/ithaca/dragon/bank/BankAccountTest.java | 9 --------- 3 files changed, 2 insertions(+), 10 deletions(-) diff --git a/.gitignore b/.gitignore index de73317e..4dd9646a 100644 --- a/.gitignore +++ b/.gitignore @@ -9,6 +9,7 @@ target/ .idea/**/dictionaries .idea/**/shelf .idea/misc.xml +.idea/SoftwareEngineeringPractice.iml # Generated files .idea/**/contentModel.xml diff --git a/.idea/misc.xml b/.idea/misc.xml index 8073cbd7..d85cd037 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -4,7 +4,7 @@ - + \ No newline at end of file diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index 3bc5d7ab..c81209fb 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -7,15 +7,6 @@ class BankAccountTest { - - - - - - - - - @Test void getBalanceTest() throws InsufficientFundsException, IllegalArgumentException { //classes - fresh account, after withdrawal, after unsuccessful withdrawal From 77b44b9c086cd87ed4345310e12977e2f0e963c2 Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Wed, 5 Feb 2020 15:00:02 -0500 Subject: [PATCH 32/45] Merge branch 'master' of https://github.com/mcquill99/SoftwareEngineeringPractice # Conflicts: # .idea/SoftwareEngineeringPractice.iml --- .idea/SoftwareEngineeringPractice.iml | 2 -- 1 file changed, 2 deletions(-) delete mode 100644 .idea/SoftwareEngineeringPractice.iml diff --git a/.idea/SoftwareEngineeringPractice.iml b/.idea/SoftwareEngineeringPractice.iml deleted file mode 100644 index 78b2cc53..00000000 --- a/.idea/SoftwareEngineeringPractice.iml +++ /dev/null @@ -1,2 +0,0 @@ - - \ No newline at end of file From bbc87f3a6c150a6c250004f9bc0afe73158eb96d Mon Sep 17 00:00:00 2001 From: thegoat Date: Wed, 5 Feb 2020 16:35:46 -0500 Subject: [PATCH 33/45] account stuff --- .idea/compiler.xml | 1 + 1 file changed, 1 insertion(+) diff --git a/.idea/compiler.xml b/.idea/compiler.xml index 8e6ce1f3..edefae33 100644 --- a/.idea/compiler.xml +++ b/.idea/compiler.xml @@ -7,6 +7,7 @@ + From 6be9a17cf82737cf4fcbc35e852a166dfc2d1595 Mon Sep 17 00:00:00 2001 From: thegoat Date: Wed, 5 Feb 2020 16:48:51 -0500 Subject: [PATCH 34/45] close account test and function implemented --- src/main/java/edu/ithaca/dragon/bank/CentralBank.java | 4 +--- src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java | 2 +- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java index cac23058..923c5622 100644 --- a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java +++ b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java @@ -61,9 +61,7 @@ public void createAccount(String acctId, String email, String password, double s public void closeAccount(String acctId) { -// CentralBank bank = new CentralBank(); -// -// bank.accountMap.remove(acctId); + accountMap.remove(acctId); diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index d56abbbb..5b33e0db 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -32,7 +32,7 @@ void closeAccountTest() { bankAccount.createAccount("1245", "a1@hello.com", "testpassword", 500); assertEquals("a1@hello.com", bankAccount.accountMap.get("1245").getEmail()); bankAccount.closeAccount("1245"); - assertEquals(null, bankAccount.accountMap.get("1245").getEmail()); + assertEquals(null, bankAccount.accountMap.get("1245")); CentralBank bankAccount2 = new CentralBank(); bankAccount2.createAccount("BH8525", "atest3@gmail.com", "funny", 1000); From 3a07b85aa1c48e067700c64a93cfa33279b2f1ba Mon Sep 17 00:00:00 2001 From: thegoat Date: Wed, 5 Feb 2020 17:46:53 -0500 Subject: [PATCH 35/45] Created Tester classes for each API and added tests to it --- .../edu/ithaca/dragon/bank/AdminAPITest.java | 13 ++++ .../ithaca/dragon/bank/AdvancedAPITest.java | 43 +++++++++++++ .../ithaca/dragon/bank/BankAccountTest.java | 61 ------------------- .../edu/ithaca/dragon/bank/BasicAPITest.java | 37 +++++++++++ 4 files changed, 93 insertions(+), 61 deletions(-) create mode 100644 src/test/java/edu/ithaca/dragon/bank/AdminAPITest.java create mode 100644 src/test/java/edu/ithaca/dragon/bank/AdvancedAPITest.java create mode 100644 src/test/java/edu/ithaca/dragon/bank/BasicAPITest.java diff --git a/src/test/java/edu/ithaca/dragon/bank/AdminAPITest.java b/src/test/java/edu/ithaca/dragon/bank/AdminAPITest.java new file mode 100644 index 00000000..87769bfc --- /dev/null +++ b/src/test/java/edu/ithaca/dragon/bank/AdminAPITest.java @@ -0,0 +1,13 @@ +package edu.ithaca.dragon.bank; + +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +public class AdminAPITest { + + + + + + +} diff --git a/src/test/java/edu/ithaca/dragon/bank/AdvancedAPITest.java b/src/test/java/edu/ithaca/dragon/bank/AdvancedAPITest.java new file mode 100644 index 00000000..2fdbb24f --- /dev/null +++ b/src/test/java/edu/ithaca/dragon/bank/AdvancedAPITest.java @@ -0,0 +1,43 @@ +package edu.ithaca.dragon.bank; + +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +public class AdvancedAPITest { + + @Test + void createAccountTest(){ + CentralBank bankAccount = new CentralBank(); + bankAccount.createAccount("1245", "a1@hello.com", "testpassword", 500); + assertNull( bankAccount.accountMap.get("12466")); + assertEquals(500, bankAccount.accountMap.get("1245").getBalance()); + assertEquals("a1@hello.com", bankAccount.accountMap.get("1245").getEmail()); + assertEquals("testpassword", bankAccount.accountMap.get("1245").getPassword()); + + CentralBank bankAccount2 = new CentralBank(); + bankAccount2.createAccount("BH8525", "atest3@gmail.com", "funny", 1000); + assertNull(bankAccount2.accountMap.get("BH85425")); + assertEquals(1000, bankAccount2.accountMap.get("BH8525").getBalance()); + assertEquals("atest3@gmail.com", bankAccount2.accountMap.get("BH8525").getEmail()); + assertEquals("funny", bankAccount2.accountMap.get("BH8525").getPassword()); + + } + + + @Test + void closeAccountTest() { + CentralBank bankAccount = new CentralBank(); + bankAccount.createAccount("1245", "a1@hello.com", "testpassword", 500); + assertEquals("a1@hello.com", bankAccount.accountMap.get("1245").getEmail()); + bankAccount.closeAccount("1245"); + assertNull(bankAccount.accountMap.get("1245")); + + CentralBank bankAccount2 = new CentralBank(); + bankAccount2.createAccount("BH8525", "atest3@gmail.com", "funny", 1000); + assertEquals("atest3@gmail.com", bankAccount2.accountMap.get("BH8525").getEmail()); + bankAccount2.closeAccount("BH8525"); + assertNull(bankAccount2.accountMap.get("BH8525")); + + } + +} diff --git a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java index 5b33e0db..2ba66830 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java @@ -6,67 +6,6 @@ class BankAccountTest { - - @Test - void createAccountTest(){ - CentralBank bankAccount = new CentralBank(); - bankAccount.createAccount("1245", "a1@hello.com", "testpassword", 500); - assertNull( bankAccount.accountMap.get("12466")); - assertEquals(500, bankAccount.accountMap.get("1245").getBalance()); - assertEquals("a1@hello.com", bankAccount.accountMap.get("1245").getEmail()); - assertEquals("testpassword", bankAccount.accountMap.get("1245").getPassword()); - - CentralBank bankAccount2 = new CentralBank(); - bankAccount2.createAccount("BH8525", "atest3@gmail.com", "funny", 1000); - assertNull(bankAccount2.accountMap.get("BH85425")); - assertEquals(1000, bankAccount2.accountMap.get("BH8525").getBalance()); - assertEquals("atest3@gmail.com", bankAccount2.accountMap.get("BH8525").getEmail()); - assertEquals("funny", bankAccount2.accountMap.get("BH8525").getPassword()); - - } - - - @Test - void closeAccountTest() { - CentralBank bankAccount = new CentralBank(); - bankAccount.createAccount("1245", "a1@hello.com", "testpassword", 500); - assertEquals("a1@hello.com", bankAccount.accountMap.get("1245").getEmail()); - bankAccount.closeAccount("1245"); - assertEquals(null, bankAccount.accountMap.get("1245")); - - CentralBank bankAccount2 = new CentralBank(); - bankAccount2.createAccount("BH8525", "atest3@gmail.com", "funny", 1000); - } - - @Test - void checkBalanceTest(){ - } - - - - - - @Test - void confirmCredentialsTest(){ - - CentralBank bankAccount = new CentralBank(); - CentralBank bankAccount2 = new CentralBank(); - bankAccount.createAccount("11212", "a@b.com", "testingPassword", 500); - bankAccount2.createAccount("11BFWGG", "tester@gmail.com", "singleLetter", 1000); - - assertFalse(bankAccount.confirmCredentials("11212", "test")); - assertFalse( bankAccount.confirmCredentials("112", "testingPassword")); - assertTrue( bankAccount.confirmCredentials("11212", "testingPassword")); - - assertFalse(bankAccount2.confirmCredentials("11bfwgg", "singleLetter")); - assertFalse(bankAccount2.confirmCredentials("11bfwgg", "SingleLetter")); - assertTrue(bankAccount2.confirmCredentials("11BFWGG", "singleLetter")); - - - - - } - @Test void getBalanceTest() throws InsufficientFundsException, IllegalArgumentException { //classes - fresh account, after withdrawal, after unsuccessful withdrawal diff --git a/src/test/java/edu/ithaca/dragon/bank/BasicAPITest.java b/src/test/java/edu/ithaca/dragon/bank/BasicAPITest.java new file mode 100644 index 00000000..cac72e84 --- /dev/null +++ b/src/test/java/edu/ithaca/dragon/bank/BasicAPITest.java @@ -0,0 +1,37 @@ +package edu.ithaca.dragon.bank; + +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +public class BasicAPITest { + + @Test + void confirmCredentialsTest(){ + + CentralBank bankAccount = new CentralBank(); + CentralBank bankAccount2 = new CentralBank(); + bankAccount.createAccount("11212", "a@b.com", "testingPassword", 500); + bankAccount2.createAccount("11BFWGG", "tester@gmail.com", "singleLetter", 1000); + + assertFalse(bankAccount.confirmCredentials("11212", "test")); + assertFalse( bankAccount.confirmCredentials("112", "testingPassword")); + assertTrue( bankAccount.confirmCredentials("11212", "testingPassword")); + + assertFalse(bankAccount2.confirmCredentials("11bfwgg", "singleLetter")); + assertFalse(bankAccount2.confirmCredentials("11bfwgg", "SingleLetter")); + assertTrue(bankAccount2.confirmCredentials("11BFWGG", "singleLetter")); + + } + + @Test + void checkBalanceTest(){ + + } + + + + + + + +} From fc596f9b9a5ef3f76561bed297045b407d2370af Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Wed, 5 Feb 2020 18:00:12 -0500 Subject: [PATCH 36/45] Merge branch 'master' into checking-and-savings # Conflicts: # src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java Removed .idea folder, causing multiple merge conflicts. --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 4dd9646a..d44406b9 100644 --- a/.gitignore +++ b/.gitignore @@ -3,6 +3,7 @@ # User-specific stuff target/ +.idea/ .idea/**/workspace.xml .idea/**/tasks.xml .idea/**/usage.statistics.xml From d2077261e2695151621f66a01a7b1e9d51967a52 Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Wed, 5 Feb 2020 18:03:12 -0500 Subject: [PATCH 37/45] Removed SoftwareEngineeringPractice.iml and Bank.iml from project, more merge conflicts --- .gitignore | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index d44406b9..0487bfaa 100644 --- a/.gitignore +++ b/.gitignore @@ -97,4 +97,7 @@ Icon .AppleDesktop Network Trash Folder Temporary Items -.apdisk \ No newline at end of file +.apdisk + +.SoftwareEngineeringPractice.iml +.SoftwareEngineeringPracticeBank.iml \ No newline at end of file From 1ed38c91c8d7498384212a7107fe205640750944 Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Wed, 5 Feb 2020 18:04:39 -0500 Subject: [PATCH 38/45] Merge branch 'master' into checking-and-savings # Conflicts: # src/test/java/edu/ithaca/dragon/bank/BankAccountTest.java Removed .idea folder, causing multiple merge conflicts. --- .gitignore | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.gitignore b/.gitignore index 0487bfaa..1790ed21 100644 --- a/.gitignore +++ b/.gitignore @@ -99,5 +99,5 @@ Network Trash Folder Temporary Items .apdisk -.SoftwareEngineeringPractice.iml -.SoftwareEngineeringPracticeBank.iml \ No newline at end of file +SoftwareEngineeringPractice.iml +SoftwareEngineeringPracticeBank.iml \ No newline at end of file From d65c3a481e32de3632f8caf0669fd7b8e810fa15 Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Wed, 5 Feb 2020 18:07:27 -0500 Subject: [PATCH 39/45] file tracking -changed --- SoftwareEngineeringPractice.iml | 52 ----------------------------- SoftwareEngineeringPracticeBank.iml | 2 -- 2 files changed, 54 deletions(-) delete mode 100644 SoftwareEngineeringPractice.iml delete mode 100644 SoftwareEngineeringPracticeBank.iml diff --git a/SoftwareEngineeringPractice.iml b/SoftwareEngineeringPractice.iml deleted file mode 100644 index 9cd7562e..00000000 --- a/SoftwareEngineeringPractice.iml +++ /dev/null @@ -1,52 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/SoftwareEngineeringPracticeBank.iml b/SoftwareEngineeringPracticeBank.iml deleted file mode 100644 index 74f3f131..00000000 --- a/SoftwareEngineeringPracticeBank.iml +++ /dev/null @@ -1,2 +0,0 @@ - - \ No newline at end of file From 7a314bd403ab17dc20cef92cdeb08393c18240c2 Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Wed, 5 Feb 2020 19:03:54 -0500 Subject: [PATCH 40/45] Updated gitignore --- .gitignore | 1 - 1 file changed, 1 deletion(-) diff --git a/.gitignore b/.gitignore index 1790ed21..1b3916ee 100644 --- a/.gitignore +++ b/.gitignore @@ -99,5 +99,4 @@ Network Trash Folder Temporary Items .apdisk -SoftwareEngineeringPractice.iml SoftwareEngineeringPracticeBank.iml \ No newline at end of file From 018b791cca46bf6e51a001cf0c85d2c2e79f6b0e Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Wed, 5 Feb 2020 21:17:41 -0500 Subject: [PATCH 41/45] Added iml file --- SoftwareEngineeringPractice.iml | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 SoftwareEngineeringPractice.iml diff --git a/SoftwareEngineeringPractice.iml b/SoftwareEngineeringPractice.iml new file mode 100644 index 00000000..53139ab2 --- /dev/null +++ b/SoftwareEngineeringPractice.iml @@ -0,0 +1,26 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file From b7451c5caf34e27d0efc81c133be8b8c00880aea Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Thu, 6 Feb 2020 11:17:24 -0500 Subject: [PATCH 42/45] Added tests for withdraw and checkBalance --- .../edu/ithaca/dragon/bank/BasicAPITest.java | 44 ++++++++++++++++++- 1 file changed, 43 insertions(+), 1 deletion(-) diff --git a/src/test/java/edu/ithaca/dragon/bank/BasicAPITest.java b/src/test/java/edu/ithaca/dragon/bank/BasicAPITest.java index cac72e84..b5608354 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BasicAPITest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BasicAPITest.java @@ -24,7 +24,49 @@ void confirmCredentialsTest(){ } @Test - void checkBalanceTest(){ + void checkBalanceTest() throws IllegalArgumentException, InsufficientFundsException{ + CentralBank bank = new CentralBank(); + bank.createAccount("test123", "a@b.com", "testpass", 1000); + assertEquals(1000, bank.checkBalance("test123")); + //different account names + bank.withdraw("test123", 1); + assertEquals(999, bank.checkBalance("test123")); + bank.withdraw("test123", 250.47); + assertEquals(748.53, bank.checkBalance("test123")); + bank.withdraw("test123", 748.53); + assertEquals(0, bank.checkBalance("test123")); + + bank.createAccount("test456", "b@a.com", "testpass", 3290.57); + assertEquals(3290.57, bank.checkBalance("test456")); + + bank.createAccount("test789", "b@a.com", "testpass", 999999999.99); + assertEquals(999999999.99, bank.checkBalance("test789")); + + + + } + + @Test + void withdrawTest() throws IllegalArgumentException, InsufficientFundsException{ + CentralBank bank = new CentralBank(); + bank.createAccount("test123", "a@b.com", "testpass", 1000); + assertEquals(1000, bank.checkBalance("test123")); + //legal withdraws + bank.withdraw("test123", 1); + assertEquals(999, bank.checkBalance("test123")); + bank.withdraw("test123", 250.47); + assertEquals(748.53, bank.checkBalance("test123")); + bank.withdraw("test123", 748.53); + assertEquals(0, bank.checkBalance("test123")); + //illegal withdraws + assertThrows(IllegalArgumentException.class, ()->bank.withdraw("test123", -1)); + assertThrows(IllegalArgumentException.class, ()->bank.withdraw("test123", -500.89)); + assertThrows(IllegalArgumentException.class, ()->bank.withdraw("test123", -1000000.45)); + assertThrows(IllegalArgumentException.class, ()->bank.withdraw("test123", -1.96646)); + assertThrows(IllegalArgumentException.class, ()->bank.withdraw("test123", -1.9648690548065809546)); + assertThrows(IllegalArgumentException.class, ()->bank.withdraw("test123", 50.3940685)); + + } From a5c8ed633104dadd6e9562cbb1ecc0b1f2c52e3f Mon Sep 17 00:00:00 2001 From: Sean McQuillan Date: Thu, 6 Feb 2020 16:52:51 -0500 Subject: [PATCH 43/45] Added withdraw and getBalance functions to centralBank --- .../java/edu/ithaca/dragon/bank/CentralBank.java | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java index 923c5622..8b2b13f1 100644 --- a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java +++ b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java @@ -14,7 +14,9 @@ public class CentralBank implements AdvancedAPI, AdminAPI { + public boolean confirmCredentials(String acctId, String password){ + if(accountMap.containsKey(acctId)){ return accountMap.get(acctId).getPassword().equals(password); } @@ -25,13 +27,19 @@ public boolean confirmCredentials(String acctId, String password){ } - public double checkBalance(String acctId) { - BankAccount accountToCheck = new BankAccount(acctId, 1000); - return accountToCheck.getBalance(); + public double checkBalance(String acctId) throws IllegalArgumentException { + if(!accountMap.containsKey(acctId)){ + throw new IllegalArgumentException("Account does not exist with name: " + acctId); + } + return accountMap.get(acctId).getBalance(); } - public void withdraw(String acctId, double amount) throws InsufficientFundsException { + public void withdraw(String acctId, double amount) throws InsufficientFundsException, IllegalArgumentException { + if(!accountMap.containsKey(acctId)){ + throw new IllegalArgumentException("Account does not exist with name: " + acctId); + } + accountMap.get(acctId).withdraw(amount); } From 596d0452c36c8715785e6a86ee8711d737279755 Mon Sep 17 00:00:00 2001 From: thegoat Date: Thu, 6 Feb 2020 18:36:01 -0500 Subject: [PATCH 44/45] implemented deposit and transfer with testers --- .../edu/ithaca/dragon/bank/CentralBank.java | 25 ++++++- .../edu/ithaca/dragon/bank/BasicAPITest.java | 69 +++++++++++++++++++ 2 files changed, 92 insertions(+), 2 deletions(-) diff --git a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java index 8b2b13f1..f3326c73 100644 --- a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java +++ b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java @@ -43,11 +43,32 @@ public void withdraw(String acctId, double amount) throws InsufficientFundsExcep } - public void deposit(String acctId, double amount) { + public void deposit(String acctId, double amount) throws IllegalArgumentException { + if(!accountMap.containsKey(acctId)){ + throw new IllegalArgumentException("Account does not exist with ID" + acctId); + } + + accountMap.get(acctId).deposit(amount); + } - public void transfer(String acctIdToWithdrawFrom, String acctIdToDepositTo, double amount) throws InsufficientFundsException { + public void transfer(String acctIdToWithdrawFrom, String acctIdToDepositTo, double amount) throws IllegalArgumentException, InsufficientFundsException { + if(!accountMap.containsKey(acctIdToWithdrawFrom) || !accountMap.containsKey(acctIdToDepositTo)){ + throw new IllegalArgumentException("Account does not exist with IDs given"); + + } + + if(accountMap.get(acctIdToWithdrawFrom).getBalance() < amount){ + throw new InsufficientFundsException("Account does not have enough money"); + } + + //accountMap.get(acctIdToWithdrawFrom).transfer(amount, accountMap.get(acctIdToDepositTo)); + + accountMap.get(acctIdToWithdrawFrom).withdraw(amount); + accountMap.get(acctIdToDepositTo).deposit(amount); + + } diff --git a/src/test/java/edu/ithaca/dragon/bank/BasicAPITest.java b/src/test/java/edu/ithaca/dragon/bank/BasicAPITest.java index b5608354..6cf3893d 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BasicAPITest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BasicAPITest.java @@ -68,6 +68,75 @@ void withdrawTest() throws IllegalArgumentException, InsufficientFundsException{ + } + + @Test + void depositTest() throws IllegalArgumentException{ + CentralBank bank = new CentralBank(); + bank.createAccount("test123", "a@b.com", "testpass", 1000); + bank.deposit("test123", 100); + assertEquals(1100, bank.checkBalance("test123")); + bank.deposit("test123", 1000); + assertEquals(2100, bank.checkBalance("test123")); + bank.deposit("test123", .19); + assertEquals(2100.19, bank.checkBalance("test123")); + + //account not found deposits + assertThrows(IllegalArgumentException.class, ()-> bank.deposit("test13", 50)); + assertThrows(IllegalArgumentException.class, ()-> bank.deposit("tes3", 100)); + //illegal deposits + assertThrows(IllegalArgumentException.class, ()-> bank.deposit("test123", 50.53894329)); + assertThrows(IllegalArgumentException.class, ()-> bank.deposit("test123", .3894329)); + //check balance remains the same + assertEquals(2100.19, bank.checkBalance("test123")); + + } + + @Test + void transferTest() throws InsufficientFundsException, IllegalArgumentException { + CentralBank bank = new CentralBank(); + bank.createAccount("test1", "a@b.com", "testpass", 10000); + bank.createAccount("test2", "b@c.com", "testpass", 500); + + assertEquals(10000, bank.checkBalance("test1")); + bank.transfer("test1", "test2", 500); + //check legal transfers both ways + assertEquals(9500,bank.checkBalance("test1")); + assertEquals(1000,bank.checkBalance("test2")); + bank.transfer("test1", "test2", 1500); + assertEquals(8000, bank.checkBalance("test1")); + assertEquals(2500,bank.checkBalance("test2")); + bank.transfer("test2", "test1", 150.02); + assertEquals(8150.02, bank.checkBalance("test1")); + assertEquals(2349.98,bank.checkBalance("test2")); + + //check for illegal transfers + assertThrows(IllegalArgumentException.class, ()-> bank.transfer("test1", "test2", .5424506)); + assertThrows(IllegalArgumentException.class, ()-> bank.transfer("test2", "test1", .506)); + assertThrows(IllegalArgumentException.class, ()-> bank.transfer("test2", "test1", -.506)); + assertThrows(IllegalArgumentException.class, ()-> bank.transfer("test1", "tt1", 100)); + assertThrows(IllegalArgumentException.class, ()-> bank.transfer("t1", "doesntexist", 10)); + + + //check for insufficient funds + assertThrows(InsufficientFundsException.class, ()-> bank.transfer("test1", "test2", 10000)); + assertThrows(InsufficientFundsException.class, ()-> bank.transfer("test2", "test1", 2349.99)); + assertThrows(InsufficientFundsException.class, ()-> bank.transfer("test1", "test2", 8150.03)); + assertThrows(InsufficientFundsException.class, ()-> bank.transfer("test2", "test", 8150.03)); + + + + + + + + + + + + + + } From bf2b9dc8b1eb621be5d7f8da9918a4ec2d2b2525 Mon Sep 17 00:00:00 2001 From: thegoat Date: Thu, 6 Feb 2020 18:43:56 -0500 Subject: [PATCH 45/45] pass all tests for transfer and deposit --- src/main/java/edu/ithaca/dragon/bank/CentralBank.java | 3 +-- src/test/java/edu/ithaca/dragon/bank/BasicAPITest.java | 7 ++++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java index f3326c73..9798908d 100644 --- a/src/main/java/edu/ithaca/dragon/bank/CentralBank.java +++ b/src/main/java/edu/ithaca/dragon/bank/CentralBank.java @@ -54,7 +54,7 @@ public void deposit(String acctId, double amount) throws IllegalArgumentExceptio } public void transfer(String acctIdToWithdrawFrom, String acctIdToDepositTo, double amount) throws IllegalArgumentException, InsufficientFundsException { - if(!accountMap.containsKey(acctIdToWithdrawFrom) || !accountMap.containsKey(acctIdToDepositTo)){ + if(!accountMap.containsKey(acctIdToWithdrawFrom) || !accountMap.containsKey(acctIdToDepositTo) || acctIdToWithdrawFrom.equals(acctIdToDepositTo)){ throw new IllegalArgumentException("Account does not exist with IDs given"); } @@ -63,7 +63,6 @@ public void transfer(String acctIdToWithdrawFrom, String acctIdToDepositTo, doub throw new InsufficientFundsException("Account does not have enough money"); } - //accountMap.get(acctIdToWithdrawFrom).transfer(amount, accountMap.get(acctIdToDepositTo)); accountMap.get(acctIdToWithdrawFrom).withdraw(amount); accountMap.get(acctIdToDepositTo).deposit(amount); diff --git a/src/test/java/edu/ithaca/dragon/bank/BasicAPITest.java b/src/test/java/edu/ithaca/dragon/bank/BasicAPITest.java index 6cf3893d..18192ec7 100644 --- a/src/test/java/edu/ithaca/dragon/bank/BasicAPITest.java +++ b/src/test/java/edu/ithaca/dragon/bank/BasicAPITest.java @@ -114,15 +114,16 @@ void transferTest() throws InsufficientFundsException, IllegalArgumentException assertThrows(IllegalArgumentException.class, ()-> bank.transfer("test1", "test2", .5424506)); assertThrows(IllegalArgumentException.class, ()-> bank.transfer("test2", "test1", .506)); assertThrows(IllegalArgumentException.class, ()-> bank.transfer("test2", "test1", -.506)); - assertThrows(IllegalArgumentException.class, ()-> bank.transfer("test1", "tt1", 100)); - assertThrows(IllegalArgumentException.class, ()-> bank.transfer("t1", "doesntexist", 10)); + assertThrows(IllegalArgumentException.class, ()-> bank.transfer("test1", "test2", 100.64345)); + assertThrows(IllegalArgumentException.class, ()-> bank.transfer("test1", "test1", 10)); //transfer to same account + assertThrows(IllegalArgumentException.class, ()-> bank.transfer("test2", "test2", 1093)); //transfer to same account //check for insufficient funds assertThrows(InsufficientFundsException.class, ()-> bank.transfer("test1", "test2", 10000)); assertThrows(InsufficientFundsException.class, ()-> bank.transfer("test2", "test1", 2349.99)); assertThrows(InsufficientFundsException.class, ()-> bank.transfer("test1", "test2", 8150.03)); - assertThrows(InsufficientFundsException.class, ()-> bank.transfer("test2", "test", 8150.03)); + assertThrows(InsufficientFundsException.class, ()-> bank.transfer("test2", "test1", 8150.03));