001: /*
002: * $Id: BPELProcessTest.java,v 1.8 2004/11/22 08:48:09 kowap Exp $
003: *
004: * Copyright (c) 2004 Patric Fornasier, Pawel Kowalski
005: * Berne University of Applied Sciences
006: * School of Engineering and Information Technology
007: * All rights reserved.
008: */
009: package bexee.model;
010:
011: import java.util.*;
012:
013: import javax.xml.namespace.QName;
014:
015: import org.jmock.*;
016:
017: import bexee.core.*;
018: import bexee.model.activity.*;
019: import bexee.model.activity.impl.*;
020: import bexee.model.elements.*;
021: import bexee.model.elements.impl.*;
022: import bexee.model.process.Process;
023: import bexee.model.process.impl.ProcessImpl;
024:
025: /**
026: * @version $Revision: 1.8 $, $Date: 2004/11/22 08:48:09 $
027: * @author Pawel Kowalski
028: */
029: public class BPELProcessTest extends MockObjectTestCase {
030:
031: /*
032: * @see TestCase#setUp()
033: */
034: protected void setUp() throws Exception {
035: super .setUp();
036: }
037:
038: /*
039: * @see TestCase#tearDown()
040: */
041: protected void tearDown() throws Exception {
042: super .tearDown();
043: }
044:
045: //**************************************************/
046: // test
047: //**************************************************/
048:
049: public final void testCreateBPELElements() {
050:
051: // test partnerlink one
052: //
053: String clientPartnerLinkName = "client";
054: PartnerLink clientPartnerLink = new PartnerLinkImpl();
055: assertNotNull(clientPartnerLink);
056: clientPartnerLink.setName(clientPartnerLinkName);
057: assertEquals(clientPartnerLinkName, clientPartnerLink.getName());
058:
059: // test partnerlink two
060: //
061: String servicePartnerLinkName = "service";
062: PartnerLink servicePartnerLink = new PartnerLinkImpl();
063: assertNotNull(servicePartnerLink);
064: servicePartnerLink.setName(servicePartnerLinkName);
065: assertEquals(servicePartnerLinkName, servicePartnerLink
066: .getName());
067:
068: // test variable input
069: //
070: String inputVariableName = "input";
071: QName messageType = new QName("tns", "ReceiveRequestMessage");
072: Variable inputVariable = new VariableImpl();
073: assertNotNull(inputVariable);
074: inputVariable.setName(inputVariableName);
075: inputVariable.setMessageType(messageType);
076: assertEquals(inputVariableName, inputVariable.getName());
077: assertEquals(messageType, inputVariable.getMessageType());
078:
079: // test variable response
080: //
081: String responseVariableName = "response";
082: messageType = new QName("tns", "ReceiveResultMessage");
083: Variable responseVariable = new VariableImpl();
084: assertNotNull(responseVariable);
085: responseVariable.setName(responseVariableName);
086: responseVariable.setMessageType(messageType);
087: assertEquals(responseVariableName, responseVariable.getName());
088: assertEquals(messageType, responseVariable.getMessageType());
089:
090: // test sequence
091: //
092: Sequence sequence = new SequenceImpl();
093: assertNotNull(sequence);
094:
095: // test the first receive
096: //
097: String receiveName = "receiveInput";
098: String operationName = "initiate";
099: boolean createInstance = true;
100: // create receive and set parameters
101: //
102: Receive receiveInput = new ReceiveImpl();
103: assertNotNull(receiveInput);
104: receiveInput.setName(receiveName);
105: receiveInput.setPartnerLink(clientPartnerLink);
106: receiveInput.setOperation(operationName);
107: receiveInput.setVariable(inputVariable);
108: receiveInput.setCreateInstance(createInstance);
109: // test the receive element
110: //
111: assertEquals(receiveName, receiveInput.getName());
112: assertEquals(clientPartnerLink, receiveInput.getPartnerLink());
113: assertEquals(operationName, receiveInput.getOperation());
114: assertEquals(inputVariable, receiveInput.getVariable());
115: assertEquals(createInstance, receiveInput.isCreateInstance());
116:
117: // test the invoke
118: //
119: String invokeName = "asynchInvoke";
120: QName invokePortType = new QName("services",
121: "AsynchBPELService");
122: String invokeOperationName = "initiate";
123: // create invoke and set parameters
124: //
125: Invoke invoke = new InvokeImpl();
126: assertNotNull(invoke);
127: invoke.setName(invokeName);
128: invoke.setPartnerLink(servicePartnerLink);
129: invoke.setPortType(invokePortType);
130: invoke.setOperation(invokeOperationName);
131: invoke.setInputVariable(inputVariable);
132: // test the invoke element
133: //
134: assertEquals(invokeName, invoke.getName());
135: assertEquals(servicePartnerLink, invoke.getPartnerLink());
136: assertEquals(invokePortType, invoke.getPortType());
137: assertEquals(invokeOperationName, invoke.getOperation());
138: assertEquals(inputVariable, invoke.getInputVariable());
139:
140: // test the response receive
141: //
142: receiveName = "receiveResult";
143: operationName = "onResult";
144: createInstance = false;
145: QName receiveResultPortType = new QName("services",
146: "AsyncBPELServiceCallback");
147: // create receive and set parameters
148: //
149: Receive receiveResult = new ReceiveImpl();
150: receiveResult.setName(receiveName);
151: receiveResult.setPartnerLink(servicePartnerLink);
152: receiveResult.setOperation(operationName);
153: receiveResult.setVariable(responseVariable);
154: // test the receive element
155: //
156: assertNotNull(receiveResult);
157: assertEquals(receiveName, receiveResult.getName());
158: assertEquals(servicePartnerLink, receiveResult.getPartnerLink());
159: assertEquals(operationName, receiveResult.getOperation());
160: assertEquals(responseVariable, receiveResult.getVariable());
161: assertEquals(createInstance, receiveResult.isCreateInstance());
162:
163: // compose the sequence
164: //
165: sequence.addActivity(receiveInput);
166: sequence.addActivity(invoke);
167: sequence.addActivity(receiveResult);
168: // test the sequence
169: //
170: Collection sequenceActivities = sequence.getActivities();
171: assertEquals(sequenceActivities.size(), 3);
172: Iterator iter = sequenceActivities.iterator();
173: assertEquals(receiveInput, (Activity) iter.next());
174: assertTrue(iter.hasNext());
175: assertEquals(invoke, (Activity) iter.next());
176: assertTrue(iter.hasNext());
177: assertEquals(receiveResult, (Activity) iter.next());
178: assertFalse(iter.hasNext());
179:
180: // create the process
181: //
182: String processName = "bexeeExample";
183: Process process = new ProcessImpl();
184: assertNotNull(process);
185: process.setName(processName);
186: process.setPartnerLinks(new PartnerLinksImpl());
187: process.getPartnerLinks().addPartnerLink(clientPartnerLink);
188: process.getPartnerLinks().addPartnerLink(servicePartnerLink);
189: process.setVariables(new VariablesImpl());
190: process.getVariables().addVariable(inputVariable);
191: process.getVariables().addVariable(responseVariable);
192: process.setActivity(sequence);
193: // test the process
194: //
195: assertEquals(processName, process.getName());
196: assertTrue(process.getPartnerLinks().getPartnerLinks()
197: .contains(clientPartnerLink));
198: assertTrue(process.getPartnerLinks().getPartnerLinks()
199: .contains(servicePartnerLink));
200: assertTrue(process.getVariables().getVariables().contains(
201: inputVariable));
202: assertTrue(process.getVariables().getVariables().contains(
203: responseVariable));
204: assertEquals(sequence, process.getActivity());
205:
206: // test process double dispatch during initiation
207: //
208: Mock mockProcessController = new Mock(ProcessController.class);
209: ProcessInstance processInstance = new ProcessInstance(null,
210: null);
211:
212: mockProcessController.expects(once()).method("process").with(
213: same(process), same(processInstance));
214: mockProcessController.expects(once()).method("process").with(
215: same(inputVariable), same(processInstance));
216: mockProcessController.expects(once()).method("process").with(
217: same(responseVariable), same(processInstance));
218: mockProcessController.expects(once()).method("process").with(
219: same(clientPartnerLink), same(processInstance));
220: mockProcessController.expects(once()).method("process").with(
221: same(servicePartnerLink), same(processInstance));
222: mockProcessController.expects(once()).method("process").with(
223: same(sequence), same(processInstance));
224: mockProcessController.expects(once()).method("process").with(
225: same(receiveInput), same(processInstance));
226: mockProcessController.expects(once()).method("process").with(
227: same(invoke), same(processInstance));
228: mockProcessController.expects(once()).method("process").with(
229: same(receiveResult), same(processInstance));
230:
231: try {
232: process.accept((ProcessController) mockProcessController
233: .proxy(), processInstance);
234: inputVariable.accept(
235: (ProcessController) mockProcessController.proxy(),
236: processInstance);
237: responseVariable.accept(
238: (ProcessController) mockProcessController.proxy(),
239: processInstance);
240: clientPartnerLink.accept(
241: (ProcessController) mockProcessController.proxy(),
242: processInstance);
243: servicePartnerLink.accept(
244: (ProcessController) mockProcessController.proxy(),
245: processInstance);
246: sequence.accept((ProcessController) mockProcessController
247: .proxy(), processInstance);
248: receiveInput.accept(
249: (ProcessController) mockProcessController.proxy(),
250: processInstance);
251: invoke.accept((ProcessController) mockProcessController
252: .proxy(), processInstance);
253: receiveResult.accept(
254: (ProcessController) mockProcessController.proxy(),
255: processInstance);
256: } catch (Exception e) {
257: fail("Shoult not throw an Exception");
258:
259: }
260:
261: mockProcessController.verify();
262:
263: }
264: }
|