Author: tchemit Date: 2013-01-20 18:41:41 +0100 (Sun, 20 Jan 2013) New Revision: 236 Url: http://forge.codelutin.com/projects/tutti/repository/revisions/236 Log: refs #1874: [IMP/EXP] - Synchronisation de r?\195?\169f?\195?\169rentiel (continue, nearly done) Modified: trunk/tutti-persistence-adagio/src/main/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeServiceImpl.java trunk/tutti-persistence-adagio/src/test/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeServiceImplTest.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeService.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/synchro/TuttiTable.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/synchro/TuttiTableMetadata.java Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeService.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeService.java 2013-01-20 15:57:06 UTC (rev 235) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeService.java 2013-01-20 17:41:41 UTC (rev 236) @@ -29,9 +29,10 @@ import org.springframework.transaction.annotation.Transactional; import java.sql.Connection; -import java.sql.ResultSet; import java.sql.SQLException; import java.util.Date; +import java.util.List; +import java.util.Set; /** * Servide to synchronize referential. @@ -76,7 +77,7 @@ * {@link DataRetrievalFailureException} exception will be thrown. * * @param schema1 schema 1 to check - * @param schema2 shcema 2 to check + * @param schema2 schema 2 to check */ void checkSchemas(TuttiDatabaseMetadata schema1, TuttiDatabaseMetadata schema2); @@ -89,6 +90,28 @@ Dialect getInternalDialect(); /** + * Gets the min updateDate for the internal datasource. + * + * @param schema the db schema + * @return the last update date of the given table, or {@code null} + * if table does not use a updateDate columns or if there + * is no data in table. + */ + Date getMinUpdateDate(TuttiDatabaseMetadata schema) throws SQLException; + + /** + * Gets the min updateDate for the given datasource. + * + * @param connection connection to data source to query + * @param schema the db schema + * @return the last update date of the given table, or {@code null} + * if table does not use a updateDate columns or if there + * is no data in table. + */ + Date getMinUpdateDate(Connection connection, + TuttiDatabaseMetadata schema) throws SQLException; + + /** * Gets the last updateDate for the given {@code table} of the internal datasource. * * @param table the table to query @@ -97,6 +120,7 @@ * if table does not use a updateDate columns or if there * is no data in table. */ + //TODO Make sure a new transaction is not created at each invoaction Date getLastUpdateDate(TableToSynchronize table, TuttiDatabaseMetadata schema) throws SQLException; @@ -115,6 +139,27 @@ TableToSynchronize table, TuttiDatabaseMetadata schema) throws SQLException; - ResultSet getDataToUpdate(TableToSynchronize table, - TuttiDatabaseMetadata schema, Date fromDate); + List<Object[]> getDataToUpdate(TableToSynchronize table, + TuttiDatabaseMetadata schema, Date fromDate) throws SQLException; + + List<Object[]> getDataToUpdate(Connection connection, TableToSynchronize table, + TuttiDatabaseMetadata schema, Date fromDate) throws SQLException; + + Set<String> getExistingIds(TableToSynchronize table, + TuttiDatabaseMetadata schema) throws SQLException; + + Set<String> getExistingIds(Connection connection, + TableToSynchronize table, + TuttiDatabaseMetadata schema) throws SQLException; + + void updateTable(TableToSynchronize table, + TuttiDatabaseMetadata schema, + Set<String> existingIds, + List<Object[]> incomingData ) throws SQLException; + + void updateTable(Connection connection, + TableToSynchronize table, + TuttiDatabaseMetadata schema, + Set<String> existingIds, + List<Object[]> incomingData ) throws SQLException; } Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/synchro/TuttiTable.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/synchro/TuttiTable.java 2013-01-20 15:57:06 UTC (rev 235) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/synchro/TuttiTable.java 2013-01-20 17:41:41 UTC (rev 236) @@ -39,7 +39,7 @@ AGGREGATION_LEVEL, PARAMETER_GROUP, QUALITATIVE_VALUE(false), - PARAMETER, + PARAMETER(TableToSynchronize.newCode("PARAMETER")), MATRIX, FRACTION, METHOD, @@ -58,12 +58,12 @@ //TODO Association LOCATIONHierarchyException(TableToSynchronize.newId("LOCATIONHierarchyException")), // TAXON - TAXONOMIC_LEVEL, + TAXONOMIC_LEVEL(TableToSynchronize.newCode("TAXONOMIC_LEVEL")), REFERENCE_TAXON, TAXON_NAME, // TAXON GROUP - TAXON_GROUP_TYPE, + TAXON_GROUP_TYPE(TableToSynchronize.newCode("TAXON_GROUP_TYPE")), TAXON_GROUP, // CONVERSION @@ -74,7 +74,7 @@ VESSEL_TYPE, //TODO Association VESSEL_REGISTRATION_PERIOD(false), // VESSEL_FLEET_EVENT, - VESSEL, + VESSEL(TableToSynchronize.newCode("VESSEL")), // FEATURES GEAR_PHYSICAL_FEATURES, Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/synchro/TuttiTableMetadata.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/synchro/TuttiTableMetadata.java 2013-01-20 15:57:06 UTC (rev 235) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/synchro/TuttiTableMetadata.java 2013-01-20 17:41:41 UTC (rev 236) @@ -34,7 +34,7 @@ import java.lang.reflect.Field; import java.util.Map; -import java.util.Set; +import java.util.SortedSet; /** * TODO @@ -66,8 +66,8 @@ return columns.size(); } - public Set<String> getColumnNames() { - return Sets.newHashSet(columns.keySet()); + public SortedSet<String> getColumnNames() { + return Sets.newTreeSet(columns.keySet()); } public String getName() { Modified: trunk/tutti-persistence-adagio/src/main/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeServiceImpl.java =================================================================== --- trunk/tutti-persistence-adagio/src/main/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeServiceImpl.java 2013-01-20 15:57:06 UTC (rev 235) +++ trunk/tutti-persistence-adagio/src/main/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeServiceImpl.java 2013-01-20 17:41:41 UTC (rev 236) @@ -24,6 +24,8 @@ * #L% */ +import com.google.common.collect.Lists; +import com.google.common.collect.Sets; import fr.ifremer.tutti.persistence.entities.TuttiEntities; import fr.ifremer.tutti.persistence.service.AbstractPersistenceService; import org.apache.commons.logging.Log; @@ -40,7 +42,9 @@ import java.sql.ResultSet; import java.sql.SQLException; import java.util.Date; +import java.util.List; import java.util.Set; +import java.util.SortedSet; /** * TODO @@ -57,6 +61,13 @@ public static final String QUERY_SELECT_MAX_UPDATE = "SELECT max(update_date) FROM %s"; + public static final String QUERY_SELECT_IDS = "SELECT %s FROM %s"; + + public static final String QUERY_INSERT = "INSERT INTO %s (%s) VALUES (%s)"; + + public static final String QUERY_UPDATE = "UPDATE INTO %s (%s) VALUES (%s) WHERE %s = ?"; + + protected Dialect dialect; @Override @@ -162,9 +173,195 @@ } @Override - public ResultSet getDataToUpdate(TableToSynchronize table, - TuttiDatabaseMetadata schema, Date fromDate) { - return null; + public Date getMinUpdateDate(TuttiDatabaseMetadata schema) throws SQLException { + return getMinUpdateDate(getConnection(), schema); } + @Override + public Date getMinUpdateDate(Connection connection, + TuttiDatabaseMetadata schema) throws SQLException { + Date result = null; + for (TuttiTable tuttiTable : TuttiTable.values()) { + Date lastUpdateDate = getLastUpdateDate(connection, tuttiTable.getMeta(), schema); + if (result == null || (lastUpdateDate != null && lastUpdateDate.before(result))) { + result = lastUpdateDate; + } + } + return result; + } + + @Override + public List<Object[]> getDataToUpdate(TableToSynchronize table, + TuttiDatabaseMetadata schema, Date fromDate) throws SQLException { + return getDataToUpdate(getConnection(), table, schema, fromDate); + } + + @Override + public List<Object[]> getDataToUpdate(Connection connection, + TableToSynchronize table, + TuttiDatabaseMetadata schema, + Date fromDate) throws SQLException { + + TuttiTableMetadata tableMeta = schema.getTable(table.getTableName()); + SortedSet<String> columnNames = tableMeta.getColumnNames(); + StringBuilder queryParams = new StringBuilder(""); + for (String columnName : columnNames) { + queryParams.append(", ").append(columnName); + } + StringBuilder query = new StringBuilder("SELECT "); + query.append(queryParams.substring(2)); + query.append(" FROM ").append(tableMeta.getName()); + + if (table.isWithUpdateColumn()) { + + // add a filter + query.append(" WHERE update_date >= ?"); + } + String sql = query.toString(); + + if (log.isDebugEnabled()) { + log.debug("Query: " + sql); + } + PreparedStatement statement = connection.prepareStatement(sql); + if (table.isWithUpdateColumn()) { + statement.setDate(1, new java.sql.Date(fromDate.getTime())); + } + + List<Object[]> result = Lists.newArrayList(); + try { + ResultSet resultSet = statement.executeQuery(); + int columnCount = resultSet.getMetaData().getColumnCount(); + while (resultSet.next()) { + Object[] row = new Object[columnCount]; + for (int i = 0; i < columnCount; i++) { + row[i] = resultSet.getObject(i + 1); + } + result.add(row); + } + statement.close(); + return result; + } finally { + TuttiEntities.closeSilently(statement); + } + } + + @Override + public Set<String> getExistingIds(TableToSynchronize table, + TuttiDatabaseMetadata schema) throws SQLException { + return getExistingIds(getConnection(), table, schema); + } + + @Override + public Set<String> getExistingIds(Connection connection, + TableToSynchronize table, + TuttiDatabaseMetadata schema) throws SQLException { + + String sql = String.format(QUERY_SELECT_IDS, + table.getPkColumnName(), + table.getTableName()); + + PreparedStatement statement = connection.prepareStatement(sql); + + Set<String> result = Sets.newHashSet(); + try { + ResultSet resultSet = statement.executeQuery(); + while (resultSet.next()) { + result.add(String.valueOf(resultSet.getObject(1))); + } + statement.close(); + return result; + } finally { + TuttiEntities.closeSilently(statement); + } + } + + @Override + public void updateTable(TableToSynchronize table, + TuttiDatabaseMetadata schema, + Set<String> existingIds, + List<Object[]> incomingData) throws SQLException { + + updateTable(getConnection(), + table, + schema, + existingIds, + incomingData); + } + + @Override + public void updateTable(Connection connection, + TableToSynchronize table, + TuttiDatabaseMetadata schema, + Set<String> existingIds, + List<Object[]> incomingData) throws SQLException { + + TuttiTableMetadata tableMeta = schema.getTable(table.getTableName()); + ColumnMetadata pkColumn = tableMeta.getColumnMetadata(table.getPkColumnName()); + String pkColumnName = pkColumn.getName(); + int pkIndex = 0; + SortedSet<String> columnNames = tableMeta.getColumnNames(); + int columnCount = tableMeta.getColumnsCount(); + + StringBuilder queryParams = new StringBuilder(""); + StringBuilder valueParams = new StringBuilder(""); + int i = 0; + + for (String columnName : columnNames) { + queryParams.append(", ").append(columnName); + valueParams.append(", ?"); + if (pkColumnName.equals(columnName)) { + pkIndex = i; + } else { + i++; + } + } + + String tableName = tableMeta.getName(); + + String insertSql = String.format(QUERY_INSERT, tableName, queryParams.substring(2), valueParams.substring(2)); + String updateSql = String.format(QUERY_UPDATE, tableName, queryParams.substring(2), valueParams.substring(2), pkColumnName); + + PreparedStatement insertStatement = connection.prepareStatement(insertSql); + PreparedStatement updateStatement = connection.prepareStatement(updateSql); + + int nbInsert = 0; + int nbUpdate = 0; + for (Object[] row : incomingData) { + + Object pk = row[pkIndex]; + + PreparedStatement statement; + + boolean doUpdate = existingIds.contains(String.valueOf(pk)); + if (doUpdate) { + + // use update query + statement = updateStatement; + nbUpdate++; + } else { + + // use insert query + statement = insertStatement; + nbInsert++; + } + + for (int c = 0; c < columnCount; c++) { + statement.setObject(c + 1, row[c]); + } + + if (doUpdate) { + statement.setObject(columnCount + 1, pk); + } + + statement.executeUpdate(); + } + + if (log.isInfoEnabled()) { + log.info("[" + tableName + "] INSERT count: " + nbInsert); + log.info("[" + tableName + "] UPDATE count: " + nbUpdate); + } + +// connection.commit(); + } + } Modified: trunk/tutti-persistence-adagio/src/test/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeServiceImplTest.java =================================================================== --- trunk/tutti-persistence-adagio/src/test/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeServiceImplTest.java 2013-01-20 15:57:06 UTC (rev 235) +++ trunk/tutti-persistence-adagio/src/test/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeServiceImplTest.java 2013-01-20 17:41:41 UTC (rev 236) @@ -34,15 +34,17 @@ import org.junit.Assert; import org.junit.Before; import org.junit.ClassRule; -import org.junit.Ignore; import org.junit.Test; import org.springframework.dao.DataRetrievalFailureException; +import java.io.IOException; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.SQLException; import java.util.Calendar; import java.util.Date; +import java.util.List; +import java.util.Set; /** * @author tchemit <chemit@codelutin.com> @@ -170,18 +172,188 @@ } } - @Ignore @Test - public void getDataToUpdate() throws SQLException { + public void getMinUpdateDate() throws Exception { + TuttiDatabaseMetadata internalDb = service.loadInternalDb(); + Assert.assertNotNull(internalDb); + + Date minUpdateDate = service.getMinUpdateDate(internalDb); + Assert.assertNotNull(minUpdateDate); + + if (log.isInfoEnabled()) { + log.info("Min update date: " + minUpdateDate); + } + + assertDate(getSqlDate(2009, 6, 18), minUpdateDate); + + // try it on a empty db (no min update_date since no data) + + // create a external empty db + externalConnection = dbResource.createEmptyDb("getMinUpdateDate", "newDb"); + Assert.assertNotNull(externalConnection); + + TuttiDatabaseMetadata externalDb = + service.loadExternalDb(externalConnection); + + Date minUpdateDate2 = service.getMinUpdateDate(externalConnection, + internalDb); + Assert.assertNull(minUpdateDate2); + } + + @Test + public void getDataToUpdate() throws SQLException, IOException { + Date fromDate = getDate(2012, 1, 1); TuttiDatabaseMetadata internalDb = service.loadInternalDb(); Assert.assertNotNull(internalDb); + getDataToUpdate(TuttiTable.STATUS, internalDb, fromDate, 4); + getDataToUpdate(TuttiTable.QUALITY_FLAG, internalDb, fromDate, 8); + getDataToUpdate(TuttiTable.UNIT, internalDb, fromDate, 2); + getDataToUpdate(TuttiTable.AGGREGATION_LEVEL, internalDb, fromDate, 0); + getDataToUpdate(TuttiTable.PARAMETER_GROUP, internalDb, fromDate, 6); + getDataToUpdate(TuttiTable.QUALITATIVE_VALUE, internalDb, fromDate, 1162); + getDataToUpdate(TuttiTable.PARAMETER, internalDb, fromDate, 36); + getDataToUpdate(TuttiTable.MATRIX, internalDb, fromDate, 1); + getDataToUpdate(TuttiTable.FRACTION, internalDb, fromDate, 0); + getDataToUpdate(TuttiTable.METHOD, internalDb, fromDate, 5); + getDataToUpdate(TuttiTable.PMFM, internalDb, fromDate, 51); + getDataToUpdate(TuttiTable.GEAR_CLASSIFICATION, internalDb, fromDate, 1); + getDataToUpdate(TuttiTable.GEAR, internalDb, fromDate, 94); + getDataToUpdate(TuttiTable.LOCATION_CLASSIFICATION, internalDb, fromDate, 0); + getDataToUpdate(TuttiTable.LOCATION_LEVEL, internalDb, fromDate, 23); + getDataToUpdate(TuttiTable.LOCATION, internalDb, fromDate, 5333); + getDataToUpdate(TuttiTable.TAXONOMIC_LEVEL, internalDb, fromDate, 28); + getDataToUpdate(TuttiTable.REFERENCE_TAXON, internalDb, fromDate, 781); + getDataToUpdate(TuttiTable.TAXON_NAME, internalDb, fromDate, 2393); + getDataToUpdate(TuttiTable.TAXON_GROUP_TYPE, internalDb, fromDate, 1); + getDataToUpdate(TuttiTable.TAXON_GROUP, internalDb, fromDate, 1149); + getDataToUpdate(TuttiTable.ROUND_WEIGHT_CONVERSION, internalDb, fromDate, 3518); + getDataToUpdate(TuttiTable.WEIGHT_LENGTH_CONVERSION, internalDb, fromDate, 83); + getDataToUpdate(TuttiTable.VESSEL_TYPE, internalDb, fromDate, 2); + getDataToUpdate(TuttiTable.VESSEL, internalDb, fromDate, 181608); + getDataToUpdate(TuttiTable.GEAR_PHYSICAL_FEATURES, internalDb, fromDate, 1); + getDataToUpdate(TuttiTable.VESSEL_PHYSICAL_FEATURES, internalDb, fromDate, 0); + getDataToUpdate(TuttiTable.USER_PROFIL, internalDb, fromDate, 0); + getDataToUpdate(TuttiTable.DEPARTMENT, internalDb, fromDate, 25); + getDataToUpdate(TuttiTable.PERSON, internalDb, fromDate, 194); + // try it on a empty db (nothing to synch) + + // create a external empty db + externalConnection = dbResource.createEmptyDb("getDataToUpdate", "newDb"); + Assert.assertNotNull(externalConnection); + + TuttiDatabaseMetadata externalDb = + service.loadExternalDb(externalConnection); + + for (TuttiTable tuttiTable : TuttiTable.values()) { + getDataToUpdate(tuttiTable, externalDb, true, fromDate, 0); + } } + @Test + public void getExistingIds() throws SQLException, IOException { + + TuttiDatabaseMetadata internalDb = service.loadInternalDb(); + Assert.assertNotNull(internalDb); + + getExistingIds(TuttiTable.STATUS, internalDb, 4); + getExistingIds(TuttiTable.QUALITY_FLAG, internalDb, 8); + getExistingIds(TuttiTable.UNIT, internalDb, 30); + getExistingIds(TuttiTable.AGGREGATION_LEVEL, internalDb, 8); + getExistingIds(TuttiTable.PARAMETER_GROUP, internalDb, 11); + getExistingIds(TuttiTable.QUALITATIVE_VALUE, internalDb, 1162); + getExistingIds(TuttiTable.PARAMETER, internalDb, 294); + getExistingIds(TuttiTable.MATRIX, internalDb, 16); + getExistingIds(TuttiTable.FRACTION, internalDb, 52); + getExistingIds(TuttiTable.METHOD, internalDb, 39); + getExistingIds(TuttiTable.PMFM, internalDb, 538); + getExistingIds(TuttiTable.GEAR_CLASSIFICATION, internalDb, 5); + getExistingIds(TuttiTable.GEAR, internalDb, 185); + getExistingIds(TuttiTable.LOCATION_CLASSIFICATION, internalDb, 3); + getExistingIds(TuttiTable.LOCATION_LEVEL, internalDb, 78); + getExistingIds(TuttiTable.LOCATION, internalDb, 17887); + getExistingIds(TuttiTable.TAXONOMIC_LEVEL, internalDb, 30); + getExistingIds(TuttiTable.REFERENCE_TAXON, internalDb, 8609); + getExistingIds(TuttiTable.TAXON_NAME, internalDb, 16821); + getExistingIds(TuttiTable.TAXON_GROUP_TYPE, internalDb, 4); + getExistingIds(TuttiTable.TAXON_GROUP, internalDb, 13353); + getExistingIds(TuttiTable.ROUND_WEIGHT_CONVERSION, internalDb, 3518); + getExistingIds(TuttiTable.WEIGHT_LENGTH_CONVERSION, internalDb, 2579); + getExistingIds(TuttiTable.VESSEL_TYPE, internalDb, 10); + getExistingIds(TuttiTable.VESSEL, internalDb, 199299); + getExistingIds(TuttiTable.GEAR_PHYSICAL_FEATURES, internalDb, 1); + getExistingIds(TuttiTable.VESSEL_PHYSICAL_FEATURES, internalDb, 0); + getExistingIds(TuttiTable.USER_PROFIL, internalDb, 4); + getExistingIds(TuttiTable.DEPARTMENT, internalDb, 76); + getExistingIds(TuttiTable.PERSON, internalDb, 417); + + // try it on a empty db (nothing to synch) + + // create a external empty db + externalConnection = dbResource.createEmptyDb("getExistingIds", "newDb"); + Assert.assertNotNull(externalConnection); + + TuttiDatabaseMetadata externalDb = + service.loadExternalDb(externalConnection); + + for (TuttiTable tuttiTable : TuttiTable.values()) { + getExistingIds(tuttiTable, externalDb, true, 0); + } + } + + protected void getExistingIds(TuttiTable tuttiTable, + TuttiDatabaseMetadata db, + int expectedResult) throws SQLException { + getExistingIds(tuttiTable, db, false, expectedResult); + } + + protected void getExistingIds(TuttiTable tuttiTable, + TuttiDatabaseMetadata db, + boolean external, + int expectedResult) throws SQLException { + + TuttiDatabaseMetadata internalDb = service.loadInternalDb(); + Assert.assertNotNull(internalDb); + Set<String> actual; + if (external) { + actual = service.getExistingIds(externalConnection, + tuttiTable.getMeta(), db); + } else { + actual = service.getExistingIds(tuttiTable.getMeta(), db); + } + Assert.assertNotNull(actual); + Assert.assertEquals(expectedResult, actual.size()); + } + + protected void getDataToUpdate(TuttiTable tuttiTable, + TuttiDatabaseMetadata db, + Date fromDate, + int expectedResult) throws SQLException { + getDataToUpdate(tuttiTable, db, false, fromDate, expectedResult); + } + + protected void getDataToUpdate(TuttiTable tuttiTable, + TuttiDatabaseMetadata db, + boolean external, + Date fromDate, int expectedResult) throws SQLException { + + TuttiDatabaseMetadata internalDb = service.loadInternalDb(); + Assert.assertNotNull(internalDb); + List<Object[]> actual; + if (external) { + actual = service.getDataToUpdate(externalConnection, + tuttiTable.getMeta(), db, fromDate); + } else { + actual = service.getDataToUpdate(tuttiTable.getMeta(), db, fromDate); + } + Assert.assertNotNull(actual); + Assert.assertEquals(expectedResult, actual.size()); + } + protected void getLastUpdateDate(TuttiTable tuttiTable, TuttiDatabaseMetadata db, Date expected) throws SQLException { @@ -206,16 +378,20 @@ Assert.assertNull(actual); } else { - Calendar expectedCal = Calendar.getInstance(); - expectedCal.setTime(expected); - Calendar actualCal = Calendar.getInstance(); - actualCal.setTime(actual); - Assert.assertEquals(expectedCal.get(Calendar.YEAR), actualCal.get(Calendar.YEAR)); - Assert.assertEquals(expectedCal.get(Calendar.MONTH), actualCal.get(Calendar.MONTH)); - Assert.assertEquals(expectedCal.get(Calendar.DAY_OF_MONTH), actualCal.get(Calendar.DAY_OF_MONTH)); + assertDate(expected, actual); } } + protected void assertDate(Date expected, Date actual) { + Calendar expectedCal = Calendar.getInstance(); + expectedCal.setTime(expected); + Calendar actualCal = Calendar.getInstance(); + actualCal.setTime(actual); + Assert.assertEquals(expectedCal.get(Calendar.YEAR), actualCal.get(Calendar.YEAR)); + Assert.assertEquals(expectedCal.get(Calendar.MONTH), actualCal.get(Calendar.MONTH)); + Assert.assertEquals(expectedCal.get(Calendar.DAY_OF_MONTH), actualCal.get(Calendar.DAY_OF_MONTH)); + } + protected Date getSqlDate(int year, int month, int day) { return getDate(year, month - 1, day); }