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 FastObjectDBManager.registerManager(new SynchroFastObjectDBManager());
00140 FastObjectDB db = FastObjectDBManager.getManager().getCurrentFODB();
00141
00142
00143
00144 if (!db.isCollectionExist("dummy")) {
00145
00146
00147
00148
00149 FODBCollectionDescriptor coldes = new FODBCollectionDescriptor("dummy", DummyObject.class);
00150 db.createCollection(coldes);
00151
00152 FODBStringIndexDescriptor IDDescriptor = new FODBStringIndexDescriptor("ID", FODBIndexDescriptor.UNIQUE, "id", 12, 26);
00153 IDDescriptor.setCaseSensitive(true);
00154 db.addIndex("dummy", IDDescriptor);
00155 }
00156
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
00166
00167
00168 protected void tearDown() throws Exception {
00169 super.tearDown();
00170 }
00171
00172 public void testDoSynchro() {
00173
00174
00175 SynchroDescriptor descriptor = new SynchroDescriptor();
00176 descriptor.setSynchroConduit(new HttpOpenMSPSynchroConduit(synchroInstallPath, ""));
00177 SimpleMockSynchroManager synchromock = new SimpleMockSynchroManager(synchroInstallPath);
00178
00179
00180 OpenMSPSyncListener source = OpenMSPSynchroManager.getManager().getListenerByName("dummy");
00181 TestDummyFODBSyncTarget target = new TestDummyFODBSyncTarget();
00182
00183
00184 synchromock.registerTerminalSynchroListener(source);
00185 synchromock.registerServerSynchroTarget(new FODBOpenMSPSynchroTargetWrapper(target));
00186 Credential cred = new Credential("test", "test");
00187 try {
00188
00189 synchromock.synchronize("defgroup", cred, descriptor);
00190
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);
00203 returnListener.notifySynchroBeginCall = false;
00204 target.connectCall = false;
00205
00206
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
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
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
00235 Assert.assertEquals("first", returnListener.notifyFODBObjectSynchroDoneId);
00236 Assert.assertTrue(obj.equals(target.updateCollectionObject));
00237
00238
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
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
00263 Assert.assertTrue(obj2.equals(target.updateCollectionObject));
00264 Assert.assertEquals("second", returnListener.notifyFODBObjectSynchroDoneId);
00265
00266
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
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
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
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
00313 target.updateCollectionObject = null;
00314 returnListener.notifyFODBObjectSynchroDoneId = null;
00315 returnListener.testMetadata = "test metadata";
00316 target.currentAO = new DefaultSynchroAtomicObject("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
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
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
00349 target.updateCollectionObject = null;
00350 returnListener.notifyFODBObjectSynchroDoneId = null;
00351 returnListener.testMetadata = "test metadata";
00352 target.currentAO = new DefaultSynchroAtomicObject("first", "");
00353 target.updateMaxNbRow = 0;
00354 obj2 = new DummyObject("sync_comp");
00355 obj2.value = "second object";
00356 FastObjectDBManager.getManager().getCurrentFODB().add("dummy", obj2);
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);
00363 Assert.assertTrue(target.updateSynchroDBCall);
00364 Assert.assertFalse(returnListener.notifyBeginDBUpdateCall);
00365
00366
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
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 }