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.ApacheHTTPClientSynchroConduit;
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     path = System.getProperty("user.dir") + "/WEB-INF/conf/misc.properties";
00129     file = new File(path);
00130     file.delete();
00131 
00132     path = System.getProperty("user.dir") + "/synchro/importdb/dummy";
00133     file = new File(path);
00134     file.delete();
00135 
00136     //create collection
00137     try {
00138         FastObjectDBManager.registerManager(new SynchroFastObjectDBManager());
00139         FastObjectDB db = FastObjectDBManager.getManager().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     ApacheHTTPClientSynchroConduit conduit = new ApacheHTTPClientSynchroConduit();
00176         conduit.setSynchroPath(synchroInstallPath);
00177         conduit.setSynchroUserAgent("OpenMSPPlug-WI-V[1.0]-WINCE[DR-FR-WINCE/04-02-00-00]");
00178     descriptor.setSynchroConduit(conduit);
00179     SimpleMockSynchroManager synchromock = new SimpleMockSynchroManager(synchroInstallPath);
00180 
00181     //get synchro terminal listener
00182     OpenMSPSyncListener source = OpenMSPSynchroManager.getManager().getListenerByName("dummy");
00183     TestDummyFODBSyncTarget target = new TestDummyFODBSyncTarget();
00184 
00185     //do the synchro
00186     synchromock.registerTerminalSynchroListener(source);
00187     synchromock.registerServerSynchroTarget(new FODBOpenMSPSynchroTargetWrapper(target));
00188     Credential cred = new Credential("test", "test");
00189     try {
00190       // do a empty synchro No meta data, do data on both side
00191       synchromock.synchronize("defgroup", cred, descriptor);
00192       //validate that the synchro goes everywhere
00193       Assert.assertTrue(returnListener.notifySynchroBeginCall);
00194       Assert.assertTrue(returnListener.notifySynchroEndCall);
00195       Assert.assertNull(returnListener.testMetadata);
00196       Assert.assertNull(returnListener.notifyFODBObjectSynchroDoneId);
00197       Assert.assertNull(returnListener.notifyDBDeleteId);
00198       Assert.assertFalse(returnListener.notifyBeginDBUpdateCall);
00199       Assert.assertNull(target.synchroMetaData);
00200       Assert.assertNull(target.updateCollectionObject);
00201       Assert.assertNull(target.deleteCollectionObjectId);
00202       Assert.assertTrue(target.connectCall);
00203       Assert.assertTrue(target.disconnectCall);
00204       Assert.assertFalse(target.updateSynchroDBCall); //call only for complete.
00205       returnListener.notifySynchroBeginCall = false;
00206       target.connectCall = false;
00207 
00208       // do a meta data synchro. no collection object
00209       returnListener.testMetadata = "test metadata";
00210       synchromock.synchronize("defgroup", cred, descriptor);
00211       Assert.assertEquals("test metadata", target.synchroMetaData);
00212       Assert.assertEquals("test metadata", returnListener.testMetadata);
00213 
00214       //validate that the synchro goes everywhere
00215       Assert.assertTrue(returnListener.notifySynchroBeginCall);
00216       Assert.assertTrue(returnListener.notifySynchroEndCall);
00217       Assert.assertNull(returnListener.notifyFODBObjectSynchroDoneId);
00218       Assert.assertNull(returnListener.notifyDBDeleteId);
00219       Assert.assertFalse(returnListener.notifyBeginDBUpdateCall);
00220       Assert.assertNull(target.updateCollectionObject);
00221       Assert.assertNull(target.deleteCollectionObjectId);
00222       Assert.assertTrue(target.connectCall);
00223       Assert.assertTrue(target.disconnectCall);
00224       Assert.assertFalse(target.updateSynchroDBCall);
00225       returnListener.notifySynchroBeginCall = false;
00226       target.connectCall = false;
00227 
00228       //synchro one update to server.
00229       returnListener.testMetadata = null;
00230 
00231       DummyObject obj = new DummyObject("first");
00232       obj.value = "first object";
00233       FastObjectDBManager.getManager().getCurrentFODB().add("dummy", obj);
00234       synchromock.synchronize("defgroup", cred, descriptor);
00235 
00236       //validate the object has been synchronized
00237       Assert.assertEquals("first", returnListener.notifyFODBObjectSynchroDoneId);
00238       Assert.assertTrue(obj.equals(target.updateCollectionObject));
00239 
00240       //validate that the synchro goes everywhere
00241       Assert.assertTrue(returnListener.notifySynchroBeginCall);
00242       Assert.assertTrue(returnListener.notifySynchroEndCall);
00243       Assert.assertNull(returnListener.notifyDBDeleteId);
00244       Assert.assertFalse(returnListener.notifyBeginDBUpdateCall);
00245       Assert.assertNull(returnListener.testMetadata);
00246       Assert.assertNull(target.synchroMetaData);
00247       Assert.assertNull(target.deleteCollectionObjectId);
00248       Assert.assertTrue(target.connectCall);
00249       Assert.assertTrue(target.disconnectCall);
00250       Assert.assertFalse(target.updateSynchroDBCall);
00251       returnListener.notifySynchroBeginCall = false;
00252       target.connectCall = false;
00253 
00254 
00255       //do an insert with meta data
00256       DummyObject obj2 = new DummyObject("second");
00257       obj2.value = "second object";
00258       FastObjectDBManager.getManager().getCurrentFODB().add("dummy", obj2);
00259       returnListener.testMetadata = "test metadata";
00260       synchromock.synchronize("defgroup", cred, descriptor);
00261       Assert.assertEquals("test metadata", target.synchroMetaData);
00262       Assert.assertEquals("test metadata", returnListener.testMetadata);
00263 
00264       //validate the object has been synchronized
00265       Assert.assertTrue(obj2.equals(target.updateCollectionObject));
00266       Assert.assertEquals("second", returnListener.notifyFODBObjectSynchroDoneId);
00267 
00268       //validate that the synchro goes everywhere
00269       Assert.assertTrue(returnListener.notifySynchroBeginCall);
00270       Assert.assertTrue(returnListener.notifySynchroEndCall);
00271       Assert.assertNull(returnListener.notifyDBDeleteId);
00272       Assert.assertFalse(returnListener.notifyBeginDBUpdateCall);
00273       Assert.assertNull(target.deleteCollectionObjectId);
00274       Assert.assertTrue(target.connectCall);
00275       Assert.assertTrue(target.disconnectCall);
00276       Assert.assertFalse(target.updateSynchroDBCall);
00277       returnListener.notifySynchroBeginCall = false;
00278       target.connectCall = false;
00279 
00280 
00281       //test  synchro server update CREATE.
00282       target.updateCollectionObject = null;
00283       returnListener.notifyFODBObjectSynchroDoneId = null;
00284       returnListener.testMetadata = "test metadata";
00285       target.currentAO = new DefaultSynchroAtomicObject("third", "");
00286       synchromock.synchronize("defgroup", cred, descriptor);
00287       Assert.assertEquals("test metadata", target.synchroMetaData);
00288       Assert.assertEquals("test metadata", returnListener.testMetadata);
00289 
00290       //validate the object has been synchronized
00291       Assert.assertTrue(returnListener.notifyBeginDBUpdateCall);
00292       Query q = FastObjectDBManager.getManager().getCurrentFODB().query();
00293       q.constrain(DummyObject.class);
00294       Query subq = q.descend("id");
00295       subq.constrain("third").equal();
00296       ObjectSet set = q.execute();
00297       obj = (DummyObject)set.next();
00298       Assert.assertNotNull(obj);
00299       Assert.assertEquals("getCollectionObjectWithId", obj.value);
00300 
00301       //validate that the synchro goes everywhere
00302       Assert.assertTrue(returnListener.notifySynchroBeginCall);
00303       Assert.assertTrue(returnListener.notifySynchroEndCall);
00304       Assert.assertNull(returnListener.notifyDBDeleteId);
00305       Assert.assertNull(target.deleteCollectionObjectId);
00306       Assert.assertTrue(target.connectCall);
00307       Assert.assertTrue(target.disconnectCall);
00308       Assert.assertFalse(target.updateSynchroDBCall);
00309       Assert.assertNull(target.updateCollectionObject);
00310       Assert.assertNull(returnListener.notifyFODBObjectSynchroDoneId);
00311       returnListener.notifySynchroBeginCall = false;
00312       target.connectCall = false;
00313 
00314       //test  synchro server update UPDATE and terminal update.
00315       target.updateCollectionObject = null;
00316       returnListener.notifyFODBObjectSynchroDoneId = null;
00317       returnListener.testMetadata = "test metadata";
00318       target.currentAO = new DefaultSynchroAtomicObject("first", ""); //update first.
00319 
00320       FastObjectDBManager.getManager().getCurrentFODB().replace("dummy", obj2);
00321 
00322       synchromock.synchronize("defgroup", cred, descriptor);
00323       Assert.assertEquals("test metadata", target.synchroMetaData);
00324       Assert.assertEquals("test metadata", returnListener.testMetadata);
00325       Assert.assertTrue(obj2.equals(target.updateCollectionObject));
00326       Assert.assertEquals("second", returnListener.notifyFODBObjectSynchroDoneId);
00327 
00328       //validate the object has been synchronized
00329       Assert.assertTrue(returnListener.notifyBeginDBUpdateCall);
00330       q = FastObjectDBManager.getManager().getCurrentFODB().query();
00331       q.constrain(DummyObject.class);
00332       subq = q.descend("id");
00333       subq.constrain("first").equal();
00334       set = q.execute();
00335       obj = (DummyObject)set.next();
00336       Assert.assertNotNull(obj);
00337       Assert.assertEquals("getCollectionObjectWithId", obj.value);
00338 
00339       //validate that the synchro goes everywhere
00340       Assert.assertTrue(returnListener.notifySynchroBeginCall);
00341       Assert.assertTrue(returnListener.notifySynchroEndCall);
00342       Assert.assertNull(returnListener.notifyDBDeleteId);
00343       Assert.assertNull(target.deleteCollectionObjectId);
00344       Assert.assertTrue(target.connectCall);
00345       Assert.assertTrue(target.disconnectCall);
00346       Assert.assertFalse(target.updateSynchroDBCall);
00347       returnListener.notifySynchroBeginCall = false;
00348       target.connectCall = false;
00349 
00350       //test  complete synchro.
00351       target.updateCollectionObject = null;
00352       returnListener.notifyFODBObjectSynchroDoneId = null;
00353       returnListener.testMetadata = "test metadata";
00354       target.currentAO = new DefaultSynchroAtomicObject("first", ""); //server update first server to terminal. Not done because complete forced
00355       target.updateMaxNbRow = 0; //force complete.
00356       obj2 = new DummyObject("sync_comp");
00357       obj2.value = "second object";
00358       FastObjectDBManager.getManager().getCurrentFODB().add("dummy", obj2); //ob2 synchronized terminal to server
00359 
00360       synchromock.synchronize("defgroup", cred, descriptor);
00361       Assert.assertEquals("test metadata", target.synchroMetaData);
00362       Assert.assertEquals("test metadata", returnListener.testMetadata);
00363       Assert.assertTrue(obj2.equals(target.updateCollectionObject));
00364       Assert.assertEquals(obj2.id, returnListener.notifyFODBObjectSynchroDoneId); //terminal to server done
00365       Assert.assertTrue(target.updateSynchroDBCall); //complete done
00366       Assert.assertFalse(returnListener.notifyBeginDBUpdateCall); //no update synchro complete
00367 
00368       //validate the object has been synchronized (only COMPLETE not updated obj2
00369       q = FastObjectDBManager.getManager().getCurrentFODB().query();
00370       q.constrain(DummyObject.class);
00371       subq = q.descend("id");
00372       subq.constrain("COMPLETE").equal();
00373       set = q.execute();
00374       obj = (DummyObject)set.next();
00375       Assert.assertNotNull(obj);
00376       Assert.assertEquals("complete synchro", obj.value);
00377       q = FastObjectDBManager.getManager().getCurrentFODB().query();
00378       q.constrain(DummyObject.class);
00379       subq = q.descend("id");
00380       subq.constrain(obj2.id).equal();
00381       set = q.execute();
00382       Assert.assertFalse(set.hasNext());
00383 
00384       //validate that the synchro goes everywhere
00385       Assert.assertTrue(returnListener.notifySynchroBeginCall);
00386       Assert.assertTrue(returnListener.notifySynchroEndCall);
00387       Assert.assertNull(returnListener.notifyDBDeleteId);
00388       Assert.assertNull(target.deleteCollectionObjectId);
00389       Assert.assertTrue(target.connectCall);
00390       Assert.assertTrue(target.disconnectCall);
00391       returnListener.notifySynchroBeginCall = false;
00392       target.connectCall = false;
00393 
00394     } catch (Exception ex) {
00395       LogManager.traceError(0, ex);
00396       Assert.fail("Exception occurs during doSynchro :" + ex.getMessage());
00397     }
00398 
00399   }
00400 
00401 }

Generated on Mon Jan 14 17:29:50 2008 for OpenMobileIS by  doxygen 1.5.4