From 4672a1ec1afa4d58a5b98266cb78c341734d26f4 Mon Sep 17 00:00:00 2001
From: Violette Roche-Montane <violette.roche-montane@forgerock.com>
Date: Mon, 22 Oct 2012 07:38:54 +0000
Subject: [PATCH] Add tests for the ConnectionChangeRecordWriter.
---
opendj-sdk/opendj3/opendj-ldap-sdk/src/test/java/org/forgerock/opendj/ldif/ConnectionChangeRecordWriterTestCase.java | 487 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 487 insertions(+), 0 deletions(-)
diff --git a/opendj-sdk/opendj3/opendj-ldap-sdk/src/test/java/org/forgerock/opendj/ldif/ConnectionChangeRecordWriterTestCase.java b/opendj-sdk/opendj3/opendj-ldap-sdk/src/test/java/org/forgerock/opendj/ldif/ConnectionChangeRecordWriterTestCase.java
new file mode 100644
index 0000000..d25ad76
--- /dev/null
+++ b/opendj-sdk/opendj3/opendj-ldap-sdk/src/test/java/org/forgerock/opendj/ldif/ConnectionChangeRecordWriterTestCase.java
@@ -0,0 +1,487 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (the "License"). You may not use this file except in compliance
+ * with the License.
+ *
+ * You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
+ * or http://forgerock.org/license/CDDLv1.0.html.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at legal-notices/CDDLv1_0.txt.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information:
+ * Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ *
+ *
+ * Copyright 2009-2010 Sun Microsystems, Inc.
+ * Portions copyright 2012 ForgeRock AS.
+ */
+
+package org.forgerock.opendj.ldif;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.io.IOException;
+
+import org.forgerock.i18n.LocalizedIllegalArgumentException;
+import org.forgerock.opendj.ldap.Connection;
+import org.forgerock.opendj.ldap.DN;
+import org.forgerock.opendj.ldap.ErrorResultException;
+import org.forgerock.opendj.ldap.ErrorResultIOException;
+import org.forgerock.opendj.ldap.ResultCode;
+import org.forgerock.opendj.ldap.requests.AddRequest;
+import org.forgerock.opendj.ldap.requests.DeleteRequest;
+import org.forgerock.opendj.ldap.requests.ModifyDNRequest;
+import org.forgerock.opendj.ldap.requests.ModifyRequest;
+import org.forgerock.opendj.ldap.requests.Requests;
+import org.mockito.Mockito;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+/**
+ * This class tests the ConnectionChangeRecordWriter functionality.
+ */
+@SuppressWarnings("javadoc")
+public class ConnectionChangeRecordWriterTestCase extends AbstractLDIFTestCase {
+
+ /**
+ * Provide a standard LDIF Change Record, valid, for tests below.
+ *
+ * @return a string containing a standard LDIF Change Record.
+ */
+ public final String[] getStandardLDIFChangeRecord() {
+
+ // @formatter:off
+ final String[] cr = {
+ "version: 1",
+ "dn: uid=scarter,ou=People,dc=example,dc=com",
+ "changetype: add",
+ "sn: Carter",
+ "cn: Samnatha Carter",
+ "givenName: Sam",
+ "objectClass: inetOrgPerson",
+ "telephoneNumber: 555 555-5555",
+ "mail: scarter@mail.org",
+ "entryDN: uid=scarter,ou=people,dc=example,dc=org",
+ "entryUUID: ad55a34a-763f-358f-93f9-da86f9ecd9e4",
+ "modifyTimestamp: 20120903142126Z",
+ "modifiersName: cn=Internal Client,cn=Root DNs,cn=config"
+ };
+ // @formatter:on
+ return cr;
+ }
+
+ /**
+ * Write a Change Record - AddRequest.
+ *
+ * @throws Exception
+ */
+ @Test()
+ public final void testWriteChangeRecordAddRequest() throws Exception {
+ Connection connection = mock(Connection.class);
+ ConnectionChangeRecordWriter writer = null;
+
+ try {
+ writer = new ConnectionChangeRecordWriter(connection);
+ writer.writeChangeRecord(Requests.newAddRequest(getStandardLDIFChangeRecord()));
+ verify(connection, times(1)).add(any(AddRequest.class));
+ } finally {
+ writer.close();
+ }
+ }
+
+ /**
+ * The writeChangeRecord (AddRequest) doesn't allow a null.
+ *
+ * @throws Exception
+ */
+ @Test(expectedExceptions = NullPointerException.class)
+ public final void testWriteChangeRecordAddRequestDoesntAllowNull() throws Exception {
+ final Connection connection = mock(Connection.class);
+ ConnectionChangeRecordWriter writer = null;
+ try {
+ writer = new ConnectionChangeRecordWriter(connection);
+ writer.writeChangeRecord((AddRequest) null);
+ } finally {
+ writer.close();
+ }
+ }
+
+ /**
+ * ConnectionChangeRecordWriter write a change record (in this example the
+ * ChangeRecord is an AddRequest)
+ *
+ * @throws Exception
+ */
+ @Test()
+ public final void testWriteChangeRecordContainingAddRequest() throws Exception {
+ Connection connection = mock(Connection.class);
+ ConnectionChangeRecordWriter writer = null;
+
+ try {
+ writer = new ConnectionChangeRecordWriter(connection);
+ writer.writeChangeRecord(Requests.newChangeRecord(getStandardLDIFChangeRecord()));
+ Assert.assertTrue(Requests.newChangeRecord(getStandardLDIFChangeRecord()) instanceof AddRequest);
+ verify(connection, times(1)).add(any(AddRequest.class));
+ } finally {
+ writer.close();
+ }
+ }
+
+ /**
+ * ConnectionChangeRecordWriter write a change record (in this example the
+ * ChangeRecord is a DeleteRequest)
+ *
+ * @throws Exception
+ */
+ @Test()
+ public final void testWriteChangeRecordContainingDeleteRequest() throws Exception {
+ Connection connection = mock(Connection.class);
+ ConnectionChangeRecordWriter writer = null;
+
+ try {
+ writer = new ConnectionChangeRecordWriter(connection);
+ // @formatter:off
+ ChangeRecord cr = Requests.newChangeRecord(
+ "dn: dc=example,dc=com",
+ "changetype: delete"
+ );
+ writer.writeChangeRecord(cr);
+ // @formatter:on
+ Assert.assertTrue(cr instanceof DeleteRequest);
+ verify(connection, times(1)).delete(any(DeleteRequest.class));
+ } finally {
+ writer.close();
+ }
+ }
+
+ /**
+ * The writer allow only one LDIF ChangeRecord. Exception expected.
+ *
+ * @throws Exception
+ */
+ @Test(expectedExceptions = LocalizedIllegalArgumentException.class)
+ public final void testWriteChangeRecordDoesntAllowMultipleLDIF() throws Exception {
+ Connection connection = mock(Connection.class);
+ ConnectionChangeRecordWriter writer = null;
+
+ try {
+ writer = new ConnectionChangeRecordWriter(connection);
+ // @formatter:off
+ writer.writeChangeRecord(Requests.newChangeRecord(
+ "dn: uid=scarter,ou=People,dc=example,dc=com",
+ "changetype: modify",
+ "replace:sn",
+ "sn: scarter",
+ "",
+ "dn: uid=user.0,ou=People,dc=example,dc=com",
+ "changetype: modify",
+ "replace:sn",
+ "sn: Amarr")
+ );
+ // @formatter:on
+
+ } finally {
+ writer.close();
+ }
+ }
+
+ /**
+ * ConnectionChangeRecordWriter writes a ChangeRecord and an IOException
+ * occurs on the ChangeAccept call.
+ *
+ * @throws Exception
+ */
+ @SuppressWarnings("unchecked")
+ @Test(expectedExceptions = RuntimeException.class)
+ public final void testWriteChangeRecordChangeAcceptSendIOException() throws Exception {
+ Connection connection = mock(Connection.class);
+ ConnectionChangeRecordWriter writer = null;
+ ChangeRecord cr = mock(ChangeRecord.class);
+
+ when(cr.accept(any(ChangeRecordVisitor.class), any(ConnectionChangeRecordWriter.class)))
+ .thenAnswer(new Answer<IOException>() {
+ @Override
+ public IOException answer(final InvocationOnMock invocation) throws Throwable {
+ // Execute handler and return future.
+ final ChangeRecordVisitor<?, ?> handler =
+ (ChangeRecordVisitor<?, ?>) invocation.getArguments()[0];
+ if (handler != null) {
+ // Data here if needed.
+ }
+ return new IOException("IOException_e_is_not_null");
+ }
+ });
+
+ try {
+ writer = new ConnectionChangeRecordWriter(connection);
+ writer.writeChangeRecord(cr);
+ } finally {
+ writer.close();
+ }
+ }
+
+ /**
+ * ConnectionChangeRecordWriter writes a ChangeRecord and an
+ * ErrorResultIOException occurs on the ChangeAccept call.
+ *
+ * @throws Exception
+ */
+ @SuppressWarnings("unchecked")
+ @Test(expectedExceptions = ErrorResultIOException.class)
+ public final void testWriteChangeRecordChangeAcceptSendErrorResultIOException()
+ throws Exception {
+ Connection connection = mock(Connection.class);
+ ConnectionChangeRecordWriter writer = null;
+ ChangeRecord cr = mock(ChangeRecord.class);
+
+ when(cr.accept(any(ChangeRecordVisitor.class), any(ConnectionChangeRecordWriter.class)))
+ .thenAnswer(new Answer<ErrorResultIOException>() {
+ @Override
+ public ErrorResultIOException answer(final InvocationOnMock invocation)
+ throws Throwable {
+ // Execute handler and return future.
+ final ChangeRecordVisitor<?, ?> handler =
+ (ChangeRecordVisitor<?, ?>) invocation.getArguments()[0];
+ if (handler != null) {
+ // Data here if needed.
+ }
+ return new ErrorResultIOException(ErrorResultException
+ .newErrorResult(ResultCode.UNAVAILABLE_CRITICAL_EXTENSION));
+ }
+ });
+
+ try {
+ writer = new ConnectionChangeRecordWriter(connection);
+ writer.writeChangeRecord(cr);
+ } finally {
+ writer.close();
+ }
+ }
+
+ /**
+ * The writeChangeRecord (ChangeRecord) doesn't allow a null.
+ *
+ * @throws Exception
+ */
+ @Test(expectedExceptions = NullPointerException.class)
+ public final void testWriteChangeRecordChangeRecordDoesntAllowNull() throws Exception {
+ final Connection connection = mock(Connection.class);
+ ConnectionChangeRecordWriter writer = null;
+ try {
+ writer = new ConnectionChangeRecordWriter(connection);
+ writer.writeChangeRecord((ChangeRecord) null);
+ } finally {
+ writer.close();
+ }
+ }
+
+ /**
+ * Use the ConnectionChangeRecordWriter to write a DeleteRequest.
+ *
+ * @throws Exception
+ */
+ @Test()
+ public final void testWriteChangeRecordDeleteRequest() throws Exception {
+ Connection connection = mock(Connection.class);
+ ConnectionChangeRecordWriter writer = null;
+
+ try {
+ ChangeRecord cr = Requests.newDeleteRequest(DN.valueOf("cn=scarter,dc=example,dc=com"));
+ writer = new ConnectionChangeRecordWriter(connection);
+ writer.writeChangeRecord(cr);
+ verify(connection, times(1)).delete(any(DeleteRequest.class));
+ } finally {
+ writer.close();
+ }
+ }
+
+ /**
+ * The writeChangeRecord (DeleteRequest) doesn't allow a null.
+ *
+ * @throws Exception
+ */
+ @Test(expectedExceptions = NullPointerException.class)
+ public final void testWriteChangeRecordDeleteRequestDoesntAllowNull() throws Exception {
+ final Connection connection = mock(Connection.class);
+ ConnectionChangeRecordWriter writer = null;
+ try {
+ writer = new ConnectionChangeRecordWriter(connection);
+ writer.writeChangeRecord((DeleteRequest) null);
+ } finally {
+ writer.close();
+ }
+ }
+
+ /**
+ * Use the ConnectionChangeRecordWriter to write a ModifyDNRequest.
+ *
+ * @throws Exception
+ */
+ @Test()
+ public final void testWriteChangeRecordModifyDNRequest() throws Exception {
+ Connection connection = mock(Connection.class);
+ ConnectionChangeRecordWriter writer = null;
+
+ try {
+ // @formatter:off
+ ChangeRecord cr = Requests.newModifyDNRequest(
+ "cn=scarter,dc=example,dc=com",
+ "cn=Susan Jacobs");
+ //@formatter:on
+ writer = new ConnectionChangeRecordWriter(connection);
+ writer.writeChangeRecord(cr);
+ verify(connection, times(1)).modifyDN(any(ModifyDNRequest.class));
+ } finally {
+ writer.close();
+ }
+ }
+
+ /**
+ * The writeChangeRecord (ModifyDNRequest) doesn't allow a null.
+ *
+ * @throws Exception
+ */
+ @Test(expectedExceptions = NullPointerException.class)
+ public final void testWriteChangeRecordModifyDNRequestDoesntAllowNull() throws Exception {
+ final Connection connection = mock(Connection.class);
+ ConnectionChangeRecordWriter writer = null;
+ try {
+ writer = new ConnectionChangeRecordWriter(connection);
+ writer.writeChangeRecord((ModifyDNRequest) null);
+ } finally {
+ writer.close();
+ }
+ }
+
+ /**
+ * Use the ConnectionChangeRecordWriter to write a ModifyRequest.
+ *
+ * @throws Exception
+ */
+ @Test()
+ public final void testWriteChangeRecordModifyRequest() throws Exception {
+ Connection connection = mock(Connection.class);
+ ConnectionChangeRecordWriter writer = null;
+
+ try {
+ writer = new ConnectionChangeRecordWriter(connection);
+ // @formatter:off
+ ChangeRecord cr = Requests.newModifyRequest(
+ "dn: cn=Fiona Jensen, ou=Marketing, dc=airius, dc=com",
+ "changetype: modify",
+ "delete: telephonenumber",
+ "telephonenumber: +1 408 555 1212"
+ );
+ writer.writeChangeRecord(cr);
+ // @formatter:on
+ verify(connection, times(1)).modify(any(ModifyRequest.class));
+ } finally {
+ writer.close();
+ }
+ }
+
+ /**
+ * The writeChangeRecord (ModifyRequest) doesn't allow a null.
+ *
+ * @throws Exception
+ */
+ @Test(expectedExceptions = NullPointerException.class)
+ public final void testWriteChangeRecordModifyRequestDoesntAllowNull() throws Exception {
+ final Connection connection = mock(Connection.class);
+ ConnectionChangeRecordWriter writer = null;
+ try {
+ writer = new ConnectionChangeRecordWriter(connection);
+ writer.writeChangeRecord((ModifyRequest) null);
+ } finally {
+ writer.close();
+ }
+ }
+
+ /**
+ * The writeComment do nothing. ConnectionChangeRecordWriter do not support
+ * Comment.
+ *
+ * @throws Exception
+ */
+ @Test()
+ public final void testWriteCommentDoNotSupportComment() throws Exception {
+ Connection connection = mock(Connection.class);
+ ConnectionChangeRecordWriter writer = null;
+
+ try {
+ writer = new ConnectionChangeRecordWriter(connection);
+ writer.writeComment("# A new comment");
+ verify(connection, Mockito.never()).add(any(String.class));
+ verify(connection, Mockito.never()).delete(any(String.class));
+ verify(connection, Mockito.never()).modify(any(String.class));
+ verify(connection, Mockito.never()).modifyDN(any(String.class), any(String.class));
+ } finally {
+ writer.close();
+ }
+ }
+
+ /**
+ * The writeComment doesn't allow a null.
+ *
+ * @throws Exception
+ */
+ @Test(expectedExceptions = NullPointerException.class)
+ public final void testWriteCommentDoesntAllowNull() throws Exception {
+ final Connection connection = mock(Connection.class);
+ ConnectionChangeRecordWriter writer = null;
+ try {
+ writer = new ConnectionChangeRecordWriter(connection);
+ writer.writeComment(null);
+ } finally {
+ writer.close();
+ }
+ }
+
+ /**
+ * The ConnectionChangeRecordWriter doesn't allow a null connection.
+ *
+ * @throws Exception
+ */
+ @Test(expectedExceptions = NullPointerException.class)
+ public final void testConnectionChangeRecordWriterDoesntAllowNull() throws Exception {
+ ConnectionChangeRecordWriter writer = null;
+ try {
+ writer = new ConnectionChangeRecordWriter(null);
+ } finally {
+ writer.close();
+ }
+ }
+
+ /**
+ * Verify ConnectionChangeRecordWriter close function.
+ *
+ * @throws Exception
+ * If the test failed unexpectedly.
+ */
+ @Test()
+ public final void testConnectionChangeRecordWriterClose() throws Exception {
+ Connection connection = mock(Connection.class);
+ ConnectionChangeRecordWriter writer = null;
+ try {
+ writer = new ConnectionChangeRecordWriter(connection);
+ } finally {
+ writer.close();
+ verify(connection, times(1)).close();
+ }
+ }
+}
--
Gitblit v1.10.0