diff --git a/pom.xml b/pom.xml index 55ec7986225b83a7cb4dc0d128e90e41128ce4de..062bb86facfc4568a8f4c54747486bd6db016941 100644 --- a/pom.xml +++ b/pom.xml @@ -16,8 +16,12 @@ + 1.8 1.8 + UTF-8 + + 2.15 5.1.34 1.4 @@ -25,7 +29,13 @@ 4.12 2.44.0 4.1.4.RELEASE - UTF-8 + 3.3.1 + + + 0.7.2.201409121644 + 2.18.1 + 2.6 + 2.2 @@ -89,20 +99,21 @@ ${spring.test.version} test + + + org.easymock + easymock + ${easymock.version} + test + - - org.codehaus.mojo - cobertura-maven-plugin - 2.6 - - org.apache.maven.plugins maven-surefire-report-plugin - 2.18.1 + ${surefire.version} integration-tests @@ -122,34 +133,76 @@ maven-war-plugin org.apache.maven.plugins - 2.6 + ${maven.war.plugin.version} DAAExample + + + org.jacoco + jacoco-maven-plugin + ${jacoco.version} + + + default-prepare-agent + + prepare-agent + + + + default-prepare-agent-integration + + prepare-agent-integration + + + + coverage-report + test + + report + + + + coverage-report-integration + integration-test + + report-integration + + + + default-check + + check + + + + org.apache.maven.plugins maven-surefire-plugin - 2.18.1 + ${surefire.version} - - **/*WebTest* - + + **/UnitTestSuite.java + org.apache.maven.plugins maven-failsafe-plugin - 2.18.1 + ${surefire.version} - **/*WebTest* + **/IntegrationTestSuite.java + **/AcceptanceTestSuite.java + default-integration-tests integration-test verify @@ -161,7 +214,7 @@ org.apache.maven.plugins maven-surefire-report-plugin - 2.18.1 + ${surefire.version} @@ -185,7 +238,7 @@ org.apache.tomcat.maven tomcat7-maven-plugin - 2.2 + ${tomcat.maven.plugin.version} 9080 /DAAExample @@ -213,5 +266,38 @@ + + + + + org.eclipse.m2e + lifecycle-mapping + 1.0.0 + + + + + + org.jacoco + + jacoco-maven-plugin + + + [0.7.2.201409121644,) + + + prepare-agent + + + + + + + + + + + + diff --git a/src/main/java/es/uvigo/esei/daa/DAAExampleApplication.java b/src/main/java/es/uvigo/esei/daa/DAAExampleApplication.java index cbce3c8972a090412d3b0813551a47bcd10c74d2..7fbbbcb565ccb7eeb9c6449db4ff67c7e1555d52 100644 --- a/src/main/java/es/uvigo/esei/daa/DAAExampleApplication.java +++ b/src/main/java/es/uvigo/esei/daa/DAAExampleApplication.java @@ -15,7 +15,9 @@ import es.uvigo.esei.daa.rest.PeopleResource; public class DAAExampleApplication extends Application { @Override public Set> getClasses() { - return new HashSet<>(Arrays.asList(PeopleResource.class)); + return new HashSet<>(Arrays.asList( + PeopleResource.class + )); } @Override diff --git a/src/main/java/es/uvigo/esei/daa/dao/DAO.java b/src/main/java/es/uvigo/esei/daa/dao/DAO.java index bd5d925372ca9ca6d3a969ff2810979866ba6845..0c2320d17fc7c40039d51600b97407069d1601c6 100644 --- a/src/main/java/es/uvigo/esei/daa/dao/DAO.java +++ b/src/main/java/es/uvigo/esei/daa/dao/DAO.java @@ -14,7 +14,7 @@ public abstract class DAO { private final static Logger LOG = Logger.getLogger("DAO"); private final static String JNDI_NAME = "java:/comp/env/jdbc/daaexample"; - private final DataSource dataSource; + private DataSource dataSource; public DAO() { Context initContext; diff --git a/src/main/java/es/uvigo/esei/daa/dao/PeopleDAO.java b/src/main/java/es/uvigo/esei/daa/dao/PeopleDAO.java index 4c5a5683021221075bf5d37bfdbe30ce1aa9b824..dfbbb13ca1c6bb28416d0d8eda6ffc0f87c85084 100644 --- a/src/main/java/es/uvigo/esei/daa/dao/PeopleDAO.java +++ b/src/main/java/es/uvigo/esei/daa/dao/PeopleDAO.java @@ -20,10 +20,10 @@ public class PeopleDAO extends DAO { try (final Connection conn = this.getConnection()) { final String query = "SELECT * FROM people WHERE id=?"; - try (PreparedStatement statement = conn.prepareStatement(query)) { + try (final PreparedStatement statement = conn.prepareStatement(query)) { statement.setInt(1, id); - try (ResultSet result = statement.executeQuery()) { + try (final ResultSet result = statement.executeQuery()) { if (result.next()) { return new Person( result.getInt("id"), @@ -43,8 +43,10 @@ public class PeopleDAO extends DAO { public List list() throws DAOException { try (final Connection conn = this.getConnection()) { - try (Statement statement = conn.createStatement()) { - try (ResultSet result = statement.executeQuery("SELECT * FROM people")) { + final String query = "SELECT * FROM people"; + + try (final PreparedStatement statement = conn.prepareStatement(query)) { + try (final ResultSet result = statement.executeQuery()) { final List people = new LinkedList<>(); while (result.next()) { @@ -69,7 +71,7 @@ public class PeopleDAO extends DAO { try (final Connection conn = this.getConnection()) { final String query = "DELETE FROM people WHERE id=?"; - try (PreparedStatement statement = conn.prepareStatement(query)) { + try (final PreparedStatement statement = conn.prepareStatement(query)) { statement.setInt(1, id); if (statement.executeUpdate() != 1) { @@ -88,7 +90,7 @@ public class PeopleDAO extends DAO { throw new IllegalArgumentException("name and surname can't be null"); } - try (final Connection conn = this.getConnection()) { + try (Connection conn = this.getConnection()) { final String query = "UPDATE people SET name=?, surname=? WHERE id=?"; try (PreparedStatement statement = conn.prepareStatement(query)) { @@ -114,7 +116,7 @@ public class PeopleDAO extends DAO { throw new IllegalArgumentException("name and surname can't be null"); } - try (final Connection conn = this.getConnection()) { + try (Connection conn = this.getConnection()) { final String query = "INSERT INTO people VALUES(null, ?, ?)"; try (PreparedStatement statement = conn.prepareStatement(query, Statement.RETURN_GENERATED_KEYS)) { diff --git a/src/main/java/es/uvigo/esei/daa/dao/UsersDAO.java b/src/main/java/es/uvigo/esei/daa/dao/UsersDAO.java index 7015600d1b32619eb81a7587583c7a1329c63612..01460d9af2de6eba3be423733c258f7e6049cf9d 100644 --- a/src/main/java/es/uvigo/esei/daa/dao/UsersDAO.java +++ b/src/main/java/es/uvigo/esei/daa/dao/UsersDAO.java @@ -17,10 +17,10 @@ public class UsersDAO extends DAO { try (final Connection conn = this.getConnection()) { final String query = "SELECT password FROM users WHERE login=?"; - try (PreparedStatement statement = conn.prepareStatement(query)) { + try (final PreparedStatement statement = conn.prepareStatement(query)) { statement.setString(1, login); - try (ResultSet result = statement.executeQuery()) { + try (final ResultSet result = statement.executeQuery()) { if (result.next()) { final String dbPassword = result.getString("password"); final String shaPassword = encodeSha256(password); @@ -56,10 +56,10 @@ public class UsersDAO extends DAO { try (final Connection conn = this.getConnection()) { final String query = "SELECT password FROM users WHERE login=?"; - try (PreparedStatement statement = conn.prepareStatement(query)) { + try (final PreparedStatement statement = conn.prepareStatement(query)) { statement.setString(1, login); - try (ResultSet result = statement.executeQuery()) { + try (final ResultSet result = statement.executeQuery()) { if (result.next()) { final String dbPassword = result.getString("password"); diff --git a/src/main/java/es/uvigo/esei/daa/entities/Person.java b/src/main/java/es/uvigo/esei/daa/entities/Person.java index 05f53a4632e3be85c2298eb16f5902ea7a1e61ab..ae5c73fb346a10935ea1ea04b0a6e0e3730f0054 100644 --- a/src/main/java/es/uvigo/esei/daa/entities/Person.java +++ b/src/main/java/es/uvigo/esei/daa/entities/Person.java @@ -37,4 +37,38 @@ public class Person { public void setSurname(String surname) { this.surname = surname; } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + id; + result = prime * result + ((name == null) ? 0 : name.hashCode()); + result = prime * result + ((surname == null) ? 0 : surname.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + Person other = (Person) obj; + if (id != other.id) + return false; + if (name == null) { + if (other.name != null) + return false; + } else if (!name.equals(other.name)) + return false; + if (surname == null) { + if (other.surname != null) + return false; + } else if (!surname.equals(other.surname)) + return false; + return true; + } } diff --git a/src/main/java/es/uvigo/esei/daa/rest/PeopleResource.java b/src/main/java/es/uvigo/esei/daa/rest/PeopleResource.java index e9f856ebe3cebb2f6b4ce410ff057a2efd3dda26..9d69d300c463f766a4f8f95a5c611a77fd852360 100644 --- a/src/main/java/es/uvigo/esei/daa/rest/PeopleResource.java +++ b/src/main/java/es/uvigo/esei/daa/rest/PeopleResource.java @@ -25,13 +25,18 @@ public class PeopleResource { private final PeopleDAO dao; public PeopleResource() { - this.dao = new PeopleDAO(); + this(new PeopleDAO()); + } + + // For testing purposes + PeopleResource(PeopleDAO dao) { + this.dao = dao; } @GET public Response list() { try { - return Response.ok(this.dao.list(), MediaType.APPLICATION_JSON).build(); + return Response.ok(this.dao.list()).build(); } catch (DAOException e) { LOG.log(Level.SEVERE, "Error listing people", e); return Response.serverError().entity(e.getMessage()).build(); @@ -46,7 +51,7 @@ public class PeopleResource { try { return Response.ok(this.dao.get(id), MediaType.APPLICATION_JSON).build(); } catch (IllegalArgumentException iae) { - iae.printStackTrace(); + LOG.log(Level.FINE, "Invalid person id in get method", iae); return Response.status(Response.Status.BAD_REQUEST) .entity(iae.getMessage()).build(); } catch (DAOException e) { @@ -65,7 +70,7 @@ public class PeopleResource { return Response.ok(id).build(); } catch (IllegalArgumentException iae) { - iae.printStackTrace(); + LOG.log(Level.FINE, "Invalid person id in delete method", iae); return Response.status(Response.Status.BAD_REQUEST) .entity(iae.getMessage()).build(); } catch (DAOException e) { @@ -84,7 +89,7 @@ public class PeopleResource { try { return Response.ok(this.dao.modify(id, name, surname)).build(); } catch (IllegalArgumentException iae) { - iae.printStackTrace(); + LOG.log(Level.FINE, "Invalid person id in modify method", iae); return Response.status(Response.Status.BAD_REQUEST) .entity(iae.getMessage()).build(); } catch (DAOException e) { @@ -101,7 +106,7 @@ public class PeopleResource { try { return Response.ok(this.dao.add(name, surname)).build(); } catch (IllegalArgumentException iae) { - iae.printStackTrace(); + LOG.log(Level.FINE, "Invalid person id in add method", iae); return Response.status(Response.Status.BAD_REQUEST) .entity(iae.getMessage()).build(); } catch (DAOException e) { diff --git a/src/test/java/es/uvigo/esei/daa/DatabaseQueryUnitTest.java b/src/test/java/es/uvigo/esei/daa/DatabaseQueryUnitTest.java new file mode 100644 index 0000000000000000000000000000000000000000..6f6ab5ea2710f62ea51637c71c801ecb1cc04630 --- /dev/null +++ b/src/test/java/es/uvigo/esei/daa/DatabaseQueryUnitTest.java @@ -0,0 +1,88 @@ +package es.uvigo.esei.daa; + +import static org.easymock.EasyMock.anyString; +import static org.easymock.EasyMock.createMock; +import static org.easymock.EasyMock.createNiceMock; +import static org.easymock.EasyMock.expect; +import static org.easymock.EasyMock.replay; +import static org.easymock.EasyMock.reset; +import static org.easymock.EasyMock.verify; + +import java.sql.Connection; +import java.sql.ResultSet; + +import javax.sql.DataSource; + +import org.junit.After; +import org.junit.Before; +import org.junit.BeforeClass; + +import com.mysql.jdbc.PreparedStatement; + +public abstract class DatabaseQueryUnitTest { + protected DataSource datasource; + protected Connection connection; + protected PreparedStatement statement; + protected ResultSet result; + + protected boolean verify; + + @BeforeClass + public static void setUpBeforeClass() + throws Exception { + TestUtils.clearTestDatabase(); + TestUtils.clearContextBuilder(); + } + + @Before + public void setUp() throws Exception { + TestUtils.initTestDatabase(); + + datasource = createMock(DataSource.class); + connection = createMock(Connection.class); + statement = createNiceMock(PreparedStatement.class); + result = createMock(ResultSet.class); + + expect(datasource.getConnection()) + .andReturn(connection); + expect(connection.prepareStatement(anyString())) + .andReturn(statement); + expect(statement.executeQuery()) + .andReturn(result) + .anyTimes(); // executeQuery is optional; + statement.close(); + connection.close(); + + verify = true; + } + + protected void resetAll() { + reset(result, statement, connection, datasource); + verify = false; + } + + protected void replayAll() + throws Exception { + replay(result, statement, connection, datasource); + + TestUtils.createFakeContext(datasource); + } + + @After + public void tearDown() throws Exception { + TestUtils.clearTestDatabase(); + TestUtils.clearContextBuilder(); + + try { + if (verify) { + verify(datasource, connection, statement, result); + verify = false; + } + } finally { + datasource = null; + connection = null; + statement = null; + result = null; + } + } +} diff --git a/src/test/java/es/uvigo/esei/daa/TestUtils.java b/src/test/java/es/uvigo/esei/daa/TestUtils.java index b186037b850e98c2d3019c321807009b7cb1700e..b19ed104883b3cdc857d52de70d3b056aad5b097 100644 --- a/src/test/java/es/uvigo/esei/daa/TestUtils.java +++ b/src/test/java/es/uvigo/esei/daa/TestUtils.java @@ -15,15 +15,27 @@ import org.springframework.mock.jndi.SimpleNamingContextBuilder; public final class TestUtils { + private final static SimpleNamingContextBuilder CONTEXT_BUILDER + = new SimpleNamingContextBuilder(); + private TestUtils() {} - + public static void createFakeContext() throws NamingException { - final SimpleNamingContextBuilder builder = new SimpleNamingContextBuilder(); - builder.bind("java:/comp/env/jdbc/daaexample", createTestingDataSource()); - builder.activate(); + createFakeContext(createTestingDataSource()); } - private static BasicDataSource createTestingDataSource() { + public static void createFakeContext(DataSource datasource) + throws IllegalStateException, NamingException { + CONTEXT_BUILDER.bind("java:/comp/env/jdbc/daaexample", datasource); + CONTEXT_BUILDER.activate(); + } + + public static void clearContextBuilder() { + CONTEXT_BUILDER.clear(); + CONTEXT_BUILDER.deactivate(); + } + + public static BasicDataSource createTestingDataSource() { final BasicDataSource ds = new BasicDataSource(); ds.setDriverClassName("com.mysql.jdbc.Driver"); ds.setUrl("jdbc:mysql://localhost:3306/daaexampletest?allowMultiQueries=true"); @@ -34,6 +46,10 @@ public final class TestUtils { ds.setMaxWait(10000); return ds; } + + public static BasicDataSource createEmptyDataSource() { + return new BasicDataSource(); + } public static void clearTestDatabase() throws SQLException { final String queries = new StringBuilder() diff --git a/src/test/java/es/uvigo/esei/daa/dao/PeopleDAOUnitTest.java b/src/test/java/es/uvigo/esei/daa/dao/PeopleDAOUnitTest.java new file mode 100644 index 0000000000000000000000000000000000000000..c3c9009fbe95f89f9681cb747db2c047bdaea6f5 --- /dev/null +++ b/src/test/java/es/uvigo/esei/daa/dao/PeopleDAOUnitTest.java @@ -0,0 +1,272 @@ +package es.uvigo.esei.daa.dao; + +import static org.easymock.EasyMock.anyString; +import static org.easymock.EasyMock.eq; +import static org.easymock.EasyMock.expect; +import static org.easymock.EasyMock.reset; +import static org.junit.Assert.assertEquals; + +import java.sql.SQLException; +import java.util.Arrays; +import java.util.List; + +import org.junit.Test; + +import es.uvigo.esei.daa.DatabaseQueryUnitTest; +import es.uvigo.esei.daa.entities.Person; + +public class PeopleDAOUnitTest extends DatabaseQueryUnitTest { + @Test + public void testGet() throws Exception { + final Person person = new Person(1, "Pepe", "Pérez"); + + expect(result.next()).andReturn(true); + expect(result.getInt("id")).andReturn(person.getId()); + expect(result.getString("name")).andReturn(person.getName()); + expect(result.getString("surname")).andReturn(person.getSurname()); + result.close(); + + replayAll(); + + final PeopleDAO peopleDAO = new PeopleDAO(); + + assertEquals("Unexpected person data", + person, peopleDAO.get(person.getId()) + ); + } + + @Test(expected = IllegalArgumentException.class) + public void testGetMissing() throws Exception { + expect(result.next()).andReturn(false); + result.close(); + + replayAll(); + + final PeopleDAO peopleDAO = new PeopleDAO(); + peopleDAO.get(2); + } + + @Test(expected = DAOException.class) + public void testGetUnexpectedException() throws Exception { + expect(result.next()).andThrow(new SQLException()); + result.close(); + + replayAll(); + + final PeopleDAO peopleDAO = new PeopleDAO(); + peopleDAO.get(2); + } + + @Test + public void testList() throws Exception { + final List people = Arrays.asList( + new Person(1, "Pepe", "Pérez"), + new Person(2, "Paco", "Martínez"), + new Person(3, "Martina", "Juárez") + ); + + for (Person person : people) { + expect(result.next()).andReturn(true); + expect(result.getInt("id")).andReturn(person.getId()); + expect(result.getString("name")).andReturn(person.getName()); + expect(result.getString("surname")).andReturn(person.getSurname()); + } + expect(result.next()).andReturn(false); + result.close(); + + replayAll(); + final PeopleDAO peopleDAO = new PeopleDAO(); + + assertEquals("Unexpected people data", + people, peopleDAO.list() + ); + } + + @Test(expected = DAOException.class) + public void testListUnexpectedException() throws Exception { + expect(result.next()).andThrow(new SQLException()); + result.close(); + + replayAll(); + + final PeopleDAO peopleDAO = new PeopleDAO(); + peopleDAO.list(); + } + + @Test + public void testAdd() throws Exception { + final Person person = new Person(1, "Pepe", "Pérez"); + + reset(connection); + expect(connection.prepareStatement(anyString(), eq(1))) + .andReturn(statement); + expect(statement.executeUpdate()).andReturn(1); + expect(statement.getGeneratedKeys()).andReturn(result); + expect(result.next()).andReturn(true); + expect(result.getInt(1)).andReturn(person.getId()); // Key retrieval + connection.close(); + result.close(); + + replayAll(); + + final PeopleDAO peopleDAO = new PeopleDAO(); + final Person newPerson = peopleDAO.add(person.getName(), person.getSurname()); + + assertEquals(person, newPerson); + } + + @Test(expected = IllegalArgumentException.class) + public void testAddNullName() throws Exception { + replayAll(); + + final PeopleDAO peopleDAO = new PeopleDAO(); + + resetAll(); // No expectations + + peopleDAO.add(null, "Pepe"); + } + + @Test(expected = IllegalArgumentException.class) + public void testAddNullSurname() throws Exception { + replayAll(); + + final PeopleDAO peopleDAO = new PeopleDAO(); + + resetAll(); // No expectations + + peopleDAO.add("Pepe", null); + } + + @Test(expected = DAOException.class) + public void testAddZeroUpdatedRows() throws Exception { + reset(connection); + expect(connection.prepareStatement(anyString(), eq(1))) + .andReturn(statement); + expect(statement.executeUpdate()).andReturn(0); + connection.close(); + + replayAll(); + + final PeopleDAO peopleDAO = new PeopleDAO(); + peopleDAO.add("Paco", "Pérez"); + } + + @Test(expected = DAOException.class) + public void testAddNoGeneratedKey() throws Exception { + reset(connection); + expect(connection.prepareStatement(anyString(), eq(1))) + .andReturn(statement); + expect(statement.executeUpdate()).andReturn(1); + expect(statement.getGeneratedKeys()).andReturn(result); + expect(result.next()).andReturn(false); + result.close(); + connection.close(); + + replayAll(); + + final PeopleDAO peopleDAO = new PeopleDAO(); + peopleDAO.add("Paco", "Pérez"); + } + + @Test(expected = DAOException.class) + public void testAddUnexpectedException() throws Exception { + reset(connection); + expect(connection.prepareStatement(anyString(), eq(1))) + .andReturn(statement); + expect(statement.executeUpdate()).andThrow(new SQLException()); + connection.close(); + + replayAll(); + + final PeopleDAO peopleDAO = new PeopleDAO(); + peopleDAO.add("Paco", "Pérez"); + } + + @Test + public void testDelete() throws Exception { + expect(statement.executeUpdate()).andReturn(1); + + replayAll(); + + final PeopleDAO peopleDAO = new PeopleDAO(); + peopleDAO.delete(1); + } + + @Test(expected = IllegalArgumentException.class) + public void testDeleteInvalidId() throws Exception { + expect(statement.executeUpdate()).andReturn(0); + + replayAll(); + + final PeopleDAO peopleDAO = new PeopleDAO(); + peopleDAO.delete(1); + } + + @Test(expected = DAOException.class) + public void testDeleteUnexpectedException() throws Exception { + expect(statement.executeUpdate()).andThrow(new SQLException()); + + replayAll(); + + final PeopleDAO peopleDAO = new PeopleDAO(); + peopleDAO.delete(1); + } + + @Test + public void testModify() throws Exception { + final Person person = new Person(1, "Pepe", "Pérez"); + + expect(statement.executeUpdate()).andReturn(1); + + replayAll(); + + final PeopleDAO peopleDAO = new PeopleDAO(); + final Person newPerson = peopleDAO.modify( + person.getId(), person.getName(), person.getSurname() + ); + + assertEquals(person, newPerson); + } + + @Test(expected = IllegalArgumentException.class) + public void testModifyNullName() throws Exception { + replayAll(); + + final PeopleDAO peopleDAO = new PeopleDAO(); + + resetAll(); // No expectations + + peopleDAO.modify(1, null, "Pepe"); + } + + @Test(expected = IllegalArgumentException.class) + public void testModifyNullSurname() throws Exception { + replayAll(); + + final PeopleDAO peopleDAO = new PeopleDAO(); + + resetAll(); // No expectations + + peopleDAO.modify(1, "Pepe", null); + } + + @Test(expected = IllegalArgumentException.class) + public void testModifyZeroUpdatedRows() throws Exception { + expect(statement.executeUpdate()).andReturn(0); + + replayAll(); + + final PeopleDAO peopleDAO = new PeopleDAO(); + peopleDAO.modify(1, "Paco", "Pérez"); + } + + @Test(expected = DAOException.class) + public void testModifyUnexpectedException() throws Exception { + expect(statement.executeUpdate()).andThrow(new SQLException()); + + replayAll(); + + final PeopleDAO peopleDAO = new PeopleDAO(); + peopleDAO.modify(1, "Paco", "Pérez"); + } +} diff --git a/src/test/java/es/uvigo/esei/daa/rest/PeopleTest.java b/src/test/java/es/uvigo/esei/daa/rest/PeopleResourceTest.java similarity index 99% rename from src/test/java/es/uvigo/esei/daa/rest/PeopleTest.java rename to src/test/java/es/uvigo/esei/daa/rest/PeopleResourceTest.java index b041441f17674cc6c7a3c58a5b1de6efc2da9ee9..07ae712e1fc69ed351b45530a2cf7534afc8a6e8 100644 --- a/src/test/java/es/uvigo/esei/daa/rest/PeopleTest.java +++ b/src/test/java/es/uvigo/esei/daa/rest/PeopleResourceTest.java @@ -27,7 +27,7 @@ import com.fasterxml.jackson.jaxrs.json.JacksonJsonProvider; import es.uvigo.esei.daa.TestUtils; import es.uvigo.esei.daa.entities.Person; -public class PeopleTest extends JerseyTest { +public class PeopleResourceTest extends JerseyTest { @BeforeClass public static void setUpBeforeClass() throws Exception { TestUtils.createFakeContext(); diff --git a/src/test/java/es/uvigo/esei/daa/rest/PeopleResourceUnitTest.java b/src/test/java/es/uvigo/esei/daa/rest/PeopleResourceUnitTest.java new file mode 100644 index 0000000000000000000000000000000000000000..0ef0d631bda3cf3072ac4af9fcd3ea07a8480db5 --- /dev/null +++ b/src/test/java/es/uvigo/esei/daa/rest/PeopleResourceUnitTest.java @@ -0,0 +1,199 @@ +package es.uvigo.esei.daa.rest; + +import static org.easymock.EasyMock.anyInt; +import static org.easymock.EasyMock.anyString; +import static org.easymock.EasyMock.createMock; +import static org.easymock.EasyMock.expect; +import static org.easymock.EasyMock.expectLastCall; +import static org.easymock.EasyMock.replay; +import static org.easymock.EasyMock.verify; +import static org.junit.Assert.assertEquals; + +import java.util.Arrays; +import java.util.List; + +import javax.ws.rs.core.Response; +import javax.ws.rs.core.Response.Status; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import es.uvigo.esei.daa.dao.DAOException; +import es.uvigo.esei.daa.dao.PeopleDAO; +import es.uvigo.esei.daa.entities.Person; + +public class PeopleResourceUnitTest { + private PeopleDAO daoMock; + private PeopleResource resource; + + @Before + public void setUp() throws Exception { + daoMock = createMock(PeopleDAO.class); + resource = new PeopleResource(daoMock); + } + + @After + public void tearDown() throws Exception { + try { + verify(daoMock); + } finally { + daoMock = null; + resource = null; + } + } + + @Test + public void testList() throws Exception { + final List people = Arrays.asList( + new Person(1, "Pepe", "Pérez"), + new Person(2, "Paco", "Martínez"), + new Person(3, "Martina", "Juárez") + ); + + expect(daoMock.list()).andReturn(people); + replay(daoMock); + + final Response response = resource.list(); + assertEquals(people, response.getEntity()); + assertEquals(Status.OK, response.getStatusInfo()); + } + + @Test + public void testListDAOException() throws Exception { + expect(daoMock.list()).andThrow(new DAOException()); + replay(daoMock); + + final Response response = resource.list(); + assertEquals(Status.INTERNAL_SERVER_ERROR, response.getStatusInfo()); + } + + @Test + public void testGet() throws Exception { + final Person person = new Person(1, "Pepe", "Pérez"); + + expect(daoMock.get(person.getId())).andReturn(person); + replay(daoMock); + + final Response response = resource.get(person.getId()); + assertEquals(person, response.getEntity()); + assertEquals(Status.OK, response.getStatusInfo()); + } + + @Test + public void testGetDAOException() throws Exception { + expect(daoMock.get(anyInt())).andThrow(new DAOException()); + replay(daoMock); + + final Response response = resource.get(1); + assertEquals(Status.INTERNAL_SERVER_ERROR, response.getStatusInfo()); + } + + @Test + public void testGetIllegalArgumentException() throws Exception { + expect(daoMock.get(anyInt())).andThrow(new IllegalArgumentException()); + replay(daoMock); + + final Response response = resource.get(1); + assertEquals(Status.BAD_REQUEST, response.getStatusInfo()); + } + + @Test + public void testDelete() throws Exception { + daoMock.delete(anyInt()); + replay(daoMock); + + final Response response = resource.delete(1); + assertEquals(Status.OK, response.getStatusInfo()); + } + + @Test + public void testDeleteDAOException() throws Exception { + daoMock.delete(anyInt()); + expectLastCall().andThrow(new DAOException()); + replay(daoMock); + + final Response response = resource.delete(1); + assertEquals(Status.INTERNAL_SERVER_ERROR, response.getStatusInfo()); + } + + @Test + public void testDeleteIllegalArgumentException() throws Exception { + daoMock.delete(anyInt()); + expectLastCall().andThrow(new IllegalArgumentException()); + replay(daoMock); + + final Response response = resource.delete(1); + assertEquals(Status.BAD_REQUEST, response.getStatusInfo()); + } + + @Test + public void testModify() throws Exception { + final Person person = new Person(1, "Pepe", "Pérez"); + + expect(daoMock.modify(person.getId(), person.getName(), person.getSurname())) + .andReturn(person); + replay(daoMock); + + + final Response response = resource.modify( + person.getId(), person.getName(), person.getSurname()); + assertEquals(person, response.getEntity()); + assertEquals(Status.OK, response.getStatusInfo()); + } + + @Test + public void testModifyDAOException() throws Exception { + expect(daoMock.modify(anyInt(), anyString(), anyString())) + .andThrow(new DAOException()); + replay(daoMock); + + final Response response = resource.modify(1, "Paco", "Pérez"); + assertEquals(Status.INTERNAL_SERVER_ERROR, response.getStatusInfo()); + } + + @Test + public void testModifyIllegalArgumentException() throws Exception { + expect(daoMock.modify(anyInt(), anyString(), anyString())) + .andThrow(new IllegalArgumentException()); + replay(daoMock); + + final Response response = resource.modify(1, "Paco", "Pérez"); + assertEquals(Status.BAD_REQUEST, response.getStatusInfo()); + } + + @Test + public void testAdd() throws Exception { + final Person person = new Person(1, "Pepe", "Pérez"); + + expect(daoMock.add(person.getName(), person.getSurname())) + .andReturn(person); + replay(daoMock); + + + final Response response = resource.add( + person.getName(), person.getSurname()); + assertEquals(person, response.getEntity()); + assertEquals(Status.OK, response.getStatusInfo()); + } + + @Test + public void testAddDAOException() throws Exception { + expect(daoMock.add(anyString(), anyString())) + .andThrow(new DAOException()); + replay(daoMock); + + final Response response = resource.add("Paco", "Pérez"); + assertEquals(Status.INTERNAL_SERVER_ERROR, response.getStatusInfo()); + } + + @Test + public void testAddIllegalArgumentException() throws Exception { + expect(daoMock.add(anyString(), anyString())) + .andThrow(new IllegalArgumentException()); + replay(daoMock); + + final Response response = resource.add("Paco", "Pérez"); + assertEquals(Status.BAD_REQUEST, response.getStatusInfo()); + } +} diff --git a/src/test/java/es/uvigo/esei/daa/suites/AcceptanceTestSuite.java b/src/test/java/es/uvigo/esei/daa/suites/AcceptanceTestSuite.java new file mode 100644 index 0000000000000000000000000000000000000000..6255c166f991769456f36376fbb66b9d8cd83eed --- /dev/null +++ b/src/test/java/es/uvigo/esei/daa/suites/AcceptanceTestSuite.java @@ -0,0 +1,12 @@ +package es.uvigo.esei.daa.suites; + +import org.junit.runners.Suite.SuiteClasses; + +import es.uvigo.esei.daa.web.PeopleWebTest; + +@SuiteClasses({ + PeopleWebTest.class +}) +public class AcceptanceTestSuite { + +} diff --git a/src/test/java/es/uvigo/esei/daa/PeopleTestSuite.java b/src/test/java/es/uvigo/esei/daa/suites/IntegrationTestSuite.java similarity index 51% rename from src/test/java/es/uvigo/esei/daa/PeopleTestSuite.java rename to src/test/java/es/uvigo/esei/daa/suites/IntegrationTestSuite.java index 329217cd75387c7a1df86e11dc4b4729643ced50..a287c6257df95afd2b8f9b81dac596040f9d536e 100644 --- a/src/test/java/es/uvigo/esei/daa/PeopleTestSuite.java +++ b/src/test/java/es/uvigo/esei/daa/suites/IntegrationTestSuite.java @@ -1,14 +1,18 @@ -package es.uvigo.esei.daa; +package es.uvigo.esei.daa.suites; import org.junit.runner.RunWith; import org.junit.runners.Suite; import org.junit.runners.Suite.SuiteClasses; import es.uvigo.esei.daa.dao.PeopleDAOTest; -import es.uvigo.esei.daa.rest.PeopleTest; +import es.uvigo.esei.daa.rest.PeopleResourceTest; import es.uvigo.esei.daa.web.PeopleWebTest; -@SuiteClasses({ PeopleDAOTest.class, PeopleTest.class, PeopleWebTest.class }) +@SuiteClasses({ + PeopleDAOTest.class, + PeopleResourceTest.class, + PeopleWebTest.class +}) @RunWith(Suite.class) -public class PeopleTestSuite { +public class IntegrationTestSuite { } diff --git a/src/test/java/es/uvigo/esei/daa/suites/UnitTestSuite.java b/src/test/java/es/uvigo/esei/daa/suites/UnitTestSuite.java new file mode 100644 index 0000000000000000000000000000000000000000..fffda9e014e1500799fbe6b71dffca61a75e5c5e --- /dev/null +++ b/src/test/java/es/uvigo/esei/daa/suites/UnitTestSuite.java @@ -0,0 +1,16 @@ +package es.uvigo.esei.daa.suites; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; + +import es.uvigo.esei.daa.dao.PeopleDAOUnitTest; +import es.uvigo.esei.daa.rest.PeopleResourceUnitTest; + +@SuiteClasses({ + PeopleDAOUnitTest.class, + PeopleResourceUnitTest.class +}) +@RunWith(Suite.class) +public class UnitTestSuite { +}