Added 5.11-specific tests to the upgrade job. Fixed upgrade scripts to cope...

Added 5.11-specific tests to the upgrade job.  Fixed upgrade scripts to cope with not compiling new methods in old activiti versions.

modules/activiti-engine/src/test/resources/org/activiti/engine/test/bpmn/deployment/BpmnDeploymentTest.testProcessDefinitionDescription.bpmn20.xml

@@ -6,9 +6,7 @@
 
   <process id="processDescription">
 
-    <documentation>
-      This is really good process documentation! 
-    </documentation>
+    <documentation><![CDATA[This is really good process documentation!]]></documentation>
 
     <startEvent id="start" />
 

modules/activiti-upgrade/pom.xml

@@ -199,7 +199,7 @@
                       </path>
                     </sql>
                     <echo message="generating data in ${upgradeVersion}" />
-                    <java classname="org.activiti.upgrade.UpgradeDataGenerator" fork="true">
+                    <java classname="org.activiti.upgrade.data.UpgradeDataGenerator" fork="true">
                       <arg line="${database} ${upgradeVersion}"/>
                       <classpath>
                         <path path="${test_classpath}"/>

modules/activiti-upgrade/src/test/java/org/activiti/upgrade/CleanPostgres.java → modules/activiti-upgrade/src/main/java/org/activiti/upgrade/CleanPostgres.java

@@ -51,39 +51,43 @@ public class CleanPostgres {
   "drop table ACT_ID_USER cascade;"};
 
   public static void main(String[] args) {
+    if ("postgres".equals(args[0])) {
+      CleanPostgres cleanPostgres = new CleanPostgres();
+      cleanPostgres.execute();
+    }
+  }
+
+  public void execute() {
     try {
-      if ("postgres".equals(args[0])) {
-        ProcessEngineConfigurationImpl processEngineConfiguration = UpgradeTestCase.createProcessEngineConfiguration("postgres");
-        processEngineConfiguration.buildProcessEngine();
-        CommandExecutor commandExecutor = processEngineConfiguration.getCommandExecutorTxRequired();
-        commandExecutor.execute(new Command<Object>() {
+      ProcessEngineConfigurationImpl processEngineConfiguration = UpgradeUtil.createProcessEngineConfiguration("postgres");
+      processEngineConfiguration.buildProcessEngine();
+      CommandExecutor commandExecutor = processEngineConfiguration.getCommandExecutorTxRequired();
+      commandExecutor.execute(new Command<Object>() {
 
-          public Object execute(CommandContext commandContext) {
-            try {
-              Connection connection = commandContext.getSession(DbSqlSession.class).getSqlSession().getConnection();
-              connection.setAutoCommit(false);
+        public Object execute(CommandContext commandContext) {
+          try {
+            Connection connection = commandContext.getSession(DbSqlSession.class).getSqlSession().getConnection();
+            connection.setAutoCommit(false);
 
-              for (String cleanStatement : cleanStatements) {
-                try {
-                  PreparedStatement preparedStatement = connection.prepareStatement(cleanStatement);
-                  preparedStatement.execute();
-                  connection.commit();
-                  log.info("executed ["+cleanStatement+"] successfully");
+            for (String cleanStatement : cleanStatements) {
+              try {
+                PreparedStatement preparedStatement = connection.prepareStatement(cleanStatement);
+                preparedStatement.execute();
+                connection.commit();
+                log.info("executed [" + cleanStatement + "] successfully");
 
-                } catch (Exception e) {
-                  log.info("ERROR WHILE EXECUTING ["+cleanStatement+"]:");
-                  e.printStackTrace();
-                  connection.rollback();
-                }
+              } catch (Exception e) {
+                log.info("ERROR WHILE EXECUTING [" + cleanStatement + "]:");
+                e.printStackTrace();
+                connection.rollback();
               }
-            } catch (Exception e) {
-              e.printStackTrace();
             }
-            return null;
+          } catch (Exception e) {
+            e.printStackTrace();
           }
-        });
-      }
-      
+          return null;
+        }
+      });
     } catch (Exception e) {
       e.printStackTrace();
     }

modules/activiti-upgrade/src/test/java/org/activiti/upgrade/UpgradeTestCase.java → modules/activiti-upgrade/src/main/java/org/activiti/upgrade/UpgradeUtil.java

@@ -13,80 +13,26 @@
 package org.activiti.upgrade;
 
 import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.IOException;
 import java.util.Properties;
 
-import junit.framework.TestCase;
-
-import org.activiti.engine.HistoryService;
-import org.activiti.engine.ManagementService;
 import org.activiti.engine.ProcessEngine;
 import org.activiti.engine.ProcessEngineConfiguration;
-import org.activiti.engine.RuntimeService;
-import org.activiti.engine.TaskService;
 import org.activiti.engine.impl.cfg.ProcessEngineConfigurationImpl;
-import org.activiti.engine.impl.util.LogUtil;
-import org.junit.Ignore;
-import org.junit.runner.JUnitCore;
-import org.junit.runner.Result;
-import org.junit.runner.notification.Failure;
-
 
-@Ignore
-public abstract class UpgradeTestCase extends TestCase {
+/**
+ * @author Joram Barrez
+ */
+public class UpgradeUtil {
   
-  static {
-    LogUtil.readJavaUtilLoggingConfigFromClasspath();
-  }
-
-  protected static ProcessEngine processEngine; 
-  protected static RuntimeService runtimeService;
-  protected static TaskService taskService;
-  protected static HistoryService historyService;
-  protected static ManagementService managementService;
-
-  protected static void runBeforeAndAfterInDevelopmentMode(UpgradeTestCase upgradeTest) {
-    setProcessEngine(ProcessEngineConfiguration.createStandaloneInMemProcessEngineConfiguration().buildProcessEngine());
-
-    upgradeTest.runInTheOldVersion();
-    Result result = JUnitCore.runClasses(upgradeTest.getClass());
-    System.err.println();
-    System.err.println("Tests run: "+result.getRunCount());
-    System.err.println("Failures : "+result.getFailureCount());
-    System.err.println();
-    for (Failure failure: result.getFailures()) {
-      System.err.println(failure.getDescription());
-      Throwable e = failure.getException();
-      if (e!=null) {
-        e.printStackTrace();
-      }
-    }
+  /**
+   * Returns the number after the 5. of the process engine version. Ie 5.11 -> 11
+   */
+  public static int getProcessEngineVersion(ProcessEngine processEngine) {
+    return Integer.parseInt(processEngine.VERSION.toLowerCase()
+            .replace("-snapshot", "")
+            .replace("5.", ""));
   }
   
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
-    
-    if (processEngine==null) {
-      String database = System.getProperty("database");
-      UpgradeDataGenerator.log.fine("Configuration properties...");
-      UpgradeDataGenerator.log.fine("database.....:"+database);
-      setProcessEngine(createProcessEngineConfiguration(database).buildProcessEngine());
-    }
-  }
-
-
-  public static void setProcessEngine(ProcessEngine processEngine) {
-    UpgradeTestCase.processEngine = processEngine;
-    runtimeService = processEngine.getRuntimeService();
-    taskService = processEngine.getTaskService();
-    historyService = processEngine.getHistoryService();
-    managementService = processEngine.getManagementService();
-  }
-
-  public abstract void runInTheOldVersion();
-
   public static ProcessEngineConfigurationImpl createProcessEngineConfiguration(String database) throws Exception {
     ProcessEngineConfigurationImpl processEngineConfiguration;
     processEngineConfiguration = (ProcessEngineConfigurationImpl) ProcessEngineConfiguration
@@ -106,9 +52,7 @@ public abstract class UpgradeTestCase extends TestCase {
     processEngineConfiguration.setJdbcUsername(properties.getProperty("jdbc.username"));
     processEngineConfiguration.setJdbcPassword(properties.getProperty("jdbc.password"));
 
-    UpgradeDataGenerator.log.fine("jdbc url.....: "+processEngineConfiguration.getJdbcUrl());
-    UpgradeDataGenerator.log.fine("jdbc username: "+processEngineConfiguration.getJdbcUsername());
-
     return processEngineConfiguration;
   }
+  
 }

modules/activiti-upgrade/src/main/java/org/activiti/upgrade/data/Activiti_5_10_DataGenerator.java

+/* 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 org.activiti.upgrade.data;
+
+import org.activiti.engine.ProcessEngine;
+import org.activiti.engine.repository.Deployment;
+import org.activiti.engine.repository.ProcessDefinition;
+
+/**
+ * @author Joram Barrez
+ */
+public class Activiti_5_10_DataGenerator implements DataGenerator {
+  
+  protected ProcessEngine processEngine;
+  
+  public static int NR_OF_INSTANCES_FOR_SUSPENSION = 5;
+  
+  public void run() {
+    
+    // VerifyProcessDefinitionDescriptionTest
+    processEngine.getRepositoryService()
+      .createDeployment()
+      .name("verifyProcessDefinitionDescription")
+      .addClasspathResource("org/activiti/upgrade/test/VerifyProcessDefinitionDescriptionTest.bpmn20.xml")
+      .deploy();
+    
+    // SuspendAndActivateFunctionalityTest
+    // Deploy test process, and start a few process instances
+    Deployment deployment = processEngine.getRepositoryService().createDeployment()
+      .name(Activiti_5_10_DataGenerator.class.getName())
+      .addClasspathResource("org/activiti/upgrade/test/SuspendAndActivateUpgradeTest.bpmn20.xml")
+      .deploy();
+    
+    ProcessDefinition processDefinition = processEngine.getRepositoryService().createProcessDefinitionQuery()
+            .deploymentId(deployment.getId())
+            .singleResult();
+    
+    for (int i=0; i<NR_OF_INSTANCES_FOR_SUSPENSION; i++) {
+      processEngine.getRuntimeService().startProcessInstanceById(processDefinition.getId());
+    }
+  }
+  
+  public void setProcessEngine(org.activiti.engine.ProcessEngine processEngine) {
+    this.processEngine = processEngine;
+  };
+
+}

modules/activiti-upgrade/src/main/java/org/activiti/upgrade/data/CommonDataGenerator.java

+/* 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 org.activiti.upgrade.data;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.activiti.engine.ProcessEngine;
+import org.activiti.engine.RuntimeService;
+import org.activiti.engine.TaskService;
+
+/**
+ * @author Joram Barrez
+ */
+public class CommonDataGenerator implements DataGenerator {
+  
+  protected ProcessEngine processEngine;
+  
+  public void run() {
+    
+    // UpgradeTaskOneTest
+    RuntimeService runtimeService = processEngine.getRuntimeService();
+    TaskService taskService = processEngine.getTaskService();
+
+    processEngine.getRepositoryService()
+      .createDeployment()
+      .name("simpleTaskProcess")
+      .addClasspathResource("org/activiti/upgrade/test/UserTaskBeforeTest.testSimplestTask.bpmn20.xml")
+      .deploy();
+
+    runtimeService.startProcessInstanceByKey("simpleTaskProcess");
+    String taskId = taskService.createTaskQuery().singleResult().getId();
+    taskService.complete(taskId);
+    
+    // UpgradeTaskTwoTest
+    processEngine.getRepositoryService().createDeployment().name("simpleTaskProcess")
+            .addClasspathResource("org/activiti/upgrade/test/UserTaskBeforeTest.testTaskWithExecutionVariables.bpmn20.xml")
+            .deploy();
+
+    Map<String, Object> variables = new HashMap<String, Object>();
+    variables.put("instrument", "trumpet");
+    variables.put("player", "gonzo");
+    runtimeService.startProcessInstanceByKey("taskWithExecutionVariablesProcess", variables);
+  }
+  
+  public void setProcessEngine(ProcessEngine processEngine) {
+    this.processEngine = processEngine;
+  }
+
+}

modules/activiti-upgrade/src/main/java/org/activiti/upgrade/data/DataGenerator.java

+/* 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 org.activiti.upgrade.data;
+
+import org.activiti.engine.ProcessEngine;
+
+/**
+ * @author Joram Barrez
+ */
+public interface DataGenerator extends Runnable {
+  
+  void setProcessEngine(ProcessEngine processEngine);
+
+}

modules/activiti-upgrade/src/test/java/org/activiti/upgrade/UpgradeDataGenerator.java → modules/activiti-upgrade/src/main/java/org/activiti/upgrade/data/UpgradeDataGenerator.java

@@ -10,7 +10,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.activiti.upgrade;
+package org.activiti.upgrade.data;
 
 import java.io.PrintWriter;
 import java.sql.DriverManager;
@@ -24,21 +24,18 @@ import org.activiti.engine.impl.interceptor.CommandContext;
 import org.activiti.engine.impl.interceptor.CommandExecutor;
 import org.activiti.engine.impl.util.ClassNameUtil;
 import org.activiti.engine.impl.util.LogUtil;
-import org.activiti.upgrade.test.UpgradeTaskOneTest;
-import org.activiti.upgrade.test.UpgradeTaskTwoTest;
+import org.activiti.upgrade.CleanPostgres;
+import org.activiti.upgrade.ProxyDriver;
+import org.activiti.upgrade.UpgradeUtil;
 
 /**
  * @author Tom Baeyens
+ * @author Joram Barrez
  */
 public class UpgradeDataGenerator {
   
-  static Logger log = Logger.getLogger(UpgradeTestCase.class.getName());
+  static Logger log = Logger.getLogger(UpgradeDataGenerator.class.getName());
   
-  static UpgradeTestCase[] upgradeTestCases = new UpgradeTestCase[]{
-    new UpgradeTaskOneTest(),
-    new UpgradeTaskTwoTest()
-  };
-
   public static void main(String[] args) {
     
     ProcessEngineConfigurationImpl processEngineConfiguration = null;
@@ -56,7 +53,7 @@ public class UpgradeDataGenerator {
       log.fine("database: "+database);
       log.fine("releaseVersion: "+releaseVersion);
   
-      processEngineConfiguration = UpgradeTestCase.createProcessEngineConfiguration(database);
+      processEngineConfiguration = UpgradeUtil.createProcessEngineConfiguration(database);
 
       // install the jdbc proxy driver
       log.fine("installing jdbc proxy driver delegating to "+processEngineConfiguration.getJdbcUrl());
@@ -67,12 +64,17 @@ public class UpgradeDataGenerator {
       log.fine("building the process engine...");
       ProcessEngine processEngine = processEngineConfiguration.buildProcessEngine();
 
-      log.fine("deploy processes and start process instances");
-      UpgradeTestCase.setProcessEngine(processEngine);
       
-      for (UpgradeTestCase upgradeTestCase: upgradeTestCases) {
-        log.fine("### Running test "+ClassNameUtil.getClassNameWithoutPackage(upgradeTestCase.getClass())+" in the old version");
-        upgradeTestCase.runInTheOldVersion();
+      log.fine("### Running data generator "+ClassNameUtil.getClassNameWithoutPackage(CommonDataGenerator.class)+" in the old version");
+      CommonDataGenerator commonDataGenerator = new CommonDataGenerator();
+      commonDataGenerator.setProcessEngine(processEngine);
+      commonDataGenerator.run();
+      
+      // < 5.11 upgrade tests (ie the following data only needs to be generated when the engine is lower then or equals 5.10)
+      if (UpgradeUtil.getProcessEngineVersion(processEngine) < 11) {
+        Activiti_5_10_DataGenerator activiti_5_10_DataGenerator = new Activiti_5_10_DataGenerator();
+        activiti_5_10_DataGenerator.setProcessEngine(processEngine);
+        activiti_5_10_DataGenerator.run();
       }
 
       log.fine("### Captured SQL");
@@ -95,14 +97,23 @@ public class UpgradeDataGenerator {
   }
 
   private static void dbSchemaDrop(ProcessEngineConfigurationImpl processEngineConfiguration) {
-    CommandExecutor commandExecutor = processEngineConfiguration.getCommandExecutorTxRequired();
-    commandExecutor.execute(new Command<Object> (){
-      public Object execute(CommandContext commandContext) {
-        commandContext
-          .getSession(DbSqlSession.class)
-          .dbSchemaDrop();
-        return null;
-      }
-    });
+    if (processEngineConfiguration.getDatabaseType().equals("postgres")) {
+      
+      CleanPostgres cleanPostgres = new CleanPostgres();
+      cleanPostgres.execute();
+      
+    } else {
+    
+      CommandExecutor commandExecutor = processEngineConfiguration.getCommandExecutorTxRequired();
+      commandExecutor.execute(new Command<Object> (){
+        public Object execute(CommandContext commandContext) {
+          commandContext
+            .getSession(DbSqlSession.class)
+            .dbSchemaDrop();
+          return null;
+        }
+      });
+      
+    }
   }
 }

modules/activiti-upgrade/src/test/java/org/activiti/upgrade/test/SuspendAndActivateFunctionalityTest.java

+/* 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 org.activiti.upgrade.test;
+
+import org.activiti.engine.ActivitiException;
+import org.activiti.engine.repository.ProcessDefinition;
+import org.activiti.engine.runtime.ProcessInstance;
+import org.activiti.engine.task.Task;
+import org.activiti.upgrade.UpgradeUtil;
+import org.activiti.upgrade.data.Activiti_5_10_DataGenerator;
+
+/**
+ * Suspending and activating process definitions and process instances was added in 
+ * Activiti 5.11. This class tests this newly added functionality.
+ * 
+ * @author Joram
+ */
+public class SuspendAndActivateFunctionalityTest extends UpgradeTestCase {
+  
+  public void testSuspendProcessDefinition() {
+    
+    // Test makes only sense on 5.11
+    if (UpgradeUtil.getProcessEngineVersion(processEngine) == 11) {
+      
+      ProcessDefinition processDefinition = processEngine.getRepositoryService()
+              .createProcessDefinitionQuery().processDefinitionKey("suspendAndActivate").singleResult();
+      assertNotNull(processDefinition);
+      assertFalse(processDefinition.isSuspended());
+
+      assertEquals(Activiti_5_10_DataGenerator.NR_OF_INSTANCES_FOR_SUSPENSION, processEngine.getRuntimeService()
+              .createProcessInstanceQuery().processDefinitionId(processDefinition.getId()).active().count());
+      assertEquals(0, processEngine.getRuntimeService().createProcessInstanceQuery()
+              .processDefinitionId(processDefinition.getId()).suspended().count());
+      
+      
+      // Suspend
+      processEngine.getRepositoryService().suspendProcessDefinitionById(processDefinition.getId(), true, null);
+      try {
+        processEngine.getRuntimeService().startProcessInstanceById(processDefinition.getId());
+      } catch (ActivitiException e) {
+        assertTrue(e.getMessage().toLowerCase().contains("suspend"));
+      }
+      
+      // Verify process instances
+      assertEquals(0, processEngine.getRuntimeService().createProcessInstanceQuery()
+              .processDefinitionId(processDefinition.getId()).active().count());
+      assertEquals(Activiti_5_10_DataGenerator.NR_OF_INSTANCES_FOR_SUSPENSION, processEngine.getRuntimeService()
+              .createProcessInstanceQuery(). processDefinitionId(processDefinition.getId()).suspended().count());
+      
+      // Activate again
+      processEngine.getRepositoryService().activateProcessDefinitionById(processDefinition.getId(), true, null);
+      assertEquals(Activiti_5_10_DataGenerator.NR_OF_INSTANCES_FOR_SUSPENSION, processEngine.getRuntimeService()
+              .createProcessInstanceQuery().processDefinitionId(processDefinition.getId()).active().count());
+      assertEquals(0, processEngine.getRuntimeService().createProcessInstanceQuery()
+              .processDefinitionId(processDefinition.getId()).suspended().count());
+      
+    }
+  }
+  
+  public void testSuspendProcessInstance() {
+    
+    // Test makes only sense on 5.11
+    if (UpgradeUtil.getProcessEngineVersion(processEngine) == 11) {
+      
+      ProcessDefinition processDefinition = processEngine.getRepositoryService()
+              .createProcessDefinitionQuery().processDefinitionKey("suspendAndActivate").singleResult();
+      assertNotNull(processDefinition);
+      assertFalse(processDefinition.isSuspended());
+    
+      assertEquals(Activiti_5_10_DataGenerator.NR_OF_INSTANCES_FOR_SUSPENSION, processEngine.getRuntimeService()
+              .createProcessInstanceQuery().processDefinitionId(processDefinition.getId()).active().count());
+      assertEquals(0, processEngine.getRuntimeService().createProcessInstanceQuery()
+              .processDefinitionId(processDefinition.getId()).suspended().count());
+      
+
+      ProcessInstance processInstance = processEngine.getRuntimeService().createProcessInstanceQuery()
+              .processDefinitionId(processDefinition.getId()).list().get(0);
+      assertFalse(processInstance.isSuspended());
+      
+      // Suspend process instance
+      processEngine.getRuntimeService().suspendProcessInstanceById(processInstance.getId());
+      assertEquals(Activiti_5_10_DataGenerator.NR_OF_INSTANCES_FOR_SUSPENSION - 1, processEngine.getRuntimeService()
+              .createProcessInstanceQuery().processDefinitionId(processDefinition.getId()).active().count());
+      assertEquals(1, processEngine.getRuntimeService().createProcessInstanceQuery()
+              .processDefinitionId(processDefinition.getId()).suspended().count());
+      
+      try {
+        Task task = processEngine.getTaskService().createTaskQuery().processInstanceId(processInstance.getId()).singleResult();
+        processEngine.getTaskService().complete(task.getId());
+      } catch (ActivitiException e) {
+        assertTrue(e.getMessage().toLowerCase().contains("suspend"));
+      }
+      
+      // Activate again
+      processEngine.getRuntimeService().activateProcessInstanceById(processInstance.getId());
+      
+    }
+  }
+
+}

modules/activiti-upgrade/src/test/java/org/activiti/upgrade/test/UpgradeTaskOneTest.java

@@ -17,30 +17,9 @@ import org.activiti.engine.ManagementService;
 import org.activiti.engine.RuntimeService;
 import org.activiti.engine.TaskService;
 import org.activiti.engine.task.Task;
-import org.activiti.upgrade.UpgradeTestCase;
-
 
 public class UpgradeTaskOneTest extends UpgradeTestCase {
   
-  public static void main(String[] args) {
-    runBeforeAndAfterInDevelopmentMode(new UpgradeTaskOneTest());
-  }
-
-  public void runInTheOldVersion() {
-    RuntimeService runtimeService = processEngine.getRuntimeService();
-    TaskService taskService = processEngine.getTaskService();
-
-    processEngine.getRepositoryService()
-      .createDeployment()
-      .name("simpleTaskProcess")
-      .addClasspathResource("org/activiti/upgrade/test/UserTaskBeforeTest.testSimplestTask.bpmn20.xml")
-      .deploy();
-
-    runtimeService.startProcessInstanceByKey("simpleTaskProcess");
-    String taskId = taskService.createTaskQuery().singleResult().getId();
-    taskService.complete(taskId);
-  }
-
   public void testSimplestTask() {
     RuntimeService runtimeService = processEngine.getRuntimeService();
     TaskService taskService = processEngine.getTaskService();

modules/activiti-upgrade/src/test/java/org/activiti/upgrade/test/UpgradeTaskTwoTest.java

@@ -16,28 +16,10 @@ import java.util.HashMap;
 import java.util.Map;
 
 import org.activiti.engine.task.Task;
-import org.activiti.upgrade.UpgradeTestCase;
 
 
 public class UpgradeTaskTwoTest extends UpgradeTestCase {
   
-  public static void main(String[] args) {
-    runBeforeAndAfterInDevelopmentMode(new UpgradeTaskOneTest());
-  }
-
-  public void runInTheOldVersion() {
-    processEngine.getRepositoryService()
-      .createDeployment()
-      .name("simpleTaskProcess")
-      .addClasspathResource("org/activiti/upgrade/test/UserTaskBeforeTest.testTaskWithExecutionVariables.bpmn20.xml")
-      .deploy();
-
-    Map<String, Object> variables = new HashMap<String, Object>();
-    variables.put("instrument", "trumpet");
-    variables.put("player", "gonzo");
-    runtimeService.startProcessInstanceByKey("taskWithExecutionVariablesProcess", variables);
-  }
-
   public void testTaskWithExecutionVariables() {
     Task task = taskService
       .createTaskQuery()

modules/activiti-upgrade/src/test/java/org/activiti/upgrade/test/UpgradeTestCase.java

+/* 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 org.activiti.upgrade.test;
+
+import java.util.logging.Logger;
+
+import junit.framework.TestCase;
+
+import org.activiti.engine.HistoryService;
+import org.activiti.engine.ManagementService;
+import org.activiti.engine.ProcessEngine;
+import org.activiti.engine.RuntimeService;
+import org.activiti.engine.TaskService;
+import org.activiti.engine.impl.util.LogUtil;
+import org.activiti.upgrade.UpgradeUtil;
+import org.junit.Ignore;
+
+
+@Ignore
+/**
+ * @author Tom Baeyens
+ * @author Joram Barrez
+ */
+public abstract class UpgradeTestCase extends TestCase {
+  
+  static {
+    LogUtil.readJavaUtilLoggingConfigFromClasspath();
+  }
+  
+  static Logger log = Logger.getLogger(UpgradeTestCase.class.getName());
+
+  protected static ProcessEngine processEngine; 
+  protected static RuntimeService runtimeService;
+  protected static TaskService taskService;
+  protected static HistoryService historyService;
+  protected static ManagementService managementService;
+
+//  protected static void runBeforeAndAfterInDevelopmentMode(UpgradeTestCase upgradeTest) {
+//    setProcessEngine(ProcessEngineConfiguration.createStandaloneInMemProcessEngineConfiguration().setDatabaseSchemaUpdate("true").buildProcessEngine());
+//
+//    upgradeTest.runInTheOldVersion();
+//    
+//    // 'Reboot' the process engine, keep the data
+//    processEngine.close();
+//    setProcessEngine(ProcessEngineConfiguration.createStandaloneInMemProcessEngineConfiguration().setDatabaseSchemaUpdate("true").buildProcessEngine());
+//    
+//    Result result = JUnitCore.runClasses(upgradeTest.getClass());
+//    System.err.println();
+//    System.err.println("Tests run: "+result.getRunCount());
+//    System.err.println("Failures : "+result.getFailureCount());
+//    System.err.println();
+//    for (Failure failure: result.getFailures()) {
+//      System.err.println(failure.getDescription());
+//      Throwable e = failure.getException();
+//      if (e!=null) {
+//        e.printStackTrace();
+//      }
+//    }
+//  }
+  
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    
+    if (processEngine==null) {
+      String database = System.getProperty("database");
+      log.fine("Configuration properties...");
+      log.fine("database.....:"+database);
+      setProcessEngine(UpgradeUtil.createProcessEngineConfiguration(database).buildProcessEngine());
+    }
+  }
+
+
+  public static void setProcessEngine(ProcessEngine processEngine) {
+    UpgradeTestCase.processEngine = processEngine;
+    runtimeService = processEngine.getRuntimeService();
+    taskService = processEngine.getTaskService();
+    historyService = processEngine.getHistoryService();
+    managementService = processEngine.getManagementService();
+  }
+
+}

modules/activiti-upgrade/src/test/java/org/activiti/upgrade/test/VerifyProcessDefinitionDescriptionTest.java

+/* 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 org.activiti.upgrade.test;
+
+import org.activiti.engine.repository.ProcessDefinition;
+import org.activiti.upgrade.UpgradeUtil;
+
+/**
+ * This is an upgrade test added for the 5.11 release. In that release, we've added a database
+ * column to store the process definition description (documentation element in bpmn 2.0 xml).
+ * 
+ * @author Joram Barrez
+ */
+public class VerifyProcessDefinitionDescriptionTest extends UpgradeTestCase {
+  
+  public void testProcessDefinitionDescription() {
+    
+    // Test makes only sense on 5.11
+    if (UpgradeUtil.getProcessEngineVersion(processEngine) == 11) {
+      
+      // We don't upgrade the process definition description, we only add the column.
+      // So we'll just verify if the process definition description is null and if 
+      // we can add a process description afterwards
+      
+      ProcessDefinition processDefinition = getLatestVersionOfProcessDefinition();
+      assertNotNull(processDefinition);
+      assertNull(processDefinition.getDescription());
+      
+      // If we now redeploy the same process definition, the description should be set
+      deployTestProcess();
+      processDefinition = getLatestVersionOfProcessDefinition();
+      assertEquals("This is not really a very usable process...", processDefinition.getDescription());
+      
+    }
+  }
+  
+  protected void deployTestProcess() {
+    processEngine.getRepositoryService()
+      .createDeployment()
+      .name("verifyProcessDefinitionDescription")
+      .addClasspathResource("org/activiti/upgrade/test/VerifyProcessDefinitionDescriptionTest.bpmn20.xml")
+      .deploy();
+  }
+  
+  protected ProcessDefinition getLatestVersionOfProcessDefinition() {
+    return processEngine.getRepositoryService()
+            .createProcessDefinitionQuery()
+            .processDefinitionKey("verifyProcessDefinitionDescription")
+            .latestVersion()
+            .singleResult();
+  }
+
+}

modules/activiti-upgrade/src/test/resources/org/activiti/upgrade/test/SuspendAndActivateUpgradeTest.bpmn20.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<definitions
+  xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
+  xmlns:activiti="http://activiti.org/bpmn"
+  targetNamespace="Examples">
+
+  <process id="suspendAndActivate" name="The One Task Process">
+    <documentation>This is a process for testing purposes</documentation>
+  
+    <startEvent id="theStart" />
+    <sequenceFlow id="flow1" sourceRef="theStart" targetRef="theTask" />
+    <userTask id="theTask" name="my task" />    
+    <sequenceFlow id="flow2" sourceRef="theTask" targetRef="theEnd" />
+    <endEvent id="theEnd" />
+    
+  </process>
+
+</definitions>

modules/activiti-upgrade/src/test/resources/org/activiti/upgrade/test/VerifyProcessDefinitionDescriptionTest.bpmn20.xml

+<?xml version="1.0" encoding="UTF-8"?>
+
+<definitions id="taskAssigneeExample" 
+             xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
+             xmlns:activiti="http://activiti.org/bpmn"
+             targetNamespace="Upgrade">
+  
+  <process id="verifyProcessDefinitionDescription">
+  
+    <documentation><![CDATA[This is not really a very usable process...]]></documentation>
+  
+    <startEvent id="start"/>
+    <sequenceFlow id="flow1" sourceRef="start" targetRef="one" />
+
+    <userTask id="one" name="one" />
+    <sequenceFlow id="flow2" sourceRef="one" targetRef="end" />
+    
+    <endEvent id="end" />
+    
+  </process>
+
+</definitions>
\ No newline at end of file