SpringBatchOperationCollectionAspectTestSupport.java

/**
 * Copyright (c) 2009-2011 VMware, Inc. All Rights Reserved.
 *
 * 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 com.springsource.insight.plugin.springbatch;

import java.util.List;

import org.mockito.Mockito;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobInstance;
import org.springframework.batch.core.JobInterruptedException;
import org.springframework.batch.core.StartLimitExceededException;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.StepExecution;
import org.springframework.batch.core.job.flow.FlowExecution;
import org.springframework.batch.core.job.flow.FlowExecutionStatus;
import org.springframework.batch.core.job.flow.FlowExecutor;
import org.springframework.batch.core.repository.JobRestartException;
import org.springframework.util.StringUtils;

import com.springsource.insight.collection.OperationCollectionAspectSupport;
import com.springsource.insight.collection.OperationCollector;
import com.springsource.insight.collection.test.OperationCollectionAspectTestSupport;
import com.springsource.insight.intercept.operation.Operation;

/**
 *
 */
public abstract class SpringBatchOperationCollectionAspectTestSupport
        extends OperationCollectionAspectTestSupport {
    protected SpringBatchOperationCollectionAspectTestSupport() {
        super();
    }

    @Override
    protected OperationCollector createSpiedOperationCollector(OperationCollector originalCollector) {
        return new TestDummyOperationCollector();
    }

    @Override
    protected Operation getLastEnteredOperation(OperationCollector spiedCollector) {
        assertTrue("Spied collector type mismatch", spiedCollector instanceof TestDummyOperationCollector);

        List<Operation> opsList = ((TestDummyOperationCollector) spiedCollector).getCapturedOperations();
        assertNotNull("No operations list data", opsList);
        assertTrue("No operations collected", opsList.size() > 0);
        return opsList.get(opsList.size() - 1);
    }

    protected Operation getFirstEntered() {
        OperationCollectionAspectSupport aspectInstance = getAspect();
        OperationCollector spiedCollector = aspectInstance.getCollector();
        assertTrue("Spied collector type mismatch", spiedCollector instanceof TestDummyOperationCollector);

        List<Operation> opsList = ((TestDummyOperationCollector) spiedCollector).getCapturedOperations();
        assertNotNull("No operations list data", opsList);
        assertTrue("No operations collected", opsList.size() > 0);
        return opsList.get(0);
    }

    protected Operation assertOperationDetails(Operation op, String action, String name) {
        assertNotNull("No operation extracted", op);
        assertEquals("Mismatched type value", SpringBatchDefinitions.BATCH_TYPE, op.getType());
        assertEquals("Mismatched action", action, op.get(SpringBatchDefinitions.ACTION_ATTR, String.class));
        assertEquals("Mismatched name", name, op.get(SpringBatchDefinitions.NAME_ATTR, String.class));

        SpringBatchOperationCollectionAspect aspectInstance =
                (SpringBatchOperationCollectionAspect) getAspect();
        Class<?> batchType = aspectInstance.getBatchType();
        assertEquals("Mismatched batch type", batchType.getSimpleName(), op.get(SpringBatchDefinitions.TYPE_ATTR, String.class));
        return op;
    }

    protected Operation assertOperationPath(Operation op, FlowExecutor flowExecutor) {
        return assertOperationPath(op, flowExecutor.getStepExecution());
    }

    protected Operation assertOperationPath(Operation op, StepExecution stepExecution) {
        JobExecution jobExecution = stepExecution.getJobExecution();
        JobInstance jobInstance = jobExecution.getJobInstance();
        return assertOperationPath(op, jobInstance.getJobName(), stepExecution.getStepName());
    }

    protected Operation assertOperationPath(Operation op, String jobName, String stepName) {
        assertNotNull("No operation extracted", op);

        if (StringUtils.hasText(jobName)) {
            assertEquals("Mismatched job name", jobName, op.get(SpringBatchDefinitions.JOBNAME_ATTR, String.class));
        }

        if (StringUtils.hasText(stepName)) {
            assertEquals("Mismatched step name", stepName, op.get(SpringBatchDefinitions.STEPNAME_ATTR, String.class));
        }

        return op;
    }

    protected Step createTestStep(final String name) {
        return new Step() {
            public String getName() {
                return name;
            }

            public boolean isAllowStartIfComplete() {
                return false;
            }

            public int getStartLimit() {
                return 0;
            }

            public void execute(StepExecution stepExecution)
                    throws JobInterruptedException {
                System.out.println(Step.class.getSimpleName() + "#execute(" + name + ")");
            }
        };
    }

    protected FlowExecutor createFlowExecutor(String jobName, String stepName) {
        return createFlowExecutor(createStepExecution(jobName, stepName));
    }

    protected StepExecution createStepExecution(String jobName, String stepName) {
        JobExecution jobExecution = createJobExecution(jobName);
        StepExecution stepExecution = Mockito.mock(StepExecution.class);
        Mockito.when(stepExecution.getStepName()).thenReturn(stepName);
        Mockito.when(stepExecution.getJobExecution()).thenReturn(jobExecution);
        return stepExecution;
    }

    protected JobExecution createJobExecution(String jobName) {
        JobInstance jobInstance = Mockito.mock(JobInstance.class);
        Mockito.when(jobInstance.getJobName()).thenReturn(jobName);
        JobExecution jobExecution = Mockito.mock(JobExecution.class);
        Mockito.when(jobExecution.getJobInstance()).thenReturn(jobInstance);
        return jobExecution;
    }

    protected FlowExecutor createFlowExecutor(final StepExecution stepExecution) {
        return new FlowExecutor() {
            public String executeStep(Step step)
                    throws JobInterruptedException, JobRestartException, StartLimitExceededException {
                step.execute(getStepExecution());
                return "done";
            }

            public JobExecution getJobExecution() {
                return Mockito.mock(JobExecution.class);
            }

            public StepExecution getStepExecution() {
                return stepExecution;
            }

            public void close(FlowExecution result) {
                // ignored
            }

            public void abandonStepExecution() {
                if (stepExecution != null) {
                    System.out.println("abandonStepExecution(" + stepExecution.getStepName() + ")");
                }
            }

            public void updateJobExecutionStatus(FlowExecutionStatus status) {
                // ignored
            }

            public boolean isRestart() {
                return false;
            }

            public void addExitStatus(String code) {
                // ignored
            }
        };
    }
}