simpledecisiontest.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 SimpleDecisionTest extends TestCase
{

    Workflow m_workflow;
    Decision m_decision;

    protected void setUp() throws Exception
    {
        super.setUp();
        m_workflow = new Workflow("workflow.key", new WikiPrincipal("Owner1"));
        m_decision = new SimpleDecision(m_workflow, "decision.key", new WikiPrincipal("Actor1"));
    }

    public void testAddFacts()
    {
        Fact f1 = new Fact("fact1",new Integer(1));
        Fact f2 = new Fact("fact2","A factual String");
        Fact f3 = new Fact("fact3",Outcome.DECISION_ACKNOWLEDGE);
        m_decision.addFact(f1);
        m_decision.addFact(f2);
        m_decision.addFact(f3);

        // The facts should be available, and returned in order
        List facts = m_decision.getFacts();
        assertEquals(f1, facts.get(0));
        assertEquals(f2, facts.get(1));
        assertEquals(f3, facts.get(2));
    }

    public void testGetActor()
    {
       assertEquals(new WikiPrincipal("Actor1"), m_decision.getActor());
    }

    public void testGetDefaultOutcome()
    {
        assertEquals(Outcome.DECISION_APPROVE, m_decision.getDefaultOutcome());
    }

    public void testIsReassignable()
    {
        assertTrue(m_decision.isReassignable());
    }

    public void testReassign()
    {
        m_decision.reassign(new WikiPrincipal("Actor2"));
        assertEquals(new WikiPrincipal("Actor2"), m_decision.getActor());
    }

    public void testSuccessors()
    {
        // If the decision is approved, branch to another decision (d2)
        Step d2 = new SimpleDecision(m_workflow, "decision2.key", new WikiPrincipal("Actor1"));
        m_decision.addSuccessor(Outcome.DECISION_APPROVE, d2);

        // If the decision is denied, branch to another decision (d3)
        Step d3 = new SimpleDecision(m_workflow, "decision3.key", new WikiPrincipal("Actor1"));
        m_decision.addSuccessor(Outcome.DECISION_DENY, d3);

        assertEquals(d2, m_decision.getSuccessor(Outcome.DECISION_APPROVE));
        assertEquals(d3, m_decision.getSuccessor(Outcome.DECISION_DENY));

        // The other Outcomes should return null when looked up
        assertNull(m_decision.getSuccessor(Outcome.DECISION_HOLD));
        assertNull(m_decision.getSuccessor(Outcome.DECISION_REASSIGN));
        assertNull(m_decision.getSuccessor(Outcome.STEP_ABORT));
    }

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

        List errors = m_decision.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_decision.getAvailableOutcomes();
        assertTrue(outcomes.contains(Outcome.DECISION_APPROVE));
        assertTrue(outcomes.contains(Outcome.DECISION_DENY));
        assertFalse(outcomes.contains(Outcome.DECISION_HOLD));
        assertFalse(outcomes.contains(Outcome.DECISION_REASSIGN));
        assertFalse(outcomes.contains(Outcome.STEP_ABORT));
        assertFalse(outcomes.contains(Outcome.STEP_COMPLETE));
    }

    public void testGetEndTime() throws WikiException
    {
        assertEquals(Workflow.TIME_NOT_SET, m_decision.getEndTime());
        m_decision.start();
        m_decision.decide(Outcome.DECISION_APPROVE);
        assertTrue((Workflow.TIME_NOT_SET  !=  m_decision.getEndTime()));
    }

    public void testGetMessageKey()
    {
        assertEquals("decision.key",m_decision.getMessageKey());
    }

    public void testGetOutcome() throws WikiException
    {
        assertEquals(Outcome.STEP_CONTINUE,m_decision.getOutcome());
        m_decision.start();
        m_decision.decide(Outcome.DECISION_APPROVE);
        assertEquals(Outcome.DECISION_APPROVE, m_decision.getOutcome());
    }

    public void testGetStartTime() throws WikiException
    {
        assertEquals(Workflow.TIME_NOT_SET, m_decision.getStartTime());
        m_decision.start();
        m_decision.decide(Outcome.DECISION_APPROVE);
        assertTrue((Workflow.TIME_NOT_SET  !=  m_decision.getStartTime()));
    }

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

    public void testIsCompleted() throws WikiException
    {
        assertFalse(m_decision.isCompleted());
        m_decision.start();
        m_decision.decide(Outcome.DECISION_APPROVE);
        assertTrue(m_decision.isCompleted());
    }

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

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

}