tasktest.java

jspwiki source code,jspwiki source code

package com.ecyrd.jspwiki.workflow;

import java.util.Collection;
import java.util.List;

import junit.framework.TestCase;

import com.ecyrd.jspwiki.WikiException;
import com.ecyrd.jspwiki.auth.WikiPrincipal;

public class TaskTest extends TestCase
{

    Workflow m_workflow;
    Task m_task;

    /** Sample Task that completes normally. */
    public static class NormalTask extends Task
    {
        private static final long serialVersionUID = 1L;

        public NormalTask(Workflow workflow)
        {
            super(workflow, "task.normal");
        }
        public Outcome execute() throws WikiException
        {
            return Outcome.STEP_COMPLETE;
        }

    }

    /** Sample Task that encounters an error during processing. */
    public static class ErrorTask extends Task
    {
        private static final long serialVersionUID = 1L;

        public ErrorTask(Workflow workflow)
        {
            super(workflow, "task.error");
        }
        public Outcome execute() throws WikiException
        {
            addError("Found an error.");
            addError("Found a second one!");
            return Outcome.STEP_ABORT;
        }

    }

    protected void setUp() throws Exception
    {
        super.setUp();
        m_workflow = new Workflow("workflow.key", new WikiPrincipal("Owner1"));
        m_task = new NormalTask(m_workflow);
    }

    public void testGetActor()
    {
       assertNotSame(new WikiPrincipal("Actor1"), m_task.getActor());
       assertEquals(SystemPrincipal.SYSTEM_USER, m_task.getActor());
    }

    public void testSuccessors()
    {
        // If task finishes normally, branch to a decision (d1)
        Step d1 = new SimpleDecision(m_workflow, "decision1.key", new WikiPrincipal("Actor1"));
        m_task.addSuccessor(Outcome.STEP_COMPLETE, d1);

        // If the task aborts, branch to an alternate decision (d2)
        Step d2 = new SimpleDecision(m_workflow, "decision2.key", new WikiPrincipal("Actor2"));
        m_task.addSuccessor(Outcome.STEP_ABORT, d2);

        assertEquals(d1, m_task.getSuccessor(Outcome.STEP_COMPLETE));
        assertEquals(d2, m_task.getSuccessor(Outcome.STEP_ABORT));

        // The other Outcomes should return null when looked up
        assertNull(m_task.getSuccessor(Outcome.DECISION_APPROVE));
        assertNull(m_task.getSuccessor(Outcome.DECISION_DENY));
        assertNull(m_task.getSuccessor(Outcome.DECISION_HOLD));
        assertNull(m_task.getSuccessor(Outcome.DECISION_REASSIGN));
        assertNull(m_task.getSuccessor(Outcome.STEP_CONTINUE));
    }

    public void testErrors()
    {
        m_task.addError("Error deciding something.");
        m_task.addError("Error deciding something else.");

        List errors = m_task.getErrors();
        assertEquals(2, errors.size());
        assertEquals("Error deciding something.", errors.get(0));
        assertEquals("Error deciding something else.", errors.get(1));
    }

    public void testAvailableOutcomes()
    {
        Collection outcomes = m_task.getAvailableOutcomes();
        assertFalse(outcomes.contains(Outcome.DECISION_APPROVE));
        assertFalse(outcomes.contains(Outcome.DECISION_DENY));
        assertFalse(outcomes.contains(Outcome.DECISION_HOLD));
        assertFalse(outcomes.contains(Outcome.DECISION_REASSIGN));
        assertTrue(outcomes.contains(Outcome.STEP_ABORT));
        assertTrue(outcomes.contains(Outcome.STEP_COMPLETE));
    }

    public void testGetEndTime() throws WikiException
    {
        assertEquals(Workflow.TIME_NOT_SET, m_task.getEndTime());
        m_task.start();
        m_task.setOutcome(m_task.execute());
        assertTrue((Workflow.TIME_NOT_SET  !=  m_task.getEndTime()));
    }

    public void testGetMessageKey()
    {
        assertEquals("task.normal",m_task.getMessageKey());
    }

    public void testGetOutcome() throws WikiException
    {
        assertEquals(Outcome.STEP_CONTINUE,m_task.getOutcome());
        m_task.start();
        m_task.setOutcome(m_task.execute());
        assertEquals(Outcome.STEP_COMPLETE, m_task.getOutcome());

        // Test the "error task"
        m_task = new ErrorTask(m_workflow);
        assertEquals(Outcome.STEP_CONTINUE,m_task.getOutcome());
        m_task.start();
        m_task.setOutcome(m_task.execute());
        assertEquals(Outcome.STEP_ABORT, m_task.getOutcome());
    }

    public void testGetStartTime() throws WikiException
    {
        assertEquals(Workflow.TIME_NOT_SET, m_task.getStartTime());
        m_task.start();
        m_task.execute();
        assertTrue((Workflow.TIME_NOT_SET  !=  m_task.getStartTime()));
    }

    public void testGetWorkflow()
    {
        assertEquals(m_workflow, m_task.getWorkflow());
    }

    public void testIsCompleted() throws WikiException
    {
        assertFalse(m_task.isCompleted());
        m_task.start();
        m_task.setOutcome(m_task.execute());
        assertTrue(m_task.isCompleted());
    }

    public void testIsStarted() throws WikiException
    {
        assertFalse(m_task.isStarted());
        m_task.start();
        assertTrue(m_task.isStarted());
    }

    public void testStartTwice() throws WikiException
    {
        m_task.start();
        try
        {
            m_task.start();
        }
        catch (IllegalStateException e)
        {
            // Swallow
            return;
        }
        // We should never get here
        fail("Decision allowed itself to be started twice!");
    }

}