TestFODBSynchro.java

00001 
00025 package org.openmobileis.test.database;
00026 
00027 import java.io.File;
00028 
00029 import org.odbms.ObjectSet;
00030 import org.odbms.Query;
00031 import org.openmobileis.common.context.SessionContext;
00032 import org.openmobileis.common.context.SessionContextManager;
00033 import org.openmobileis.common.user.UserManager;
00034 import org.openmobileis.common.util.PropertiesManager;
00035 import org.openmobileis.common.util.log.LogManager;
00036 import org.openmobileis.database.fastobjectdb.FODBCollectionDescriptor;
00037 import org.openmobileis.database.fastobjectdb.FODBIndexDescriptor;
00038 import org.openmobileis.database.fastobjectdb.FODBStringIndexDescriptor;
00039 import org.openmobileis.database.fastobjectdb.FastObjectDB;
00040 import org.openmobileis.database.fastobjectdb.FastObjectDBManager;
00041 import org.openmobileis.database.fastobjectdb.synchro.client.SynchroFastObjectDB;
00042 import org.openmobileis.database.fastobjectdb.synchro.client.SynchroFastObjectDBManager;
00043 import org.openmobileis.database.fastobjectdb.synchro.server.FODBOpenMSPSynchroTargetWrapper;
00044 import org.openmobileis.synchro.algo.replication.utils.DefaultSynchroAtomicObject;
00045 import org.openmobileis.synchro.algo.syncnumber.SyncNumberManager;
00046 import org.openmobileis.synchro.algo.syncnumber.impl.EmptySyncNumberManagerDelegate;
00047 import org.openmobileis.synchro.client.SynchroDescriptor;
00048 import org.openmobileis.synchro.openmsp.client.OpenMSPSyncListener;
00049 import org.openmobileis.synchro.openmsp.client.OpenMSPSynchroManager;
00050 import org.openmobileis.synchro.openmsp.client.conduit.HttpOpenMSPSynchroConduit;
00051 import org.openmobileis.synchro.security.auth.Credential;
00052 import org.openmobileis.test.mock.common.MockUserManagerFactory;
00053 import org.openmobileis.test.mock.synchro.SimpleMockSynchroManager;
00054 
00055 import junit.framework.Assert;
00056 import junit.framework.TestCase;
00057 
00058 /*
00059  * Title:        OpenMobileIS project source <BR>
00060  * Description:
00061  * @author      Philippe Delrieu
00062  * @since       JDK 1.1
00063  * @version 1.0.
00064  */
00065 
00066 public class TestFODBSynchro extends TestCase {
00067 
00068   private TestSynchroFODBReturnListener returnListener;
00069   private String synchroInstallPath;
00070 
00074   public TestFODBSynchro(String name) {
00075     super(name);
00076 
00077     returnListener = new TestSynchroFODBReturnListener();
00078     synchroInstallPath = System.getProperty("user.dir") + "/synchro";
00079 
00080     //setup application context
00081     LogManager.registerLogManager(null);
00082 
00083     PropertiesManager.getManager().addProperty("org.openmobileis.synchro.client.openmsp.numsyncpropsfile", System.getProperty("user.dir") + "/WEB-INF/conf/numsync.txt");
00084 
00085     //init db properties.
00086     PropertiesManager.getManager().addProperty("fastobjectdb.database.path", System.getProperty("user.dir") + "/database");
00087     PropertiesManager.getManager().addProperty("fastobjectdb.database.name", "testdb");
00088 
00089 
00090     //init context data
00091     Credential cred = new Credential("test", "test");
00092     UserManager.getManager().registerUserManagerFactoryForGroup("defgroup", new MockUserManagerFactory("defgroup", "defname", cred));
00093 
00094     //manage session
00095     SessionContext context = SessionContextManager.getManager().createSessionContext("testsession");
00096     SessionContextManager.getManager().joinSessionContext("testsession");
00097     context.setUserGroup("defgroup");
00098     context.setUserId("defname");
00099 
00100     //init synchro
00101     PropertiesManager.getManager().addProperty("org.openmobileis.synchro.direct.installpath", synchroInstallPath);
00102     SyncNumberManager.getManager().registerDelegate(new EmptySyncNumberManagerDelegate());
00103 }
00104 
00105   /* (non-Javadoc)
00106    * @see junit.framework.TestCase#setUp()
00107    */
00108   protected void setUp() throws Exception {
00109     super.setUp();
00110     //remove all previously created files
00111     //db files
00112     String path = System.getProperty("user.dir") + "/database/testdb/dummy.col";
00113     File file = new File(path);
00114     file.delete();
00115     path = System.getProperty("user.dir") + "/database/testdb/FWKACTIONDB.col";
00116     file = new File(path);
00117     file.delete();
00118     path = System.getProperty("user.dir") + "/database/testdb/OMJournalEntry.col";
00119     file = new File(path);
00120     file.delete();
00121     path = System.getProperty("user.dir") + "/database/testdb/testdb.db";
00122     file = new File(path);
00123     file.delete();
00124 
00125     path = System.getProperty("user.dir") + "/WEB-INF/conf/numsync.txt";
00126     file = new File(path);
00127     file.delete();
00128 
00129     path = System.getProperty("user.dir") + "/WEB-INF/conf/misc.properties";
00130     file = new File(path);
00131     file.delete();
00132 
00133     path = System.getProperty("user.dir") + "/synchro/importdb/dummy";
00134     file = new File(path);
00135     file.delete();
00136 
00137     //create collection
00138     try {
00139         FastObjectDBManager.registerManager(new SynchroFastObjectDBManager());
00140       FastObjectDB db = FastObjectDBManager.getManager().getCurrentFODB();
00141       // test if the collection has already been created.
00142       //if not create it. Created collection are automatiquely
00143       // loaded when FODB is initialized.
00144       if (!db.isCollectionExist("dummy")) {
00145         //SimpleOpenMISInit intialize the synchronized version of FODB.
00146         // all created collection are synchronized by default.
00147         // Synchro listener are automatiquely registered when the collection is created or loaded.
00148         // use the FODBCollectionDescriptor to define a collection that is not synchronized.
00149         FODBCollectionDescriptor coldes = new FODBCollectionDescriptor("dummy", DummyObject.class);
00150         db.createCollection(coldes);
00151         //add index to query the collection by id
00152         FODBStringIndexDescriptor IDDescriptor = new FODBStringIndexDescriptor("ID", FODBIndexDescriptor.UNIQUE, "id", 12, 26);
00153         IDDescriptor.setCaseSensitive(true); //id is case sensitive.
00154         db.addIndex("dummy", IDDescriptor);
00155       }
00156       // always register notification listener because it's not persistent.
00157       ((SynchroFastObjectDB) db).registerSynchroFODBReturnListener("dummy", returnListener);
00158 
00159     } catch (Exception ex) {
00160       LogManager.traceError(0, ex);
00161       Assert.fail("Exception occurs during setUp :" + ex.getMessage());
00162     }
00163   }
00164 
00165   /* (non-Javadoc)
00166    * @see junit.framework.TestCase#tearDown()
00167    */
00168   protected void tearDown() throws Exception {
00169     super.tearDown();
00170   }
00171 
00172   public void testDoSynchro()    {
00173 
00174     //init synchro
00175     SynchroDescriptor descriptor = new SynchroDescriptor();
00176     descriptor.setSynchroConduit(new HttpOpenMSPSynchroConduit(synchroInstallPath, ""));
00177     SimpleMockSynchroManager synchromock = new SimpleMockSynchroManager(synchroInstallPath);
00178 
00179     //get synchro terminal listener
00180     OpenMSPSyncListener source = OpenMSPSynchroManager.getManager().getListenerByName("dummy");
00181     TestDummyFODBSyncTarget target = new TestDummyFODBSyncTarget();
00182 
00183     //do the synchro
00184     synchromock.registerTerminalSynchroListener(source);
00185     synchromock.registerServerSynchroTarget(new FODBOpenMSPSynchroTargetWrapper(target));
00186     Credential cred = new Credential("test", "test");
00187     try {
00188       // do a empty synchro No meta data, do data on both side
00189       synchromock.synchronize("defgroup", cred, descriptor);
00190       //validate that the synchro goes everywhere
00191       Assert.assertTrue(returnListener.notifySynchroBeginCall);
00192       Assert.assertTrue(returnListener.notifySynchroEndCall);
00193       Assert.assertNull(returnListener.testMetadata);
00194       Assert.assertNull(returnListener.notifyFODBObjectSynchroDoneId);
00195       Assert.assertNull(returnListener.notifyDBDeleteId);
00196       Assert.assertFalse(returnListener.notifyBeginDBUpdateCall);
00197       Assert.assertNull(target.synchroMetaData);
00198       Assert.assertNull(target.updateCollectionObject);
00199       Assert.assertNull(target.deleteCollectionObjectId);
00200       Assert.assertTrue(target.connectCall);
00201       Assert.assertTrue(target.disconnectCall);
00202       Assert.assertFalse(target.updateSynchroDBCall); //call only for complete.
00203       returnListener.notifySynchroBeginCall = false;
00204       target.connectCall = false;
00205 
00206       // do a meta data synchro. no collection object
00207       returnListener.testMetadata = "test metadata";
00208       synchromock.synchronize("defgroup", cred, descriptor);
00209       Assert.assertEquals("test metadata", target.synchroMetaData);
00210       Assert.assertEquals("test metadata", returnListener.testMetadata);
00211 
00212       //validate that the synchro goes everywhere
00213       Assert.assertTrue(returnListener.notifySynchroBeginCall);
00214       Assert.assertTrue(returnListener.notifySynchroEndCall);
00215       Assert.assertNull(returnListener.notifyFODBObjectSynchroDoneId);
00216       Assert.assertNull(returnListener.notifyDBDeleteId);
00217       Assert.assertFalse(returnListener.notifyBeginDBUpdateCall);
00218       Assert.assertNull(target.updateCollectionObject);
00219       Assert.assertNull(target.deleteCollectionObjectId);
00220       Assert.assertTrue(target.connectCall);
00221       Assert.assertTrue(target.disconnectCall);
00222       Assert.assertFalse(target.updateSynchroDBCall);
00223       returnListener.notifySynchroBeginCall = false;
00224       target.connectCall = false;
00225 
00226       //synchro one update to server.
00227       returnListener.testMetadata = null;
00228 
00229       DummyObject obj = new DummyObject("first");
00230       obj.value = "first object";
00231       FastObjectDBManager.getManager().getCurrentFODB().add("dummy", obj);
00232       synchromock.synchronize("defgroup", cred, descriptor);
00233 
00234       //validate the object has been synchronized
00235       Assert.assertEquals("first", returnListener.notifyFODBObjectSynchroDoneId);
00236       Assert.assertTrue(obj.equals(target.updateCollectionObject));
00237 
00238       //validate that the synchro goes everywhere
00239       Assert.assertTrue(returnListener.notifySynchroBeginCall);
00240       Assert.assertTrue(returnListener.notifySynchroEndCall);
00241       Assert.assertNull(returnListener.notifyDBDeleteId);
00242       Assert.assertFalse(returnListener.notifyBeginDBUpdateCall);
00243       Assert.assertNull(returnListener.testMetadata);
00244       Assert.assertNull(target.synchroMetaData);
00245       Assert.assertNull(target.deleteCollectionObjectId);
00246       Assert.assertTrue(target.connectCall);
00247       Assert.assertTrue(target.disconnectCall);
00248       Assert.assertFalse(target.updateSynchroDBCall);
00249       returnListener.notifySynchroBeginCall = false;
00250       target.connectCall = false;
00251 
00252 
00253       //do an insert with meta data
00254       DummyObject obj2 = new DummyObject("second");
00255       obj2.value = "second object";
00256       FastObjectDBManager.getManager().getCurrentFODB().add("dummy", obj2);
00257       returnListener.testMetadata = "test metadata";
00258       synchromock.synchronize("defgroup", cred, descriptor);
00259       Assert.assertEquals("test metadata", target.synchroMetaData);
00260       Assert.assertEquals("test metadata", returnListener.testMetadata);
00261 
00262       //validate the object has been synchronized
00263       Assert.assertTrue(obj2.equals(target.updateCollectionObject));
00264       Assert.assertEquals("second", returnListener.notifyFODBObjectSynchroDoneId);
00265 
00266       //validate that the synchro goes everywhere
00267       Assert.assertTrue(returnListener.notifySynchroBeginCall);
00268       Assert.assertTrue(returnListener.notifySynchroEndCall);
00269       Assert.assertNull(returnListener.notifyDBDeleteId);
00270       Assert.assertFalse(returnListener.notifyBeginDBUpdateCall);
00271       Assert.assertNull(target.deleteCollectionObjectId);
00272       Assert.assertTrue(target.connectCall);
00273       Assert.assertTrue(target.disconnectCall);
00274       Assert.assertFalse(target.updateSynchroDBCall);
00275       returnListener.notifySynchroBeginCall = false;
00276       target.connectCall = false;
00277 
00278 
00279       //test  synchro server update CREATE.
00280       target.updateCollectionObject = null;
00281       returnListener.notifyFODBObjectSynchroDoneId = null;
00282       returnListener.testMetadata = "test metadata";
00283       target.currentAO = new DefaultSynchroAtomicObject("third", "");
00284       synchromock.synchronize("defgroup", cred, descriptor);
00285       Assert.assertEquals("test metadata", target.synchroMetaData);
00286       Assert.assertEquals("test metadata", returnListener.testMetadata);
00287 
00288       //validate the object has been synchronized
00289       Assert.assertTrue(returnListener.notifyBeginDBUpdateCall);
00290       Query q = FastObjectDBManager.getManager().getCurrentFODB().query();
00291       q.constrain(DummyObject.class);
00292       Query subq = q.descend("id");
00293       subq.constrain("third").equal();
00294       ObjectSet set = q.execute();
00295       obj = (DummyObject)set.next();
00296       Assert.assertNotNull(obj);
00297       Assert.assertEquals("getCollectionObjectWithId", obj.value);
00298 
00299       //validate that the synchro goes everywhere
00300       Assert.assertTrue(returnListener.notifySynchroBeginCall);
00301       Assert.assertTrue(returnListener.notifySynchroEndCall);
00302       Assert.assertNull(returnListener.notifyDBDeleteId);
00303       Assert.assertNull(target.deleteCollectionObjectId);
00304       Assert.assertTrue(target.connectCall);
00305       Assert.assertTrue(target.disconnectCall);
00306       Assert.assertFalse(target.updateSynchroDBCall);
00307       Assert.assertNull(target.updateCollectionObject);
00308       Assert.assertNull(returnListener.notifyFODBObjectSynchroDoneId);
00309       returnListener.notifySynchroBeginCall = false;
00310       target.connectCall = false;
00311 
00312       //test  synchro server update UPDATE and terminal update.
00313       target.updateCollectionObject = null;
00314       returnListener.notifyFODBObjectSynchroDoneId = null;
00315       returnListener.testMetadata = "test metadata";
00316       target.currentAO = new DefaultSynchroAtomicObject("first", ""); //update first.
00317 
00318       FastObjectDBManager.getManager().getCurrentFODB().replace("dummy", obj2);
00319 
00320       synchromock.synchronize("defgroup", cred, descriptor);
00321       Assert.assertEquals("test metadata", target.synchroMetaData);
00322       Assert.assertEquals("test metadata", returnListener.testMetadata);
00323       Assert.assertTrue(obj2.equals(target.updateCollectionObject));
00324       Assert.assertEquals("second", returnListener.notifyFODBObjectSynchroDoneId);
00325 
00326       //validate the object has been synchronized
00327       Assert.assertTrue(returnListener.notifyBeginDBUpdateCall);
00328       q = FastObjectDBManager.getManager().getCurrentFODB().query();
00329       q.constrain(DummyObject.class);
00330       subq = q.descend("id");
00331       subq.constrain("first").equal();
00332       set = q.execute();
00333       obj = (DummyObject)set.next();
00334       Assert.assertNotNull(obj);
00335       Assert.assertEquals("getCollectionObjectWithId", obj.value);
00336 
00337       //validate that the synchro goes everywhere
00338       Assert.assertTrue(returnListener.notifySynchroBeginCall);
00339       Assert.assertTrue(returnListener.notifySynchroEndCall);
00340       Assert.assertNull(returnListener.notifyDBDeleteId);
00341       Assert.assertNull(target.deleteCollectionObjectId);
00342       Assert.assertTrue(target.connectCall);
00343       Assert.assertTrue(target.disconnectCall);
00344       Assert.assertFalse(target.updateSynchroDBCall);
00345       returnListener.notifySynchroBeginCall = false;
00346       target.connectCall = false;
00347 
00348       //test  complete synchro.
00349       target.updateCollectionObject = null;
00350       returnListener.notifyFODBObjectSynchroDoneId = null;
00351       returnListener.testMetadata = "test metadata";
00352       target.currentAO = new DefaultSynchroAtomicObject("first", ""); //server update first server to terminal. Not done because complete forced
00353       target.updateMaxNbRow = 0; //force complete.
00354       obj2 = new DummyObject("sync_comp");
00355       obj2.value = "second object";
00356       FastObjectDBManager.getManager().getCurrentFODB().add("dummy", obj2); //ob2 synchronized terminal to server
00357 
00358       synchromock.synchronize("defgroup", cred, descriptor);
00359       Assert.assertEquals("test metadata", target.synchroMetaData);
00360       Assert.assertEquals("test metadata", returnListener.testMetadata);
00361       Assert.assertTrue(obj2.equals(target.updateCollectionObject));
00362       Assert.assertEquals(obj2.id, returnListener.notifyFODBObjectSynchroDoneId); //terminal to server done
00363       Assert.assertTrue(target.updateSynchroDBCall); //complete done
00364       Assert.assertFalse(returnListener.notifyBeginDBUpdateCall); //no update synchro complete
00365 
00366       //validate the object has been synchronized (only COMPLETE not updated obj2
00367       q = FastObjectDBManager.getManager().getCurrentFODB().query();
00368       q.constrain(DummyObject.class);
00369       subq = q.descend("id");
00370       subq.constrain("COMPLETE").equal();
00371       set = q.execute();
00372       obj = (DummyObject)set.next();
00373       Assert.assertNotNull(obj);
00374       Assert.assertEquals("complete synchro", obj.value);
00375       q = FastObjectDBManager.getManager().getCurrentFODB().query();
00376       q.constrain(DummyObject.class);
00377       subq = q.descend("id");
00378       subq.constrain(obj2.id).equal();
00379       set = q.execute();
00380       Assert.assertFalse(set.hasNext());
00381 
00382       //validate that the synchro goes everywhere
00383       Assert.assertTrue(returnListener.notifySynchroBeginCall);
00384       Assert.assertTrue(returnListener.notifySynchroEndCall);
00385       Assert.assertNull(returnListener.notifyDBDeleteId);
00386       Assert.assertNull(target.deleteCollectionObjectId);
00387       Assert.assertTrue(target.connectCall);
00388       Assert.assertTrue(target.disconnectCall);
00389       returnListener.notifySynchroBeginCall = false;
00390       target.connectCall = false;
00391 
00392     } catch (Exception ex) {
00393       LogManager.traceError(0, ex);
00394       Assert.fail("Exception occurs during doSynchro :" + ex.getMessage());
00395     }
00396 
00397   }
00398 
00399 }

Generated on Tue May 22 23:01:12 2007 for OpenMobileIS by  doxygen 1.5.1-p1