feat: files changes/ Savings account & MoneyOrder/ Angielesson17

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

@@ -67,6 +67,18 @@ public boolean equals(Object obj) {
     return false;
   }
 
+  public String getCheckNumber() {
+    return checkNumber;
+  }
+
+  public double getAmount() {
+    return amount;
+  }
+
+  public CheckingAccount newAccount() {
+    return account;
+  }
+
   @Override
   public String toString() {
     return "Check{"

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

@@ -25,6 +25,10 @@ public CheckingAccount(String accountNumber, Set<Customer> owners, double initia
     isActive = true;
   }
 
+  public boolean getIsActive() {
+    return isActive;
+  }
+
   /**
    * Gets the account number.
    *

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

@@ -0,0 +1,24 @@
+package com.codedifferently.lesson17.bank;
+
+import java.util.Set;
+
+public class SavingsAccount extends CheckingAccount {
+
+  public SavingsAccount(String accountNumber, Set<Customer> owners, double initialBalance) {
+    super(accountNumber, owners, initialBalance);
+  }
+
+  @Override
+  public String toString() {
+
+    return "SavingsAccount{"
+        + "accountNumber='"
+        + getAccountNumber()
+        + '\''
+        + ", balance="
+        + getBalance()
+        + ", isActive="
+        + getIsActive()
+        + '}';
+  }
+}

lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/exceptions/moneyOrderVoidedException.java

@@ -0,0 +1,10 @@
+package com.codedifferently.lesson17.bank.exceptions;
+
+public class moneyOrderVoidedException extends RuntimeException {
+
+  public moneyOrderVoidedException() {}
+
+  public moneyOrderVoidedException(String message) {
+    super(message);
+  }
+}

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

@@ -0,0 +1,49 @@
+package com.codedifferently.lesson17.bank;
+
+import com.codedifferently.lesson17.bank.exceptions.moneyOrderVoidedException;
+
+public class moneyOrder extends Check {
+
+  public moneyOrder(String checkNumber, double amount, CheckingAccount account) {
+    super(checkNumber, amount, account);
+    if (amount < 0) {
+      throw new IllegalArgumentException("moneyOrder is positive");
+    }
+    account.withdraw(amount);
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (obj instanceof moneyOrder other) {
+      return getCheckNumber().equals(other.getCheckNumber());
+    }
+    return false;
+  }
+
+  @Override
+  /**
+   * Deposits the check into an account.
+   *
+   * @param toAccount The account to deposit the check into.
+   */
+  public void depositFunds(CheckingAccount toAccount) {
+    if (getIsVoided()) {
+      throw new moneyOrderVoidedException("moneyOrder is voided");
+    }
+    toAccount.deposit(getAmount());
+    voidCheck();
+  }
+
+  @Override
+  public String toString() {
+    return "moneyOrder{"
+        + "moneyOrderNumber='"
+        + getCheckNumber()
+        + '\''
+        + ", amount="
+        + getAmount()
+        + ", account="
+        + newAccount().getAccountNumber()
+        + '}';
+  }
+}

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

@@ -0,0 +1,106 @@
+package com.codedifferently.lesson17.bank;
+
+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 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;
+
+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 = "SavingsAccount{accountNumber='123456789', balance=100.0, isActive=true}";
+    assertEquals(expected, classUnderTest.toString());
+  }
+}

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

@@ -0,0 +1,69 @@
+package com.codedifferently.lesson17.bank;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+
+import com.codedifferently.lesson17.bank.exceptions.moneyOrderVoidedException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class moneyOrderTest {
+
+  private CheckingAccount account1;
+  private CheckingAccount account2;
+  private moneyOrder classUnderTest;
+
+  @BeforeEach
+  void setUp() {
+    account1 = new CheckingAccount("123456789", null, 100.0);
+    account2 = new CheckingAccount("987654321", null, 200.0);
+    classUnderTest = new moneyOrder("123456789", 50.0, account1);
+  }
+
+  @Test
+  void testDepositFunds() {
+    // Act
+    classUnderTest.depositFunds(account2);
+    // Assert
+    assertThat(account1.getBalance()).isEqualTo(50.0);
+    assertThat(account2.getBalance()).isEqualTo(250.0);
+  }
+
+  @Test
+  void testDepositFunds_moneyOrderVoided() {
+    // Arrange
+    classUnderTest.voidCheck();
+
+    // Act & Assert
+    assertThatExceptionOfType(moneyOrderVoidedException.class)
+        .isThrownBy(() -> classUnderTest.depositFunds(account2))
+        .withMessage("moneyOrder is voided");
+  }
+
+  @Test
+  void testHashCode() {
+    // Arrange
+    moneyOrder otherCheck = new moneyOrder("123456789", 50.0, account1);
+
+    // Assert
+    assertThat(classUnderTest.hashCode()).isEqualTo(otherCheck.hashCode());
+  }
+
+  @Test
+  void testEquals() {
+    // Arrange
+    moneyOrder newPaymentOrder = new moneyOrder("123456789", 25.0, account1);
+    moneyOrder differentCheck = new moneyOrder("987654321", 25.0, account1);
+
+    // Assert
+    assertThat(classUnderTest.equals(newPaymentOrder)).isTrue();
+    assertThat(classUnderTest.equals(differentCheck)).isFalse();
+  }
+
+  @Test
+  void testToString() {
+    // Assert
+    assertThat(classUnderTest.toString())
+        .isEqualTo("moneyOrder{moneyOrderNumber='123456789', amount=50.0, account=123456789}");
+  }
+}