Fix AbstractTaskletStepBuilderTest

Author: ilpyoyang

spring-batch-core/src/test/java/org/springframework/batch/core/step/builder/AbstractTaskletStepBuilderTests.java

@@ -19,91 +19,58 @@
 import static org.junit.Assert.assertEquals;
 import static org.mockito.Mockito.mock;
 
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.platform.commons.util.ReflectionUtils;
 import org.springframework.batch.core.repository.JobRepository;
+import org.springframework.batch.core.step.tasklet.TaskletStep;
 import org.springframework.batch.item.ItemProcessor;
 import org.springframework.batch.item.ItemReader;
 import org.springframework.batch.item.ItemWriter;
+import org.springframework.batch.repeat.support.RepeatTemplate;
 import org.springframework.core.task.SimpleAsyncTaskExecutor;
-import org.springframework.core.task.TaskExecutor;
+import org.springframework.transaction.PlatformTransactionManager;
 
 /**
  * Test cases for verifying the {@link AbstractTaskletStepBuilder} and faultTolerant() functionality.
  *
+ * @author Jérôme Navez
  * @author Ilpyo Yang
  */
 
 class AbstractTaskletStepBuilderTests {
+	private final PlatformTransactionManager transactionManager = mock(PlatformTransactionManager.class);
 	private final JobRepository jobRepository =  mock(JobRepository.class);
-	private final int chunkSize = 10;
 	private final ItemReader itemReader = mock(ItemReader.class);
 	private final ItemProcessor itemProcessor = mock(ItemProcessor.class);
 	private final ItemWriter itemWriter = mock(ItemWriter.class);
-	private final SimpleAsyncTaskExecutor taskExecutor  = new SimpleAsyncTaskExecutor();
-	SimpleStepBuilder simpleStepBuilder;
-
-	private <T> T accessPrivateField(Object o, String fieldName) throws ReflectiveOperationException {
-		Field field = o.getClass().getDeclaredField(fieldName);
-		field.setAccessible(true);
-		return (T) field.get(o);
-	}
 
-	private <T> T accessSuperClassPrivateField(Object o, String fieldName) throws ReflectiveOperationException {
-		Field field = o.getClass().getSuperclass().getDeclaredField(fieldName);
-		field.setAccessible(true);
-		return (T) field.get(o);
-	}
-
-	@BeforeEach
-	void set(){
-		StepBuilderHelper stepBuilderHelper = new StepBuilderHelper("test", jobRepository) {
-			@Override
-			protected StepBuilderHelper self() {
-				return null;
-			}
-		};
-		simpleStepBuilder = new SimpleStepBuilder(stepBuilderHelper);
-		simpleStepBuilder.chunk(chunkSize);
-		simpleStepBuilder.reader(itemReader);
-		simpleStepBuilder.processor(itemProcessor);
-		simpleStepBuilder.writer(itemWriter);
-	}
+	private final SimpleAsyncTaskExecutor taskExecutor  = new SimpleAsyncTaskExecutor();
 
 	@Test
-	void copyConstractorTest() throws ReflectiveOperationException {
-		Constructor<SimpleStepBuilder> constructor = SimpleStepBuilder.class.getDeclaredConstructor(SimpleStepBuilder.class);
-		constructor.setAccessible(true);
-		SimpleStepBuilder copySimpleStepBuilder = constructor.newInstance(simpleStepBuilder);
-
-		int copyChunkSize = accessPrivateField(copySimpleStepBuilder, "chunkSize");
-		ItemReader copyItemReader = accessPrivateField(copySimpleStepBuilder, "reader");
-		ItemProcessor copyItemProcessor = accessPrivateField(copySimpleStepBuilder, "processor");
-		ItemWriter copyItemWriter = accessPrivateField(copySimpleStepBuilder, "writer");
+	void testCopyConstractorFaultTolerant() {
+		TaskletStep step1 = new StepBuilder("step-name", jobRepository)
+				.chunk(10, transactionManager)
+				.reader(itemReader)
+				.processor(itemProcessor)
+				.writer(itemWriter)
+				.faultTolerant()
+				.taskExecutor(taskExecutor)
+				.build();
 
-		assertEquals(chunkSize, copyChunkSize);
-		assertEquals(itemReader, copyItemReader);
-		assertEquals(itemProcessor, copyItemProcessor);
-		assertEquals(itemWriter, copyItemWriter);
-	}
-
-	@Test
-	void faultTolerantMethodTest() throws ReflectiveOperationException {
-		simpleStepBuilder.taskExecutor(taskExecutor); // The task executor is set before faultTolerant()
-		simpleStepBuilder.faultTolerant();
+		TaskletStep step2 = new StepBuilder("step-name", jobRepository)
+				.chunk(10, transactionManager)
+				.taskExecutor(taskExecutor)
+				.reader(itemReader)
+				.processor(itemProcessor)
+				.writer(itemWriter)
+				.faultTolerant()
+				.build();
 
-		int afterChunkSize = accessPrivateField(simpleStepBuilder, "chunkSize");
-		ItemReader afterItemReader = accessPrivateField(simpleStepBuilder, "reader");
-		ItemProcessor afterItemProcessor = accessPrivateField(simpleStepBuilder, "processor");
-		ItemWriter afterItemWriter = accessPrivateField(simpleStepBuilder, "writer");
-		TaskExecutor afterTaskExecutor = accessSuperClassPrivateField(simpleStepBuilder, "taskExecutor");
+		RepeatTemplate stepOperations1 = (RepeatTemplate) ReflectionUtils
+				.readFieldValue(TaskletStep.class, "stepOperations", step1).get();
+		RepeatTemplate stepOperations2 = (RepeatTemplate) ReflectionUtils
+				.readFieldValue(TaskletStep.class, "stepOperations", step2).get();
 
-		assertEquals(chunkSize, afterChunkSize);
-		assertEquals(itemReader, afterItemReader);
-		assertEquals(itemProcessor, afterItemProcessor);
-		assertEquals(itemWriter, afterItemWriter);
-		assertEquals(taskExecutor, afterTaskExecutor);
+		assertEquals(stepOperations1.getClass(), stepOperations2.getClass());
 	}
 }