This is an automated email from the git hooks/post-receive script. New commit to branch develop in repository observe. See http://git.codelutin.com/observe.git commit 84c3c445ee2117d251d22ccafc48360e8f66cc1f Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Apr 23 12:19:31 2015 +0200 ajout d'un test de replication aussi pour le modèle seine (refs #7015) --- .../replication/H2LonglineReplicateDataTest.java | 204 ------------ .../its/replication/H2ReplicateDataTest.java | 348 +++++++++++++++++++++ .../ANO-6611.sql.gz => replication/data.sql.gz} | Bin 172739 -> 176610 bytes 3 files changed, 348 insertions(+), 204 deletions(-) diff --git a/observe-business/src/test/java/fr/ird/observe/its/replication/H2LonglineReplicateDataTest.java b/observe-business/src/test/java/fr/ird/observe/its/replication/H2LonglineReplicateDataTest.java deleted file mode 100644 index 2b7846f..0000000 --- a/observe-business/src/test/java/fr/ird/observe/its/replication/H2LonglineReplicateDataTest.java +++ /dev/null @@ -1,204 +0,0 @@ -package fr.ird.observe.its.replication; - -/* - * #%L - * ObServe :: Business - * %% - * Copyright (C) 2008 - 2015 IRD, Codelutin, Tony Chemit - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/gpl-3.0.html>. - * #L% - */ - -import com.google.common.collect.Maps; -import fr.ird.observe.ObserveEntityEnum; -import fr.ird.observe.db.DBTestHelper; -import fr.ird.observe.db.DataSource; -import fr.ird.observe.entities.Entities; -import fr.ird.observe.entities.longline.ActivityLongline; -import fr.ird.observe.entities.longline.SetLongline; -import fr.ird.observe.entities.longline.TripLongline; -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; -import org.nuiton.topia.TopiaContext; -import org.nuiton.topia.TopiaException; -import org.nuiton.topia.framework.TopiaContextImplementor; -import org.nuiton.topia.persistence.TopiaDAO; -import org.nuiton.topia.persistence.TopiaEntityEnum; - -import java.io.File; -import java.util.EnumMap; - -/** - * Created on 4/7/15. - * - * @author Tony Chemit - chemit@codelutin.com - * @since 3.16 - */ -public class H2LonglineReplicateDataTest extends AbstractReplicateDataTest { - - /** Logger */ - private static final Log log = LogFactory.getLog(H2LonglineReplicateDataTest.class); - - @BeforeClass - public static void init() throws Exception { - - replicationDataModel = null; - DBTestHelper.initDbForTest(H2LonglineReplicateDataTest.class, false, false); - - } - - @Override - protected DataSource createStorage(String name) throws Exception { - - File sourceDbDump = new File("src/test/resources/db/3.16/ANO-6611.sql.gz"); - - File dir = new File(getTestDir(getClass()), "localDB_" + name); - - DataSource dataSource = DBTestHelper.createAndOpenFromDump(dir, sourceDbDump.toURI().toURL(), false, false, false, true, true); - return dataSource; - } - - @Override - protected Log getLog() { - return log; - } - - @Override - protected void createModel(DataSource service) throws Exception { - // Do not create model, imported db is the model - } - - @Override - protected void updateModel() throws Exception { - // Do not update model, imported db is the model - } - - @Override - protected TopiaEntityEnum[] getContracts() { - return Entities.DATA_LONGLINE_ENTITIES; - } - - @Test - @Override - public void testDoReplicate() throws Exception { - if (getLog().isDebugEnabled()) { - getLog().debug("start test"); - } - - EnumMap<ObserveEntityEnum, Long> counts = Maps.newEnumMap(ObserveEntityEnum.class); - - counts.put(ObserveEntityEnum.TargetSample, 0l); - counts.put(ObserveEntityEnum.TargetLength, 0l); - counts.put(ObserveEntityEnum.NonTargetSample, 0l); - counts.put(ObserveEntityEnum.NonTargetLength, 0l); - counts.put(ObserveEntityEnum.NonTargetCatch, 0l); - counts.put(ObserveEntityEnum.SetSeine, 0l); - counts.put(ObserveEntityEnum.TargetCatch, 0l); - counts.put(ObserveEntityEnum.TransmittingBuoy, 0l); - counts.put(ObserveEntityEnum.ObjectObservedSpecies, 0l); - counts.put(ObserveEntityEnum.SchoolEstimate, 0l); - counts.put(ObserveEntityEnum.ObjectSchoolEstimate, 0l); - counts.put(ObserveEntityEnum.FloatingObject, 0l); - counts.put(ObserveEntityEnum.ActivitySeine, 0l); - counts.put(ObserveEntityEnum.Route, 0l); - counts.put(ObserveEntityEnum.GearUseFeaturesSeine, 0l); - counts.put(ObserveEntityEnum.GearUseFeaturesMeasurementSeine, 0l); - counts.put(ObserveEntityEnum.TripSeine, 0l); - counts.put(ObserveEntityEnum.HooksComposition, 2l); - counts.put(ObserveEntityEnum.BranchlinesComposition, 2l); - counts.put(ObserveEntityEnum.BaitsComposition, 2l); - counts.put(ObserveEntityEnum.FloatlinesComposition, 2l); - counts.put(ObserveEntityEnum.SizeMeasure, 2l); - counts.put(ObserveEntityEnum.WeightMeasure, 2l); - counts.put(ObserveEntityEnum.SetLongline, 1l); - counts.put(ObserveEntityEnum.Branchline, 2l); - counts.put(ObserveEntityEnum.Basket, 1l); - counts.put(ObserveEntityEnum.Section, 1l); - counts.put(ObserveEntityEnum.CatchLongline, 2l); - counts.put(ObserveEntityEnum.Tdr, 2l); - counts.put(ObserveEntityEnum.Encounter, 2l); - counts.put(ObserveEntityEnum.SensorUsed, 2l); - counts.put(ObserveEntityEnum.ActivityLongline, 1l); - counts.put(ObserveEntityEnum.TdrRecord, 0l); - counts.put(ObserveEntityEnum.GearUseFeaturesLongline, 1l); - counts.put(ObserveEntityEnum.GearUseFeaturesMeasurementLongline, 2l); - counts.put(ObserveEntityEnum.TripLongline, 1l); - - String tripLonglineId = "fr.ird.observe.entities.longline.TripLongline#1428427025277#0.8587988145746449"; - assertNbEntities(ctxt, counts, tripLonglineId); - - dstCtxt = (TopiaContextImplementor) createReplicateDb("doReplicateWithComputedOrder"); - - localService.getReplicationService().replicateData(localService, dbCible, tripLonglineId); - - TopiaContext tx = dstCtxt.beginTransaction(); - - try { - - assertNbEntities(tx, counts, tripLonglineId); - - } finally { - tx.closeContext(); - } - - } - - @Override - protected void assertDbEquals(TopiaEntityEnum[] contracts, TopiaContextImplementor ctxt, TopiaContextImplementor ctxt2) throws TopiaException { - // No! - } - - protected void assertNbEntities(TopiaContext tx, EnumMap<ObserveEntityEnum, Long> counts, String tripLonglineId) throws TopiaException { - - for (ObserveEntityEnum dataEntity : Entities.DATA_ENTITIES) { - - long expected = counts.get(dataEntity); - - TopiaDAO<?> dao = ((TopiaContextImplementor) tx).getDAO(dataEntity.getContract()); - long actual = dao.count(); - - - Assert.assertEquals("For entity: " + dataEntity, expected, actual); - } - - TripLongline tripLongline = (TripLongline) tx.findByTopiaId(tripLonglineId); - Assert.assertNotNull(tripLongline); - Assert.assertFalse(tripLongline.isActivityLonglineEmpty()); - Assert.assertEquals(1, tripLongline.sizeActivityLongline()); - - ActivityLongline activityLongline = tripLongline.getActivityLongline().get(0); - Assert.assertNotNull(activityLongline); - - Assert.assertFalse(activityLongline.isEncounterEmpty()); - Assert.assertEquals(2, activityLongline.sizeEncounter()); - - Assert.assertFalse(activityLongline.isSensorUsedEmpty()); - Assert.assertEquals(2, activityLongline.sizeSensorUsed()); - - SetLongline setLongline = activityLongline.getSetLongline(); - Assert.assertNotNull(setLongline); - - Assert.assertFalse(setLongline.isCatchLonglineEmpty()); - Assert.assertEquals(2, setLongline.sizeCatchLongline()); - - Assert.assertFalse(setLongline.isTdrEmpty()); - Assert.assertEquals(2, setLongline.sizeTdr()); - - } -} diff --git a/observe-business/src/test/java/fr/ird/observe/its/replication/H2ReplicateDataTest.java b/observe-business/src/test/java/fr/ird/observe/its/replication/H2ReplicateDataTest.java new file mode 100644 index 0000000..ec67b2c --- /dev/null +++ b/observe-business/src/test/java/fr/ird/observe/its/replication/H2ReplicateDataTest.java @@ -0,0 +1,348 @@ +package fr.ird.observe.its.replication; + +import com.google.common.collect.Maps; +import fr.ird.observe.ObserveEntityEnum; +import fr.ird.observe.db.DBTestHelper; +import fr.ird.observe.db.DataSource; +import fr.ird.observe.db.DataSourceException; +import fr.ird.observe.entities.Entities; +import fr.ird.observe.entities.longline.ActivityLongline; +import fr.ird.observe.entities.longline.SetLongline; +import fr.ird.observe.entities.longline.TripLongline; +import fr.ird.observe.entities.seine.ActivitySeine; +import fr.ird.observe.entities.seine.FloatingObject; +import fr.ird.observe.entities.seine.NonTargetSample; +import fr.ird.observe.entities.seine.Route; +import fr.ird.observe.entities.seine.SetSeine; +import fr.ird.observe.entities.seine.TargetSample; +import fr.ird.observe.entities.seine.TripSeine; +import fr.ird.observe.test.TestHelper; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; +import org.nuiton.topia.TopiaContext; +import org.nuiton.topia.TopiaException; +import org.nuiton.topia.framework.TopiaContextImplementor; +import org.nuiton.topia.persistence.TopiaDAO; + +import java.io.File; +import java.io.IOException; +import java.util.EnumMap; + +/** + * Created on 4/23/15. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 4.0-RC4 + */ +public class H2ReplicateDataTest { + + /** Logger. */ + private static final Log log = LogFactory.getLog(H2ReplicateDataTest.class); + + static DataSource sourceDatasource; + + static File testDir; + + public static final String TRIP_SEINE_ID = "fr.ird.observe.entities.seine.TripSeine#1429782251612#0.864032703758805"; + + public static final String TRIP_LONGLINE_ID = "fr.ird.observe.entities.longline.TripLongline#1428427025277#0.8587988145746449"; + + @BeforeClass + public static void init() throws Exception { + + DBTestHelper.initDbForTest(H2ReplicateDataTest.class, false, false); + + File sourceDbDump = new File("src/test/resources/db/replication/data.sql.gz"); + + testDir = TestHelper.getTestDir(H2ReplicateDataTest.class); + File dir = new File(testDir, "source"); + + sourceDatasource = DBTestHelper.createAndOpenFromDump(dir, sourceDbDump.toURI().toURL(), false, false, false, true, true); + + EnumMap<ObserveEntityEnum, Long> globalCount = createEmptyCounts(); + + addSeineCounts(globalCount); + addLonglineCounts(globalCount); + + assertNbEntitiesForSeine(sourceDatasource.getRootCtxt(), globalCount, TRIP_SEINE_ID); + assertNbEntitiesForLongline(sourceDatasource.getRootCtxt(), globalCount, TRIP_LONGLINE_ID); + + } + + @AfterClass + public static void close() throws Exception { + + sourceDatasource.doClose(false); + + } + + @Test + public void replicateSeineTrip() throws IOException, DataSourceException, TopiaException { + + File dir = new File(testDir, "replicateSeineTrip"); + + DataSource targetDataSource = DBTestHelper.createAndOpenEmptyDb(dir, false); + + try { + + sourceDatasource.getReplicationService().replicateReferentiel(sourceDatasource, targetDataSource); + sourceDatasource.getReplicationService().replicateData(sourceDatasource, targetDataSource, TRIP_SEINE_ID); + + EnumMap<ObserveEntityEnum, Long> replicateCounts = createEmptyCounts(); + addSeineCounts(replicateCounts); + + assertNbEntitiesForSeine(targetDataSource.getRootCtxt(), replicateCounts, TRIP_SEINE_ID); + + } finally { + + targetDataSource.doClose(false); + + } + + } + + @Test + public void replicateLonglineTrip() throws IOException, DataSourceException, TopiaException { + + File dir = new File(testDir, "replicateLonglineTrip"); + + DataSource targetDataSource = DBTestHelper.createAndOpenEmptyDb(dir, false); + + try { + + sourceDatasource.getReplicationService().replicateReferentiel(sourceDatasource, targetDataSource); + sourceDatasource.getReplicationService().replicateData(sourceDatasource, targetDataSource, TRIP_LONGLINE_ID); + + EnumMap<ObserveEntityEnum, Long> replicateCounts = createEmptyCounts(); + addLonglineCounts(replicateCounts); + + assertNbEntitiesForLongline(targetDataSource.getRootCtxt(), replicateCounts, TRIP_LONGLINE_ID); + + } finally { + + targetDataSource.doClose(false); + } + + } + + protected static EnumMap<ObserveEntityEnum, Long> createEmptyCounts() { + + EnumMap<ObserveEntityEnum, Long> result = Maps.newEnumMap(ObserveEntityEnum.class); + for (ObserveEntityEnum dataEntity : Entities.DATA_ENTITIES) { + result.put(dataEntity, 0l); + } + return result; + + } + + protected static void addSeineCounts(EnumMap<ObserveEntityEnum, Long> replicateCounts) { + + replicateCounts.put(ObserveEntityEnum.TargetSample, 2l); + replicateCounts.put(ObserveEntityEnum.TargetLength, 4l); + replicateCounts.put(ObserveEntityEnum.NonTargetSample, 1l); + replicateCounts.put(ObserveEntityEnum.NonTargetLength, 2l); + replicateCounts.put(ObserveEntityEnum.NonTargetCatch, 2l); + replicateCounts.put(ObserveEntityEnum.SetSeine, 1l); + replicateCounts.put(ObserveEntityEnum.TargetCatch, 4l); + replicateCounts.put(ObserveEntityEnum.TransmittingBuoy, 2l); + replicateCounts.put(ObserveEntityEnum.ObjectObservedSpecies, 5l); + replicateCounts.put(ObserveEntityEnum.SchoolEstimate, 2l); + replicateCounts.put(ObserveEntityEnum.ObjectSchoolEstimate, 4l); + replicateCounts.put(ObserveEntityEnum.FloatingObject, 2l); + replicateCounts.put(ObserveEntityEnum.ActivitySeine, 2l); + replicateCounts.put(ObserveEntityEnum.Route, 2l); + replicateCounts.put(ObserveEntityEnum.GearUseFeaturesMeasurementSeine, 8l); + replicateCounts.put(ObserveEntityEnum.GearUseFeaturesSeine, 1l); + replicateCounts.put(ObserveEntityEnum.TripSeine, 1l); + + } + + protected static void addLonglineCounts(EnumMap<ObserveEntityEnum, Long> replicateCounts) { + + replicateCounts.put(ObserveEntityEnum.HooksComposition, 2l); + replicateCounts.put(ObserveEntityEnum.BranchlinesComposition, 2l); + replicateCounts.put(ObserveEntityEnum.BaitsComposition, 2l); + replicateCounts.put(ObserveEntityEnum.FloatlinesComposition, 2l); + replicateCounts.put(ObserveEntityEnum.SizeMeasure, 2l); + replicateCounts.put(ObserveEntityEnum.WeightMeasure, 2l); + replicateCounts.put(ObserveEntityEnum.SetLongline, 1l); + replicateCounts.put(ObserveEntityEnum.Branchline, 2l); + replicateCounts.put(ObserveEntityEnum.Basket, 1l); + replicateCounts.put(ObserveEntityEnum.Section, 1l); + replicateCounts.put(ObserveEntityEnum.CatchLongline, 2l); + replicateCounts.put(ObserveEntityEnum.Tdr, 2l); + replicateCounts.put(ObserveEntityEnum.Encounter, 2l); + replicateCounts.put(ObserveEntityEnum.SensorUsed, 2l); + replicateCounts.put(ObserveEntityEnum.ActivityLongline, 1l); + replicateCounts.put(ObserveEntityEnum.TdrRecord, 0l); + replicateCounts.put(ObserveEntityEnum.GearUseFeaturesLongline, 1l); + replicateCounts.put(ObserveEntityEnum.GearUseFeaturesMeasurementLongline, 2l); + replicateCounts.put(ObserveEntityEnum.TripLongline, 1l); + + } + + protected static void assertNbEntitiesForSeine(TopiaContext rootTx, EnumMap<ObserveEntityEnum, Long> counts, String tripId) throws TopiaException { + + TopiaContext tx = rootTx.beginTransaction(); + + try { + + assertNbEntities((TopiaContextImplementor) tx, counts); + + TripSeine tripSeine = (TripSeine) tx.findByTopiaId(tripId); + Assert.assertNotNull(tripSeine); + + Assert.assertFalse(tripSeine.isGearUseFeaturesSeineEmpty()); + Assert.assertEquals(1, tripSeine.sizeGearUseFeaturesSeine()); + + Assert.assertFalse(tripSeine.isRouteEmpty()); + Assert.assertEquals(2, tripSeine.sizeRoute()); + + Route route = tripSeine.getRoute().get(0); + Assert.assertNotNull(route); + + Assert.assertFalse(route.isActivitySeineEmpty()); + Assert.assertEquals(2, route.sizeActivitySeine()); + + { + ActivitySeine activitySeine = route.getActivitySeine().get(0); + Assert.assertNotNull(activitySeine); + Assert.assertNull(activitySeine.getSetSeine()); + Assert.assertFalse(activitySeine.isFloatingObjectEmpty()); + Assert.assertEquals(2, activitySeine.sizeFloatingObject()); + + { + FloatingObject floatingObject = activitySeine.getFloatingObject().get(0); + Assert.assertNotNull(floatingObject); + + Assert.assertFalse(floatingObject.isObjectObservedSpeciesEmpty()); + Assert.assertEquals(2, floatingObject.sizeObjectObservedSpecies()); + + Assert.assertFalse(floatingObject.isObjectSchoolEstimateEmpty()); + Assert.assertEquals(2, floatingObject.sizeObjectSchoolEstimate()); + + Assert.assertFalse(floatingObject.isTransmittingBuoyEmpty()); + Assert.assertEquals(1, floatingObject.sizeTransmittingBuoy()); + } + + { + FloatingObject floatingObject = activitySeine.getFloatingObject().get(1); + Assert.assertNotNull(floatingObject); + + Assert.assertFalse(floatingObject.isObjectObservedSpeciesEmpty()); + Assert.assertEquals(3, floatingObject.sizeObjectObservedSpecies()); + + Assert.assertFalse(floatingObject.isObjectSchoolEstimateEmpty()); + Assert.assertEquals(2, floatingObject.sizeObjectSchoolEstimate()); + + Assert.assertFalse(floatingObject.isTransmittingBuoyEmpty()); + Assert.assertEquals(1, floatingObject.sizeTransmittingBuoy()); + } + + } + + { + + ActivitySeine activitySeine = route.getActivitySeine().get(1); + Assert.assertNotNull(activitySeine); + Assert.assertTrue(activitySeine.isFloatingObjectEmpty()); + Assert.assertNotNull(activitySeine.getSetSeine()); + + SetSeine setSeine = activitySeine.getSetSeine(); + + Assert.assertFalse(setSeine.isNonTargetCatchEmpty()); + Assert.assertEquals(2, setSeine.sizeNonTargetCatch()); + + Assert.assertFalse(setSeine.isNonTargetSampleEmpty()); + Assert.assertEquals(1, setSeine.sizeNonTargetSample()); + + NonTargetSample nonTargetSample = setSeine.getNonTargetSample().get(0); + Assert.assertNotNull(nonTargetSample); + Assert.assertFalse(nonTargetSample.isNonTargetLengthEmpty()); + Assert.assertEquals(2, nonTargetSample.sizeNonTargetLength()); + + Assert.assertFalse(setSeine.isSchoolEstimateEmpty()); + Assert.assertEquals(2, setSeine.sizeSchoolEstimate()); + + Assert.assertFalse(setSeine.isTargetCatchEmpty()); + Assert.assertEquals(4, setSeine.sizeTargetCatch()); + + Assert.assertFalse(setSeine.isTargetSampleEmpty()); + Assert.assertEquals(2, setSeine.sizeTargetSample()); + + TargetSample targetSample = setSeine.getTargetSample().get(0); + Assert.assertNotNull(targetSample); + Assert.assertFalse(targetSample.isTargetLengthEmpty()); + Assert.assertEquals(2, targetSample.sizeTargetLength()); + + } + + + } finally { + tx.closeContext(); + } + + } + + protected static void assertNbEntitiesForLongline(TopiaContext rootTx, EnumMap<ObserveEntityEnum, Long> counts, String tripId) throws TopiaException { + + TopiaContext tx = rootTx.beginTransaction(); + + try { + + assertNbEntities((TopiaContextImplementor) tx, counts); + + TripLongline tripLongline = (TripLongline) tx.findByTopiaId(tripId); + Assert.assertNotNull(tripLongline); + + Assert.assertFalse(tripLongline.isGearUseFeaturesLonglineEmpty()); + Assert.assertEquals(1, tripLongline.sizeGearUseFeaturesLongline()); + + Assert.assertFalse(tripLongline.isActivityLonglineEmpty()); + Assert.assertEquals(1, tripLongline.sizeActivityLongline()); + + ActivityLongline activityLongline = tripLongline.getActivityLongline().get(0); + Assert.assertNotNull(activityLongline); + + Assert.assertFalse(activityLongline.isEncounterEmpty()); + Assert.assertEquals(2, activityLongline.sizeEncounter()); + + Assert.assertFalse(activityLongline.isSensorUsedEmpty()); + Assert.assertEquals(2, activityLongline.sizeSensorUsed()); + + SetLongline setLongline = activityLongline.getSetLongline(); + Assert.assertNotNull(setLongline); + + Assert.assertFalse(setLongline.isCatchLonglineEmpty()); + Assert.assertEquals(2, setLongline.sizeCatchLongline()); + + Assert.assertFalse(setLongline.isTdrEmpty()); + Assert.assertEquals(2, setLongline.sizeTdr()); + + } finally { + tx.closeContext(); + } + + } + + + protected static void assertNbEntities(TopiaContextImplementor tx, EnumMap<ObserveEntityEnum, Long> counts) throws TopiaException { + + for (ObserveEntityEnum dataEntity : Entities.DATA_ENTITIES) { + + TopiaDAO<?> dao = tx.getDAO(dataEntity.getContract()); + long actual = dao.count(); + long expected = counts.get(dataEntity); +// if (log.isInfoEnabled()) { +// log.info("For entity: " + dataEntity + ", expected: " + expected + ", but was: " + actual); +// } + Assert.assertEquals("For entity: " + dataEntity + ", expected: " + expected + ", but was: " + actual, expected, actual); + + } + + } +} diff --git a/observe-business/src/test/resources/db/3.16/ANO-6611.sql.gz b/observe-business/src/test/resources/db/replication/data.sql.gz similarity index 56% rename from observe-business/src/test/resources/db/3.16/ANO-6611.sql.gz rename to observe-business/src/test/resources/db/replication/data.sql.gz index ccb6d1f..ccb9b76 100644 Binary files a/observe-business/src/test/resources/db/3.16/ANO-6611.sql.gz and b/observe-business/src/test/resources/db/replication/data.sql.gz differ -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.