definitionpersistencetest.java

一个java工作流引擎

package org.jbpm.model.definition.impl;

import java.util.*;
import org.jbpm.model.definition.EventType;
import org.jbpm.persistence.hibernate.*;
import org.jbpm.*;
import junit.framework.*;

public class DefinitionPersistenceTest extends TestCase {
  
  static { TestHelper.initLogging(); }
  
  private static boolean isDefinitionLoaded = false;
  private static Long definitionId = null;
  
  private HibernateTestHelper hibernate = null;
  private DefinitionImpl definition = null;
  
  public void setUp() throws Exception {
    hibernate = new HibernateTestHelper();
    
    if ( ! isDefinitionLoaded ) {
      loadDefinition(); 
    }
    
    hibernate.startTransaction();
    definition = (DefinitionImpl) hibernate.getSession().load( DefinitionImpl.class, definitionId );
  }
  
  public void tearDown() throws Exception {
    hibernate.commitTransaction();
  }
  
  private void loadDefinition() throws Exception {
    hibernate.startTransaction();

    // create the definition
    DefinitionImpl definition = new DefinitionImpl("holiday");
    definition.setDescription( "process description" );
    definition.setVersion( new Integer( 1 ) );
    
    // add 3 actions to the definition
    definition.add( new ActionImpl( EventType.PROCESS_START, new DelegationImpl( definition, "an.FirstActionClass" ) ) );
    definition.add( new ActionImpl( EventType.PROCESS_END, new DelegationImpl( definition, "an.SecondActionClass" ) ) );
    definition.add( new ActionImpl( EventType.STATE_AFTER_ASSIGNMENT, new DelegationImpl( definition, "an.ThirdActionClass" ) ) );
    
    // create a delegation
    DelegationImpl delegation = new DelegationImpl( definition, "a.multipurpose.Delegation" );
    delegation.setConfiguration( "delegation configuration" );
    
    // create the actors
    SwimlaneImpl requester = definition.add( new SwimlaneImpl( "requester" ) );
    requester.setAssignmentDelegation( delegation );
    SwimlaneImpl boss = definition.add( new SwimlaneImpl( "boss" ) );
    boss.setAssignmentDelegation( delegation );
    SwimlaneImpl hrdept = definition.add( new SwimlaneImpl( "hrdept" ) );
    hrdept.setAssignmentDelegation( delegation );
    
    // add actor descriptions
    requester.setDescription( "requester description" );
    boss.setDescription( "boss description" );
    hrdept.setDescription( "hrdept description" );

    // create the nodes
    NodeImpl start    = definition.setStartState( new StartStateImpl( "start", requester) );
    NodeImpl end      = definition.setEndState( new EndStateImpl( "end") );
    NodeImpl approval = definition.add( new StateImpl( "approval", boss) );
    NodeImpl fork     = definition.add( new ForkImpl( "fork") );
    NodeImpl erp      = definition.add( new StateImpl( "erp", requester) );
    NodeImpl hr       = definition.add( new StateImpl( "hr", hrdept) );
    NodeImpl join     = definition.add( new JoinImpl( "join") );

    // set the node descriptions
    start.setDescription( "start description" );
    end.setDescription( "end description" );
    approval.setDescription( "approval description" );
    fork.setDescription( "fork description" );
    erp.setDescription( "erp description" );
    hr.setDescription( "hr description" );
    join.setDescription( "join description" );

    // create the transitions
    TransitionImpl transition = new TransitionImpl( "" );
    transition.setFrom(start);
    transition.setTo(approval);
    
    transition = approval.addLeavingTransition( new TransitionImpl("approve") );
    transition.setTo(fork);
    
    transition = approval.addLeavingTransition( new TransitionImpl("disapprove") );
    transition.setTo(end);
    
    transition = fork.addLeavingTransition( new TransitionImpl("erp") );
    transition.setTo(erp);
    
    transition = fork.addLeavingTransition( new TransitionImpl("hr") );
    transition.setTo(hr);
    
    transition = erp.addLeavingTransition( new TransitionImpl("") );
    transition.setTo(join);
    
    transition = hr.addLeavingTransition( new TransitionImpl("") );
    transition.setTo(join);
    
    transition = join.addLeavingTransition( new TransitionImpl("") );
    transition.setTo(end);
    
    
    // create the types
    TypeImpl dateType = definition.add( new TypeImpl("java.util.Date") );
    dateType.setDescription( "date type description" );
    dateType.setSerializerDelegation( delegation );
    TypeImpl booleanType = definition.add( new TypeImpl("java.lang.Boolean") );
    booleanType.setSerializerDelegation( delegation );

    // add the variables
    definition.add( new VariableImpl( dateType, "start.date" ) );
    definition.add( new VariableImpl( dateType, "end.date" ) );
    
    hibernate.getSession().save( definition );
    hibernate.commitTransaction();
    
    definitionId = definition.getId();
  }


	public void testDefinition() throws Exception {
    assertEquals( "holiday", definition.getName());
    assertEquals( "process description", definition.getDescription());
    assertEquals( new Integer( 1 ), definition.getVersion());
  }

  public void testActions() throws Exception {
    List actions = definition.getActions();
    // note that the actions are ordered according in the sequence they were added. 
    assertEquals( "an.FirstActionClass", ((ActionImpl)actions.get(0)).getActionDelegation().getClassName() );
    assertEquals( "an.SecondActionClass", ((ActionImpl)actions.get(1)).getActionDelegation().getClassName() );
    assertEquals( "an.ThirdActionClass", ((ActionImpl)actions.get(2)).getActionDelegation().getClassName() );
    assertSame( EventType.PROCESS_START, ((ActionImpl)actions.get(0)).getEventType() );
    assertSame( EventType.PROCESS_END, ((ActionImpl)actions.get(1)).getEventType() );
    assertSame( EventType.STATE_AFTER_ASSIGNMENT, ((ActionImpl)actions.get(2)).getEventType() );
  }
    
  public void testNodes() throws Exception {
    NodeImpl start    = definition.getNode( "start");
    NodeImpl end      = definition.getNode( "end");
    NodeImpl approval = definition.getNode( "approval");
    NodeImpl fork     = definition.getNode( "fork");
    NodeImpl erp      = definition.getNode( "erp");
    NodeImpl hr       = definition.getNode( "hr");
    NodeImpl join     = definition.getNode( "join");
 
    // check that all nodes were retrieved
    assertNotNull( start );
    assertNotNull( end );
    assertNotNull( approval );
    assertNotNull( fork );
    assertNotNull( erp );
    assertNotNull( hr );
    assertNotNull( join );

    // check the classes of the nodes
    assertSame( start.getClass(), StartStateImpl.class );
    assertSame( end.getClass(), EndStateImpl.class );
    assertSame( approval.getClass(), StateImpl.class );
    assertSame( fork.getClass(), ForkImpl.class );
    assertSame( erp.getClass(), StateImpl.class );
    assertSame( hr.getClass(), StateImpl.class );
    assertSame( join.getClass(), JoinImpl.class );

    // check the descriptions
    assertEquals( "start description", start.getDescription() );
    assertEquals( "end description", end.getDescription() );
    assertEquals( "approval description", approval.getDescription() );
    assertEquals( "fork description", fork.getDescription() );
    assertEquals( "erp description", erp.getDescription() );
    assertEquals( "hr description", hr.getDescription() );
    assertEquals( "join description", join.getDescription() );

    // check the node definition
    assertSame( definition, start.getDefinition() );
    assertSame( definition, end.getDefinition() );
    assertSame( definition, approval.getDefinition() );
    assertSame( definition, fork.getDefinition() );
    assertSame( definition, erp.getDefinition() );
    assertSame( definition, hr.getDefinition() );
    assertSame( definition, join.getDefinition() );

    // check the start and end state
    assertSame( definition.getStartState(), start );
    assertSame( definition.getEndState(), end );

    // check the actor names
    assertEquals( "requester", ((StateImpl)start).getSwimlane().getName());
    assertEquals( "boss", ((StateImpl)approval).getSwimlane().getName());
    assertEquals( "requester", ((StateImpl)erp).getSwimlane().getName());
    assertEquals( "hrdept", ((StateImpl)hr).getSwimlane().getName());
    
  }

  public void testDelegations() {
    NodeImpl start    = definition.getNode( "start");
    NodeImpl hr      = definition.getNode( "hr");
    NodeImpl approval = definition.getNode( "approval");

    // check the actor delegations
    DelegationImpl delegation = ((SwimlaneImpl)((StateImpl)start).getSwimlane()).getAssignmentDelegation();
    assertEquals( "a.multipurpose.Delegation", delegation.getClassName());
    assertEquals( "delegation configuration", delegation.getConfiguration());
    assertSame( delegation, ((SwimlaneImpl)((StateImpl)approval).getSwimlane()).getAssignmentDelegation());
    assertSame( delegation, ((SwimlaneImpl)((StateImpl)hr).getSwimlane()).getAssignmentDelegation());
  }


  public void testTypes() {
    List types = definition.getTypes();
    assertNotNull( types );
    assertEquals( 2, types.size() );

    TypeImpl dateType = (TypeImpl) types.get(0);
    assertEquals( "java.util.Date", dateType.getJavaType() );
    assertEquals( "date type description", dateType.getDescription() );
    assertEquals( 2, definition.getVariables().size() );
    Collection expectedVariableNames = Arrays.asList( new String[] { "start.date", "end.date" } );
    Iterator iter = definition.getVariables().keySet().iterator();
		while (iter.hasNext()) {
			assertTrue( expectedVariableNames.contains( iter.next() ) );
		}
    
    TypeImpl booleanType = (TypeImpl) types.get(1); 
    assertEquals( "java.lang.Boolean", booleanType.getJavaType() );
  }

	public void testTransitions() throws Exception {
    NodeImpl fork = definition.getNode( "fork");
    Collection leavingTransitions = fork.getLeavingTransitions();
    assertEquals( 2, fork.getLeavingTransitions().size() );

    TransitionImpl erpLeavingTransition = fork.getLeavingTransition( "erp" );
    assertSame( definition.getNode( "erp" ), erpLeavingTransition.getTo() );

    TransitionImpl hrLeavingTransition = fork.getLeavingTransition( "hr" );
    assertSame( definition.getNode( "hr" ), hrLeavingTransition.getTo() );
  }
}