2 Replies Latest reply on Oct 31, 2005 8:50 PM by matafy

    run example,but got error(at the last processInstance.signal

    matafy Newbie

      package com.benjamin.jbpm;
      import org.hibernate.cfg.Configuration;
      import org.jbpm.db.JbpmSessionFactory;
      import org.jbpm.db.JbpmSession;
      import org.jbpm.graph.def.ProcessDefinition;
      import org.jbpm.graph.exe.ProcessInstance;
      import org.jbpm.db.GraphSession;
      import org.jbpm.graph.exe.Token;
      import org.jbpm.context.exe.ContextInstance;
      import java.util.List;
      import junit.framework.TestCase;
      public class HelloWorldDBTest extends TestCase {

      // We need one JbpmSessionFactory per application. So we put it in
      // a static variable. The JbpmSessionFactory will be used in the
      // test methods to create JbpmSession's.
      static JbpmSessionFactory jbpmSessionFactory =
      JbpmSessionFactory.buildJbpmSessionFactory();

      static {
      // Since the hypersonic in-memory database is a new, fresh database,
      // we need to create the schema at runtime before we start the tests.
      // The next line creates the database tables and foreign key
      // constraints.
      //jbpmSessionFactory.getJbpmSchema().createSchema();
      }

      public void testSimplePersistence() {
      // Between the 3 method calls below, all data is passed via the
      // database. Here, in this unit test, these 3 methods are executed
      // right after each other because we want to test a complete process
      // scenario. But in reality, these methods represent different
      // requests to a server.

      // Since we start with a clean, empty in-memory database, we have to
      // deploy the process first. In reality, this is done once by the
      // process developer.
      deployProcessDefinition();

      // Suppose we want to start a process instance (=process execution)
      // when a user submits a form in a web application...
      processInstanceIsCreatedWhenUserSubmitsWebappForm();

      // Then, the arrival of an asynchronous message will continue
      // execution.
      theProcessInstanceContinuesWhenAnAsyncMessageIsReceived();
      }

      public void deployProcessDefinition() {
      // This test shows a process definition and one execution
      // of the process definition. The process definition has
      // 3 nodes: an unnamed start-state, a state 's' and an
      // end-state named 'end'.
      ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(
      "<process-definition name='hello world'>" +
      " <start-state name='start'>" +
      " " +
      " </start-state>" +
      " " +
      " " +
      " " +
      " <end-state name='end' />" +
      "</process-definition>"
      );

      // Let's open a new persistence session
      JbpmSession jbpmSession = jbpmSessionFactory.openJbpmSession();
      // ... and begin a transaction on the persistence session
      jbpmSession.beginTransaction();

      // Save the process definition in the database
      jbpmSession
      .getGraphSession()
      .saveProcessDefinition(processDefinition);

      // Commit the transaction
      jbpmSession.commitTransaction();
      // And close the jbpmSession.
      jbpmSession.close();
      }

      public void processInstanceIsCreatedWhenUserSubmitsWebappForm() {
      // The code in this method could be inside a struts-action
      // or a JSF managed bean.

      // Let's open a new persistence session
      JbpmSession jbpmSession = jbpmSessionFactory.openJbpmSession();
      // ... and begin a transaction on the persistence session.
      jbpmSession.beginTransaction();

      // Now we can query the database for the process definition that we
      // deployed above.
      ProcessDefinition processDefinition =
      jbpmSession
      .getGraphSession()
      .findLatestProcessDefinition("hello world");

      // With the processDefinition that we retrieved from the database, we
      // can create an execution of the process definition just like in the
      // hello world example (which was without persistence).
      ProcessInstance processInstance =
      new ProcessInstance(processDefinition);

      Token token = processInstance.getRootToken();
      assertEquals("start", token.getNode().getName());
      // Let's start the process execution
      token.signal();
      // Now the process is in the state 's'.
      assertEquals("s", token.getNode().getName());

      // Now the processInstance is saved in the database. So the
      // current state of the execution of the process is stored in the
      // database.
      jbpmSession
      .getGraphSession()
      .saveProcessInstance(processInstance);
      // The method below will get the process instance back out
      // of the database and resume execution by providing another
      // external signal.

      // At the end of the webapp action, the transaction is committed.
      jbpmSession.commitTransaction();
      // And close the jbpmSession.
      jbpmSession.close();
      }

      public void theProcessInstanceContinuesWhenAnAsyncMessageIsReceived() {
      // The code in this method could be the content of a message driven bean.

      // Let's open a new persistence session.
      JbpmSession jbpmSession = jbpmSessionFactory.openJbpmSession();
      // ... and begin a transaction on the persistence session
      // note that it's also possible to use a jdbc connection from a
      // DataSource in your application server.
      jbpmSession.beginTransaction();
      GraphSession graphSession = jbpmSession.getGraphSession();

      // First, we need to get the process instance back out of the database.
      // There are several options to know what process instance we are dealing
      // with here. The easiest in this simple test case is just to look for
      // the full list of process instances. That should give us only one
      // result. So let's look up the process definition.
      ProcessDefinition processDefinition =
      graphSession.findLatestProcessDefinition("hello world");

      // Now, we search for all process instances of this process definition.
      List processInstances =
      graphSession.findProcessInstances(processDefinition.getId());

      // We know that in the context of this unit test there is
      // only one execution. In real life, the processInstanceId can be
      // extracted from the content of the message that arrived or from
      // the user making a choice.
      ProcessInstance processInstance =
      (ProcessInstance) processInstances.get(0);

      // Now we can continue the execution. Note that the processInstance
      // delegates signals to the main path of execution (=the root token).
      processInstance.signal();

      // After this signal, we know the process execution should have
      // arrived in the end-state.
      assertTrue(processInstance.hasEnded());

      // Now we can update the state of the execution in the database
      graphSession.saveProcessInstance(processInstance);

      // At the end of the MDB, the transaction is committed.
      jbpmSession.commitTransaction();
      // And the jbpmSession is closed.
      jbpmSession.close();
      }
      }

      java.lang.IllegalStateException: couldn't signal token : token has ended
      at org.jbpm.graph.exe.ProcessInstance.signal(ProcessInstance.java:199)
      at com.benjamin.jbpm.HelloWorldDBTest.theProcessInstanceContinuesWhenAnAsyncMessageIsReceived(HelloWorldDBTest.java:159)
      at com.benjamin.jbpm.HelloWorldDBTest.testSimplePersistence(HelloWorldDBTest.java:46)
      at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
      at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
      at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
      at java.lang.reflect.Method.invoke(Method.java:585)
      at junit.framework.TestCase.runTest(TestCase.java:154)
      at junit.framework.TestCase.runBare(TestCase.java:127)
      at junit.framework.TestResult$1.protect(TestResult.java:106)
      at junit.framework.TestResult.runProtected(TestResult.java:124)
      at junit.framework.TestResult.run(TestResult.java:109)
      at junit.framework.TestCase.run(TestCase.java:118)
      at junit.framework.TestSuite.runTest(TestSuite.java:208)
      at junit.framework.TestSuite.run(TestSuite.java:203)
      at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:478)
      at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:344)
      at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:196)

        • 1. Re: run example,but got error(at the last processInstance.si
          Ronald van Kuijk Master

          where is the state 's'? It is in the comment, in the test but not in the pd. S
          There is a start and an end. So if you signal the root token which is in the start state, it immediately transitions to end so it has finished.

          Your process and test do not seem to match!!! Watch out for that it is like always..... who tests the tester???

          • 2. Re: run example,but got error(at the last processInstance.si
            matafy Newbie

            sorry, the processdifinition in my test example is the sample as the userguide 3.2. the definition code you see above is error because of special character in xml.
            so, it's not this reason.
            "&lt;process-definition name='hello world'&gt;" +
            " &lt;start-state name='start'&gt;" +
            " &lt;transition to='s' /&gt;" +
            " &lt;/start-state&gt;" +
            " &lt;state name='s'&gt;" +
            " &lt;transition to='end' /&gt;" +
            " &lt;/state&gt;" +
            " &lt;end-state name='end' /&gt;" +
            "&lt;/process-definition&gt;"