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       FastObjectDB db = SynchroFastObjectDBManager.getCurrentFODB();
00140       // test if the collection has already been created.
00141       //if not create it. Created collection are automatiquely 
00142       // loaded when FODB is initialized.
00143       if (!db.isCollectionExist("dummy")) {
00144         //SimpleOpenMISInit intialize the synchronized version of FODB.
00145         // all created collection are synchronized by default.
00146         // Synchro listener are automatiquely registered when the collection is created or loaded.
00147         // use the FODBCollectionDescriptor to define a collection that is not synchronized.
00148         FODBCollectionDescriptor coldes = new FODBCollectionDescriptor("dummy", DummyObject.class);
00149         db.createCollection(coldes);
00150         //add index to query the collection by id
00151         FODBStringIndexDescriptor IDDescriptor = new FODBStringIndexDescriptor("ID", FODBIndexDescriptor.UNIQUE, "id", 12, 26);
00152         IDDescriptor.setCaseSensitive(true); //id is case sensitive. 
00153         db.addIndex("dummy", IDDescriptor);
00154       }
00155       // always register notification listener because it's not persistent.
00156       ((SynchroFastObjectDB) db).registerSynchroFODBReturnListener("dummy", returnListener);
00157 
00158     } catch (Exception ex) {
00159       LogManager.traceError(0, ex);
00160       Assert.fail("Exception occurs during setUp :" + ex.getMessage());
00161     }
00162   }
00163 
00164   /* (non-Javadoc)
00165    * @see junit.framework.TestCase#tearDown()
00166    */
00167   protected void tearDown() throws Exception {
00168     super.tearDown();
00169   }
00170   
00171   public void testDoSynchro()    {
00172     
00173     //init synchro
00174     SynchroDescriptor descriptor = new SynchroDescriptor();
00175     descriptor.setSynchroConduit(new HttpOpenMSPSynchroConduit(synchroInstallPath, ""));
00176     SimpleMockSynchroManager synchromock = new SimpleMockSynchroManager(synchroInstallPath);
00177     
00178     //get synchro terminal listener 
00179     OpenMSPSyncListener source = OpenMSPSynchroManager.getManager().getListenerByName("dummy");
00180     TestDummyFODBSyncTarget target = new TestDummyFODBSyncTarget();
00181     
00182     //do the synchro
00183     synchromock.registerTerminalSynchroListener(source);
00184     synchromock.registerServerSynchroTarget(new FODBOpenMSPSynchroTargetWrapper(target));
00185     Credential cred = new Credential("test", "test");
00186     try {
00187       // do a empty synchro No meta data, do data on both side
00188       synchromock.synchronize("defgroup", cred, descriptor);
00189       //validate that the synchro goes everywhere
00190       Assert.assertTrue(returnListener.notifySynchroBeginCall);
00191       Assert.assertTrue(returnListener.notifySynchroEndCall);
00192       Assert.assertNull(returnListener.testMetadata);
00193       Assert.assertNull(returnListener.notifyFODBObjectSynchroDoneId);
00194       Assert.assertNull(returnListener.notifyDBDeleteId);
00195       Assert.assertFalse(returnListener.notifyBeginDBUpdateCall);
00196       Assert.assertNull(target.synchroMetaData);
00197       Assert.assertNull(target.updateCollectionObject);
00198       Assert.assertNull(target.deleteCollectionObjectId);
00199       Assert.assertTrue(target.connectCall);
00200       Assert.assertTrue(target.disconnectCall);
00201       Assert.assertFalse(target.updateSynchroDBCall); //call only for complete.
00202       returnListener.notifySynchroBeginCall = false;
00203       target.connectCall = false;
00204       
00205       // do a meta data synchro. no collection object
00206       returnListener.testMetadata = "test metadata";
00207       synchromock.synchronize("defgroup", cred, descriptor);
00208       Assert.assertEquals("test metadata", target.synchroMetaData);
00209       Assert.assertEquals("test metadata", returnListener.testMetadata);
00210       
00211       //validate that the synchro goes everywhere
00212       Assert.assertTrue(returnListener.notifySynchroBeginCall);
00213       Assert.assertTrue(returnListener.notifySynchroEndCall);
00214       Assert.assertNull(returnListener.notifyFODBObjectSynchroDoneId);
00215       Assert.assertNull(returnListener.notifyDBDeleteId);
00216       Assert.assertFalse(returnListener.notifyBeginDBUpdateCall);
00217       Assert.assertNull(target.updateCollectionObject);
00218       Assert.assertNull(target.deleteCollectionObjectId);
00219       Assert.assertTrue(target.connectCall);
00220       Assert.assertTrue(target.disconnectCall);
00221       Assert.assertFalse(target.updateSynchroDBCall);
00222       returnListener.notifySynchroBeginCall = false;
00223       target.connectCall = false;
00224       
00225       //synchro one update to server.
00226       returnListener.testMetadata = null;
00227       
00228       DummyObject obj = new DummyObject("first");
00229       obj.value = "first object";
00230       FastObjectDBManager.getCurrentFODB().add("dummy", obj);
00231       synchromock.synchronize("defgroup", cred, descriptor);
00232       
00233       //validate the object has been synchronized
00234       Assert.assertEquals("first", returnListener.notifyFODBObjectSynchroDoneId);
00235       Assert.assertTrue(obj.equals(target.updateCollectionObject));
00236       
00237       //validate that the synchro goes everywhere
00238       Assert.assertTrue(returnListener.notifySynchroBeginCall);
00239       Assert.assertTrue(returnListener.notifySynchroEndCall);
00240       Assert.assertNull(returnListener.notifyDBDeleteId);
00241       Assert.assertFalse(returnListener.notifyBeginDBUpdateCall);
00242       Assert.assertNull(returnListener.testMetadata);
00243       Assert.assertNull(target.synchroMetaData);
00244       Assert.assertNull(target.deleteCollectionObjectId);
00245       Assert.assertTrue(target.connectCall);
00246       Assert.assertTrue(target.disconnectCall);
00247       Assert.assertFalse(target.updateSynchroDBCall);
00248       returnListener.notifySynchroBeginCall = false;
00249       target.connectCall = false;
00250       
00251       
00252       //do an insert with meta data
00253       DummyObject obj2 = new DummyObject("second");
00254       obj2.value = "second object";
00255       FastObjectDBManager.getCurrentFODB().add("dummy", obj2);
00256       returnListener.testMetadata = "test metadata";
00257       synchromock.synchronize("defgroup", cred, descriptor);
00258       Assert.assertEquals("test metadata", target.synchroMetaData);
00259       Assert.assertEquals("test metadata", returnListener.testMetadata);
00260       
00261       //validate the object has been synchronized
00262       Assert.assertTrue(obj2.equals(target.updateCollectionObject));
00263       Assert.assertEquals("second", returnListener.notifyFODBObjectSynchroDoneId);
00264       
00265       //validate that the synchro goes everywhere
00266       Assert.assertTrue(returnListener.notifySynchroBeginCall);
00267       Assert.assertTrue(returnListener.notifySynchroEndCall);
00268       Assert.assertNull(returnListener.notifyDBDeleteId);
00269       Assert.assertFalse(returnListener.notifyBeginDBUpdateCall);
00270       Assert.assertNull(target.deleteCollectionObjectId);
00271       Assert.assertTrue(target.connectCall);
00272       Assert.assertTrue(target.disconnectCall);
00273       Assert.assertFalse(target.updateSynchroDBCall);
00274       returnListener.notifySynchroBeginCall = false;
00275       target.connectCall = false;
00276       
00277       
00278       //test  synchro server update CREATE.
00279       target.updateCollectionObject = null;
00280       returnListener.notifyFODBObjectSynchroDoneId = null;
00281       returnListener.testMetadata = "test metadata";
00282       target.currentAO = new DefaultSynchroAtomicObject("third", "");
00283       synchromock.synchronize("defgroup", cred, descriptor);
00284       Assert.assertEquals("test metadata", target.synchroMetaData);
00285       Assert.assertEquals("test metadata", returnListener.testMetadata);
00286       
00287       //validate the object has been synchronized
00288       Assert.assertTrue(returnListener.notifyBeginDBUpdateCall);
00289       Query q = FastObjectDBManager.getCurrentFODB().query();
00290       q.constrain(DummyObject.class);
00291       Query subq = q.descend("id");
00292       subq.constrain("third").equal();
00293       ObjectSet set = q.execute();
00294       obj = (DummyObject)set.next();
00295       Assert.assertNotNull(obj);
00296       Assert.assertEquals("getCollectionObjectWithId", obj.value);
00297       
00298       //validate that the synchro goes everywhere
00299       Assert.assertTrue(returnListener.notifySynchroBeginCall);
00300       Assert.assertTrue(returnListener.notifySynchroEndCall);
00301       Assert.assertNull(returnListener.notifyDBDeleteId);
00302       Assert.assertNull(target.deleteCollectionObjectId);
00303       Assert.assertTrue(target.connectCall);
00304       Assert.assertTrue(target.disconnectCall);
00305       Assert.assertFalse(target.updateSynchroDBCall);
00306       Assert.assertNull(target.updateCollectionObject);
00307       Assert.assertNull(returnListener.notifyFODBObjectSynchroDoneId);
00308       returnListener.notifySynchroBeginCall = false;
00309       target.connectCall = false;
00310       
00311       //test  synchro server update UPDATE and terminal update.
00312       target.updateCollectionObject = null;
00313       returnListener.notifyFODBObjectSynchroDoneId = null;
00314       returnListener.testMetadata = "test metadata";
00315       target.currentAO = new DefaultSynchroAtomicObject("first", ""); //update first.
00316       
00317       FastObjectDBManager.getCurrentFODB().replace("dummy", obj2);
00318       
00319       synchromock.synchronize("defgroup", cred, descriptor);
00320       Assert.assertEquals("test metadata", target.synchroMetaData);
00321       Assert.assertEquals("test metadata", returnListener.testMetadata);
00322       Assert.assertTrue(obj2.equals(target.updateCollectionObject));
00323       Assert.assertEquals("second", returnListener.notifyFODBObjectSynchroDoneId);
00324       
00325       //validate the object has been synchronized
00326       Assert.assertTrue(returnListener.notifyBeginDBUpdateCall);
00327       q = FastObjectDBManager.getCurrentFODB().query();
00328       q.constrain(DummyObject.class);
00329       subq = q.descend("id");
00330       subq.constrain("first").equal();
00331       set = q.execute();
00332       obj = (DummyObject)set.next();
00333       Assert.assertNotNull(obj);
00334       Assert.assertEquals("getCollectionObjectWithId", obj.value);
00335       
00336       //validate that the synchro goes everywhere
00337       Assert.assertTrue(returnListener.notifySynchroBeginCall);
00338       Assert.assertTrue(returnListener.notifySynchroEndCall);
00339       Assert.assertNull(returnListener.notifyDBDeleteId);
00340       Assert.assertNull(target.deleteCollectionObjectId);
00341       Assert.assertTrue(target.connectCall);
00342       Assert.assertTrue(target.disconnectCall);
00343       Assert.assertFalse(target.updateSynchroDBCall);
00344       returnListener.notifySynchroBeginCall = false;
00345       target.connectCall = false;
00346  
00347       //test  complete synchro.
00348       target.updateCollectionObject = null;
00349       returnListener.notifyFODBObjectSynchroDoneId = null;
00350       returnListener.testMetadata = "test metadata";
00351       target.currentAO = new DefaultSynchroAtomicObject("first", ""); //server update first server to terminal. Not done because complete forced
00352       target.updateMaxNbRow = 0; //force complete.
00353       obj2 = new DummyObject("sync_comp");
00354       obj2.value = "second object";
00355       FastObjectDBManager.getCurrentFODB().add("dummy", obj2); //ob2 synchronized terminal to server
00356       
00357       synchromock.synchronize("defgroup", cred, descriptor);
00358       Assert.assertEquals("test metadata", target.synchroMetaData);
00359       Assert.assertEquals("test metadata", returnListener.testMetadata);
00360       Assert.assertTrue(obj2.equals(target.updateCollectionObject));
00361       Assert.assertEquals(obj2.id, returnListener.notifyFODBObjectSynchroDoneId); //terminal to server done
00362       Assert.assertTrue(target.updateSynchroDBCall); //complete done
00363       Assert.assertFalse(returnListener.notifyBeginDBUpdateCall); //no update synchro complete
00364       
00365       //validate the object has been synchronized (only COMPLETE not updated obj2
00366       q = FastObjectDBManager.getCurrentFODB().query();
00367       q.constrain(DummyObject.class);
00368       subq = q.descend("id");
00369       subq.constrain("COMPLETE").equal();
00370       set = q.execute();
00371       obj = (DummyObject)set.next();
00372       Assert.assertNotNull(obj);
00373       Assert.assertEquals("complete synchro", obj.value);
00374       q = FastObjectDBManager.getCurrentFODB().query();
00375       q.constrain(DummyObject.class);
00376       subq = q.descend("id");
00377       subq.constrain(obj2.id).equal();
00378       set = q.execute();
00379       Assert.assertFalse(set.hasNext());
00380       
00381       //validate that the synchro goes everywhere
00382       Assert.assertTrue(returnListener.notifySynchroBeginCall);
00383       Assert.assertTrue(returnListener.notifySynchroEndCall);
00384       Assert.assertNull(returnListener.notifyDBDeleteId);
00385       Assert.assertNull(target.deleteCollectionObjectId);
00386       Assert.assertTrue(target.connectCall);
00387       Assert.assertTrue(target.disconnectCall);
00388       returnListener.notifySynchroBeginCall = false;
00389       target.connectCall = false;
00390     
00391     } catch (Exception ex) {
00392       LogManager.traceError(0, ex);
00393       Assert.fail("Exception occurs during doSynchro :" + ex.getMessage());
00394     }
00395    
00396   }
00397 
00398 }

Generated on Mon Dec 4 11:03:31 2006 for OpenMobileIS by  doxygen 1.5.1-p1