diff --git a/lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/Check.java b/lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/Check.java index 061fa4a5c..4b0abd15a 100644 --- a/lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/Check.java +++ b/lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/Check.java @@ -54,6 +54,18 @@ public void depositFunds(CheckingAccount toAccount) { voidCheck(); } + public String getCheckNumber() { + return checkNumber; + } + + public double getAmount() { + return amount; + } + + public CheckingAccount getAccount() { + return account; + } + @Override public int hashCode() { return checkNumber.hashCode(); diff --git a/lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/CheckingAccount.java b/lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/CheckingAccount.java index 5d8aeb74d..6f4542dab 100644 --- a/lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/CheckingAccount.java +++ b/lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/CheckingAccount.java @@ -103,6 +103,10 @@ public boolean isClosed() { return !isActive; } + public boolean getIsActive() { + return isActive; + } + @Override public int hashCode() { return accountNumber.hashCode(); diff --git a/lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/MoneyOrder.java b/lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/MoneyOrder.java new file mode 100644 index 000000000..e6a415036 --- /dev/null +++ b/lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/MoneyOrder.java @@ -0,0 +1,42 @@ +package com.codedifferently.lesson17.bank; + +import com.codedifferently.lesson17.bank.exceptions.CheckVoidedException; + +public class MoneyOrder extends Check { + + public MoneyOrder(String checkNumber, double amount, CheckingAccount account) { + super(checkNumber, amount, account); + if (amount < 0) { + throw new IllegalArgumentException("MoneyOrder amount must be positive"); + } + account.withdraw(amount); + } + + @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 CheckVoidedException("MoneyOrder is voided"); + } + // getAccount().withdraw(getAmount()); + toAccount.deposit(getAmount()); + voidCheck(); + } + + @Override + public String toString() { + return "MoneyOrder{" + + "checkNumber='" + + getCheckNumber() + + '\'' + + ", amount=" + + getAmount() + + ", account=" + + getAccount().getAccountNumber() + + '}'; + } +} diff --git a/lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/SavingsAccount.java b/lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/SavingsAccount.java new file mode 100644 index 000000000..51b78f9f6 --- /dev/null +++ b/lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/SavingsAccount.java @@ -0,0 +1,23 @@ +package com.codedifferently.lesson17.bank; + +import java.util.Set; + +public class SavingsAccount extends CheckingAccount { + + public SavingsAccount(String accountNumber, Set owners, double initialBalance) { + super(accountNumber, owners, initialBalance); + } + + @Override + public String toString() { + return "SavingsAccount{" + + "accountNumber='" + + getAccountNumber() + + '\'' + + ", balance=" + + getBalance() + + ", isActive=" + + getIsActive() + + '}'; + } +} diff --git a/lesson_17/bank/bank_app/src/test/java/com/codedifferently/lesson17/bank/MoneyOrderTest.java b/lesson_17/bank/bank_app/src/test/java/com/codedifferently/lesson17/bank/MoneyOrderTest.java new file mode 100644 index 000000000..ddd1395ab --- /dev/null +++ b/lesson_17/bank/bank_app/src/test/java/com/codedifferently/lesson17/bank/MoneyOrderTest.java @@ -0,0 +1,70 @@ +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.CheckVoidedException; +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_CheckVoided() { + // Arrange + classUnderTest.voidCheck(); + + // Act & Assert + assertThatExceptionOfType(CheckVoidedException.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 + Check otherCheck = new MoneyOrder("123456789", 25.0, account1); + Check differentCheck = new MoneyOrder("987654321", 25.0, account1); + + // Assert + assertThat(classUnderTest.equals(otherCheck)).isTrue(); + assertThat(classUnderTest.equals(differentCheck)).isFalse(); + } + + @Test + void testToString() { + // Assert + assertThat(classUnderTest.toString()) + .isEqualTo("MoneyOrder{checkNumber='123456789', amount=50.0, account=123456789}"); + } +} diff --git a/lesson_17/bank/bank_app/src/test/java/com/codedifferently/lesson17/bank/SavingsAccountTest.java b/lesson_17/bank/bank_app/src/test/java/com/codedifferently/lesson17/bank/SavingsAccountTest.java new file mode 100644 index 000000000..934ea6b70 --- /dev/null +++ b/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; + +class SavingsAccountTest { + + private SavingsAccount classUnderTest; + private Set 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()); + } +}