feat: try to add savingAccount to bankATMLesson 17

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

@@ -1,23 +1,29 @@
 package com.codedifferently.lesson17.bank;
 
-import com.codedifferently.lesson17.bank.exceptions.AccountNotFoundException;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
+import java.util.stream.Collectors;
+
+import com.codedifferently.lesson17.bank.exceptions.AccountNotFoundException;
 
 /** Represents a bank ATM. */
 public class BankAtm {
 
   private final Map<UUID, Customer> customerById = new HashMap<>();
   private final Map<String, CheckingAccount> accountByNumber = new HashMap<>();
+  private final Map<String, BusinessAccount> accountByType = new HashMap<>();
 
   /**
    * Adds a checking account to the bank.
    *
    * @param account The account to add.
    */
   public void addAccount(CheckingAccount account) {
+    if (account == null) {
+      throw new IllegalArgumentException("Account cannot be null");
+    }
     accountByNumber.put(account.getAccountNumber(), account);
     account
         .getOwners()
@@ -33,9 +39,9 @@ public void addAccount(CheckingAccount account) {
    * @param customerId The ID of the customer.
    * @return The unique set of accounts owned by the customer.
    */
-  public Set<CheckingAccount> findAccountsByCustomerId(UUID customerId) {
+  public Set<Account> findAccountsByCustomerId(UUID customerId) {
     return customerById.containsKey(customerId)
-        ? customerById.get(customerId).getAccounts()
+        ? customerById.get(customerId).getAccounts().stream().collect(Collectors.toSet())
         : Set.of();
   }
 
@@ -46,9 +52,15 @@ public Set<CheckingAccount> findAccountsByCustomerId(UUID customerId) {
    * @param amount The amount to deposit.
    */
   public void depositFunds(String accountNumber, double amount) {
-    CheckingAccount account = getAccountOrThrow(accountNumber);
-    account.deposit(amount);
-  }
+    Account account = getAccountOrThrow(accountNumber);
+
+    if (account instanceof CheckingAccount) {
+        ((CheckingAccount) account).deposit(amount);
+    } else if (account instanceof BusinessAccount) {
+        ((BusinessAccount) account).deposit(amount);
+    } else {
+        throw new IllegalArgumentException("Unsupported account type");
+    }
 
   /**
    * Deposits funds into an account using a check.

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

@@ -0,0 +1,34 @@
+package com.codedifferently.lesson17.bank;
+
+import java.util.Set;
+
+import com.codedifferently.lesson17.bank.exceptions.InsufficientFundsException;
+
+public class BusinessAccount extends CheckingAccount {
+
+    /**
+     * Creates a new business account.
+     *
+     * @param accountNumber  The account number.
+     * @param owners         The owners of the account.
+     * @param initialBalance The initial balance of the account.
+     */
+    public BusinessAccount(String accountNumber, Set<Customer> owners, double initialBalance) {
+        super(accountNumber, owners, initialBalance);
+    }
+
+    /**
+     * Withdraws funds from the account.
+     *
+     * @param amount The amount to withdraw.
+     * @throws InsufficientFundsException If there are insufficient funds in the account.
+     */
+    @Override
+    public void withdraw(double amount) throws InsufficientFundsException {
+        if (amount > getBalance()) {
+            throw new InsufficientFundsException("Insufficient funds in the account.");
+        }
+        super.withdraw(amount);
+    }
+
+}

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

@@ -9,21 +9,27 @@ public class Check {
   private final double amount;
   private final CheckingAccount account;
   private boolean isVoided = false;
+  private final SavingsAccount savings;
 
   /**
    * Creates a new check.
    *
    * @param checkNumber The check number.
    * @param amount The amount of the check.
-   * @param account The account the check is drawn on.
+   * @param account The account the check is drawn on. Because account is represents checking it could also represent savings.so if 
+   * we call saving account saving we should be able to throw the exception on the check.
    */
-  public Check(String checkNumber, double amount, CheckingAccount account) {
-    if (amount < 0) {
+  public Check(String checkNumber, double amount, CheckingAccount account, SavingsAccount savings) {
+    if (checkNumber == null || checkNumber.isEmpty()) {
+      throw new IllegalArgumentException("Check number cannot be null or empty");
+    }
+    if (amount < 0 ) {
       throw new IllegalArgumentException("Check amount must be positive");
     }
     this.checkNumber = checkNumber;
     this.amount = amount;
     this.account = account;
+    this.savings = null;
   }
 
   /**

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

@@ -1,8 +1,9 @@
 package com.codedifferently.lesson17.bank;
 
-import com.codedifferently.lesson17.bank.exceptions.InsufficientFundsException;
 import java.util.Set;
 
+import com.codedifferently.lesson17.bank.exceptions.InsufficientFundsException;
+
 /** Represents a checking account. */
 public class CheckingAccount {
 

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

@@ -0,0 +1,47 @@
+package com.codedifferently.lesson17.bank;
+
+import java.util.Set;
+
+import com.codedifferently.lesson17.bank.exceptions.InsufficientFundsException;
+// Removed redundant or incorrect import
+
+
+/** Represents a savings account, which does not support check writing. */
+public class SavingsAccount extends CheckingAccount {
+
+    /**
+     * Creates a new savings account.
+     *
+     * @param accountNumber  The account number.
+     * @param owners         The owners of the account.
+     * @param initialBalance The initial balance of the account.
+     */
+    public SavingsAccount(String accountNumber, Set<Customer> owners, double initialBalance) {
+        super(accountNumber, owners, initialBalance);
+    }
+
+    /**
+     * Withdraws funds from the account.
+     *
+     * @param amount The amount to withdraw.
+     * @throws InsufficientFundsException If there are insufficient funds in the account.
+     */
+    @Override
+    public void withdraw(double amount) throws InsufficientFundsException {
+        if (amount > getBalance()) {
+            throw new InsufficientFundsException("Insufficient funds in the account.");
+        }
+        // Use a protected setter or a method in parent class if balance is private
+        super.withdraw(amount); // Use super if parent class has the logic
+    }
+
+    /**
+     * Disallows writing checks from a savings account.
+     *
+     * @param check The amount to write on the check.
+     * @throws UnsupportedOperationException Always, since savings accounts don't support checks.
+     */
+    public void writeCheck(Check check) {
+        throw new UnsupportedOperationException("Savings accounts can't write checks.");
+    }
+}

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

@@ -0,0 +1,5 @@
+package com.codedifferently.lesson17.bank;
+
+public class SavingAccount {
+
+}

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

@@ -0,0 +1,127 @@
+package com.codedifferently.lesson17.bank;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import com.codedifferently.lesson17.bank.SavingsAccount;
+import com.codedifferently.lesson17.bank.exceptions.InsufficientFundsException;
+
+public class SavingsAccountTest {
+
+
+  private SavingsAccount classUnderTest;
+  private Set<Customer> owners;
+
+  @BeforeEach
+  void setUp() {
+    owners = new HashSet<>();
+    owners.add(new Customer(UUID.randomUUID(), "John Doe"));
+    owners.add(new Customer(UUID.randomUUID(), "Jane Smith"));
+    classUnderTest = new SavingsAccount("123456789", owners, 100.0);
+  }
+
+  @Test
+  void getAccountNumber() {
+    assertEquals("123456789", classUnderTest.getAccountNumber());
+  }
+
+  @Test
+  void getOwners() {
+    assertEquals(owners, classUnderTest.getOwners());
+  }
+
+  @Test
+  void deposit() {
+    classUnderTest.deposit(50.0);
+    assertEquals(150.0, classUnderTest.getBalance());
+  }
+
+  @Test
+  void deposit_withNegativeAmount() {
+    assertThatExceptionOfType(IllegalArgumentException.class)
+        .isThrownBy(() -> classUnderTest.deposit(-50.0));
+  }
+
+  @Test
+  void withdraw() {
+    classUnderTest.withdraw(50.0);
+    assertEquals(50.0, classUnderTest.getBalance());
+  }
+
+  @Test
+  void withdraw_withNegativeAmount() {
+    assertThatExceptionOfType(IllegalStateException.class)
+        .isThrownBy(() -> classUnderTest.withdraw(-50.0))
+        .withMessage("Withdrawal amount must be positive");
+  }
+
+  @Test
+  void withdraw_withInsufficientBalance() {
+    assertThatExceptionOfType(InsufficientFundsException.class)
+        .isThrownBy(() -> classUnderTest.withdraw(150.0))
+        .withMessage("Account does not have enough funds for withdrawal");
+  }
+
+  @Test
+  void getBalance() {
+    assertEquals(100.0, classUnderTest.getBalance());
+  }
+
+  @Test
+  void closeAccount_withPositiveBalance() {
+    assertThatExceptionOfType(IllegalStateException.class)
+        .isThrownBy(() -> classUnderTest.closeAccount());
+  }
+
+  @Test
+  void isClosed() {
+    assertFalse(classUnderTest.isClosed());
+    classUnderTest.withdraw(100);
+    classUnderTest.closeAccount();
+    assertTrue(classUnderTest.isClosed());
+  }
+
+  @Test
+  void equals() {
+    SavingsAccount otherAccount = new SavingsAccount("123456789", owners, 200.0);
+    assertEquals(classUnderTest, otherAccount);
+  }
+
+  @Test
+  void hashCodeTest() {
+    SavingsAccount otherAccount = new SavingsAccount("123456789", owners, 200.0);
+    assertEquals(classUnderTest.hashCode(), otherAccount.hashCode());
+  }
+
+  @Test
+  void toStringTest() {
+    String expected = "CheckingAccount{accountNumber='123456789', balance=100.0, isActive=true}";
+    assertEquals(expected, classUnderTest.toString());
+  }
+
+  @Test 
+    void writeCheck() {
+        // Arrange
+        Check check = new Check("987654321", 50.0, classUnderTest, classUnderTest);
+
+        // Act
+        classUnderTest.writeCheck(check);
+
+        // Assert
+        assertEquals(50.0, classUnderTest.getBalance());
+        assertTrue(check.getIsVoided());
+
+    }
+}
+
+
+
+