Add builder for LdifReader.

Resolves #BATCH-2600

spring-batch-core-tests/src/test/java/org/springframework/batch/core/test/ldif/builder/LdifReaderBuilderTests.java

@@ -0,0 +1,164 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package org.springframework.batch.core.test.ldif.builder;
+
+import org.junit.After;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import org.springframework.batch.item.ExecutionContext;
+import org.springframework.batch.item.ItemStreamException;
+import org.springframework.batch.item.ldif.LdifReader;
+import org.springframework.batch.item.ldif.RecordCallbackHandler;
+import org.springframework.batch.item.ldif.builder.LdifReaderBuilder;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.ldap.core.LdapAttributes;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.fail;
+
+/**
+ * @author Glenn Renfro
+ */
+@RunWith(SpringRunner.class)
+public class LdifReaderBuilderTests {
+
+	@Autowired
+	private ApplicationContext context;
+
+	private LdifReader ldifReader;
+
+	private String callbackAttributeName;
+
+	@After
+	public void tearDown() {
+		this.callbackAttributeName = null;
+		if (this.ldifReader != null) {
+			this.ldifReader.close();
+		}
+	}
+
+	@Test
+	public void testSkipRecord() throws Exception {
+		this.ldifReader = new LdifReaderBuilder().recordsToSkip(1).resource(context.getResource("classpath:/test.ldif"))
+				.name("foo").build();
+		LdapAttributes ldapAttributes = firstRead();
+		assertEquals("The attribute name for the second record did not match expected result",
+				"cn=Bjorn Jensen, ou=Accounting, dc=airius, dc=com", ldapAttributes.getName().toString());
+	}
+
+	@Test
+	public void testBasicRead() throws Exception {
+		this.ldifReader = new LdifReaderBuilder().resource(context.getResource("classpath:/test.ldif")).name("foo").build();
+		LdapAttributes ldapAttributes = firstRead();
+		assertEquals("The attribute name for the first record did not match expected result",
+				"cn=Barbara Jensen, ou=Product Development, dc=airius, dc=com", ldapAttributes.getName().toString());
+	}
+
+	@Test
+	public void testCurrentItemCount() throws Exception {
+		this.ldifReader = new LdifReaderBuilder().currentItemCount(3)
+				.resource(context.getResource("classpath:/test.ldif")).name("foo").build();
+		LdapAttributes ldapAttributes = firstRead();
+		assertEquals("The attribute name for the third record did not match expected result",
+				"cn=Gern Jensen, ou=Product Testing, dc=airius, dc=com", ldapAttributes.getName().toString());
+	}
+
+	@Test
+	public void testMaxItemCount() throws Exception {
+		this.ldifReader = new LdifReaderBuilder().maxItemCount(1).resource(context.getResource("classpath:/test.ldif"))
+				.name("foo").build();
+		LdapAttributes ldapAttributes = firstRead();
+		assertEquals("The attribute name for the first record did not match expected result",
+				"cn=Barbara Jensen, ou=Product Development, dc=airius, dc=com", ldapAttributes.getName().toString());
+		ldapAttributes = this.ldifReader.read();
+		assertNull("The second read should have returned null", ldapAttributes);
+	}
+
+	@Test
+	public void testSkipRecordCallback() throws Exception {
+		this.ldifReader = new LdifReaderBuilder().recordsToSkip(1).skippedRecordsCallback(new TestCallBackHandler())
+				.resource(context.getResource("classpath:/test.ldif")).name("foo").build();
+		firstRead();
+		assertEquals("The attribute name from the callback handler did not match the  expected result",
+				"cn=Barbara Jensen, ou=Product Development, dc=airius, dc=com", this.callbackAttributeName);
+	}
+
+	@Test
+	public void testSaveState() throws Exception {
+		this.ldifReader = new LdifReaderBuilder().resource(context.getResource("classpath:/test.ldif")).name("foo").build();
+		ExecutionContext executionContext = new ExecutionContext();
+		firstRead(executionContext);
+		this.ldifReader.update(executionContext);
+		assertEquals("foo.read.count did not have the expected result", 1,
+				executionContext.getInt("foo.read.count"));
+	}
+
+	@Test
+	public void testSaveStateDisabled() throws Exception {
+		this.ldifReader = new LdifReaderBuilder().saveState(false).resource(context.getResource("classpath:/test.ldif"))
+				.build();
+		ExecutionContext executionContext = new ExecutionContext();
+		firstRead(executionContext);
+		this.ldifReader.update(executionContext);
+		assertEquals("ExecutionContext should have been empty", 0, executionContext.size());
+	}
+
+	@Test
+	public void testStrict() {
+		// Test that strict when enabled will throw an exception.
+		try {
+			this.ldifReader = new LdifReaderBuilder().resource(context.getResource("classpath:/teadsfst.ldif")).name("foo").build();
+			this.ldifReader.open(new ExecutionContext());
+			fail("IllegalStateException should have been thrown, because strict was set to true");
+		}
+		catch (ItemStreamException ise) {
+			assertEquals("IllegalStateException message did not match the expected result.",
+					"Failed to initialize the reader", ise.getMessage());
+		}
+		// Test that strict when disabled will still allow the ldap resource to be opened.
+		this.ldifReader = new LdifReaderBuilder().strict(false)
+				.resource(context.getResource("classpath:/teadsfst.ldif")).name("foo").build();
+		this.ldifReader.open(new ExecutionContext());
+	}
+
+	private LdapAttributes firstRead() throws Exception {
+		return firstRead(new ExecutionContext());
+	}
+
+	private LdapAttributes firstRead(ExecutionContext executionContext) throws Exception {
+		this.ldifReader.open(executionContext);
+		return this.ldifReader.read();
+	}
+
+	@Configuration
+	public static class LdifConfiguration {
+
+	}
+
+	public class TestCallBackHandler implements RecordCallbackHandler {
+
+		@Override
+		public void handleRecord(LdapAttributes attributes) {
+			callbackAttributeName = attributes.getName().toString();
+		}
+	}
+}

spring-batch-infrastructure/src/main/java/org/springframework/batch/item/ldif/LdifReader.java

@@ -74,7 +74,7 @@ public class LdifReader extends AbstractItemCountingItemStreamItemReader<LdapAtt
 	 * In strict mode the reader will throw an exception on
 	 * {@link #open(org.springframework.batch.item.ExecutionContext)} if the
 	 * input resource does not exist.
-	 * @param strict false by default
+	 * @param strict true by default
 	 */
 	public void setStrict(boolean strict) {
 		this.strict = strict;
@@ -155,6 +155,11 @@ public class LdifReader extends AbstractItemCountingItemStreamItemReader<LdapAtt
 		}
 	}
 
+	/**
+	 * Establishes the resource that will be used as the input for the LdifReader.
+	 *
+	 * @param resource the resource that will be read.
+	 */
 	public void setResource(Resource resource) {
 		this.resource = resource;
 		this.ldifParser = new LdifParser(resource);

spring-batch-infrastructure/src/main/java/org/springframework/batch/item/ldif/builder/LdifReaderBuilder.java

@@ -0,0 +1,186 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package org.springframework.batch.item.ldif.builder;
+
+import org.springframework.batch.item.ldif.LdifReader;
+import org.springframework.batch.item.ldif.RecordCallbackHandler;
+import org.springframework.core.io.Resource;
+import org.springframework.util.Assert;
+
+/**
+ * Creates a fully qualified LdifReader.
+ *
+ * @author Glenn Renfro
+ *
+ * @since 4.0
+ */
+public class LdifReaderBuilder  {
+	private Resource resource;
+
+	private int recordsToSkip = 0;
+
+	private boolean strict = true;
+
+	private RecordCallbackHandler skippedRecordsCallback;
+
+	private boolean saveState = true;
+
+	private String name;
+
+	private int maxItemCount = Integer.MAX_VALUE;
+
+	private int currentItemCount;
+
+	/**
+	 * Configure if the state of the {@link org.springframework.batch.item.ItemStreamSupport}
+	 * should be persisted within the {@link org.springframework.batch.item.ExecutionContext}
+	 * for restart purposes.
+	 *
+	 * @param saveState defaults to true
+	 * @return The current instance of the builder.
+	 */
+	public LdifReaderBuilder saveState(boolean saveState) {
+		this.saveState = saveState;
+
+		return this;
+	}
+
+	/**
+	 * The name used to calculate the key within the
+	 * {@link org.springframework.batch.item.ExecutionContext}. Required if
+	 * {@link #saveState(boolean)} is set to true.
+	 *
+	 * @param name name of the reader instance
+	 * @return The current instance of the builder.
+	 * @see org.springframework.batch.item.ItemStreamSupport#setName(String)
+	 */
+	public LdifReaderBuilder name(String name) {
+		this.name = name;
+
+		return this;
+	}
+
+	/**
+	 * Configure the max number of items to be read.
+	 *
+	 * @param maxItemCount the max items to be read
+	 * @return The current instance of the builder.
+	 * @see org.springframework.batch.item.support.AbstractItemCountingItemStreamItemReader#setMaxItemCount(int)
+	 */
+	public LdifReaderBuilder maxItemCount(int maxItemCount) {
+		this.maxItemCount = maxItemCount;
+
+		return this;
+	}
+
+	/**
+	 * Index for the current item. Used on restarts to indicate where to start from.
+	 *
+	 * @param currentItemCount current index
+	 * @return this instance for method chaining
+	 * @see org.springframework.batch.item.support.AbstractItemCountingItemStreamItemReader#setCurrentItemCount(int)
+	 */
+	public LdifReaderBuilder currentItemCount(int currentItemCount) {
+		this.currentItemCount = currentItemCount;
+
+		return this;
+	}
+
+	/**
+	 * In strict mode the reader will throw an exception on
+	 * {@link LdifReader#open(org.springframework.batch.item.ExecutionContext)} if the
+	 * input resource does not exist.
+	 *
+	 * @param strict true by default
+	 * @return this instance for method chaining.
+	 * @see LdifReader#setStrict(boolean)
+	 */
+	public LdifReaderBuilder strict(boolean strict) {
+		this.strict = strict;
+
+		return this;
+	}
+
+	/**
+	 * {@link RecordCallbackHandler RecordCallbackHandler} implementations can be used to
+	 * take action on skipped records.
+	 *
+	 * @param skippedRecordsCallback will be called for each one of the initial skipped
+	 * lines before any items are read.
+	 * @return this instance for method chaining.
+	 * @see LdifReader#setSkippedRecordsCallback(RecordCallbackHandler)
+	 */
+	public LdifReaderBuilder skippedRecordsCallback(RecordCallbackHandler skippedRecordsCallback) {
+		this.skippedRecordsCallback = skippedRecordsCallback;
+
+		return this;
+	}
+
+	/**
+	 * Public setter for the number of lines to skip at the start of a file. Can be used
+	 * if the file contains a header without useful (column name) information, and without
+	 * a comment delimiter at the beginning of the lines.
+	 *
+	 * @param recordsToSkip the number of lines to skip
+	 * @return this instance for method chaining.
+	 * @see LdifReader#setRecordsToSkip(int)
+	 */
+	public LdifReaderBuilder recordsToSkip(int recordsToSkip) {
+		this.recordsToSkip = recordsToSkip;
+
+		return this;
+	}
+
+	/**
+	 * Establishes the resource that will be used as the input for the LdifReader.
+	 *
+	 * @param resource the resource that will be read.
+	 * @return this instance for method chaining.
+	 * @see LdifReader#setResource(Resource)
+	 */
+	public LdifReaderBuilder resource(Resource resource) {
+		this.resource = resource;
+
+		return this;
+	}
+
+	/**
+	 * Returns a fully constructed {@link LdifReader}.
+	 *
+	 * @return a new {@link org.springframework.batch.item.ldif.LdifReader}
+	 */
+	public LdifReader build() {
+		Assert.notNull(this.resource, "Resource is required.");
+		if (this.saveState) {
+			Assert.hasText(this.name, "A name is required when saveState is set to true");
+		}
+		LdifReader reader = new LdifReader();
+		reader.setResource(this.resource);
+		reader.setRecordsToSkip(this.recordsToSkip);
+		reader.setSaveState(this.saveState);
+		reader.setName(this.name);
+		reader.setCurrentItemCount(this.currentItemCount);
+		reader.setMaxItemCount(this.maxItemCount);
+		if (this.skippedRecordsCallback != null) {
+			reader.setSkippedRecordsCallback(this.skippedRecordsCallback);
+		}
+		reader.setStrict(this.strict);
+
+		return reader;
+	}
+
+}