diff --git a/.github/workflows/DiffblueCover.yml b/.github/workflows/DiffblueCover.yml new file mode 100644 index 0000000..35a631e --- /dev/null +++ b/.github/workflows/DiffblueCover.yml @@ -0,0 +1,39 @@ +name: Diffblue Cover + +on: + pull_request: + +jobs: + Diffblue: + runs-on: ubuntu-latest + steps: + + - name: Checkout + uses: actions/checkout@v3 + with: + # The default GITHUB_TOKEN doesn't have the necessary permissions + # so a custom token should be used here with sufficient access. + token: ${{ secrets.DIFFBLUE_TOKEN }} + + - name: Setup Java + uses: actions/setup-java@v3 + with: + java-version: '8' + distribution: 'zulu' + + - name: Maven Install + run: mvn --batch-mode install + + - name: Diffblue Cover + uses: diffblue/cover-github-action@main + env: + GITHUB_TOKEN: ${{ secrets.DIFFBLUE_TOKEN }} + JVM_ARGS: -Xmx4096m + with: + # License key used to activate the installation + license-key: ${{ secrets.DIFFBLUE_LICENSE_KEY }} + # User name and email used to author commits + user-name: Diffblue CI + user-email: db-ci-platform@diffblue.com + # Add a differentiator based on the matrix + topic-id-differentiator: ${{ matrix.os }} diff --git a/src/test/java/io/diffblue/corebanking/CoreBankingDiffblueTest.java b/src/test/java/io/diffblue/corebanking/CoreBankingDiffblueTest.java new file mode 100644 index 0000000..886f03d --- /dev/null +++ b/src/test/java/io/diffblue/corebanking/CoreBankingDiffblueTest.java @@ -0,0 +1,88 @@ +package io.diffblue.corebanking; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; +import io.diffblue.corebanking.account.Account; +import io.diffblue.corebanking.client.Client; +import io.diffblue.corebanking.datamanagement.ReadFromDB; +import io.diffblue.corebanking.transaction.TransactionException; +import java.util.List; +import org.junit.jupiter.api.Test; + +class CoreBankingDiffblueTest { + /** + * Methods under test: + * + * + */ + @Test + void testConstructor() { + // Arrange and Act + CoreBanking actualCoreBanking = new CoreBanking(); + List actualAccounts = actualCoreBanking.getAccounts(); + List actualClients = actualCoreBanking.getClients(); + + // Assert + assertTrue(actualAccounts.isEmpty()); + assertTrue(actualClients.isEmpty()); + } + + /** + * Method under test: {@link CoreBanking#purgeCoreBanking()} + */ + @Test + void testPurgeCoreBanking() throws TransactionException { + // Arrange + CoreBanking readFromDBResult = ReadFromDB.readFromDB(); + + // Act + readFromDBResult.purgeCoreBanking(); + + // Assert + assertTrue(readFromDBResult.getAccounts().isEmpty()); + assertTrue(readFromDBResult.getClients().isEmpty()); + } + + /** + * Method under test: {@link CoreBanking#openNewAccount(Client, long)} + */ + @Test + void testOpenNewAccount() throws TransactionException { + // Arrange + CoreBanking readFromDBResult = ReadFromDB.readFromDB(); + Client client = new Client("Dr Jane Doe"); + + // Act + Account actualOpenNewAccountResult = readFromDBResult.openNewAccount(client, 10L); + + // Assert + assertEquals("Current", actualOpenNewAccountResult.getAccountName()); + assertEquals(10L, actualOpenNewAccountResult.getCurrentBalance()); + Client client2 = actualOpenNewAccountResult.getClient(); + assertSame(client, client2); + assertEquals(Account.AccountState.OPEN, actualOpenNewAccountResult.getAccountState()); + assertEquals(1, client2.getAccounts().size()); + assertTrue(actualOpenNewAccountResult.getAccountStatement().getTransactions().isEmpty()); + assertEquals(7, readFromDBResult.getAccounts().size()); + } + + /** + * Method under test: {@link CoreBanking#registerNewClient(Client)} + */ + @Test + void testRegisterNewClient() throws TransactionException { + // Arrange + CoreBanking readFromDBResult = ReadFromDB.readFromDB(); + Client client = new Client("Dr Jane Doe"); + + // Act and Assert + assertSame(client, readFromDBResult.registerNewClient(client)); + assertEquals(4, readFromDBResult.getClients().size()); + } +} + diff --git a/src/test/java/io/diffblue/corebanking/CoreBankingExceptionDiffblueTest.java b/src/test/java/io/diffblue/corebanking/CoreBankingExceptionDiffblueTest.java new file mode 100644 index 0000000..31d916b --- /dev/null +++ b/src/test/java/io/diffblue/corebanking/CoreBankingExceptionDiffblueTest.java @@ -0,0 +1,23 @@ +package io.diffblue.corebanking; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import org.junit.jupiter.api.Test; + +class CoreBankingExceptionDiffblueTest { + /** + * Method under test: {@link CoreBankingException#CoreBankingException(String)} + */ + @Test + void testConstructor() { + // Arrange and Act + CoreBankingException actualCoreBankingException = new CoreBankingException("An error occurred"); + + // Assert + assertNull(actualCoreBankingException.getCause()); + assertEquals(0, actualCoreBankingException.getSuppressed().length); + assertEquals("An error occurred", actualCoreBankingException.getMessage()); + assertEquals("An error occurred", actualCoreBankingException.getLocalizedMessage()); + } +} + diff --git a/src/test/java/io/diffblue/corebanking/account/AccountDiffblueTest.java b/src/test/java/io/diffblue/corebanking/account/AccountDiffblueTest.java new file mode 100644 index 0000000..318d5b7 --- /dev/null +++ b/src/test/java/io/diffblue/corebanking/account/AccountDiffblueTest.java @@ -0,0 +1,270 @@ +package io.diffblue.corebanking.account; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.mock; +import io.diffblue.corebanking.client.Client; +import io.diffblue.corebanking.transaction.CashTransaction; +import io.diffblue.corebanking.transaction.Transaction; +import java.time.LocalDate; +import java.time.ZoneOffset; +import java.util.Date; +import org.junit.jupiter.api.Test; + +class AccountDiffblueTest { + /** + * Methods under test: + * + * + */ + @Test + void testAccountStatementConstructor() { + // Arrange, Act and Assert + assertTrue(((new Account(1234567890L, new Client("Dr Jane Doe"), 10L)).new AccountStatement()).getTransactions() + .isEmpty()); + } + + /** + * Method under test: {@link Account.AccountStatement#toString()} + */ + @Test + void testAccountStatementToString() { + // Arrange, Act and Assert + assertEquals("Account statement empty.", + ((new Account(1234567890L, new Client("Dr Jane Doe"), 10L)).new AccountStatement()).toString()); + } + + /** + * Method under test: {@link Account#Account(long, Client, long)} + */ + @Test + void testConstructor() { + // Arrange + Client client = new Client("Dr Jane Doe"); + + // Act + Account actualAccount = new Account(1234567890L, client, 10L); + + // Assert + assertEquals("Current", actualAccount.getAccountName()); + assertEquals(10L, actualAccount.getCurrentBalance()); + assertSame(client, actualAccount.getClient()); + assertEquals(1234567890L, actualAccount.getAccountNumber()); + assertEquals(Account.AccountState.OPEN, actualAccount.getAccountState()); + assertTrue(actualAccount.getAccountStatement().getTransactions().isEmpty()); + } + + /** + * Method under test: {@link Account#addToBalance(long)} + */ + @Test + void testAddToBalance() throws AccountException { + // Arrange + Account account = new Account(1234567890L, new Client("Dr Jane Doe"), 10L); + + // Act + account.addToBalance(10L); + + // Assert + assertEquals(20L, account.getCurrentBalance()); + } + + /** + * Method under test: {@link Account#takeFromBalance(long)} + */ + @Test + void testTakeFromBalance() throws AccountException { + // Arrange + Account account = new Account(1234567890L, new Client("Dr Jane Doe"), 10L); + + // Act + account.takeFromBalance(10L); + + // Assert + assertEquals(0L, account.getCurrentBalance()); + } + + /** + * Method under test: {@link Account#takeFromBalance(long)} + */ + @Test + void testTakeFromBalance2() throws AccountException { + // Arrange, Act and Assert + assertThrows(AccountException.class, + () -> (new Account(1234567890L, new Client("Dr Jane Doe"), 1L)).takeFromBalance(10L)); + } + + /** + * Method under test: {@link Account#setAccountName(String)} + */ + @Test + void testSetAccountName() throws AccountException { + // Arrange + Account account = new Account(1234567890L, new Client("Dr Jane Doe"), 10L); + + // Act + account.setAccountName("Dr Jane Doe"); + + // Assert + assertEquals("Dr Jane Doe", account.getAccountName()); + } + + /** + * Method under test: {@link Account#closeAccount()} + */ + @Test + void testCloseAccount() throws AccountException { + // Arrange + Account account = new Account(1234567890L, new Client("Dr Jane Doe"), 10L); + + // Act + account.closeAccount(); + + // Assert + assertEquals(Account.AccountState.CLOSED, account.getAccountState()); + } + + /** + * Method under test: {@link Account#addTransaction(Transaction)} + */ + @Test + void testAddTransaction() throws AccountException { + // Arrange + Account account = new Account(1234567890L, new Client("Dr Jane Doe"), 10L); + Date date = Date.from(LocalDate.of(1970, 1, 1).atStartOfDay().atZone(ZoneOffset.UTC).toInstant()); + + // Act + account.addTransaction(new CashTransaction(10L, date, new Account(1234567890L, new Client("Dr Jane Doe"), 10L))); + + // Assert + assertEquals(1, account.getAccountStatement().getTransactions().size()); + } + + /** + * Method under test: {@link Account#addTransaction(Transaction)} + */ + @Test + void testAddTransaction2() throws AccountException { + // Arrange + Account account = new Account(1234567890L, new Client("Dr Jane Doe"), 10L); + java.sql.Date date = mock(java.sql.Date.class); + + // Act + account.addTransaction(new CashTransaction(10L, date, new Account(1234567890L, new Client("Dr Jane Doe"), 10L))); + + // Assert + assertEquals(1, account.getAccountStatement().getTransactions().size()); + } + + /** + * Method under test: {@link Account#equals(Object)} + */ + @Test + void testEquals() { + // Arrange, Act and Assert + assertNotEquals(new Account(1234567890L, new Client("Dr Jane Doe"), 10L), null); + assertNotEquals(new Account(1234567890L, new Client("Dr Jane Doe"), 10L), "Different type to Account"); + } + + /** + * Method under test: {@link Account#equals(Object)} + */ + @Test + void testEquals2() { + // Arrange + Account account = new Account(1234567890L, new Client("Dr Jane Doe"), 10L); + + // Act and Assert + assertEquals(account, account); + int expectedHashCodeResult = account.hashCode(); + assertEquals(expectedHashCodeResult, account.hashCode()); + } + + /** + * Method under test: {@link Account#equals(Object)} + */ + @Test + void testEquals3() { + // Arrange + Account account = new Account(1234567890L, new Client("Dr Jane Doe"), 10L); + Account account2 = new Account(1234567890L, new Client("Dr Jane Doe"), 10L); + + // Act and Assert + assertEquals(account, account2); + int notExpectedHashCodeResult = account.hashCode(); + assertNotEquals(notExpectedHashCodeResult, account2.hashCode()); + } + + /** + * Method under test: {@link Account#equals(Object)} + */ + @Test + void testEquals4() { + // Arrange + Account account = new Account(3L, new Client("Dr Jane Doe"), 10L); + + // Act and Assert + assertNotEquals(account, new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + } + + /** + * Method under test: {@link Account#equals(Object)} + */ + @Test + void testEquals5() { + // Arrange + Account account = new Account(1234567890L, mock(Client.class), 10L); + Account account2 = new Account(1234567890L, new Client("Dr Jane Doe"), 10L); + + // Act and Assert + assertEquals(account, account2); + int notExpectedHashCodeResult = account.hashCode(); + assertNotEquals(notExpectedHashCodeResult, account2.hashCode()); + } + + /** + * Methods under test: + * + * + */ + @Test + void testToString() { + // Arrange + Client client = new Client("Dr Jane Doe"); + Account account = new Account(1234567890L, client, 10L); + + // Act + String actualToStringResult = account.toString(); + String actualAccountName = account.getAccountName(); + long actualAccountNumber = account.getAccountNumber(); + Account.AccountState actualAccountState = account.getAccountState(); + account.getAccountStatement(); + Client actualClient = account.getClient(); + + // Assert + assertEquals("Current", actualAccountName); + assertEquals(1234567890L, actualAccountNumber); + assertEquals(Account.AccountState.OPEN, actualAccountState); + assertSame(client, actualClient); + assertEquals(10L, account.getCurrentBalance()); + assertEquals( + "Account: | Acc #: 1234567890\t | Acc name: Current\t | Acc holder: Dr Jane Doe\t | Acc balance: 10\t | Acc" + + " state: OPEN\t |\n" + "Account statement empty.", + actualToStringResult); + } +} + diff --git a/src/test/java/io/diffblue/corebanking/account/AccountExceptionDiffblueTest.java b/src/test/java/io/diffblue/corebanking/account/AccountExceptionDiffblueTest.java new file mode 100644 index 0000000..d12032e --- /dev/null +++ b/src/test/java/io/diffblue/corebanking/account/AccountExceptionDiffblueTest.java @@ -0,0 +1,23 @@ +package io.diffblue.corebanking.account; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import org.junit.jupiter.api.Test; + +class AccountExceptionDiffblueTest { + /** + * Method under test: {@link AccountException#AccountException(String)} + */ + @Test + void testConstructor() { + // Arrange and Act + AccountException actualAccountException = new AccountException("An error occurred"); + + // Assert + assertNull(actualAccountException.getCause()); + assertEquals(0, actualAccountException.getSuppressed().length); + assertEquals("An error occurred", actualAccountException.getMessage()); + assertEquals("An error occurred", actualAccountException.getLocalizedMessage()); + } +} + diff --git a/src/test/java/io/diffblue/corebanking/client/ClientDiffblueTest.java b/src/test/java/io/diffblue/corebanking/client/ClientDiffblueTest.java new file mode 100644 index 0000000..f232c14 --- /dev/null +++ b/src/test/java/io/diffblue/corebanking/client/ClientDiffblueTest.java @@ -0,0 +1,85 @@ +package io.diffblue.corebanking.client; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import io.diffblue.corebanking.account.Account; +import io.diffblue.corebanking.account.AccountException; +import org.junit.jupiter.api.Test; + +class ClientDiffblueTest { + /** + * Methods under test: + * + * + */ + @Test + void testConstructor() { + // Arrange and Act + Client actualClient = new Client("Dr Jane Doe"); + actualClient.getAccounts(); + + // Assert + assertEquals("Dr Jane Doe", actualClient.getClientName()); + } + + /** + * Method under test: {@link Client#addAccount(Account)} + */ + @Test + void testAddAccount() { + // Arrange + Client client = new Client("Dr Jane Doe"); + + // Act + client.addAccount(new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Assert + assertEquals(1, client.getAccounts().size()); + } + + /** + * Method under test: {@link Client#toString()} + */ + @Test + void testToString() { + // Arrange, Act and Assert + assertEquals("Client name: Dr Jane Doe\n", (new Client("Dr Jane Doe")).toString()); + } + + /** + * Method under test: {@link Client#toString()} + */ + @Test + void testToString2() { + // Arrange + Client client = new Client("Dr Jane Doe"); + client.addAccount(new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Act and Assert + assertEquals("Client name: Dr Jane Doe\n" + + "Account: | Acc #: 1234567890\t | Acc name: Current\t | Acc holder: Dr Jane Doe\t | Acc balance: 10\t | Acc" + + " state: OPEN\t |\n" + "Account statement empty.\n", client.toString()); + } + + /** + * Method under test: {@link Client#toString()} + */ + @Test + void testToString3() throws AccountException { + // Arrange + Account account = new Account(1234567890L, new Client("Dr Jane Doe"), 10L); + account.addTransaction(null); + + Client client = new Client("Dr Jane Doe"); + client.addAccount(account); + + // Act and Assert + assertEquals("Client name: Dr Jane Doe\n" + + "Account: | Acc #: 1234567890\t | Acc name: Current\t | Acc holder: Dr Jane Doe\t | Acc balance: 10\t | Acc" + + " state: OPEN\t |\n" + "null\n" + "\n", client.toString()); + } +} + diff --git a/src/test/java/io/diffblue/corebanking/compliance/rules/ComplianceRuleBalanceAboveOrEqualToZeroDiffblueTest.java b/src/test/java/io/diffblue/corebanking/compliance/rules/ComplianceRuleBalanceAboveOrEqualToZeroDiffblueTest.java new file mode 100644 index 0000000..91003e7 --- /dev/null +++ b/src/test/java/io/diffblue/corebanking/compliance/rules/ComplianceRuleBalanceAboveOrEqualToZeroDiffblueTest.java @@ -0,0 +1,57 @@ +package io.diffblue.corebanking.compliance.rules; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; +import io.diffblue.corebanking.account.Account; +import io.diffblue.corebanking.client.Client; +import org.junit.jupiter.api.Test; + +class ComplianceRuleBalanceAboveOrEqualToZeroDiffblueTest { + /** + * Method under test: {@link ComplianceRuleBalanceAboveOrEqualToZero#validateAccountCompliance(Account)} + */ + @Test + void testValidateAccountCompliance() { + // Arrange + ComplianceRuleBalanceAboveOrEqualToZero complianceRuleBalanceAboveOrEqualToZero = new ComplianceRuleBalanceAboveOrEqualToZero(); + + // Act + complianceRuleBalanceAboveOrEqualToZero + .validateAccountCompliance(new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Assert + assertEquals(1, complianceRuleBalanceAboveOrEqualToZero.getCompliantAccounts().size()); + assertTrue(complianceRuleBalanceAboveOrEqualToZero.getNonCompliantAccounts().isEmpty()); + } + + /** + * Method under test: {@link ComplianceRuleBalanceAboveOrEqualToZero#validateAccountCompliance(Account)} + */ + @Test + void testValidateAccountCompliance2() { + // Arrange + ComplianceRuleBalanceAboveOrEqualToZero complianceRuleBalanceAboveOrEqualToZero = new ComplianceRuleBalanceAboveOrEqualToZero(); + + // Act + complianceRuleBalanceAboveOrEqualToZero + .validateAccountCompliance(new Account(1234567890L, new Client("Dr Jane Doe"), -1L)); + + // Assert + assertTrue(complianceRuleBalanceAboveOrEqualToZero.getCompliantAccounts().isEmpty()); + assertEquals(1, complianceRuleBalanceAboveOrEqualToZero.getNonCompliantAccounts().size()); + } + + /** + * Method under test: default or parameterless constructor of {@link ComplianceRuleBalanceAboveOrEqualToZero} + */ + @Test + void testConstructor() { + // Arrange and Act + ComplianceRuleBalanceAboveOrEqualToZero actualComplianceRuleBalanceAboveOrEqualToZero = new ComplianceRuleBalanceAboveOrEqualToZero(); + + // Assert + assertTrue(actualComplianceRuleBalanceAboveOrEqualToZero.getCompliantAccounts().isEmpty()); + assertTrue(actualComplianceRuleBalanceAboveOrEqualToZero.getNonCompliantAccounts().isEmpty()); + } +} + diff --git a/src/test/java/io/diffblue/corebanking/compliance/rules/ComplianceRuleDiffblueTest.java b/src/test/java/io/diffblue/corebanking/compliance/rules/ComplianceRuleDiffblueTest.java new file mode 100644 index 0000000..c58e19b --- /dev/null +++ b/src/test/java/io/diffblue/corebanking/compliance/rules/ComplianceRuleDiffblueTest.java @@ -0,0 +1,124 @@ +package io.diffblue.corebanking.compliance.rules; + +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 io.diffblue.corebanking.account.Account; +import io.diffblue.corebanking.client.Client; +import org.junit.jupiter.api.Test; + +class ComplianceRuleDiffblueTest { + /** + * Method under test: {@link ComplianceRule#addToNonCompliantAccounts(Account)} + */ + @Test + void testAddToNonCompliantAccounts() { + // Arrange + ComplianceRuleBalanceAboveOrEqualToZero complianceRuleBalanceAboveOrEqualToZero = new ComplianceRuleBalanceAboveOrEqualToZero(); + + // Act + complianceRuleBalanceAboveOrEqualToZero + .addToNonCompliantAccounts(new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Assert + assertEquals(1, complianceRuleBalanceAboveOrEqualToZero.getNonCompliantAccounts().size()); + } + + /** + * Method under test: {@link ComplianceRule#addToNonCompliantAccounts(Account)} + */ + @Test + void testAddToNonCompliantAccounts2() { + // Arrange + ComplianceRuleBalanceAboveOrEqualToZero complianceRuleBalanceAboveOrEqualToZero = new ComplianceRuleBalanceAboveOrEqualToZero(); + complianceRuleBalanceAboveOrEqualToZero + .addToNonCompliantAccounts(new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Act and Assert + assertThrows(IllegalStateException.class, () -> complianceRuleBalanceAboveOrEqualToZero + .addToNonCompliantAccounts(new Account(1234567890L, new Client("Dr Jane Doe"), 10L))); + } + + /** + * Method under test: {@link ComplianceRule#addToCompliantAccounts(Account)} + */ + @Test + void testAddToCompliantAccounts() { + // Arrange + ComplianceRuleBalanceAboveOrEqualToZero complianceRuleBalanceAboveOrEqualToZero = new ComplianceRuleBalanceAboveOrEqualToZero(); + + // Act + complianceRuleBalanceAboveOrEqualToZero + .addToCompliantAccounts(new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Assert + assertEquals(1, complianceRuleBalanceAboveOrEqualToZero.getCompliantAccounts().size()); + } + + /** + * Method under test: {@link ComplianceRule#addToCompliantAccounts(Account)} + */ + @Test + void testAddToCompliantAccounts2() { + // Arrange + ComplianceRuleBalanceAboveOrEqualToZero complianceRuleBalanceAboveOrEqualToZero = new ComplianceRuleBalanceAboveOrEqualToZero(); + complianceRuleBalanceAboveOrEqualToZero + .addToCompliantAccounts(new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Act and Assert + assertThrows(IllegalStateException.class, () -> complianceRuleBalanceAboveOrEqualToZero + .addToCompliantAccounts(new Account(1234567890L, new Client("Dr Jane Doe"), 10L))); + } + + /** + * Method under test: {@link ComplianceRule#removeFromComplianceLists(Account)} + */ + @Test + void testRemoveFromComplianceLists() { + // Arrange + ComplianceRuleBalanceAboveOrEqualToZero complianceRuleBalanceAboveOrEqualToZero = new ComplianceRuleBalanceAboveOrEqualToZero(); + + // Act + complianceRuleBalanceAboveOrEqualToZero + .removeFromComplianceLists(new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Assert + assertTrue(complianceRuleBalanceAboveOrEqualToZero.getCompliantAccounts().isEmpty()); + assertTrue(complianceRuleBalanceAboveOrEqualToZero.getNonCompliantAccounts().isEmpty()); + } + + /** + * Method under test: {@link ComplianceRule#getNonCompliantAccounts()} + */ + @Test + void testGetNonCompliantAccounts() { + // Arrange, Act and Assert + assertTrue((new ComplianceRuleBalanceAboveOrEqualToZero()).getNonCompliantAccounts().isEmpty()); + } + + /** + * Method under test: {@link ComplianceRule#getCompliantAccounts()} + */ + @Test + void testGetCompliantAccounts() { + // Arrange, Act and Assert + assertTrue((new ComplianceRuleBalanceAboveOrEqualToZero()).getCompliantAccounts().isEmpty()); + } + + /** + * Method under test: {@link ComplianceRule#purgeAccounts()} + */ + @Test + void testPurgeAccounts() { + // Arrange + ComplianceRuleBalanceAboveOrEqualToZero complianceRuleBalanceAboveOrEqualToZero = new ComplianceRuleBalanceAboveOrEqualToZero(); + + // Act + complianceRuleBalanceAboveOrEqualToZero.purgeAccounts(); + + // Assert + assertTrue(complianceRuleBalanceAboveOrEqualToZero.getCompliantAccounts().isEmpty()); + assertTrue(complianceRuleBalanceAboveOrEqualToZero.getNonCompliantAccounts().isEmpty()); + } +} + diff --git a/src/test/java/io/diffblue/corebanking/datamanagement/ReadFromDBDiffblueTest.java b/src/test/java/io/diffblue/corebanking/datamanagement/ReadFromDBDiffblueTest.java new file mode 100644 index 0000000..84b80b8 --- /dev/null +++ b/src/test/java/io/diffblue/corebanking/datamanagement/ReadFromDBDiffblueTest.java @@ -0,0 +1,60 @@ +package io.diffblue.corebanking.datamanagement; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import io.diffblue.corebanking.CoreBanking; +import io.diffblue.corebanking.client.Client; +import io.diffblue.corebanking.transaction.TransactionException; +import java.util.List; +import org.junit.jupiter.api.Test; + +class ReadFromDBDiffblueTest { + /** + * Method under test: {@link ReadFromDB#readFromDB()} + */ + @Test + void testReadFromDB() throws TransactionException { + // Arrange and Act + CoreBanking actualReadFromDBResult = ReadFromDB.readFromDB(); + + // Assert + assertEquals(6, actualReadFromDBResult.getAccounts().size()); + List clients = actualReadFromDBResult.getClients(); + assertEquals(3, clients.size()); + Client getResult = clients.get(2); + assertEquals("Emily Simmons", getResult.getClientName()); + Client getResult2 = clients.get(1); + assertEquals("Jane Robbins", getResult2.getClientName()); + assertEquals(2, getResult2.getAccounts().size()); + assertEquals(1, getResult.getAccounts().size()); + Client getResult3 = clients.get(0); + assertEquals(3, getResult3.getAccounts().size()); + assertEquals("John Field", getResult3.getClientName()); + } + + /** + * Method under test: {@link ReadFromDB#readFromDB(CoreBanking)} + */ + @Test + void testReadFromDB2() throws TransactionException { + // Arrange + CoreBanking coreBanking = ReadFromDB.readFromDB(); + + // Act + ReadFromDB.readFromDB(coreBanking); + + // Assert + assertEquals(6, coreBanking.getAccounts().size()); + List clients = coreBanking.getClients(); + assertEquals(3, clients.size()); + Client getResult = clients.get(2); + assertEquals("Emily Simmons", getResult.getClientName()); + Client getResult2 = clients.get(1); + assertEquals("Jane Robbins", getResult2.getClientName()); + assertEquals(2, getResult2.getAccounts().size()); + assertEquals(1, getResult.getAccounts().size()); + Client getResult3 = clients.get(0); + assertEquals(3, getResult3.getAccounts().size()); + assertEquals("John Field", getResult3.getClientName()); + } +} + diff --git a/src/test/java/io/diffblue/corebanking/transaction/BankTransactionDiffblueTest.java b/src/test/java/io/diffblue/corebanking/transaction/BankTransactionDiffblueTest.java new file mode 100644 index 0000000..a18f2a0 --- /dev/null +++ b/src/test/java/io/diffblue/corebanking/transaction/BankTransactionDiffblueTest.java @@ -0,0 +1,169 @@ +package io.diffblue.corebanking.transaction; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.Mockito.mock; +import io.diffblue.corebanking.account.Account; +import io.diffblue.corebanking.client.Client; +import java.time.LocalDate; +import java.time.ZoneOffset; +import java.util.Date; +import org.junit.jupiter.api.Test; + +class BankTransactionDiffblueTest { + /** + * Method under test: {@link BankTransaction#BankTransaction(long, Date, Account, Account)} + */ + @Test + void testConstructor() { + // Arrange + Date date = Date.from(LocalDate.of(1970, 1, 1).atStartOfDay().atZone(ZoneOffset.UTC).toInstant()); + Account sourceAcc = new Account(1234567890L, new Client("Dr Jane Doe"), 10L); + + // Act + BankTransaction actualBankTransaction = new BankTransaction(10L, date, sourceAcc, + new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Assert + assertEquals("1234567890", actualBankTransaction.getSource()); + assertEquals(Transaction.TransactionState.NOT_EXECUTED_YET, actualBankTransaction.getTransactionState()); + assertSame(date, actualBankTransaction.getTransactionDate()); + assertEquals(10L, actualBankTransaction.getTransactionAmount()); + assertEquals("1234567890", actualBankTransaction.getTarget()); + } + + /** + * Method under test: {@link BankTransaction#BankTransaction(long, java.util.Date, Account, Account)} + */ + @Test + void testConstructor2() { + // Arrange + java.sql.Date date = mock(java.sql.Date.class); + Account sourceAcc = new Account(1234567890L, new Client("Dr Jane Doe"), 10L); + + // Act + BankTransaction actualBankTransaction = new BankTransaction(10L, date, sourceAcc, + new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Assert + assertEquals("1234567890", actualBankTransaction.getSource()); + assertEquals(Transaction.TransactionState.NOT_EXECUTED_YET, actualBankTransaction.getTransactionState()); + assertSame(date, actualBankTransaction.getTransactionDate()); + assertEquals(10L, actualBankTransaction.getTransactionAmount()); + assertEquals("1234567890", actualBankTransaction.getTarget()); + } + + /** + * Method under test: {@link BankTransaction#getSource()} + */ + @Test + void testGetSource() { + // Arrange + Date date = Date.from(LocalDate.of(1970, 1, 1).atStartOfDay().atZone(ZoneOffset.UTC).toInstant()); + Account sourceAcc = new Account(1234567890L, new Client("Dr Jane Doe"), 10L); + + // Act and Assert + assertEquals("1234567890", + (new BankTransaction(10L, date, sourceAcc, new Account(1234567890L, new Client("Dr Jane Doe"), 10L))) + .getSource()); + } + + /** + * Method under test: {@link BankTransaction#getSource()} + */ + @Test + void testGetSource2() { + // Arrange + java.sql.Date date = mock(java.sql.Date.class); + Account sourceAcc = new Account(1234567890L, new Client("Dr Jane Doe"), 10L); + + // Act and Assert + assertEquals("1234567890", + (new BankTransaction(10L, date, sourceAcc, new Account(1234567890L, new Client("Dr Jane Doe"), 10L))) + .getSource()); + } + + /** + * Method under test: {@link BankTransaction#getTarget()} + */ + @Test + void testGetTarget() { + // Arrange + Date date = Date.from(LocalDate.of(1970, 1, 1).atStartOfDay().atZone(ZoneOffset.UTC).toInstant()); + Account sourceAcc = new Account(1234567890L, new Client("Dr Jane Doe"), 10L); + + // Act and Assert + assertEquals("1234567890", + (new BankTransaction(10L, date, sourceAcc, new Account(1234567890L, new Client("Dr Jane Doe"), 10L))) + .getTarget()); + } + + /** + * Method under test: {@link BankTransaction#getTarget()} + */ + @Test + void testGetTarget2() { + // Arrange + java.sql.Date date = mock(java.sql.Date.class); + Account sourceAcc = new Account(1234567890L, new Client("Dr Jane Doe"), 10L); + + // Act and Assert + assertEquals("1234567890", + (new BankTransaction(10L, date, sourceAcc, new Account(1234567890L, new Client("Dr Jane Doe"), 10L))) + .getTarget()); + } + + /** + * Method under test: {@link BankTransaction#executeTransaction()} + */ + @Test + void testExecuteTransaction() throws TransactionException { + // Arrange + Date date = Date.from(LocalDate.of(1970, 1, 1).atStartOfDay().atZone(ZoneOffset.UTC).toInstant()); + Account sourceAcc = new Account(1234567890L, new Client("Dr Jane Doe"), 10L); + + BankTransaction bankTransaction = new BankTransaction(10L, date, sourceAcc, + new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Act + bankTransaction.executeTransaction(); + + // Assert + assertEquals(Transaction.TransactionState.EXECUTED, bankTransaction.getTransactionState()); + } + + /** + * Method under test: {@link BankTransaction#executeTransaction()} + */ + @Test + void testExecuteTransaction2() throws TransactionException { + // Arrange + Date date = Date.from(LocalDate.of(1970, 1, 1).atStartOfDay().atZone(ZoneOffset.UTC).toInstant()); + Account sourceAcc = new Account(1234567890L, new Client("Dr Jane Doe"), 10L); + + // Act and Assert + assertThrows(TransactionException.class, () -> (new BankTransaction(Long.MAX_VALUE, date, sourceAcc, + new Account(1234567890L, new Client("Dr Jane Doe"), 10L))).executeTransaction()); + } + + /** + * Method under test: {@link BankTransaction#executeTransaction()} + */ + @Test + void testExecuteTransaction3() throws TransactionException { + // Arrange + java.sql.Date date = mock(java.sql.Date.class); + Account sourceAcc = new Account(1234567890L, new Client("Dr Jane Doe"), 10L); + + BankTransaction bankTransaction = new BankTransaction(10L, date, sourceAcc, + new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Act + bankTransaction.executeTransaction(); + + // Assert + assertEquals(Transaction.TransactionState.EXECUTED, bankTransaction.getTransactionState()); + } +} + diff --git a/src/test/java/io/diffblue/corebanking/transaction/CashTransactionDiffblueTest.java b/src/test/java/io/diffblue/corebanking/transaction/CashTransactionDiffblueTest.java new file mode 100644 index 0000000..c4688da --- /dev/null +++ b/src/test/java/io/diffblue/corebanking/transaction/CashTransactionDiffblueTest.java @@ -0,0 +1,220 @@ +package io.diffblue.corebanking.transaction; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.mockito.Mockito.mock; +import io.diffblue.corebanking.account.Account; +import io.diffblue.corebanking.client.Client; +import java.time.LocalDate; +import java.time.ZoneOffset; +import java.util.Date; +import org.junit.jupiter.api.Test; + +class CashTransactionDiffblueTest { + /** + * Method under test: {@link CashTransaction#CashTransaction(long, Date, Account)} + */ + @Test + void testConstructor() { + // Arrange + Date date = Date.from(LocalDate.of(1970, 1, 1).atStartOfDay().atZone(ZoneOffset.UTC).toInstant()); + + // Act + CashTransaction actualCashTransaction = new CashTransaction(10L, date, + new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Assert + assertEquals("CASH", actualCashTransaction.getSource()); + assertEquals(Transaction.TransactionState.NOT_EXECUTED_YET, actualCashTransaction.getTransactionState()); + assertSame(date, actualCashTransaction.getTransactionDate()); + assertEquals(10L, actualCashTransaction.getTransactionAmount()); + assertEquals("1234567890", actualCashTransaction.getTarget()); + } + + /** + * Method under test: {@link CashTransaction#CashTransaction(long, Date, Account)} + */ + @Test + void testConstructor2() { + // Arrange + Date date = Date.from(LocalDate.of(1970, 1, 1).atStartOfDay().atZone(ZoneOffset.UTC).toInstant()); + + // Act + CashTransaction actualCashTransaction = new CashTransaction(-1L, date, + new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Assert + assertEquals("1234567890", actualCashTransaction.getSource()); + assertEquals(Transaction.TransactionState.NOT_EXECUTED_YET, actualCashTransaction.getTransactionState()); + assertSame(date, actualCashTransaction.getTransactionDate()); + assertEquals(-1L, actualCashTransaction.getTransactionAmount()); + assertEquals("CASH", actualCashTransaction.getTarget()); + } + + /** + * Method under test: {@link CashTransaction#CashTransaction(long, java.util.Date, Account)} + */ + @Test + void testConstructor3() { + // Arrange + java.sql.Date date = mock(java.sql.Date.class); + + // Act + CashTransaction actualCashTransaction = new CashTransaction(10L, date, + new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Assert + assertEquals("CASH", actualCashTransaction.getSource()); + assertEquals(Transaction.TransactionState.NOT_EXECUTED_YET, actualCashTransaction.getTransactionState()); + assertSame(date, actualCashTransaction.getTransactionDate()); + assertEquals(10L, actualCashTransaction.getTransactionAmount()); + assertEquals("1234567890", actualCashTransaction.getTarget()); + } + + /** + * Method under test: {@link CashTransaction#getSource()} + */ + @Test + void testGetSource() { + // Arrange + Date date = Date.from(LocalDate.of(1970, 1, 1).atStartOfDay().atZone(ZoneOffset.UTC).toInstant()); + + // Act and Assert + assertEquals("CASH", + (new CashTransaction(10L, date, new Account(1234567890L, new Client("Dr Jane Doe"), 10L))).getSource()); + } + + /** + * Method under test: {@link CashTransaction#getSource()} + */ + @Test + void testGetSource2() { + // Arrange + Date date = Date.from(LocalDate.of(1970, 1, 1).atStartOfDay().atZone(ZoneOffset.UTC).toInstant()); + + // Act and Assert + assertEquals("1234567890", + (new CashTransaction(-1L, date, new Account(1234567890L, new Client("Dr Jane Doe"), 10L))).getSource()); + } + + /** + * Method under test: {@link CashTransaction#getSource()} + */ + @Test + void testGetSource3() { + // Arrange + java.sql.Date date = mock(java.sql.Date.class); + + // Act and Assert + assertEquals("CASH", + (new CashTransaction(10L, date, new Account(1234567890L, new Client("Dr Jane Doe"), 10L))).getSource()); + } + + /** + * Method under test: {@link CashTransaction#getTarget()} + */ + @Test + void testGetTarget() { + // Arrange + Date date = Date.from(LocalDate.of(1970, 1, 1).atStartOfDay().atZone(ZoneOffset.UTC).toInstant()); + + // Act and Assert + assertEquals("1234567890", + (new CashTransaction(10L, date, new Account(1234567890L, new Client("Dr Jane Doe"), 10L))).getTarget()); + } + + /** + * Method under test: {@link CashTransaction#getTarget()} + */ + @Test + void testGetTarget2() { + // Arrange + Date date = Date.from(LocalDate.of(1970, 1, 1).atStartOfDay().atZone(ZoneOffset.UTC).toInstant()); + + // Act and Assert + assertEquals("CASH", + (new CashTransaction(-1L, date, new Account(1234567890L, new Client("Dr Jane Doe"), 10L))).getTarget()); + } + + /** + * Method under test: {@link CashTransaction#getTarget()} + */ + @Test + void testGetTarget3() { + // Arrange + java.sql.Date date = mock(java.sql.Date.class); + + // Act and Assert + assertEquals("1234567890", + (new CashTransaction(10L, date, new Account(1234567890L, new Client("Dr Jane Doe"), 10L))).getTarget()); + } + + /** + * Method under test: {@link CashTransaction#executeTransaction()} + */ + @Test + void testExecuteTransaction() throws TransactionException { + // Arrange + Date date = Date.from(LocalDate.of(1970, 1, 1).atStartOfDay().atZone(ZoneOffset.UTC).toInstant()); + CashTransaction cashTransaction = new CashTransaction(10L, date, + new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Act + cashTransaction.executeTransaction(); + + // Assert + assertEquals(Transaction.TransactionState.EXECUTED, cashTransaction.getTransactionState()); + } + + /** + * Method under test: {@link CashTransaction#executeTransaction()} + */ + @Test + void testExecuteTransaction2() throws TransactionException { + // Arrange + Date date = Date.from(LocalDate.of(1970, 1, 1).atStartOfDay().atZone(ZoneOffset.UTC).toInstant()); + CashTransaction cashTransaction = new CashTransaction(-1L, date, + new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Act + cashTransaction.executeTransaction(); + + // Assert + assertEquals(Transaction.TransactionState.EXECUTED, cashTransaction.getTransactionState()); + } + + /** + * Method under test: {@link CashTransaction#executeTransaction()} + */ + @Test + void testExecuteTransaction3() throws TransactionException { + // Arrange + Date date = Date.from(LocalDate.of(1970, 1, 1).atStartOfDay().atZone(ZoneOffset.UTC).toInstant()); + CashTransaction cashTransaction = new CashTransaction(Long.MIN_VALUE, date, + new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Act + cashTransaction.executeTransaction(); + + // Assert + assertEquals(Transaction.TransactionState.FAILED, cashTransaction.getTransactionState()); + } + + /** + * Method under test: {@link CashTransaction#executeTransaction()} + */ + @Test + void testExecuteTransaction4() throws TransactionException { + // Arrange + java.sql.Date date = mock(java.sql.Date.class); + CashTransaction cashTransaction = new CashTransaction(10L, date, + new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Act + cashTransaction.executeTransaction(); + + // Assert + assertEquals(Transaction.TransactionState.EXECUTED, cashTransaction.getTransactionState()); + } +} + diff --git a/src/test/java/io/diffblue/corebanking/transaction/TransactionDiffblueTest.java b/src/test/java/io/diffblue/corebanking/transaction/TransactionDiffblueTest.java new file mode 100644 index 0000000..e94b258 --- /dev/null +++ b/src/test/java/io/diffblue/corebanking/transaction/TransactionDiffblueTest.java @@ -0,0 +1,167 @@ +package io.diffblue.corebanking.transaction; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import io.diffblue.corebanking.account.Account; +import io.diffblue.corebanking.client.Client; +import java.time.LocalDate; +import java.time.ZoneOffset; +import java.util.Date; +import org.junit.jupiter.api.Test; + +class TransactionDiffblueTest { + /** + * Method under test: {@link Transaction#getTransactionAmount()} + */ + @Test + void testGetTransactionAmount() { + // Arrange + Date date = Date.from(LocalDate.of(1970, 1, 1).atStartOfDay().atZone(ZoneOffset.UTC).toInstant()); + + // Act and Assert + assertEquals(10L, (new CashTransaction(10L, date, new Account(1234567890L, new Client("Dr Jane Doe"), 10L))) + .getTransactionAmount()); + } + + /** + * Method under test: {@link Transaction#getTransactionAmount()} + */ + @Test + void testGetTransactionAmount2() { + // Arrange + java.sql.Date date = mock(java.sql.Date.class); + + // Act and Assert + assertEquals(10L, (new CashTransaction(10L, date, new Account(1234567890L, new Client("Dr Jane Doe"), 10L))) + .getTransactionAmount()); + } + + /** + * Method under test: {@link Transaction#getTransactionDate()} + */ + @Test + void testGetTransactionDate() { + // Arrange + Date date = Date.from(LocalDate.of(1970, 1, 1).atStartOfDay().atZone(ZoneOffset.UTC).toInstant()); + + // Act and Assert + assertSame(date, (new CashTransaction(10L, date, new Account(1234567890L, new Client("Dr Jane Doe"), 10L))) + .getTransactionDate()); + } + + /** + * Method under test: {@link Transaction#getTransactionState()} + */ + @Test + void testGetTransactionState() { + // Arrange + Date date = Date.from(LocalDate.of(1970, 1, 1).atStartOfDay().atZone(ZoneOffset.UTC).toInstant()); + + // Act and Assert + assertEquals(Transaction.TransactionState.NOT_EXECUTED_YET, + (new CashTransaction(10L, date, new Account(1234567890L, new Client("Dr Jane Doe"), 10L))) + .getTransactionState()); + } + + /** + * Method under test: {@link Transaction#getTransactionState()} + */ + @Test + void testGetTransactionState2() { + // Arrange + java.sql.Date date = mock(java.sql.Date.class); + + // Act and Assert + assertEquals(Transaction.TransactionState.NOT_EXECUTED_YET, + (new CashTransaction(10L, date, new Account(1234567890L, new Client("Dr Jane Doe"), 10L))) + .getTransactionState()); + } + + /** + * Method under test: {@link Transaction#setCurrentStateFailed()} + */ + @Test + void testSetCurrentStateFailed() throws TransactionException { + // Arrange + Date date = Date.from(LocalDate.of(1970, 1, 1).atStartOfDay().atZone(ZoneOffset.UTC).toInstant()); + CashTransaction cashTransaction = new CashTransaction(10L, date, + new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Act + cashTransaction.setCurrentStateFailed(); + + // Assert + assertEquals(Transaction.TransactionState.FAILED, cashTransaction.getTransactionState()); + } + + /** + * Method under test: {@link Transaction#setCurrentStateFailed()} + */ + @Test + void testSetCurrentStateFailed2() throws TransactionException { + // Arrange + java.sql.Date date = mock(java.sql.Date.class); + CashTransaction cashTransaction = new CashTransaction(10L, date, + new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Act + cashTransaction.setCurrentStateFailed(); + + // Assert + assertEquals(Transaction.TransactionState.FAILED, cashTransaction.getTransactionState()); + } + + /** + * Method under test: {@link Transaction#markTransactionAsExecuted()} + */ + @Test + void testMarkTransactionAsExecuted() { + // Arrange + Date date = Date.from(LocalDate.of(1970, 1, 1).atStartOfDay().atZone(ZoneOffset.UTC).toInstant()); + CashTransaction cashTransaction = new CashTransaction(10L, date, + new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Act + cashTransaction.markTransactionAsExecuted(); + + // Assert + assertEquals(Transaction.TransactionState.EXECUTED, cashTransaction.getTransactionState()); + } + + /** + * Method under test: {@link Transaction#markTransactionAsExecuted()} + */ + @Test + void testMarkTransactionAsExecuted2() { + // Arrange + java.sql.Date date = mock(java.sql.Date.class); + CashTransaction cashTransaction = new CashTransaction(10L, date, + new Account(1234567890L, new Client("Dr Jane Doe"), 10L)); + + // Act + cashTransaction.markTransactionAsExecuted(); + + // Assert + assertEquals(Transaction.TransactionState.EXECUTED, cashTransaction.getTransactionState()); + } + + /** + * Method under test: {@link Transaction#toString()} + */ + @Test + void testToString() { + // Arrange + java.sql.Date date = mock(java.sql.Date.class); + when(date.getTime()).thenReturn(10L); + + // Act + (new CashTransaction(10L, date, new Account(1234567890L, new Client("Dr Jane Doe"), 10L))).toString(); + + // Assert + verify(date).getTime(); + } +} + diff --git a/src/test/java/io/diffblue/corebanking/transaction/TransactionExceptionDiffblueTest.java b/src/test/java/io/diffblue/corebanking/transaction/TransactionExceptionDiffblueTest.java new file mode 100644 index 0000000..7fc9e5b --- /dev/null +++ b/src/test/java/io/diffblue/corebanking/transaction/TransactionExceptionDiffblueTest.java @@ -0,0 +1,23 @@ +package io.diffblue.corebanking.transaction; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import org.junit.jupiter.api.Test; + +class TransactionExceptionDiffblueTest { + /** + * Method under test: {@link TransactionException#TransactionException(String)} + */ + @Test + void testConstructor() { + // Arrange and Act + TransactionException actualTransactionException = new TransactionException("An error occurred"); + + // Assert + assertNull(actualTransactionException.getCause()); + assertEquals(0, actualTransactionException.getSuppressed().length); + assertEquals("An error occurred", actualTransactionException.getMessage()); + assertEquals("An error occurred", actualTransactionException.getLocalizedMessage()); + } +} + diff --git a/src/test/java/io/diffblue/corebanking/ui/menu/AccountsMenuDiffblueTest.java b/src/test/java/io/diffblue/corebanking/ui/menu/AccountsMenuDiffblueTest.java new file mode 100644 index 0000000..eb4e9be --- /dev/null +++ b/src/test/java/io/diffblue/corebanking/ui/menu/AccountsMenuDiffblueTest.java @@ -0,0 +1,42 @@ +package io.diffblue.corebanking.ui.menu; + +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import io.diffblue.corebanking.CoreBanking; +import io.diffblue.corebanking.datamanagement.ReadFromDB; +import io.diffblue.corebanking.transaction.TransactionException; +import java.util.ArrayList; +import org.junit.jupiter.api.Test; + +class AccountsMenuDiffblueTest { + /** + * Method under test: {@link AccountsMenu#AccountsMenu(CoreBanking)} + */ + @Test + void testConstructor() throws TransactionException { + // Arrange + CoreBanking coreBanking = ReadFromDB.readFromDB(); + + // Act and Assert + assertSame((new AccountsMenu(coreBanking)).coreBanking, coreBanking); + } + + /** + * Method under test: {@link AccountsMenu#executeMenuOption(int)} + */ + @Test + void testExecuteMenuOption() { + // Arrange + CoreBanking coreBanking = mock(CoreBanking.class); + when(coreBanking.getAccounts()).thenReturn(new ArrayList<>()); + + // Act + (new AccountsMenu(coreBanking)).executeMenuOption(1); + + // Assert + verify(coreBanking).getAccounts(); + } +} + diff --git a/src/test/java/io/diffblue/corebanking/ui/menu/ClientsMenuDiffblueTest.java b/src/test/java/io/diffblue/corebanking/ui/menu/ClientsMenuDiffblueTest.java new file mode 100644 index 0000000..8ff1141 --- /dev/null +++ b/src/test/java/io/diffblue/corebanking/ui/menu/ClientsMenuDiffblueTest.java @@ -0,0 +1,42 @@ +package io.diffblue.corebanking.ui.menu; + +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import io.diffblue.corebanking.CoreBanking; +import io.diffblue.corebanking.datamanagement.ReadFromDB; +import io.diffblue.corebanking.transaction.TransactionException; +import java.util.ArrayList; +import org.junit.jupiter.api.Test; + +class ClientsMenuDiffblueTest { + /** + * Method under test: {@link ClientsMenu#ClientsMenu(CoreBanking)} + */ + @Test + void testConstructor() throws TransactionException { + // Arrange + CoreBanking coreBanking = ReadFromDB.readFromDB(); + + // Act and Assert + assertSame((new ClientsMenu(coreBanking)).coreBanking, coreBanking); + } + + /** + * Method under test: {@link ClientsMenu#executeMenuOption(int)} + */ + @Test + void testExecuteMenuOption() { + // Arrange + CoreBanking coreBanking = mock(CoreBanking.class); + when(coreBanking.getClients()).thenReturn(new ArrayList<>()); + + // Act + (new ClientsMenu(coreBanking)).executeMenuOption(1); + + // Assert + verify(coreBanking).getClients(); + } +} + diff --git a/src/test/java/io/diffblue/corebanking/ui/menu/ComplianceMenuDiffblueTest.java b/src/test/java/io/diffblue/corebanking/ui/menu/ComplianceMenuDiffblueTest.java new file mode 100644 index 0000000..415ec7d --- /dev/null +++ b/src/test/java/io/diffblue/corebanking/ui/menu/ComplianceMenuDiffblueTest.java @@ -0,0 +1,42 @@ +package io.diffblue.corebanking.ui.menu; + +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import io.diffblue.corebanking.CoreBanking; +import io.diffblue.corebanking.datamanagement.ReadFromDB; +import io.diffblue.corebanking.transaction.TransactionException; +import java.util.ArrayList; +import org.junit.jupiter.api.Test; + +class ComplianceMenuDiffblueTest { + /** + * Method under test: {@link ComplianceMenu#ComplianceMenu(CoreBanking)} + */ + @Test + void testConstructor() throws TransactionException { + // Arrange + CoreBanking coreBanking = ReadFromDB.readFromDB(); + + // Act and Assert + assertSame((new ComplianceMenu(coreBanking)).coreBanking, coreBanking); + } + + /** + * Method under test: {@link ComplianceMenu#executeMenuOption(int)} + */ + @Test + void testExecuteMenuOption() { + // Arrange + CoreBanking coreBanking = mock(CoreBanking.class); + when(coreBanking.getAccounts()).thenReturn(new ArrayList<>()); + + // Act + (new ComplianceMenu(coreBanking)).executeMenuOption(1); + + // Assert + verify(coreBanking).getAccounts(); + } +} + diff --git a/src/test/java/io/diffblue/corebanking/ui/menu/CoreBankingDataManagementMenuDiffblueTest.java b/src/test/java/io/diffblue/corebanking/ui/menu/CoreBankingDataManagementMenuDiffblueTest.java new file mode 100644 index 0000000..a1f8551 --- /dev/null +++ b/src/test/java/io/diffblue/corebanking/ui/menu/CoreBankingDataManagementMenuDiffblueTest.java @@ -0,0 +1,53 @@ +package io.diffblue.corebanking.ui.menu; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertSame; +import io.diffblue.corebanking.CoreBanking; +import io.diffblue.corebanking.client.Client; +import io.diffblue.corebanking.datamanagement.ReadFromDB; +import io.diffblue.corebanking.transaction.TransactionException; +import java.util.List; +import org.junit.jupiter.api.Test; + +class CoreBankingDataManagementMenuDiffblueTest { + /** + * Method under test: {@link CoreBankingDataManagementMenu#CoreBankingDataManagementMenu(CoreBanking)} + */ + @Test + void testConstructor() throws TransactionException { + // Arrange + CoreBanking coreBanking = ReadFromDB.readFromDB(); + + // Act and Assert + assertSame((new CoreBankingDataManagementMenu(coreBanking)).coreBanking, coreBanking); + } + + /** + * Method under test: {@link CoreBankingDataManagementMenu#executeMenuOption(int)} + */ + @Test + void testExecuteMenuOption() throws TransactionException { + // Arrange + CoreBankingDataManagementMenu coreBankingDataManagementMenu = new CoreBankingDataManagementMenu( + ReadFromDB.readFromDB()); + + // Act + coreBankingDataManagementMenu.executeMenuOption(2); + + // Assert + CoreBanking coreBanking = coreBankingDataManagementMenu.coreBanking; + assertEquals(6, coreBanking.getAccounts().size()); + List clients = coreBanking.getClients(); + assertEquals(3, clients.size()); + Client getResult = clients.get(2); + assertEquals("Emily Simmons", getResult.getClientName()); + Client getResult2 = clients.get(1); + assertEquals("Jane Robbins", getResult2.getClientName()); + assertEquals(2, getResult2.getAccounts().size()); + assertEquals(1, getResult.getAccounts().size()); + Client getResult3 = clients.get(0); + assertEquals(3, getResult3.getAccounts().size()); + assertEquals("John Field", getResult3.getClientName()); + } +} + diff --git a/src/test/java/io/diffblue/corebanking/ui/menu/MainMenuDiffblueTest.java b/src/test/java/io/diffblue/corebanking/ui/menu/MainMenuDiffblueTest.java new file mode 100644 index 0000000..b2a2636 --- /dev/null +++ b/src/test/java/io/diffblue/corebanking/ui/menu/MainMenuDiffblueTest.java @@ -0,0 +1,22 @@ +package io.diffblue.corebanking.ui.menu; + +import static org.junit.jupiter.api.Assertions.assertSame; +import io.diffblue.corebanking.CoreBanking; +import io.diffblue.corebanking.datamanagement.ReadFromDB; +import io.diffblue.corebanking.transaction.TransactionException; +import org.junit.jupiter.api.Test; + +class MainMenuDiffblueTest { + /** + * Method under test: {@link MainMenu#MainMenu(CoreBanking)} + */ + @Test + void testConstructor() throws TransactionException { + // Arrange + CoreBanking coreBanking = ReadFromDB.readFromDB(); + + // Act and Assert + assertSame((new MainMenu(coreBanking)).coreBanking, coreBanking); + } +} +