/*
* This file is part of the WfMOpen project.
* Copyright (C) 2001-2003 Danet GmbH (www.danet.de), GS-AN.
* All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* $Id: Import.java 2326 2007-03-27 21:59:44Z mlipp $
*
* $Log$
* Revision 1.4 2007/02/27 14:34:18 drmlipp
* Some refactoring to reduce cyclic dependencies.
*
* Revision 1.3 2006/09/29 12:32:09 drmlipp
* Consistently using WfMOpen as projct name now.
*
* Revision 1.2 2006/03/08 14:46:41 drmlipp
* Synchronized with 1.3.3p5.
*
* Revision 1.1.1.3.6.1 2005/12/19 10:36:38 drmlipp
* Added support for cleanup mode COMPLETED.
*
* Revision 1.1.1.3 2003/12/19 13:01:44 drmlipp
* Updated to 1.1rc1
*
* Revision 1.24 2003/10/21 21:00:45 lipp
* Moved EJBClientTest to new junit sub-package.
*
* Revision 1.23 2003/10/08 12:39:40 huaiyang
* make test weblogic compatible.
*
* Revision 1.22 2003/07/10 14:34:32 huaiyang
* Fix the tip error of the key transition in the ProcDefValidator.
*
* Revision 1.21 2003/06/27 09:44:03 lipp
* Fixed copyright/license information.
*
* Revision 1.20 2003/06/04 07:49:07 schlue
* PR48 fixed.
*
* Revision 1.19 2003/06/02 15:20:02 schlue
* PR53 fixed.
*
* Revision 1.18 2003/06/02 15:03:37 schlue
* PR47 fixed.
*
* Revision 1.17 2003/05/16 09:32:27 schlue
* Script tests added.
*
* Revision 1.16 2003/05/14 09:30:27 schlue
* Package names for minimal and full changed due to modified import behaviour.
*
* Revision 1.15 2003/05/13 16:04:23 schlue
* Comments and new test cases for parameter matching added.
*
* Revision 1.14 2003/05/13 15:32:31 schlue
* More parameter test cases added.
*
* Revision 1.13 2003/05/13 13:23:41 schlue
* More import tests added.
*
* Revision 1.12 2003/05/09 09:42:46 schlue
* Test for exception added.
*
* Revision 1.11 2003/04/23 14:28:00 lipp
* Improved modelling of header data.
*
* Revision 1.10 2003/04/16 14:06:26 schlue
* Some renames.
*
* Revision 1.9 2003/04/15 14:17:22 schlue
* Cleanup added.
*
* Revision 1.8 2003/04/15 12:57:25 schlue
* Static tests of process and activity (definitions) moved to directory process.
* More test cases for block activities added.
*
* Revision 1.7 2003/04/10 09:44:08 schlue
* Test cases for process data added.
*
* Revision 1.6 2003/03/21 10:00:28 schlue
* PR6 fixed.
*
* Revision 1.5 2003/03/12 11:46:54 schlue
* IPR5: timeEstimated activated
*
* Revision 1.4 2003/03/12 11:36:58 schlue
* IPR3: BlockID test enabled.
*
* Revision 1.3 2003/03/12 11:22:15 schlue
* IPR2: Modification acc. to PrioritizedMessage
*
* Revision 1.2 2003/03/03 14:53:13 schlue
* IPR4 (no further use of removeDefinition test)
*
* Revision 1.1 2003/01/17 10:01:19 schlue
* Initial version.
*
*
*
*/
package procdef;
import junit.framework.Test;
import junit.framework.TestSuite;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ByteArrayOutputStream;
import java.rmi.RemoteException;
import java.util.Iterator;
import de.danet.an.util.junit.EJBClientTest;
import de.danet.an.workflow.api.Participant;
import de.danet.an.workflow.api.WorkflowServiceFactory;
import de.danet.an.workflow.api.WorkflowService;
import de.danet.an.workflow.api.Application;
import de.danet.an.workflow.api.ProcessDefinitionDirectory;
import de.danet.an.workflow.api.ProcessDefinition;
import de.danet.an.workflow.api.InvalidKeyException;
import de.danet.an.workflow.api.InvalidIdException;
import de.danet.an.workflow.api.ImportException;
import de.danet.an.workflow.api.PrioritizedMessage;
import process.WfMOpenTestCase;
/**
* Test import of process definitions.
* Afterwards, process descriptions of "minimal" and full are imported
* and can be used for following test cases.
* @author <a href="mailto:schlueter@danet.de">Holger Schlueter</a>
* @version 1.0
*/
public class Import extends WfMOpenTestCase {
/**
* Access to process definition directory (singleton)
*/
private ProcessDefinitionDirectory defDir = null;
/**
* Constructor of this TestCase
* @param name a <code>String</code> value
*/
public Import(String name) {
super (name);
}
/**
* Construct this test suite.
* @return a <code>Test</code> value
*/
public static Test suite() {
TestSuite suite = new TestSuite();
suite.addTest(new Import("readMinimal"));
suite.addTest(new Import("readImplementationIllegal"));
suite.addTest(new Import("readPerformerIllegal"));
suite.addTest(new Import("readActivityRefIllegal"));
suite.addTest(new Import("readTransitionRefIllegal"));
suite.addTest(new Import("readBlockIDRefIllegal"));
suite.addTest(new Import("testDataFields"));
suite.addTest(new Import("testScript"));
suite.addTest(new Import("checkImport"));
suite.addTest(new Create("cleanup"));
return new EJBClientTest (plc, suite);
}
/**
* Test import of a minimal process definition.
* @exception Exception if an error occurs
*/
public void readMinimal() throws Exception {
ByteArrayOutputStream processDefinition = new ByteArrayOutputStream();
// Read minimal (correct) process definition
InputStream is = getClass().getResourceAsStream("/procdef/minimal.xml");
BufferedReader in = new BufferedReader
(new InputStreamReader(is, "ISO-8859-1"));
int bt = -1;
while ((bt = in.read())!= -1) {
processDefinition.write(bt);
}
// Make sure that no such description exists yet
defDir.removeProcessDefinition("SystemTest_minimal", "minimal");
assertTrue(!defDir.processDefinitionExists("SystemTest_minimal", "minimal"));
// Import process definition (using byte[] signature)
defDir.importProcessDefinitions(processDefinition.toByteArray());
assertTrue(defDir.processDefinitionExists("SystemTest_minimal", "minimal"));
}
/**
* Test import of a process definition with illegal implementation
* declaration.
* @exception Exception if an error occurs
*/
public void readImplementationIllegal() throws Exception {
StringBuffer processDefinition = new StringBuffer();
// Read incorrect process definition
InputStream is = getClass()
.getResourceAsStream("/procdef/implementation-illegal.xml");
BufferedReader in = new BufferedReader
(new InputStreamReader(is, "ISO-8859-1"));
String line = null;
while ((line = in.readLine())!= null) {
processDefinition.append(line+"\n");
}
defDir.removeProcessDefinition("SystemTest", "implementation");
assertTrue(!defDir.processDefinitionExists("SystemTest",
"implementation"));
// Try to import the process definition (should fail)
boolean gotException = false;
try {
defDir.importProcessDefinitions(processDefinition.toString());
} catch (ImportException exc) {
assertTrue(exc.messages().size() == 1);
assertTrue(((PrioritizedMessage)exc.messages().get(0)).priority()
.equals(PrioritizedMessage.Priority.ERROR));
assertTrue(((PrioritizedMessage)exc.messages().get(0)).unmappedMessage()
.equals("ImportMessages#procdef.tool.notfound"));
gotException = true;
}
assertTrue(gotException);
// Make sure that it has not been imported (due to errors)
assertTrue(!defDir.processDefinitionExists("SystemTest",
"implementation"));
// Read corrected process definition
is = getClass().getResourceAsStream("/procdef/implementation-correct.xml");
in = new BufferedReader
(new InputStreamReader(is, "ISO-8859-1"));
processDefinition.setLength(0);
while ((line = in.readLine())!= null) {
processDefinition.append(line+"\n");
}
// Import process definition
// Now it should work
defDir.importProcessDefinitions(processDefinition.toString());
assertTrue(defDir.processDefinitionExists("SystemTest",
"implementation"));
// Remove it again
defDir.removeProcessDefinition("SystemTest", "implementation");
assertTrue(!defDir.processDefinitionExists("SystemTest",
"implementation"));
}
/**
* Test import of a process definition with illegal performer
* declaration.
* @exception Exception if an error occurs
*/
public void readPerformerIllegal() throws Exception {
StringBuffer processDefinition = new StringBuffer();
// Read incorrect process definition
InputStream is = getClass()
.getResourceAsStream("/procdef/performer-illegal.xml");
BufferedReader in = new BufferedReader
(new InputStreamReader(is, "ISO-8859-1"));
String line = null;
while ((line = in.readLine())!= null) {
processDefinition.append(line+"\n");
}
defDir.removeProcessDefinition("SystemTest", "performer");
assertTrue(!defDir.processDefinitionExists("SystemTest",
"performer"));
// Try to import the process definition (should fail)
boolean gotException = false;
try {
defDir.importProcessDefinitions(processDefinition.toString());
} catch (ImportException exc) {
assertTrue(exc.messages().size() == 1);
assertTrue(((PrioritizedMessage)exc.messages().get(0)).priority()
.equals(PrioritizedMessage.Priority.ERROR));
assertTrue(((PrioritizedMessage)exc.messages().get(0)).unmappedMessage()
.equals("ImportMessages#procdef.performer.notfound"));
gotException = true;
}
assertTrue(gotException);
// Make sure that it has not been imported (due to errors)
assertTrue(!defDir.processDefinitionExists("SystemTest",
"performer"));
// Read corrected process definition
is = getClass().getResourceAsStream("/procdef/performer-correct.xml");
in = new BufferedReader
(new InputStreamReader(is, "ISO-8859-1"));
processDefinition.setLength(0);
while ((line = in.readLine())!= null) {
processDefinition.append(line+"\n");
}
// Import process definition
// Now it should work
defDir.importProcessDefinitions(processDefinition.toString());
assertTrue(defDir.processDefinitionExists("SystemTest",
"performer"));
// Remove it again
defDir.removeProcessDefinition("SystemTest", "performer");
assertTrue(!defDir.processDefinitionExists("SystemTest",
"performer"));
}
/**
* Test import of a process definition with illegal activity reference
* within transition declaration.
* @exception Exception if an error occurs
*/
public void readActivityRefIllegal() throws Exception {
StringBuffer processDefinition = new StringBuffer();
// Read incorrect process definition
InputStream is = getClass()
.getResourceAsStream("/procdef/activityRef-illegal.xml");
BufferedReader in = new BufferedReader
(new InputStreamReader(is, "ISO-8859-1"));
String line = null;
while ((line = in.readLine())!= null) {
processDefinition.append(line+"\n");
}
defDir.removeProcessDefinition("SystemTest", "activityRef");
assertTrue(!defDir.processDefinitionExists("SystemTest",
"activityRef"));
// Try to import the process definition (should fail)
boolean gotException = false;
try {
defDir.importProcessDefinitions(processDefinition.toString());
} catch (ImportException exc) {
assertTrue(exc.messages().size() == 4);
assertTrue(((PrioritizedMessage)exc.messages().get(0)).priority()
.equals(PrioritizedMessage.Priority.ERROR));
assertTrue(((PrioritizedMessage)exc.messages().get(0)).unmappedMessage()
.equals("ImportMessages#procdef.activity.ununique"));
assertTrue(((PrioritizedMessage)exc.messages().get(1)).priority()
.equals(PrioritizedMessage.Priority.ERROR));
assertTrue(((PrioritizedMessage)exc.messages().get(1)).unmappedMessage()
.endsWith("ImportMessages#procdef.transition.activityid.notfound"));
assertTrue(((PrioritizedMessage)exc.messages().get(2)).priority()
.equals(PrioritizedMessage.Priority.ERROR));
assertTrue(((PrioritizedMessage)exc.messages().get(2)).unmappedMessage()
.endsWith("ImportMessages#procdef.transition.activityid.notfound"));
assertTrue(((PrioritizedMessage)exc.messages().get(3)).priority()
.equals(PrioritizedMessage.Priority.ERROR));
assertTrue(((PrioritizedMessage)exc.messages().get(3)).unmappedMessage()
.equals("ImportMessages#procdef.transition.ununique"));
gotException = true;
}
assertTrue(gotException);
// Make sure that it has not been imported (due to errors)
assertTrue(!defDir.processDefinitionExists("SystemTest",
"activityRef"));
// Read corrected process definition
is = getClass().getResourceAsStream("/procdef/activityRef-correct.xml");
in = new BufferedReader
(new InputStreamReader(is, "ISO-8859-1"));
processDefinition.setLength(0);
while ((line = in.readLine())!= null) {
processDefinition.append(line+"\n");
}
// Import process definition
// Now it should work
defDir.importProcessDefinitions(processDefinition.toString());
assertTrue(defDir.processDefinitionExists("SystemTest",
"activityRef"));
// Remove it again
defDir.removeProcessDefinition("SystemTest", "activityRef");
assertTrue(!defDir.processDefinitionExists("SystemTest",
"activityRef"));
}
/**
* Test import of a process definition with illegal transition reference
* within activity declaration.
* @exception Exception if an error occurs
*/
public void readTransitionRefIllegal() throws Exception {
StringBuffer processDefinition = new StringBuffer();
// Read incorrect process definition
InputStream is = getClass()
.getResourceAsStream("/procdef/transitionRef-illegal.xml");
BufferedReader in = new BufferedReader
(new InputStreamReader(is, "ISO-8859-1"));
String line = null;
while ((line = in.readLine())!= null) {
processDefinition.append(line+"\n");
}
defDir.removeProcessDefinition("SystemTest", "transitionRef");
assertTrue(!defDir.processDefinitionExists("SystemTest",
"transitionRef"));
// Try to import the process definition (should fail)
boolean gotException = false;
try {
defDir.importProcessDefinitions(processDefinition.toString());
} catch (ImportException exc) {
assertTrue(exc.messages().size() == 1);
assertTrue(((PrioritizedMessage)exc.messages().get(0)).priority()
.equals(PrioritizedMessage.Priority.ERROR));
assertTrue(((PrioritizedMessage)exc.messages().get(0)).unmappedMessage()
.equals("ImportMessages#procdef.transitionid.notfound"));
gotException = true;
}
assertTrue(gotException);
// Make sure that it has not been imported (due to errors)
assertTrue(!defDir.processDefinitionExists("SystemTest",
"transitionRef"));
// Read corrected process definition
is = getClass().getResourceAsStream("/procdef/transitionRef-correct.xml");
in = new BufferedReader
(new InputStreamReader(is, "ISO-8859-1"));
processDefinition.setLength(0);
while ((line = in.readLine())!= null) {
processDefinition.append(line+"\n");
}
// Import process definition
// Now it should work
defDir.importProcessDefinitions(processDefinition.toString());
assertTrue(defDir.processDefinitionExists("SystemTest",
"transitionRef"));
// Remove it again
defDir.removeProcessDefinition("SystemTest", "transitionRef");
assertTrue(!defDir.processDefinitionExists("SystemTest",
"transitionRef"));
}
/**
* Test import of a process definition with illegal blockActivity reference
* within activity declaration.
* @exception Exception if an error occurs
*/
public void readBlockIDRefIllegal() throws Exception {
StringBuffer processDefinition = new StringBuffer();
// Read incorrect process definition
InputStream is = getClass()
.getResourceAsStream("/procdef/blockActivityRef-illegal.xml");
BufferedReader in = new BufferedReader
(new InputStreamReader(is, "ISO-8859-1"));
String line = null;
while ((line = in.readLine())!= null) {
processDefinition.append(line+"\n");
}
defDir.removeProcessDefinition("SystemTest", "blockActivityRef");
assertTrue(!defDir.processDefinitionExists("SystemTest",
"blockActivityRef"));
// Try to import the process definition (should fail)
boolean gotException = false;
try {
defDir.importProcessDefinitions(processDefinition.toString());
} catch (ImportException exc) {
Iterator msg = exc.messages().iterator();
assertTrue(exc.messages().size() == 1);
assertTrue(((PrioritizedMessage)exc.messages().get(0)).priority()
.equals(PrioritizedMessage.Priority.ERROR));
assertTrue(((PrioritizedMessage)exc.messages().get(0)).unmappedMessage()
.equals("ImportMessages#procdef.activity.activityset.invalid"));
gotException = true;
}
assertTrue(gotException);
// Make sure that it has not been imported (due to errors)
assertTrue(!defDir.processDefinitionExists("SystemTest",
"blockActivityRef"));
// Read incorrect process definition
is = getClass()
.getResourceAsStream("/procdef/blockActivityRef-emtpyActivitySet.xml");
in = new BufferedReader(new InputStreamReader(is, "ISO-8859-1"));
processDefinition.setLength(0);
while ((line = in.readLine())!= null) {
processDefinition.append(line+"\n");
}
// Try to import the process definition (should fail)
gotException = false;
try {
defDir.importProcessDefinitions(processDefinition.toString());
} catch (ImportException exc) {
Iterator msg = exc.messages().iterator();
assertTrue(exc.messages().size() == 1);
assertTrue(((PrioritizedMessage)exc.messages().get(0)).priority()
.equals(PrioritizedMessage.Priority.ERROR));
assertTrue(((PrioritizedMessage)exc.messages().get(0)).unmappedMessage()
.equals("ImportMessages#procdef.process.activityset.empty"));
gotException = true;
}
assertTrue(gotException);
// Make sure that it has not been imported (due to errors)
assertTrue(!defDir.processDefinitionExists("SystemTest",
"blockActivityRef"));
// Read corrected process definition
is = getClass().getResourceAsStream("/procdef/blockActivityRef-correct.xml");
in = new BufferedReader
(new InputStreamReader(is, "ISO-8859-1"));
processDefinition.setLength(0);
while ((line = in.readLine())!= null) {
processDefinition.append(line+"\n");
}
// Import process definition
// Now it should work
defDir.importProcessDefinitions(processDefinition.toString());
assertTrue(defDir.processDefinitionExists("SystemTest",
"blockActivityRef"));
// Remove it again
defDir.removeProcessDefinition("SystemTest", "blockActivityRef");
assertTrue(!defDir.processDefinitionExists("SystemTest",
"blockActivityRef"));
}
/**
* Test rejection of illegal script declaration.
* @exception Exception if an error occurs
*/
public void testScript() throws Exception {
StringBuffer processDefinition = new StringBuffer();
// Read incorrect process definition
InputStream is = getClass()
.getResourceAsStream("/procdef/illegalScriptType.xml");
BufferedReader in = new BufferedReader
(new InputStreamReader(is, "ISO-8859-1"));
String line = null;
while ((line = in.readLine())!= null) {
processDefinition.append(line+"\n");
}
// Try to import the process definition (should fail)
boolean gotException = false;
try {
defDir.importProcessDefinitions(processDefinition.toString());
} catch (ImportException exc) {
Iterator msg = exc.messages().iterator();
assertTrue(exc.messages().size() == 1);
assertTrue(((PrioritizedMessage)exc.messages().get(0)).priority()
.equals(PrioritizedMessage.Priority.ERROR));
assertTrue(((PrioritizedMessage)exc.messages().get(0)).unmappedMessage()
.equals("ImportMessages#package.script.type.unsupported"));
gotException = true;
}
assertTrue("PR53", gotException);
is = getClass()
.getResourceAsStream("/procdef/illegalScriptVersion.xml");
in = new BufferedReader(new InputStreamReader(is, "ISO-8859-1"));
processDefinition.setLength(0);
while ((line = in.readLine())!= null) {
processDefinition.append(line+"\n");
}
// Try to import the process definition (should fail)
gotException = false;
try {
defDir.importProcessDefinitions(processDefinition.toString());
} catch (ImportException exc) {
Iterator msg = exc.messages().iterator();
assertTrue(exc.messages().size() == 1);
assertTrue(((PrioritizedMessage)exc.messages().get(0)).priority()
.equals(PrioritizedMessage.Priority.ERROR));
assertTrue(((PrioritizedMessage)exc.messages().get(0)).unmappedMessage()
.equals("ImportMessages#package.script.version.unsupported"));
gotException = true;
}
assertTrue("PR53", gotException);
}
/**
* Test that process definitions have been correctly imported
* @exception Exception if an error occurs
*/
public void checkImport() throws Exception {
StringBuffer processDefinition = new StringBuffer();
// Read correct process definition
InputStream is = getClass().getResourceAsStream("/procdef/full.xml");
BufferedReader in = new BufferedReader
(new InputStreamReader(is, "ISO-8859-1"));
String line = null;
while ((line = in.readLine())!= null) {
processDefinition.append(line+"\n");
}
try {defDir.importProcessDefinitions(processDefinition.toString());
} catch (ImportException exc) {
Iterator msg = exc.messages().iterator();
while (msg.hasNext()) {
System.out.println(((PrioritizedMessage)msg.next()).unmappedMessage());
}
}
// Test all attributes of process definition
ProcessDefinition procdef = defDir.lookupProcessDefinition("SystemTest_full",
"full");
boolean gotException = false;
try {
procdef.applicationById("Dummy");
} catch (InvalidIdException exc) {
gotException = true;
}
assertTrue(gotException);
Application appl = procdef.applicationById("dummy");
assertTrue(appl.description().equals("Dummy application for testing"
+ " purposes only."));
assertTrue(appl.id().equals("dummy"));
assertTrue(procdef.applications().size() == 1);
assertTrue(((Application)procdef.applications().iterator().next())
.id().equals("dummy"));
gotException = false;
try {
procdef.participantById("CurrentUser");
} catch (InvalidIdException exc) {
gotException = true;
}
assertTrue(gotException);
Participant part = procdef.participantById("currentUser");
assertTrue(part.getId().equals("currentUser"));
assertTrue(part.getName().equals("Aktueller Benutzer"));
assertTrue(part.getParticipantType()
.equals(Participant.ParticipantType.HUMAN));
assertTrue(procdef.participants().size() == 1);
assertTrue(((Participant)procdef.participants().iterator().next())
.getId().equals("currentUser"));
assertTrue(procdef.removeClosedProcess());
assertTrue(procdef.cleanupMode() == ProcessDefinition.REMOVE_AUTOMATIC);
assertTrue(procdef.packageId().equals("SystemTest_full"));
assertTrue(procdef.processId().equals("full"));
assertTrue(procdef.packageName().equals("System Test (procdef)"));
assertTrue(procdef.processName().equals("PROCESS_COMPLETE_ATTRIBUTES"));
assertTrue(procdef.mgrName().equals("SystemTest_full/full"));
ProcessDefinition.ProcessHeaderData hdr = procdef.processHeader();
assertTrue(hdr.created().equals("Tue Jan 14 14:58:01 CEST 2003"));
assertTrue(hdr.description().equals("Description for test of all"
+ " accessible attributes"));
assertTrue(hdr.priority().equals("5"));
assertTrue(hdr.limit().equals("3 days"));
assertTrue(hdr.validFrom().equals("Tue Jan 14 15:00:00 CEST 2003"));
assertTrue(hdr.validTo().equals("Tue Jan 14 15:59:59 CEST 2003"));
assertTrue(hdr.timeEstimationWaiting().equals("Wait"));
assertTrue(hdr.timeEstimationWorking().equals("Work"));
assertTrue(hdr.timeEstimationDuration().equals("Dur"));
ProcessDefinition.PackageHeaderData phdr = hdr.packageHeader();
assertTrue(phdr.xpdlVersion().equals("1.0"));
assertTrue(phdr.vendor().equals("Danet GmbH, GS AN"));
assertTrue(phdr.created().equals("Tue Jan 14 14:59:01 CEST 2003"));
assertTrue(phdr.description().equals("Package for system test"));
assertTrue(phdr.documentation().equals("C:/Workflow/help.xml"));
assertTrue(phdr.priorityUnit().equals("prio"));
assertTrue(phdr.costUnit().equals("cost"));
// Make sure that processes exist
assertTrue(defDir.processDefinitionExists("SystemTest_minimal", "minimal"));
assertTrue(defDir.processDefinitionExists("SystemTest_full", "full"));
}
/**
* Test references to data fields and/or formal parameters.
* @exception Exception if an error occurs
*/
public void testDataFields() throws Exception {
StringBuffer processDefinition = new StringBuffer();
// Read process definition with parameter that has not been declared
InputStream is = getClass()
.getResourceAsStream("/procdef/paramNotDeclared.xml");
BufferedReader in = new BufferedReader
(new InputStreamReader(is, "ISO-8859-1"));
String line = null;
while ((line = in.readLine())!= null) {
processDefinition.append(line+"\n");
}
boolean gotException = false;
try {defDir.importProcessDefinitions(processDefinition.toString());
} catch (ImportException exc) {
assertTrue(exc.messages().size() == 1);
assertTrue(((PrioritizedMessage)exc.messages().get(0)).priority()
.equals(PrioritizedMessage.Priority.ERROR));
assertTrue(((PrioritizedMessage)exc.messages().get(0)).unmappedMessage()
.equals("ImportMessages#procdef.activity.subflow.datanotfound"));
gotException = true;
}
assertTrue(gotException);
// Read process definition with illegal subflow call
// (called subflow with less params than declared)
is = getClass().getResourceAsStream("/procdef/tooFewParameters.xml");
in = new BufferedReader(new InputStreamReader(is, "ISO-8859-1"));
processDefinition.setLength(0);
while ((line = in.readLine())!= null) {
processDefinition.append(line+"\n");
}
gotException = false;
try {defDir.importProcessDefinitions(processDefinition.toString());
} catch (ImportException exc) {
assertTrue(exc.messages().size() == 1);
assertTrue(((PrioritizedMessage)exc.messages().get(0)).priority()
.equals(PrioritizedMessage.Priority.ERROR));
assertTrue(((PrioritizedMessage)exc.messages().get(0)).unmappedMessage()
.equals("ImportMessages#procdef.activity.subflow.params.notmatched"));
gotException = true;
}
assertTrue(gotException);
// Read process definition with illegal subflow call
// (called subflow with more params than declared)
is = getClass().getResourceAsStream("/procdef/tooManyParameters.xml");
in = new BufferedReader(new InputStreamReader(is, "ISO-8859-1"));
processDefinition.setLength(0);
while ((line = in.readLine())!= null) {
processDefinition.append(line+"\n");
}
gotException = false;
try {defDir.importProcessDefinitions(processDefinition.toString());
} catch (ImportException exc) {
assertTrue(exc.messages().size() == 1);
assertTrue(((PrioritizedMessage)exc.messages().get(0)).priority()
.equals(PrioritizedMessage.Priority.ERROR));
assertTrue(((PrioritizedMessage)exc.messages().get(0)).unmappedMessage()
.equals("ImportMessages#procdef.activity.subflow.params.notmatched"));
gotException = true;
}
assertTrue(gotException);
// Read process definition with illegal subflow call
// (calling subflow with OUT param)
is = getClass().getResourceAsStream("/procdef/callingWithOUTParam.xml");
in = new BufferedReader(new InputStreamReader(is, "ISO-8859-1"));
processDefinition.setLength(0);
while ((line = in.readLine())!= null) {
processDefinition.append(line+"\n");
}
gotException = false;
try {defDir.importProcessDefinitions(processDefinition.toString());
} catch (ImportException exc) {
assertTrue(exc.messages().size() == 1);
assertTrue(((PrioritizedMessage)exc.messages().get(0)).priority()
.equals(PrioritizedMessage.Priority.ERROR));
assertTrue(((PrioritizedMessage)exc.messages().get(0)).unmappedMessage()
.equals("ImportMessages#procdef.activity.subflow.parammode.notmatched"));
gotException = true;
}
assertTrue(gotException);
// Read process definition with illegal subflow call
// (calling subflow with constant as INOUT parameter)
is = getClass().getResourceAsStream("/procdef/callingOUTNotDeclared.xml");
in = new BufferedReader(new InputStreamReader(is, "ISO-8859-1"));
processDefinition.setLength(0);
while ((line = in.readLine())!= null) {
processDefinition.append(line+"\n");
}
gotException = false;
try {defDir.importProcessDefinitions(processDefinition.toString());
} catch (ImportException exc) {
assertTrue(exc.messages().size() == 1);
assertTrue(((PrioritizedMessage)exc.messages().get(0)).priority()
.equals(PrioritizedMessage.Priority.ERROR));
assertTrue(((PrioritizedMessage)exc.messages().get(0)).unmappedMessage()
.equals("ImportMessages#procdef.activity.subflow.datanotfound"));
gotException = true;
}
assertTrue(gotException);
// Read process definition with illegal subflow call
// (param type mismatch)
is = getClass().getResourceAsStream("/procdef/paramTypeMismatch.xml");
in = new BufferedReader(new InputStreamReader(is, "ISO-8859-1"));
processDefinition.setLength(0);
while ((line = in.readLine())!= null) {
processDefinition.append(line+"\n");
}
gotException = false;
try {defDir.importProcessDefinitions(processDefinition.toString());
} catch (ImportException exc) {
assertTrue(exc.messages().size() == 1);
assertTrue(((PrioritizedMessage)exc.messages().get(0)).priority()
.equals(PrioritizedMessage.Priority.ERROR));
assertTrue(((PrioritizedMessage)exc.messages().get(0)).unmappedMessage()
.equals("ImportMessages#procdef.activity.subflow.paramdatatype.notmatched"));
gotException = true;
}
// s. PR 48: assertTrue(gotException);
}
/**
* Remove all imported process definitions.
* @exception Exception if an error occurs
*/
public void cleanup() throws Exception {
defDir.removeProcessDefinition("SystemTest_minimal", "minimal");
boolean procdefRemoved = false;
try {
defDir.processMgr("SystemTest_minimal", "minimal");
} catch (InvalidKeyException exc) {
procdefRemoved = true;
}
assertTrue(procdefRemoved);
defDir.removeProcessDefinition("SystemTest_full", "full");
procdefRemoved = false;
try {
defDir.processMgr("SystemTest_full", "full");
} catch (InvalidKeyException exc) {
procdefRemoved = true;
}
assertTrue(procdefRemoved);
}
/**
* Initialisation.
* The <code>setUp</code> method defines the way a state change is
* realized. Override this method to change this way.
* @exception Exception if an error occurs
*/
protected void setUp() throws Exception {
super.setUp();
WorkflowService wfs = WorkflowServiceFactory.newInstance()
.newWorkflowService();
try {
defDir = wfs.processDefinitionDirectory();
} catch(RemoteException exc) {
System.err.println("Process definition directory not accessible: "
+ exc.getMessage());
System.exit(-1);
}
}
}