private MultiDomainServerState getLastAliveCSNs() {
final MultiDomainServerState lastAliveCSNs = new MultiDomainServerState();
assertTrue(lastAliveCSNs.update(dn1, csn1));
assertTrue(lastAliveCSNs.update(dn2, csn1));
assertTrue(lastAliveCSNs.update(dn2, csn2));
return lastAliveCSNs;
}
@Test
public void testUpdateCSN() throws Exception {
final MultiDomainServerState state = new MultiDomainServerState();
assertTrue(state.update(dn1, csn1));
assertTrue(state.update(dn2, csn2));
assertFalse(state.update(dn1, (CSN) null));
assertFalse(state.update(dn1, csn1));
assertTrue(state.update(dn1, csn3));
final String expected = "o=test1:" + csn3 + ";o=test2:" + csn2 + ";";
assertEquals(state.toString(), expected);
}
@Test
public void testUpdateServerState() throws Exception {
final MultiDomainServerState state = new MultiDomainServerState();
final ServerState ss1 = new ServerState();
assertTrue(ss1.update(csn3));
final ServerState ss2 = new ServerState();
assertTrue(ss2.update(csn2));
state.update(dn1, ss1);
state.update(dn2, ss2);
final String expected = "o=test1:" + csn3 + ";o=test2:" + csn2 + ";";
assertEquals(state.toString(), expected);
}
@Test(dependsOnMethods = {"testUpdateCSN"})
public void testIsEmpty() throws Exception {
final MultiDomainServerState state = new MultiDomainServerState();
assertTrue(state.isEmpty());
assertTrue(state.update(dn1, csn1));
assertFalse(state.isEmpty());
assertThat(state).containsOnly(dn1);
assertTrue(state.update(dn2, csn2));
assertFalse(state.isEmpty());
assertThat(state).containsOnly(dn1, dn2);
state.clear();
assertTrue(state.isEmpty());
}
@Test(dependsOnMethods = {"testUpdateCSN"})
public void testEqualsTo() throws Exception {
final MultiDomainServerState state1 = new MultiDomainServerState();
assertTrue(state1.update(dn1, csn3));
final MultiDomainServerState state2 = new MultiDomainServerState();
assertFalse(state1.equalsTo(state2));
assertTrue(state2.update(dn1, csn1));
assertFalse(state1.equalsTo(state2));
assertTrue(state2.update(dn1, csn3));
assertTrue(state1.equalsTo(state2));
assertTrue(state2.update(dn2, csn2));
assertFalse(state1.equalsTo(state2));
}
/**
* Test entry.
*
* @throws Exception If the test failed unexpectedly.
*/
@Test
public void testEntryToAndFromDatabase() throws Exception {
ensureServerIsUpAndRunning();
// Convert the test LDIF string to a byte array
byte[] originalLDIFBytes = StaticUtils.getBytes(ldifString);
try (final LDIFReader reader =
new LDIFReader(new LDIFImportConfig(new ByteArrayInputStream(originalLDIFBytes)))) {
Entry entryBefore, entryAfter;
while ((entryBefore = reader.readEntry(false)) != null) {
ByteString bytes =
ID2Entry.entryToDatabase(entryBefore, new DataConfig(false, false, null));
entryAfter =
ID2Entry.entryFromDatabase(bytes, DirectoryServer.getDefaultCompressedSchema());
// check DN and number of attributes
assertEquals(entryBefore.getAttributes().size(), entryAfter.getAttributes().size());
assertEquals(entryBefore.getName(), entryAfter.getName());
// check the object classes were not changed
for (String ocBefore : entryBefore.getObjectClasses().values()) {
ObjectClass objectClass = DirectoryServer.getObjectClass(ocBefore.toLowerCase());
if (objectClass == null) {
objectClass = DirectoryServer.getDefaultObjectClass(ocBefore);
}
String ocAfter = entryAfter.getObjectClasses().get(objectClass);
assertEquals(ocBefore, ocAfter);
}
// check the user attributes were not changed
for (AttributeType attrType : entryBefore.getUserAttributes().keySet()) {
List<Attribute> listBefore = entryBefore.getAttribute(attrType);
List<Attribute> listAfter = entryAfter.getAttribute(attrType);
assertThat(listBefore).hasSameSizeAs(listAfter);
for (Attribute attrBefore : listBefore) {
boolean found = false;
for (Attribute attrAfter : listAfter) {
if (attrAfter.optionsEqual(attrBefore.getOptions())) {
// Found the corresponding attribute
assertEquals(attrBefore, attrAfter);
found = true;
}
}
assertTrue(found);
}
}
}
}
}
@Test
public void testUpdateMultiDomainServerState() throws Exception {
final MultiDomainServerState state1 = new MultiDomainServerState();
state1.update(dn1, csn3);
state1.update(dn2, csn2);
final MultiDomainServerState state2 = new MultiDomainServerState();
state2.update(state1);
assertSame(csn3, state2.getCSN(dn1, csn3.getServerId()));
assertSame(csn2, state2.getCSN(dn2, csn2.getServerId()));
assertTrue(state1.equalsTo(state2));
}
@Test
public void testTrim() throws Exception {
ReplicationServer replicationServer = null;
JEReplicaDB replicaDB = null;
try {
TestCaseUtils.startServer();
replicationServer = configureReplicationServer(100, 5000);
replicaDB = newReplicaDB(replicationServer);
CSN[] csns = generateCSNs(1, 0, 5);
replicaDB.add(new DeleteMsg(TEST_ROOT_DN, csns[0], "uid"));
replicaDB.add(new DeleteMsg(TEST_ROOT_DN, csns[1], "uid"));
replicaDB.add(new DeleteMsg(TEST_ROOT_DN, csns[2], "uid"));
DeleteMsg update4 = new DeleteMsg(TEST_ROOT_DN, csns[3], "uid");
// --
// Iterator tests with changes persisted
assertFoundInOrder(replicaDB, csns[0], csns[1], csns[2]);
assertNotFound(replicaDB, csns[4], AFTER_MATCHING_KEY);
assertEquals(replicaDB.getOldestCSN(), csns[0]);
assertEquals(replicaDB.getNewestCSN(), csns[2]);
// --
// Cursor tests with changes persisted
replicaDB.add(update4);
assertFoundInOrder(replicaDB, csns[0], csns[1], csns[2], csns[3]);
// Test cursor from existing CSN
assertFoundInOrder(replicaDB, csns[2], csns[3]);
assertFoundInOrder(replicaDB, csns[3]);
assertNotFound(replicaDB, csns[4], AFTER_MATCHING_KEY);
replicaDB.purgeUpTo(new CSN(Long.MAX_VALUE, 0, 0));
int count = 0;
boolean purgeSucceeded = false;
final CSN expectedNewestCSN = csns[3];
do {
Thread.sleep(10);
final CSN oldestCSN = replicaDB.getOldestCSN();
final CSN newestCSN = replicaDB.getNewestCSN();
purgeSucceeded = oldestCSN.equals(expectedNewestCSN) && newestCSN.equals(expectedNewestCSN);
count++;
} while (!purgeSucceeded && count < 100);
assertTrue(purgeSucceeded);
} finally {
shutdown(replicaDB);
remove(replicationServer);
}
}
/** Test If we have only the required values. */
@Test(dataProvider = "persistentSearchChangeTypeData")
public void checkRequiredValuesTest(Map<Integer, String> exceptedValues) throws Exception {
// Retrieve the values
PersistentSearchChangeType[] vals = PersistentSearchChangeType.values();
// Check if we have the correct number
assertEquals(vals.length, exceptedValues.size());
// Check if we have the correct int value
for (PersistentSearchChangeType val : vals) {
assertTrue(exceptedValues.containsKey(val.intValue()));
}
}
@Test(dependsOnMethods = {"testUpdateCSN"})
public void testGetOldestCSNExcluding_CSNNewerThanCurrentOldestCSN_givesNewOldestCSN()
throws Exception {
final MultiDomainServerState lastAliveCSNs = getLastAliveCSNs();
final MultiDomainServerState excluded = new MultiDomainServerState();
excluded.update(dn1, csn1);
final CSN newerThanCSN1 = new CSN(42, 2, 3);
assertEquals(newerThanCSN1.getServerId(), csn1.getServerId());
assertTrue(newerThanCSN1.isNewerThan(csn1));
excluded.update(dn2, newerThanCSN1);
assertEquals(lastAliveCSNs.getOldestCSNExcluding(excluded), Pair.of(dn2, csn1));
}
/** Test int to type. */
@Test(dataProvider = "persistentSearchChangeTypeData")
public void checkIntToTypeTest(Map<Integer, String> exceptedValues) throws Exception {
Set<Integer> keys = exceptedValues.keySet();
Set<PersistentSearchChangeType> expectedTypes = new HashSet<>(4);
for (int i = 1; i <= 15; i++) {
expectedTypes.clear();
for (int key : keys) {
if ((i & key) != 0) {
expectedTypes.add(PersistentSearchChangeType.valueOf(key));
}
}
Set<PersistentSearchChangeType> returnTypes = PersistentSearchChangeType.intToTypes(i);
assertEquals(expectedTypes.size(), returnTypes.size());
for (PersistentSearchChangeType type : expectedTypes) {
assertTrue(returnTypes.contains(type));
}
}
// We should have an exception
try {
PersistentSearchChangeType.intToTypes(0);
fail();
} catch (LDAPException expected) {
assertEquals(
expected.getMessage(),
"The provided integer value indicated that there were no persistent search change types, which is not allowed");
}
// We should have an exception
int i = 16;
try {
PersistentSearchChangeType.intToTypes(i);
fail();
} catch (LDAPException expected) {
assertEquals(
expected.getMessage(),
"The provided integer value "
+ i
+ " was outside the range of acceptable values for an encoded change type set");
}
}
@Test(dependsOnMethods = {"testUpdateCSN"})
public void testRemoveCSN() throws Exception {
final MultiDomainServerState state = getLastAliveCSNs();
assertNull(state.getCSN(dn3, 42));
assertFalse(state.removeCSN(dn3, csn1));
assertSame(csn1, state.getCSN(dn1, csn1.getServerId()));
assertSame(csn1, state.getCSN(dn2, csn1.getServerId()));
assertSame(csn2, state.getCSN(dn2, csn2.getServerId()));
assertFalse(state.removeCSN(dn1, csn2));
assertSame(csn1, state.getCSN(dn1, csn1.getServerId()));
assertSame(csn1, state.getCSN(dn2, csn1.getServerId()));
assertSame(csn2, state.getCSN(dn2, csn2.getServerId()));
assertTrue(state.removeCSN(dn2, csn1));
assertSame(csn1, state.getCSN(dn1, csn1.getServerId()));
assertNull(state.getCSN(dn2, csn1.getServerId()));
assertSame(csn2, state.getCSN(dn2, csn2.getServerId()));
}
