/** * Test method for * {@link org.springframework.batch.core.StepContribution#incrementFilterCount(int)} * . */ public void testIncrementFilterCount() { assertEquals(0, contribution.getFilterCount()); contribution.incrementFilterCount(1); assertEquals(1, contribution.getFilterCount()); }
/** * On successful execution just before a chunk commit, this method should be * called. Synchronizes access to the {@link StepExecution} so that changes * are atomic. * * @param contribution {@link StepContribution} instance used to update the StepExecution state. */ public synchronized void apply(StepContribution contribution) { readSkipCount += contribution.getReadSkipCount(); writeSkipCount += contribution.getWriteSkipCount(); processSkipCount += contribution.getProcessSkipCount(); filterCount += contribution.getFilterCount(); readCount += contribution.getReadCount(); writeCount += contribution.getWriteCount(); exitStatus = exitStatus.and(contribution.getExitStatus()); }
@Test public void testTransform() throws Exception { processor.setItemProcessor(new ItemProcessor<String, String>() { @Override public String process(String item) throws Exception { return item.equals("1") ? null : item; } }); Chunk<String> inputs = new Chunk<>(Arrays.asList("1", "2")); processor.process(contribution, inputs); assertEquals(1, list.size()); assertEquals(1, contribution.getFilterCount()); }
assertEquals(5, list.size()); assertEquals("[1, 2, 3, 4, 5]", list.toString()); assertEquals(2, contribution.getFilterCount()); assertEquals(2, contribution.getProcessSkipCount()); assertEquals(9, processedItems.size());
@Test public void testProcess() throws Exception { Chunk<String> chunk = new Chunk<>(); chunk.add("foo"); chunk.add("err"); chunk.add("bar"); processor.process(contribution, chunk); assertEquals(Arrays.asList("foo", "bar"), list); assertEquals(1, contribution.getFilterCount()); assertEquals(2, contribution.getWriteCount()); }
/** * Update a StepContribution with all the data from a StepContributionSource. The filter and write counts plus the * exit status will be updated to reflect the data in the source. * * @param contribution the current contribution * @param stepContributionSource a source of StepContributions */ protected void updateStepContribution(StepContribution contribution, StepContributionSource stepContributionSource) { for (StepContribution result : stepContributionSource.getStepContributions()) { contribution.incrementFilterCount(result.getFilterCount()); contribution.incrementWriteCount(result.getWriteCount()); for (int i = 0; i < result.getProcessSkipCount(); i++) { contribution.incrementProcessSkipCount(); } for (int i = 0; i < result.getWriteSkipCount(); i++) { contribution.incrementWriteSkipCount(); } contribution.setExitStatus(contribution.getExitStatus().and(result.getExitStatus())); } }
@Test // BATCH-2663 public void testFilterCountOnSkipInWriteWithoutRetry() throws Exception { processor.setWriteSkipPolicy(new AlwaysSkipItemSkipPolicy()); processor.setItemProcessor(new ItemProcessor<String, String>() { @Override public String process(String item) throws Exception { if (item.equals("1")) { return null; } return item; } }); Chunk<String> inputs = new Chunk<>(Arrays.asList("fail", "1", "2")); processAndExpectPlannedRuntimeException(inputs); // (first attempt) Process fail, 1, 2 // item 1 is filtered out so it is removed from the chunk => now inputs = [fail, 2] // using NeverRetryPolicy by default => now scanning processAndExpectPlannedRuntimeException(inputs); // (scanning) Process fail processor.process(contribution, inputs); // (scanning) Process 2 assertEquals(1, list.size()); assertEquals("[2]", list.toString()); assertEquals(1, contribution.getWriteSkipCount()); assertEquals(1, contribution.getFilterCount()); }
assertEquals(5, list.size()); assertEquals("[1, 2, 3, 4, 5]", list.toString()); assertEquals(2, contribution.getFilterCount()); assertEquals(2, contribution.getProcessSkipCount()); assertEquals(9, processedItems.size());
@Test public void testFilterCountOnSkip() throws Exception { processor.setProcessSkipPolicy(new AlwaysSkipItemSkipPolicy()); processor.setItemProcessor(new ItemProcessor<String, String>() { @Override public String process(String item) throws Exception { if (item.equals("1")) { throw new RuntimeException("Skippable"); } if (item.equals("3")) { return null; } return item; } }); Chunk<String> inputs = new Chunk<>(Arrays.asList("3", "1", "2")); try { processor.process(contribution, inputs); fail("Expected Exception"); } catch (Exception e) { assertEquals("Skippable", e.getMessage()); } processor.process(contribution, inputs); assertEquals(1, list.size()); assertEquals(1, contribution.getSkipCount()); assertEquals(1, contribution.getFilterCount()); }
@Test public void testWriteSkipOnException() throws Exception { processor.setWriteSkipPolicy(new AlwaysSkipItemSkipPolicy()); processor.setItemWriter(new ItemWriter<String>() { @Override public void write(List<? extends String> items) throws Exception { if (items.contains("fail")) { throw new RuntimeException("Expected Exception!"); } } }); Chunk<String> inputs = new Chunk<>( Arrays.asList("3", "fail", "2")); try { processor.process(contribution, inputs); fail("Expected RuntimeException"); } catch (RuntimeException e) { assertEquals("Expected Exception!", e.getMessage()); } processor.process(contribution, inputs); try { processor.process(contribution, inputs); fail("Expected RuntimeException"); } catch (RuntimeException e) { assertEquals("Expected Exception!", e.getMessage()); } assertEquals(1, contribution.getSkipCount()); assertEquals(1, contribution.getWriteCount()); assertEquals(0, contribution.getFilterCount()); }
assertEquals(1, contribution.getSkipCount()); assertEquals(0, contribution.getWriteCount()); assertEquals(0, contribution.getFilterCount());
@Test // BATCH-2663 public void testFilterCountOnSkipInWriteWithRetry() throws Exception { SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(); retryPolicy.setMaxAttempts(3); batchRetryTemplate.setRetryPolicy(retryPolicy); processor.setWriteSkipPolicy(new AlwaysSkipItemSkipPolicy()); processor.setItemProcessor(new ItemProcessor<String, String>() { @Override public String process(String item) throws Exception { if (item.equals("1")) { return null; } return item; } }); Chunk<String> inputs = new Chunk<>(Arrays.asList("fail", "1", "2")); processAndExpectPlannedRuntimeException(inputs); // (first attempt) Process fail, 1, 2 // item 1 is filtered out so it is removed from the chunk => now inputs = [fail, 2] processAndExpectPlannedRuntimeException(inputs); // (first retry) Process fail, 2 processAndExpectPlannedRuntimeException(inputs); // (second retry) Process fail, 2 // retry exhausted (maxAttempts = 3) => now scanning processAndExpectPlannedRuntimeException(inputs); // (scanning) Process fail processor.process(contribution, inputs); // (scanning) Process 2 assertEquals(1, list.size()); assertEquals("[2]", list.toString()); assertEquals(1, contribution.getWriteSkipCount()); assertEquals(3, contribution.getFilterCount()); }
assertEquals(0, contribution.getFilterCount());
assertEquals(1, contribution.getSkipCount()); assertEquals(2, contribution.getWriteCount()); assertEquals(0, contribution.getFilterCount());
assertEquals(2, contribution.getSkipCount()); assertEquals(2, contribution.getWriteCount()); assertEquals(0, contribution.getFilterCount());
/** * On successful execution just before a chunk commit, this method should be * called. Synchronizes access to the {@link StepExecution} so that changes * are atomic. * * @param contribution {@link StepContribution} instance used to update the StepExecution state. */ public synchronized void apply(StepContribution contribution) { readSkipCount += contribution.getReadSkipCount(); writeSkipCount += contribution.getWriteSkipCount(); processSkipCount += contribution.getProcessSkipCount(); filterCount += contribution.getFilterCount(); readCount += contribution.getReadCount(); writeCount += contribution.getWriteCount(); exitStatus = exitStatus.and(contribution.getExitStatus()); }
/** * On successful execution just before a chunk commit, this method should be * called. Synchronizes access to the {@link StepExecution} so that changes * are atomic. * * @param contribution */ public synchronized void apply(StepContribution contribution) { readSkipCount += contribution.getReadSkipCount(); writeSkipCount += contribution.getWriteSkipCount(); processSkipCount += contribution.getProcessSkipCount(); filterCount += contribution.getFilterCount(); readCount += contribution.getReadCount(); writeCount += contribution.getWriteCount(); exitStatus = exitStatus.and(contribution.getExitStatus()); }
/** * On successful execution just before a chunk commit, this method should be * called. Synchronizes access to the {@link StepExecution} so that changes * are atomic. * * @param contribution */ public synchronized void apply(StepContribution contribution) { readSkipCount += contribution.getReadSkipCount(); writeSkipCount += contribution.getWriteSkipCount(); processSkipCount += contribution.getProcessSkipCount(); filterCount += contribution.getFilterCount(); readCount += contribution.getReadCount(); writeCount += contribution.getWriteCount(); exitStatus = exitStatus.and(contribution.getExitStatus()); }
/** * On successful execution just before a chunk commit, this method should be * called. Synchronizes access to the {@link StepExecution} so that changes * are atomic. * * @param contribution {@link StepContribution} instance used to update the StepExecution state. */ public synchronized void apply(StepContribution contribution) { readSkipCount += contribution.getReadSkipCount(); writeSkipCount += contribution.getWriteSkipCount(); processSkipCount += contribution.getProcessSkipCount(); filterCount += contribution.getFilterCount(); readCount += contribution.getReadCount(); writeCount += contribution.getWriteCount(); exitStatus = exitStatus.and(contribution.getExitStatus()); }