gaspersic/java-design-patterns
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Work on #404, javadocs and test cases for DB and in memory dao.

Browse Source
This commit is contained in:
Narendra Pathai
2016-03-21 17:55:29 +05:30
parent 448d855809
commit fa077c8be9
8 changed files with 345 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
dao/pom.xml
View File

@@ -52,6 +52,10 @@
<groupId>de.bechte.junit</groupId>
<artifactId>junit-hierarchicalcontextrunner</artifactId>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
</dependency>
</dependencies>
<build>

12
dao/src/main/java/com/iluwatar/dao/App.java
View File

@@ -49,9 +49,11 @@ public class App {
* Program entry point.
*
* @param args command line args.
* @throws Exception if any error occurs.
*/
public static void main(final String[] args) {
final CustomerDao customerDao = new InMemoryCustomerDao(generateSampleCustomers());
public static void main(final String[] args) throws Exception {
final CustomerDao customerDao = new InMemoryCustomerDao();
addCustomers(customerDao);
log.info("customerDao.getAllCustomers(): " + customerDao.getAll());
log.info("customerDao.getCusterById(2): " + customerDao.getById(2));
final Customer customer = new Customer(4, "Dan", "Danson");
@@ -65,6 +67,12 @@ public class App {
log.info("customerDao.getAllCustomers(): " + customerDao.getAll());
}
private static void addCustomers(CustomerDao customerDao) throws Exception {
for (Customer customer : generateSampleCustomers()) {
customerDao.add(customer);
}
}
/**
* Generate customers.
*

48
dao/src/main/java/com/iluwatar/dao/CustomerDao.java
View File

@@ -26,18 +26,54 @@ import java.util.stream.Stream;
/**
*
* CustomerDao
* In an application the Data Access Object (DAO) is a part of Data access layer. It is an object
* that provides an interface to some type of persistence mechanism. By mapping application calls
* to the persistence layer, DAO provides some specific data operations without exposing details
* of the database. This isolation supports the Single responsibility principle. It separates what
* data accesses the application needs, in terms of domain-specific objects and data types
* (the public interface of the DAO), from how these needs can be satisfied with a specific DBMS,
* database schema, etc.
* <br/><br/>
* Any change in the way data is stored and retrieved will not change the client code as the client
* will be using interface and need not worry about exact source.
*
* @see InMemoryCustomerDao
* @see DBCustomerDao
*/
public interface CustomerDao {
Stream<Customer> getAll();
/**
* @return all the customers as a stream. The stream may be lazily or eagerly evaluated based on the
* implementation. The stream must be closed after use.
* @throws Exception if any error occurs.
*/
Stream<Customer> getAll() throws Exception;
Customer getById(int id);
/**
* @param id unique identifier of the customer.
* @return customer with unique identifier <code>id</code> is found, null otherwise.
* @throws Exception if any error occurs.
*/
Customer getById(int id) throws Exception;
boolean add(Customer customer);
/**
* @param customer the customer to be added.
* @return true if customer is successfully added, false if customer already exists.
* @throws Exception if any error occurs.
*/
boolean add(Customer customer) throws Exception;
boolean update(Customer customer);
/**
* @param customer the customer to be updated.
* @return true if customer exists and is successfully updated, false otherwise.
* @throws Exception if any error occurs.
*/
boolean update(Customer customer) throws Exception;
boolean delete(Customer customer);
/**
* @param customer the customer to be deleted.
* @return true if customer exists and is successfully deleted, false otherwise.
* @throws Exception if any error occurs.
*/
boolean delete(Customer customer) throws Exception;
}

72
dao/src/main/java/com/iluwatar/dao/DBCustomerDao.java
View File

@@ -1,7 +1,28 @@
/**
* The MIT License
* Copyright (c) 2014 Ilkka Seppälä
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package com.iluwatar.dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
@@ -11,16 +32,22 @@ import java.util.function.Consumer;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import javax.sql.DataSource;
/**
*
*
*/
public class DBCustomerDao implements CustomerDao {
private String dbUrl;
private final DataSource dataSource;
public DBCustomerDao(String dbUrl) {
this.dbUrl = dbUrl;
public DBCustomerDao(DataSource dataSource) {
this.dataSource = dataSource;
}
@Override
public Stream<Customer> getAll() {
public Stream<Customer> getAll() throws Exception {
Connection connection;
try {
@@ -41,14 +68,16 @@ public class DBCustomerDao implements CustomerDao {
e.printStackTrace();
return false;
}
}}, false).onClose(() -> mutedClose(connection));
} catch (SQLException e) {
e.printStackTrace();
return null;
throw new Exception(e.getMessage(), e);
}
}
private Connection getConnection() throws SQLException {
return dataSource.getConnection();
}
private void mutedClose(Connection connection) {
try {
connection.close();
@@ -64,22 +93,23 @@ public class DBCustomerDao implements CustomerDao {
}
@Override
public Customer getById(int id) {
public Customer getById(int id) throws Exception {
try (Connection connection = getConnection();
PreparedStatement statement = connection.prepareStatement("SELECT * FROM CUSTOMERS WHERE ID = ?")) {
statement.setInt(1, id);
ResultSet resultSet = statement.executeQuery();
if (resultSet.next()) {
return createCustomer(resultSet);
} else {
return null;
}
} catch (SQLException ex) {
ex.printStackTrace();
throw new Exception(ex.getMessage(), ex);
}
return null;
}
@Override
public boolean add(Customer customer) {
public boolean add(Customer customer) throws Exception {
if (getById(customer.getId()) != null) {
return false;
}
@@ -92,13 +122,12 @@ public class DBCustomerDao implements CustomerDao {
statement.execute();
return true;
} catch (SQLException ex) {
ex.printStackTrace();
return false;
throw new Exception(ex.getMessage(), ex);
}
}
@Override
public boolean update(Customer customer) {
public boolean update(Customer customer) throws Exception {
try (Connection connection = getConnection();
PreparedStatement statement = connection.prepareStatement("UPDATE CUSTOMERS SET FNAME = ?, LNAME = ? WHERE ID = ?")) {
statement.setString(1, customer.getFirstName());
@@ -106,25 +135,18 @@ public class DBCustomerDao implements CustomerDao {
statement.setInt(3, customer.getId());
return statement.executeUpdate() > 0;
} catch (SQLException ex) {
ex.printStackTrace();
return false;
throw new Exception(ex.getMessage(), ex);
}
}
@Override
public boolean delete(Customer customer) {
public boolean delete(Customer customer) throws Exception {
try (Connection connection = getConnection();
PreparedStatement statement = connection.prepareStatement("DELETE FROM CUSTOMERS WHERE ID = ?")) {
statement.setInt(1, customer.getId());
return statement.executeUpdate() > 0;
} catch (SQLException ex) {
ex.printStackTrace();
return false;
throw new Exception(ex.getMessage(), ex);
}
}
private Connection getConnection() throws SQLException {
return DriverManager.getConnection(dbUrl);
}
}

23
dao/src/main/java/com/iluwatar/dao/InMemoryCustomerDao.java
View File

@@ -23,30 +23,22 @@
package com.iluwatar.dao;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Stream;
/**
*
* The data access object (DAO) is an object that provides an abstract interface to some type of
* database or other persistence mechanism. By mapping application calls to the persistence layer,
* DAO provide some specific data operations without exposing details of the database. This
* isolation supports the Single responsibility principle. It separates what data accesses the
* application needs, in terms of domain-specific objects and data types (the public interface of
* the DAO), from how these needs can be satisfied with a specific DBMS, database schema, etc.
*
* An in memory implementation of {@link CustomerDao}, which stores the customers in JVM memory
* and data is lost when the application exits.
* <br/>
* This implementation is useful as temporary database or for testing.
*/
// TODO update the javadoc
public class InMemoryCustomerDao implements CustomerDao {
private Map<Integer, Customer> idToCustomer = new HashMap<>();
public InMemoryCustomerDao(final List<Customer> customers) {
customers.stream()
.forEach((customer) -> idToCustomer.put(customer.getId(), customer));
}
/**
* An eagerly evaluated stream of customers stored in memory.
*/
@Override
public Stream<Customer> getAll() {
return idToCustomer.values().stream();
@@ -67,7 +59,6 @@ public class InMemoryCustomerDao implements CustomerDao {
return true;
}
@Override
public boolean update(final Customer customer) {
return idToCustomer.replace(customer.getId(), customer) != null;

4
dao/src/test/java/com/iluwatar/dao/AppTest.java
View File

@@ -24,14 +24,12 @@ package com.iluwatar.dao;
import org.junit.Test;
import java.io.IOException;
/**
* Tests that DAO example runs without errors.
*/
public class AppTest {
@Test
public void test() throws IOException {
public void test() throws Exception {
String[] args = {};
App.main(args);
}

87
dao/src/test/java/com/iluwatar/dao/DBCustomerDaoTest.java
View File

@@ -5,6 +5,9 @@ import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assume.assumeTrue;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import java.sql.Connection;
import java.sql.DriverManager;
@@ -12,10 +15,16 @@ import java.sql.SQLException;
import java.sql.Statement;
import java.util.stream.Stream;
import javax.sql.DataSource;
import org.h2.jdbcx.JdbcDataSource;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import de.bechte.junit.runners.context.HierarchicalContextRunner;
@@ -34,17 +43,21 @@ public class DBCustomerDaoTest {
}
}
public class ConnectionSuccess {
@Before
public void setUp() {
dao = new DBCustomerDao(DB_URL);
public void setUp() throws Exception {
JdbcDataSource dataSource = new JdbcDataSource();
dataSource.setURL(DB_URL);
dao = new DBCustomerDao(dataSource);
boolean result = dao.add(existingCustomer);
assumeTrue(result);
assertTrue(result);
}
public class NonExistantCustomer {
@Test
public void addingShouldResultInSuccess() {
public void addingShouldResultInSuccess() throws Exception {
try (Stream<Customer> allCustomers = dao.getAll()) {
assumeTrue(allCustomers.count() == 1);
}
@@ -58,7 +71,7 @@ public class DBCustomerDaoTest {
}
@Test
public void deletionShouldBeFailureAndNotAffectExistingCustomers() {
public void deletionShouldBeFailureAndNotAffectExistingCustomers() throws Exception {
final Customer nonExistingCustomer = new Customer(2, "Robert", "Englund");
boolean result = dao.delete(nonExistingCustomer);
@@ -67,7 +80,7 @@ public class DBCustomerDaoTest {
}
@Test
public void updationShouldBeFailureAndNotAffectExistingCustomers() {
public void updationShouldBeFailureAndNotAffectExistingCustomers() throws Exception {
final int nonExistingId = getNonExistingCustomerId();
final String newFirstname = "Douglas";
final String newLastname = "MacArthur";
@@ -79,16 +92,15 @@ public class DBCustomerDaoTest {
}
@Test
public void retrieveShouldReturnNull() {
public void retrieveShouldReturnNull() throws Exception {
assertNull(dao.getById(getNonExistingCustomerId()));
}
}
public class ExistingCustomer {
@Test
public void addingShouldResultInFailureAndNotAffectExistingCustomers() {
public void addingShouldResultInFailureAndNotAffectExistingCustomers() throws Exception {
Customer existingCustomer = new Customer(1, "Freddy", "Krueger");
boolean result = dao.add(existingCustomer);
@@ -99,7 +111,7 @@ public class DBCustomerDaoTest {
}
@Test
public void deletionShouldBeSuccessAndCustomerShouldBeNonAccessible() {
public void deletionShouldBeSuccessAndCustomerShouldBeNonAccessible() throws Exception {
boolean result = dao.delete(existingCustomer);
assertTrue(result);
@@ -108,7 +120,7 @@ public class DBCustomerDaoTest {
}
@Test
public void updationShouldBeSuccessAndAccessingTheSameCustomerShouldReturnUpdatedInformation() {
public void updationShouldBeSuccessAndAccessingTheSameCustomerShouldReturnUpdatedInformation() throws Exception {
final String newFirstname = "Bernard";
final String newLastname = "Montgomery";
final Customer customer = new Customer(existingCustomer.getId(), newFirstname, newLastname);
@@ -120,6 +132,57 @@ public class DBCustomerDaoTest {
assertEquals(newFirstname, cust.getFirstName());
assertEquals(newLastname, cust.getLastName());
}
}
}
public class DBConnectivityIssue {
private static final String EXCEPTION_CAUSE = "Connection not available";
@Rule public ExpectedException exception = ExpectedException.none();
@Before
public void setUp() throws SQLException {
dao = new DBCustomerDao(mockedDatasource());
exception.expect(Exception.class);
exception.expectMessage(EXCEPTION_CAUSE);
}
private DataSource mockedDatasource() throws SQLException {
DataSource mockedDataSource = mock(DataSource.class);
Connection mockedConnection = mock(Connection.class);
SQLException exception = new SQLException(EXCEPTION_CAUSE);
doThrow(exception).when(mockedConnection).prepareStatement(Mockito.anyString());
doReturn(mockedConnection).when(mockedDataSource).getConnection();
return mockedDataSource;
}
@Test
public void addingACustomerFailsWithExceptionAsFeedbackToClient() throws Exception {
dao.add(new Customer(2, "Bernard", "Montgomery"));
}
@Test
public void deletingACustomerFailsWithExceptionAsFeedbackToTheClient() throws Exception {
dao.delete(existingCustomer);
}
@Test
public void updatingACustomerFailsWithFeedbackToTheClient() throws Exception {
final String newFirstname = "Bernard";
final String newLastname = "Montgomery";
dao.update(new Customer(existingCustomer.getId(), newFirstname, newLastname));
}
@Test
public void retrievingACustomerByIdReturnsNull() throws Exception {
dao.getById(existingCustomer.getId());
}
@Test
public void retrievingAllCustomersReturnsAnEmptyStream() throws Exception {
dao.getAll();
}
}
@@ -131,7 +194,7 @@ public class DBCustomerDaoTest {
}
}
private void assertCustomerCountIs(int count) {
private void assertCustomerCountIs(int count) throws Exception {
try (Stream<Customer> allCustomers = dao.getAll()) {
assertTrue(allCustomers.count() == count);
}

112
dao/src/test/java/com/iluwatar/dao/InMemoryCustomerDaoTest.java
View File

@@ -22,62 +22,59 @@
*/
package com.iluwatar.dao;
import static org.junit.Assert.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assume.assumeTrue;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
import org.junit.Assume;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import de.bechte.junit.runners.context.HierarchicalContextRunner;
@RunWith(HierarchicalContextRunner.class)
public class InMemoryCustomerDaoTest {
private InMemoryCustomerDao dao;
private List<Customer> customers;
private static final Customer CUSTOMER = new Customer(1, "Freddy", "Krueger");
@Before
public void setUp() {
customers = new ArrayList<>();
customers.add(CUSTOMER);
dao = new InMemoryCustomerDao(customers);
dao = new InMemoryCustomerDao();
dao.add(CUSTOMER);
}
public class NonExistantCustomer {
@Test
public void deleteExistingCustomer() {
Assume.assumeTrue(dao.getAll().count() == 1);
boolean result = dao.delete(CUSTOMER);
public void addingShouldResultInSuccess() throws Exception {
try (Stream<Customer> allCustomers = dao.getAll()) {
assumeTrue(allCustomers.count() == 1);
}
final Customer nonExistingCustomer = new Customer(2, "Robert", "Englund");
boolean result = dao.add(nonExistingCustomer);
assertTrue(result);
assertTrue(dao.getAll().count() == 0);
assertCustomerCountIs(2);
assertEquals(nonExistingCustomer, dao.getById(nonExistingCustomer.getId()));
}
@Test
public void deleteNonExistingCustomer() {
public void deletionShouldBeFailureAndNotAffectExistingCustomers() throws Exception {
final Customer nonExistingCustomer = new Customer(2, "Robert", "Englund");
boolean result = dao.delete(nonExistingCustomer);
assertFalse(result);
assertEquals(1, dao.getAll().count());
assertCustomerCountIs(1);
}
@Test
public void updateExistingCustomer() {
final String newFirstname = "Bernard";
final String newLastname = "Montgomery";
final Customer customer = new Customer(CUSTOMER.getId(), newFirstname, newLastname);
boolean result = dao.update(customer);
assertTrue(result);
final Customer cust = dao.getById(CUSTOMER.getId());
assertEquals(newFirstname, cust.getFirstName());
assertEquals(newLastname, cust.getLastName());
}
@Test
public void updateNonExistingCustomer() {
public void updationShouldBeFailureAndNotAffectExistingCustomers() throws Exception {
final int nonExistingId = getNonExistingCustomerId();
final String newFirstname = "Douglas";
final String newLastname = "MacArthur";
@@ -86,40 +83,47 @@ public class InMemoryCustomerDaoTest {
assertFalse(result);
assertNull(dao.getById(nonExistingId));
final Customer existingCustomer = dao.getById(CUSTOMER.getId());
assertEquals(CUSTOMER.getFirstName(), existingCustomer.getFirstName());
assertEquals(CUSTOMER.getLastName(), existingCustomer.getLastName());
}
@Test
public void addCustomer() {
final Customer newCustomer = new Customer(3, "George", "Patton");
boolean result = dao.add(newCustomer);
assertTrue(result);
assertEquals(2, dao.getAll().count());
public void retrieveShouldReturnNull() throws Exception {
assertNull(dao.getById(getNonExistingCustomerId()));
}
}
@Test
public void addAlreadyAddedCustomer() {
final Customer newCustomer = new Customer(3, "George", "Patton");
dao.add(newCustomer);
public class ExistingCustomer {
@Test
public void addingShouldResultInFailureAndNotAffectExistingCustomers() throws Exception {
boolean result = dao.add(CUSTOMER);
boolean result = dao.add(newCustomer);
assertFalse(result);
assertEquals(2, dao.getAll().count());
}
@Test
public void getExistinCustomerById() {
assertCustomerCountIs(1);
assertEquals(CUSTOMER, dao.getById(CUSTOMER.getId()));
}
@Test
public void getNonExistingCustomerById() {
final int nonExistingId = getNonExistingCustomerId();
public void deletionShouldBeSuccessAndCustomerShouldBeNonAccessible() throws Exception {
boolean result = dao.delete(CUSTOMER);
assertNull(dao.getById(nonExistingId));
assertTrue(result);
assertCustomerCountIs(0);
assertNull(dao.getById(CUSTOMER.getId()));
}
@Test
public void updationShouldBeSuccessAndAccessingTheSameCustomerShouldReturnUpdatedInformation() throws Exception {
final String newFirstname = "Bernard";
final String newLastname = "Montgomery";
final Customer customer = new Customer(CUSTOMER.getId(), newFirstname, newLastname);
boolean result = dao.update(customer);
assertTrue(result);
final Customer cust = dao.getById(CUSTOMER.getId());
assertEquals(newFirstname, cust.getFirstName());
assertEquals(newLastname, cust.getLastName());
}
}
/**
@@ -130,4 +134,10 @@ public class InMemoryCustomerDaoTest {
private int getNonExistingCustomerId() {
return 999;
}
private void assertCustomerCountIs(int count) throws Exception {
try (Stream<Customer> allCustomers = dao.getAll()) {
assertTrue(allCustomers.count() == count);
}
}
}