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
00060
00061
00062
00063
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
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
00086 PropertiesManager.getManager().addProperty("fastobjectdb.database.path", System.getProperty("user.dir") + "/database");
00087 PropertiesManager.getManager().addProperty("fastobjectdb.database.name", "testdb");
00088
00089
00090
00091 Credential cred = new Credential("test", "test");
00092 UserManager.getManager().registerUserManagerFactoryForGroup("defgroup", new MockUserManagerFactory("defgroup", "defname", cred));
00093
00094
00095 SessionContext context = SessionContextManager.getManager().createSessionContext("testsession");
00096 SessionContextManager.getManager().joinSessionContext("testsession");
00097 context.setUserGroup("defgroup");
00098 context.setUserId("defname");
00099
00100
00101 PropertiesManager.getManager().addProperty("org.openmobileis.synchro.direct.installpath", synchroInstallPath);
00102 SyncNumberManager.getManager().registerDelegate(new EmptySyncNumberManagerDelegate());
00103 }
00104
00105
00106
00107
00108 protected void setUp() throws Exception {
00109 super.setUp();
00110
00111
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
00138 try {
00139 FastObjectDB db = SynchroFastObjectDBManager.getCurrentFODB();
00140
00141
00142
00143 if (!db.isCollectionExist("dummy")) {
00144
00145
00146
00147
00148 FODBCollectionDescriptor coldes = new FODBCollectionDescriptor("dummy", DummyObject.class);
00149 db.createCollection(coldes);
00150
00151 FODBStringIndexDescriptor IDDescriptor = new FODBStringIndexDescriptor("ID", FODBIndexDescriptor.UNIQUE, "id", 12, 26);
00152 IDDescriptor.setCaseSensitive(true);
00153 db.addIndex("dummy", IDDescriptor);
00154 }
00155
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
00165
00166
00167 protected void tearDown() throws Exception {
00168 super.tearDown();
00169 }
00170
00171 public void testDoSynchro() {
00172
00173
00174 SynchroDescriptor descriptor = new SynchroDescriptor();
00175 descriptor.setSynchroConduit(new HttpOpenMSPSynchroConduit(synchroInstallPath, ""));
00176 SimpleMockSynchroManager synchromock = new SimpleMockSynchroManager(synchroInstallPath);
00177
00178
00179 OpenMSPSyncListener source = OpenMSPSynchroManager.getManager().getListenerByName("dummy");
00180 TestDummyFODBSyncTarget target = new TestDummyFODBSyncTarget();
00181
00182
00183 synchromock.registerTerminalSynchroListener(source);
00184 synchromock.registerServerSynchroTarget(new FODBOpenMSPSynchroTargetWrapper(target));
00185 Credential cred = new Credential("test", "test");
00186 try {
00187
00188 synchromock.synchronize("defgroup", cred, descriptor);
00189
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);
00202 returnListener.notifySynchroBeginCall = false;
00203 target.connectCall = false;
00204
00205
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
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
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
00234 Assert.assertEquals("first", returnListener.notifyFODBObjectSynchroDoneId);
00235 Assert.assertTrue(obj.equals(target.updateCollectionObject));
00236
00237
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
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
00262 Assert.assertTrue(obj2.equals(target.updateCollectionObject));
00263 Assert.assertEquals("second", returnListener.notifyFODBObjectSynchroDoneId);
00264
00265
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
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
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
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
00312 target.updateCollectionObject = null;
00313 returnListener.notifyFODBObjectSynchroDoneId = null;
00314 returnListener.testMetadata = "test metadata";
00315 target.currentAO = new DefaultSynchroAtomicObject("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
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
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
00348 target.updateCollectionObject = null;
00349 returnListener.notifyFODBObjectSynchroDoneId = null;
00350 returnListener.testMetadata = "test metadata";
00351 target.currentAO = new DefaultSynchroAtomicObject("first", "");
00352 target.updateMaxNbRow = 0;
00353 obj2 = new DummyObject("sync_comp");
00354 obj2.value = "second object";
00355 FastObjectDBManager.getCurrentFODB().add("dummy", obj2);
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);
00362 Assert.assertTrue(target.updateSynchroDBCall);
00363 Assert.assertFalse(returnListener.notifyBeginDBUpdateCall);
00364
00365
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
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 }