chore: adds more git comments

Author: txjackson252

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

@@ -3,12 +3,20 @@
 import com.codedifferently.lesson17.bank.exceptions.InsufficientFundsException;
 import java.util.Set;
 
+/** Abstract base class for all types of accounts (Checking, Savings, etc.). */
 public abstract class Account {
   private final String accountNumber;
   private final Set<Customer> owners;
   private double balance;
   private boolean isActive;
 
+  /**
+   * Creates a new account with initial balance and owners.
+   *
+   * @param accountNumber unique account identifier
+   * @param owners set of customers owning this account
+   * @param initialBalance starting balance
+   */
   public Account(String accountNumber, Set<Customer> owners, double initialBalance) {
     this.accountNumber = accountNumber;
     this.owners = owners;
@@ -32,23 +40,39 @@ public boolean isClosed() {
     return !isActive;
   }
 
+  /**
+   * Deposits a positive amount into the account.
+   *
+   * @param amount amount to deposit
+   */
   public void deposit(double amount) {
     if (amount < 0) throw new IllegalArgumentException("Deposit must be positive");
     balance += amount;
   }
 
+  /**
+   * Withdraws a positive amount from the account, ensuring sufficient funds.
+   *
+   * @param amount amount to withdraw
+   */
   public void withdraw(double amount) {
     if (amount < 0) throw new IllegalStateException("Withdrawal amount must be positive");
     if (amount > balance)
       throw new InsufficientFundsException("Account does not have enough funds for withdrawal");
     balance -= amount;
   }
 
+  /** Closes the account if the balance is zero. */
   public void closeAccount() {
     if (balance != 0) throw new IllegalStateException("Cannot close account with non-zero balance");
     isActive = false;
   }
 
+  /**
+   * Determines if this account can write checks.
+   *
+   * @return true for CheckingAccount, false for SavingsAccount
+   */
   public abstract boolean canWriteChecks();
 
   @Override

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

@@ -48,6 +48,7 @@ public Set<Account> findAccountsByCustomerId(UUID customerId) {
   public void depositFunds(String accountNumber, double amount) {
     Account account = getAccountOrThrow(accountNumber);
     account.deposit(amount);
+    // Log deposit transaction
     auditLog.logTransaction(
         account.getOwners().iterator().next().getId(),
         "Deposited $" + amount + " to " + accountNumber);
@@ -61,12 +62,16 @@ public void depositFunds(String accountNumber, double amount) {
    */
   public void depositFunds(String accountNumber, Check check) {
     Account account = getAccountOrThrow(accountNumber);
+    // Ensure only CheckingAccounts can accept checks
+
     if (!(account instanceof CheckingAccount)) {
       throw new IllegalArgumentException("Can only deposit checks into checking accounts");
     }
 
     check.depositFunds((CheckingAccount) account);
 
+    // Log check deposit transaction
+
     auditLog.logTransaction(
         account.getOwners().iterator().next().getId(),
         "Deposited check of " + check + " to account " + accountNumber);
@@ -81,6 +86,8 @@ public void depositFunds(String accountNumber, Check check) {
   public void withdrawFunds(String accountNumber, double amount) {
     Account account = getAccountOrThrow(accountNumber);
     account.withdraw(amount);
+    // Log withdrawal transaction
+
     auditLog.logTransaction(
         account.getOwners().iterator().next().getId(),
         "Withdrew $" + amount + " from " + accountNumber);
@@ -95,12 +102,16 @@ public void withdrawFunds(String accountNumber, double amount) {
   private Account getAccountOrThrow(String accountNumber) {
     Account account = accountByNumber.get(accountNumber);
     if (account == null || account.isClosed()) {
+      // Throw exception if account not found or closed
+
       throw new AccountNotFoundException("Account not found");
     }
     return account;
   }
 
   public AuditLog getAuditLog() {
+    // Getter for audit log, used in tests or external monitoring
+
     return auditLog;
   }
 }

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

@@ -2,12 +2,29 @@
 
 import java.util.Set;
 
+/**
+ * Represents a checking account, which is a type of Account. Unlike SavingsAccount, CheckingAccount
+ * allows writing checks.
+ */
 public class CheckingAccount extends Account {
 
+  /**
+   * Creates a new checking account with given account number, owners, and initial balance.
+   *
+   * @param accountNumber the unique account number
+   * @param owners set of Customer objects who own the account
+   * @param initialBalance starting balance
+   */
   public CheckingAccount(String accountNumber, Set<Customer> owners, double initialBalance) {
     super(accountNumber, owners, initialBalance);
   }
 
+  /**
+   * Indicates whether this account can write checks. For checking accounts, this always returns
+   * true.
+   *
+   * @return true because checks are allowed
+   */
   @Override
   public boolean canWriteChecks() {
     return true;

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

@@ -4,10 +4,15 @@
 
 public class SavingsAccount extends Account {
 
+  /**
+   * Represents a savings account that doesn't allow writing checks. Works like a CheckingAccount
+   * otherwise.
+   */
   public SavingsAccount(String accountNumber, Set<Customer> owners, double initialBalance) {
     super(accountNumber, owners, initialBalance);
   }
 
+  /** Savings accounts cannot write checks, so always return false. */
   @Override
   public boolean canWriteChecks() {
     return false;

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

@@ -37,31 +37,38 @@ void getOwners() {
 
   @Test
   void deposit() {
+    // Act
     classUnderTest.deposit(50.0);
+    // Assert
     assertEquals(150.0, classUnderTest.getBalance());
   }
 
   @Test
   void deposit_withNegativeAmount() {
+    // Act & Assert
     assertThatExceptionOfType(IllegalArgumentException.class)
         .isThrownBy(() -> classUnderTest.deposit(-50.0));
   }
 
   @Test
   void withdraw() {
+    // Act
     classUnderTest.withdraw(50.0);
+    // Assert
     assertEquals(50.0, classUnderTest.getBalance());
   }
 
   @Test
   void withdraw_withNegativeAmount() {
+    // Act & Assert
     assertThatExceptionOfType(IllegalStateException.class)
         .isThrownBy(() -> classUnderTest.withdraw(-50.0))
         .withMessage("Withdrawal amount must be positive");
   }
 
   @Test
   void withdraw_withInsufficientBalance() {
+    // Act & Assert
     assertThatExceptionOfType(InsufficientFundsException.class)
         .isThrownBy(() -> classUnderTest.withdraw(150.0))
         .withMessage("Account does not have enough funds for withdrawal");
@@ -74,33 +81,43 @@ void getBalance() {
 
   @Test
   void closeAccount_withPositiveBalance() {
+    // Act & Assert
     assertThatExceptionOfType(IllegalStateException.class)
         .isThrownBy(() -> classUnderTest.closeAccount());
   }
 
   @Test
   void isClosed() {
+    // Arrange
     assertFalse(classUnderTest.isClosed());
     classUnderTest.withdraw(100);
+    // Act
     classUnderTest.closeAccount();
+    // Assert
     assertTrue(classUnderTest.isClosed());
   }
 
   @Test
   void equals() {
+    // Arrange
     CheckingAccount otherAccount = new CheckingAccount("123456789", owners, 200.0);
+    // Act & Assert
     assertEquals(classUnderTest, otherAccount);
   }
 
   @Test
   void hashCodeTest() {
+    // Arrange
     CheckingAccount otherAccount = new CheckingAccount("123456789", owners, 200.0);
+    // Act & Assert
     assertEquals(classUnderTest.hashCode(), otherAccount.hashCode());
   }
 
   @Test
   void toStringTest() {
+    // Arrange
     String expected = "CheckingAccount{accountNumber='123456789', balance=100.0, isActive=true}";
+    // Act & Assert
     assertEquals(expected, classUnderTest.toString());
   }
 }

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

@@ -30,13 +30,17 @@ void testGetIdAndName() {
 
   @Test
   void testGetAccounts() {
+    // Act
     Set<Account> accounts = customer.getAccounts();
+    // Assert
     assertThat(accounts).containsExactlyInAnyOrder(account1, account2);
   }
 
   @Test
   void testEqualsAndHashCode() {
+    // Arrange
     Customer sameCustomer = new Customer(customer.getId(), "Jane Doe");
+    // Act & Assert
     assertThat(customer).isEqualTo(sameCustomer);
     assertThat(customer.hashCode()).isEqualTo(sameCustomer.hashCode());
   }

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

@@ -35,24 +35,30 @@ void getOwners() {
 
   @Test
   void depositFundsIncreasesBalance() {
+    // Act
     classUnderTest.deposit(50.0);
+    // Assert
     assertThat(classUnderTest.getBalance()).isEqualTo(150.0);
   }
 
   @Test
   void depositNegativeAmountThrowsException() {
+    // Act & Assert
     assertThatExceptionOfType(IllegalArgumentException.class)
         .isThrownBy(() -> classUnderTest.deposit(-50.0));
   }
 
   @Test
   void withdrawFundsDecreasesBalance() {
+    // Act
     classUnderTest.withdraw(50.0);
+    // Assert
     assertThat(classUnderTest.getBalance()).isEqualTo(50.0);
   }
 
   @Test
   void withdrawTooMuchThrowsException() {
+    // Act & Assert
     assertThatExceptionOfType(InsufficientFundsException.class)
         .isThrownBy(() -> classUnderTest.withdraw(150.0));
   }
@@ -69,13 +75,16 @@ void isClosedInitiallyFalse() {
 
   @Test
   void closeAccountWithZeroBalanceWorks() {
+    // Act
     classUnderTest.withdraw(100.0);
     classUnderTest.closeAccount();
+    // Assert
     assertThat(classUnderTest.isClosed()).isTrue();
   }
 
   @Test
   void closingAccountWithPositiveBalanceThrowsException() {
+    // Act & Assert
     assertThatExceptionOfType(IllegalStateException.class)
         .isThrownBy(() -> classUnderTest.closeAccount());
   }