Fixing failures

Author: dxbenson252

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

@@ -1,11 +1,12 @@
 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 com.codedifferently.lesson17.bank.exceptions.AccountNotFoundException;
+
 /**
  * Represents a bank ATM with support for multiple account types and comprehensive audit logging.
  * Enhanced to follow SOLID principles.
@@ -86,7 +87,7 @@ public void depositFunds(String accountNumber, Check check) {
 
     // Only checking accounts can accept check deposits
     if (!(account instanceof CheckingAccount)) {
-      throw new IllegalArgumentException("Cannot deposit checks to savings accounts");
+      throw new IllegalArgumentException("Cannot deposit checks to savings accounts. Account type: " + account.getClass().getSimpleName());
     }
 
     CheckingAccount checkingAccount = (CheckingAccount) account;

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

@@ -1,18 +1,21 @@
 package com.codedifferently.lesson17.bank;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import com.codedifferently.lesson17.bank.exceptions.AccountNotFoundException;
-import com.codedifferently.lesson17.bank.exceptions.InsufficientFundsException;
 import java.util.List;
 import java.util.Set;
 import java.util.UUID;
+
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
+import com.codedifferently.lesson17.bank.exceptions.AccountNotFoundException;
+import com.codedifferently.lesson17.bank.exceptions.InsufficientFundsException;
+
 /** Integration tests for BankAtm with SavingsAccount and AuditLog. */
 class BankAtmIntegrationTest {
 
@@ -89,10 +92,13 @@ void testSavingsAccountCannotAcceptCheckDeposits() {
 
     // This should throw an exception - depositing check to savings account
     Check savingsCheck = new Check("C002", 50.0, checkingAccount);
-    assertThrows(
+    IllegalArgumentException exception = assertThrows(
         IllegalArgumentException.class,
         () -> bankAtm.depositFunds("SAV001", savingsCheck),
         "Should not allow check deposits to savings accounts");
+    
+    assertThat(exception.getMessage())
+        .isEqualTo("Cannot deposit checks to savings accounts. Account type: SavingsAccount");
   }
 
   @Test

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

@@ -3,13 +3,15 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 
-import com.codedifferently.lesson17.bank.exceptions.AccountNotFoundException;
-import com.codedifferently.lesson17.bank.exceptions.CheckVoidedException;
 import java.util.Set;
 import java.util.UUID;
+
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
+import com.codedifferently.lesson17.bank.exceptions.AccountNotFoundException;
+import com.codedifferently.lesson17.bank.exceptions.CheckVoidedException;
+
 class BankAtmTest {
 
   private BankAtm classUnderTest;
@@ -166,7 +168,7 @@ void testDepositCheckToSavingsAccountThrowsException() {
     // Act & Assert
     assertThatExceptionOfType(IllegalArgumentException.class)
         .isThrownBy(() -> classUnderTest.depositFunds("SAV001", check))
-        .withMessage("Cannot deposit checks to savings accounts");
+        .withMessage("Cannot deposit checks to savings accounts. Account type: SavingsAccount");
   }
 
   @Test

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

@@ -3,12 +3,14 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 
-import com.codedifferently.lesson17.bank.exceptions.InsufficientFundsException;
 import java.util.Set;
 import java.util.UUID;
+
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
+import com.codedifferently.lesson17.bank.exceptions.InsufficientFundsException;
+
 class BaseAccountTest {
 
   private CheckingAccount account; // Using CheckingAccount as concrete implementation

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

@@ -5,13 +5,15 @@
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import com.codedifferently.lesson17.bank.exceptions.InsufficientFundsException;
 import java.util.HashSet;
 import java.util.Set;
 import java.util.UUID;
+
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
+import com.codedifferently.lesson17.bank.exceptions.InsufficientFundsException;
+
 class CheckingAccountTest {
 
   private CheckingAccount classUnderTest;

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

@@ -1,10 +1,10 @@
 package com.codedifferently.lesson17.bank;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 
 import java.util.Set;
 import java.util.UUID;
+
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 

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

@@ -0,0 +1,93 @@
+package com.codedifferently.lesson17.bank;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Set;
+import java.util.UUID;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class PolymorphicAccountTest {
+
+  private BankAtm bankAtm;
+  private Customer customer;
+  private CheckingAccount checkingAccount;
+  private SavingsAccount savingsAccount;
+
+  @BeforeEach
+  void setUp() {
+    bankAtm = new BankAtm();
+    customer = new Customer(UUID.randomUUID(), "John Doe");
+    
+    checkingAccount = new CheckingAccount("CHK001", Set.of(customer), 1000.0);
+    savingsAccount = new SavingsAccount("SAV001", Set.of(customer), 500.0);
+    
+    customer.addAccount(checkingAccount);
+    customer.addAccount(savingsAccount);
+    
+    bankAtm.addAccount(checkingAccount);
+    bankAtm.addAccount(savingsAccount);
+  }
+
+  @Test
+  void testFindAccountsByCustomerIdReturnsPolymorphicAccounts() {
+    // Act
+    Set<Account> accounts = bankAtm.findAccountsByCustomerId(customer.getId());
+
+    // Assert - Should return both checking and savings accounts as Account interface
+    assertThat(accounts).hasSize(2);
+    assertThat(accounts).containsExactlyInAnyOrder(checkingAccount, savingsAccount);
+    
+    // Verify they are polymorphic - can be treated as Account interface
+    for (Account account : accounts) {
+      assertThat(account.getAccountNumber()).isNotEmpty();
+      assertThat(account.getBalance()).isGreaterThanOrEqualTo(0);
+      assertThat(account.getOwners()).contains(customer);
+    }
+  }
+
+  @Test
+  void testPolymorphicAccountOperations() {
+    // Get accounts polymorphically
+    Set<Account> accounts = bankAtm.findAccountsByCustomerId(customer.getId());
+    
+    // Find savings account polymorphically
+    Account savingsAsAccount = accounts.stream()
+        .filter(acc -> acc.getAccountNumber().equals("SAV001"))
+        .findFirst()
+        .orElseThrow();
+        
+    // Find checking account polymorphically  
+    Account checkingAsAccount = accounts.stream()
+        .filter(acc -> acc.getAccountNumber().equals("CHK001"))
+        .findFirst()
+        .orElseThrow();
+    
+    // Both can be operated on through Account interface
+    double initialSavingsBalance = savingsAsAccount.getBalance();
+    double initialCheckingBalance = checkingAsAccount.getBalance();
+    
+    savingsAsAccount.deposit(100.0);
+    checkingAsAccount.deposit(200.0);
+    
+    assertThat(savingsAsAccount.getBalance()).isEqualTo(initialSavingsBalance + 100.0);
+    assertThat(checkingAsAccount.getBalance()).isEqualTo(initialCheckingBalance + 200.0);
+  }
+
+  @Test
+  void testCustomerCanHoldMultipleAccountTypes() {
+    // Verify customer can hold both account types
+    Set<Account> customerAccounts = customer.getAccounts();
+    
+    assertThat(customerAccounts).hasSize(2);
+    
+    boolean hasChecking = customerAccounts.stream()
+        .anyMatch(acc -> acc instanceof CheckingAccount);
+    boolean hasSavings = customerAccounts.stream()
+        .anyMatch(acc -> acc instanceof SavingsAccount);
+        
+    assertThat(hasChecking).isTrue();
+    assertThat(hasSavings).isTrue();
+  }
+}