feat: implement BusinessCheckingAccount and SavingsAccount wth asscoiated tests

Author: Meiko-S22

lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/BankAtm.java

@@ -13,7 +13,6 @@ public class BankAtm {
   private final Map<UUID, Customer> customerById = new HashMap<>();
   final Map<String, CheckingAccount> checkingAccountsByNumber = new HashMap<>();
   public Object accountByNumber;
-  
 
   /**
    * Adds a checking account to the bank.
@@ -30,8 +29,6 @@ public void addAccount(CheckingAccount account) {
             });
   }
 
-
-
   /**
    * Finds all accounts owned by a customer.
    *
@@ -85,11 +82,9 @@ public void withdrawFunds(String accountNumber, double amount) {
    */
   private CheckingAccount getAccountOrThrow(String accountNumber) {
     CheckingAccount checkingAccount = checkingAccountsByNumber.get(accountNumber);
-    if (checkingAccount != null && !checkingAccount.isClosed()) {
-      throw new AccountNotFoundException("Account not foudn");
-    }  
-      return checkingAccount;
+    if (checkingAccount == null || checkingAccount.isClosed()) {
+      throw new AccountNotFoundException("Account not found");
     }
-    
+    return checkingAccount;
   }
-
+}

lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/BusinessCheckingAccount.java

@@ -4,29 +4,27 @@
 
 public final class BusinessCheckingAccount extends CheckingAccount {
 
-    /**
-     * Represents a business checking account.
-     *
-     * <p>It is a subclass of CheckingAccount and inherits its properties and methods.
-     */
-    public BusinessCheckingAccount(String accountNumber, Set<Customer> owners, double initialBalance) {
-        super(accountNumber, owners, initialBalance);
-        if (!hasBusinessOwner(owners)) {
-            throw new IllegalArgumentException(
+  /**
+   * Represents a business checking account.
+   *
+   * <p>It is a subclass of BankAccount and inherits its properties and methods.
+   */
+  public BusinessCheckingAccount(
+      String accountNumber, Set<Customer> owners, double initialBalance) {
+    super(accountNumber, owners, initialBalance);
+    if (!hasBusinessOwner(owners)) {
+      throw new IllegalArgumentException(
           "A BusinessCheckingAccount must have at least one business owner.");
     }
   }
 
-    /**
-     * Checks if the owners of the account include at least one business customer.
-     *
-     * @param owners The owners of the account.
-     * @return true if there is a business owner, false otherwise.
-     */
-    private
-  boolean hasBusinessOwner(Set<Customer> owners) {
+  /**
+   * Checks if the owners of the account include at least one business customer.
+   *
+   * @param owners The owners of the account.
+   * @return true if there is a business owner, false otherwise.
+   */
+  private boolean hasBusinessOwner(Set<Customer> owners) {
     return owners.stream().anyMatch(owner -> owner instanceof BusinessCustomer);
   }
-
-   
 }

lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/BusinessCustomer.java

@@ -7,4 +7,4 @@ public class BusinessCustomer extends Customer {
   public BusinessCustomer(UUID id, String name) {
     super(id, name);
   }
-}
+}

lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/CheckingAccount.java

@@ -1,27 +1,18 @@
 package com.codedifferently.lesson17.bank;
 
-import java.util.Set;
-
 import com.codedifferently.lesson17.bank.exceptions.InsufficientFundsException;
+import java.util.Set;
 
 /** Represents a checking account. */
 public class CheckingAccount {
-
   private static Set<Customer> owners;
   private final String accountNumber;
   private double balance;
   private boolean isActive;
 
-  /**
-   * Creates a new checking account.
-   *
-   * @param accountNumber The account number.
-   * @param owners The owners of the account.
-   * @param initialBalance The initial balance of the account.
-   */
   public CheckingAccount(String accountNumber, Set<Customer> owners, double initialBalance) {
     this.accountNumber = accountNumber;
-    CheckingAccount.owners = owners;
+    this.owners = owners;
     this.balance = initialBalance;
     isActive = true;
   }
@@ -44,6 +35,23 @@ public Set<Customer> getOwners() {
     return owners;
   }
 
+  /**
+   * Gets the balance of the account.
+   *
+   * @return The balance of the account.
+   */
+  public double getBalance() {
+    return balance;
+  }
+
+  /** Closes the account. */
+  public void closeAccount() throws IllegalStateException {
+    if (balance > 0) {
+      throw new IllegalStateException("Cannot close account with positive balance");
+    }
+    isActive = false;
+  }
+
   /**
    * Deposits funds into the account.
    *
@@ -72,29 +80,12 @@ public void withdraw(double amount) throws InsufficientFundsException {
     if (amount <= 0) {
       throw new IllegalStateException("Withdrawal amount must be positive");
     }
-    if (balance < amount) {
+    if (amount > balance) {
       throw new InsufficientFundsException("Account does not have enough funds for withdrawal");
     }
     balance -= amount;
   }
 
-  /**
-   * Gets the balance of the account.
-   *
-   * @return The balance of the account.
-   */
-  public double getBalance() {
-    return balance;
-  }
-
-  /** Closes the account. */
-  public void closeAccount() throws IllegalStateException {
-    if (balance > 0) {
-      throw new IllegalStateException("Cannot close account with a positive balance");
-    }
-    isActive = false;
-  }
-
   /**
    * Checks if the account is closed.
    *

lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/SavingsAccount.java

@@ -1,25 +1,115 @@
 package com.codedifferently.lesson17.bank;
 
+import com.codedifferently.lesson17.bank.exceptions.InsufficientFundsException;
 import java.util.Set;
 
+public class SavingsAccount {
+  private final Set<Customer> owners;
+  private final String accountNumber;
+  private double balance;
+  private boolean isActive;
 
+  /**
+   * Represents a savings account.
+   *
+   * <p>It is a subclass of BankAccount and inherits its properties and methods.
+   */
+  public SavingsAccount(String accountNumber, Set<Customer> owners, double initialBalance) {
+    this.accountNumber = accountNumber;
+    this.owners = owners;
+    this.balance = initialBalance;
+    isActive = true;
+  }
 
+  /**
+   * Gets the account number.
+   *
+   * @return The account number.
+   */
+  public String getAccountNumber() {
+    return accountNumber;
+  }
 
-public class SavingsAccount extends CheckingAccount {
-    
   /**
-   * Represents a savings account.
+   * Gets the owners of the account.
+   *
+   * @return The owners of the account.
+   */
+  public Set<Customer> getOwners() {
+    return owners;
+  }
+
+  /**
+   * Gets the balance of the account.
+   *
+   * @return The balance of the account.
+   */
+  public double getBalance() {
+    return balance;
+  }
+
+  /**
+   * Deposits funds into the account.
    *
-   * <p>It is a subclass of CheckingAccount and inherits its properties and methods.
+   * @param amount The amount to deposit.
    */
+  public void deposit(double amount) throws IllegalStateException {
+    if (isClosed()) {
+      throw new IllegalStateException("Cannot deposit to a closed account");
+    }
+    if (amount <= 0) {
+      throw new IllegalArgumentException("Deposit amount must be positive");
+    }
+    balance += amount;
+  }
 
+  /**
+   * Withdraws funds from the account.
+   *
+   * @param amount
+   * @throws InsufficientFundsException
+   */
+  public void withdraw(double amount) throws InsufficientFundsException {
+    if (isClosed()) {
+      throw new IllegalStateException("Cannot withdraw from a closed account");
+    }
+    if (amount <= 0) {
+      throw new IllegalStateException("Withdrawal amount must be positive");
+    }
+  }
 
+  /**
+   * Checks if the account is closed.
+   *
+   * @return True if the account is closed, otherwise false.
+   */
+  public boolean isClosed() {
+    return !isActive;
+  }
 
-public SavingsAccount (String accountNumber, Set<Customer> owners, double initialBalance) {
-    super(accountNumber, owners, initialBalance);
+  @Override
+  public int hashCode() {
+    return accountNumber.hashCode();
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (obj instanceof SavingsAccount other) {
+      return accountNumber.equals(other.accountNumber);
+    }
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return "CheckingAccount{"
+        + "accountNumber='"
+        + accountNumber
+        + '\''
+        + ", balance="
+        + balance
+        + ", isActive="
+        + isActive
+        + '}';
   }
-  
-  public void depositFunds(Check check) {
-   throw new UnsupportedOperationException("Cannot deposit check into a savings account");
-}
 }

lesson_17/bank/bank_app/src/test/java/com/codedifferently/lesson17/bank/BankAtmTest.java

@@ -27,6 +27,7 @@ void setUp() {
     account2 = new CheckingAccount("987654321", Set.of(customer1, customer2), 200.0);
     customer1.addAccount(account1);
     customer1.addAccount(account2);
+    customer2.addAccount(account1);
     customer2.addAccount(account2);
     classUnderTest.addAccount(account1);
     classUnderTest.addAccount(account2);
@@ -74,7 +75,7 @@ void testDepositFunds_Check() {
     classUnderTest.depositFunds("987654321", check);
 
     // Assert
-    assertThat(account1.getBalance()).isEqualTo(0);
+    assertThat(account1.getBalance()).isEqualTo(0.0);
     assertThat(account2.getBalance()).isEqualTo(300.0);
   }
 

lesson_17/bank/bank_app/src/test/java/com/codedifferently/lesson17/BusinessCheckingAccountTest.java renamed to lesson_17/bank/bank_app/src/test/java/com/codedifferently/lesson17/bank/BusinessCheckingAccountTest.java

@@ -1,60 +1,52 @@
-package com.codedifferently.lesson17;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.UUID;
+package com.codedifferently.lesson17.bank;
 
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
 import org.junit.jupiter.api.Test;
 
-import com.codedifferently.lesson17.bank.BankAtm;
-import com.codedifferently.lesson17.bank.BusinessCheckingAccount;
-import com.codedifferently.lesson17.bank.BusinessCustomer;
-import com.codedifferently.lesson17.bank.Customer;
 public class BusinessCheckingAccountTest {
-    @Test
+  @Test
   public void testAddBusinessCheckingAccountWithBusinessOwner() {
-   
+
     BankAtm atm = new BankAtm();
 
     UUID customerId = UUID.randomUUID();
 
     BusinessCustomer businessCustomer = new BusinessCustomer(UUID.randomUUID(), "Business1");
     Customer personalCustomer = new Customer(UUID.randomUUID(), "Personal1");
 
-    
     Set<Customer> owners = new HashSet<>();
     owners.add(businessCustomer);
     owners.add(personalCustomer);
 
-   
     BusinessCheckingAccount businessAccount = new BusinessCheckingAccount("12345", owners, 2000.00);
     atm.addAccount(businessAccount);
     assertNotNull((atm.findAccountsByCustomerId(customerId)));
   }
 
   @Test
   public void testAddBusinessCheckingAccountWithoutBusinessOwner() {
-    
+
     BankAtm atm = new BankAtm();
 
-    
     Customer personalCustomer1 = new Customer(UUID.randomUUID(), "Personal1");
     Customer personalCustomer2 = new Customer(UUID.randomUUID(), "Personal2");
 
-    
     Set<Customer> owners = new HashSet<>();
     owners.add(personalCustomer1);
     owners.add(personalCustomer2);
 
-    
     IllegalArgumentException exception =
-    assertThrows(
+        assertThrows(
             IllegalArgumentException.class,
             () -> {
               BusinessCheckingAccount businessAccount =
                   new BusinessCheckingAccount("12345", owners, 2000.00);
               atm.addAccount(businessAccount);
             });
-}
+  }
 }