BPELProcessTest.java :  » Workflow-Engines » bexee » bexee » model » Java Open Source

/*
 * $Id: BPELProcessTest.java,v 1.8 2004/11/22 08:48:09 kowap Exp $
 *
 * Copyright (c) 2004 Patric Fornasier, Pawel Kowalski
 * Berne University of Applied Sciences
 * School of Engineering and Information Technology
 * All rights reserved.
 */
package bexee.model;

import java.util.*;

import javax.xml.namespace.QName;

import org.jmock.*;

import bexee.core.*;
import bexee.model.activity.*;
import bexee.model.activity.impl.*;
import bexee.model.elements.*;
import bexee.model.elements.impl.*;
import bexee.model.process.Process;
import bexee.model.process.impl.ProcessImpl;

/**
 * @version $Revision: 1.8 $, $Date: 2004/11/22 08:48:09 $
 * @author Pawel Kowalski
 */
public class BPELProcessTest extends MockObjectTestCase {

    /*
     * @see TestCase#setUp()
     */
    protected void setUp() throws Exception {
        super.setUp();
    }

    /*
     * @see TestCase#tearDown()
     */
    protected void tearDown() throws Exception {
        super.tearDown();
    }

    //**************************************************/
    // test
    //**************************************************/

    public final void testCreateBPELElements() {

        // test partnerlink one
        //
        String clientPartnerLinkName = "client";
        PartnerLink clientPartnerLink = new PartnerLinkImpl();
        assertNotNull(clientPartnerLink);
        clientPartnerLink.setName(clientPartnerLinkName);
        assertEquals(clientPartnerLinkName, clientPartnerLink.getName());

        // test partnerlink two
        //
        String servicePartnerLinkName = "service";
        PartnerLink servicePartnerLink = new PartnerLinkImpl();
        assertNotNull(servicePartnerLink);
        servicePartnerLink.setName(servicePartnerLinkName);
        assertEquals(servicePartnerLinkName, servicePartnerLink.getName());

        // test variable input
        //
        String inputVariableName = "input";
        QName messageType = new QName("tns", "ReceiveRequestMessage");
        Variable inputVariable = new VariableImpl();
        assertNotNull(inputVariable);
        inputVariable.setName(inputVariableName);
        inputVariable.setMessageType(messageType);
        assertEquals(inputVariableName, inputVariable.getName());
        assertEquals(messageType, inputVariable.getMessageType());

        // test variable response
        //
        String responseVariableName = "response";
        messageType = new QName("tns", "ReceiveResultMessage");
        Variable responseVariable = new VariableImpl();
        assertNotNull(responseVariable);
        responseVariable.setName(responseVariableName);
        responseVariable.setMessageType(messageType);
        assertEquals(responseVariableName, responseVariable.getName());
        assertEquals(messageType, responseVariable.getMessageType());

        // test sequence
        //
        Sequence sequence = new SequenceImpl();
        assertNotNull(sequence);

        // test the first receive
        //
        String receiveName = "receiveInput";
        String operationName = "initiate";
        boolean createInstance = true;
        // create receive and set parameters
        //
        Receive receiveInput = new ReceiveImpl();
        assertNotNull(receiveInput);
        receiveInput.setName(receiveName);
        receiveInput.setPartnerLink(clientPartnerLink);
        receiveInput.setOperation(operationName);
        receiveInput.setVariable(inputVariable);
        receiveInput.setCreateInstance(createInstance);
        // test the receive element
        //
        assertEquals(receiveName, receiveInput.getName());
        assertEquals(clientPartnerLink, receiveInput.getPartnerLink());
        assertEquals(operationName, receiveInput.getOperation());
        assertEquals(inputVariable, receiveInput.getVariable());
        assertEquals(createInstance, receiveInput.isCreateInstance());

        // test the invoke
        //
        String invokeName = "asynchInvoke";
        QName invokePortType = new QName("services", "AsynchBPELService");
        String invokeOperationName = "initiate";
        // create invoke and set parameters
        //
        Invoke invoke = new InvokeImpl();
        assertNotNull(invoke);
        invoke.setName(invokeName);
        invoke.setPartnerLink(servicePartnerLink);
        invoke.setPortType(invokePortType);
        invoke.setOperation(invokeOperationName);
        invoke.setInputVariable(inputVariable);
        // test the invoke element
        //
        assertEquals(invokeName, invoke.getName());
        assertEquals(servicePartnerLink, invoke.getPartnerLink());
        assertEquals(invokePortType, invoke.getPortType());
        assertEquals(invokeOperationName, invoke.getOperation());
        assertEquals(inputVariable, invoke.getInputVariable());

        // test the response receive
        //
        receiveName = "receiveResult";
        operationName = "onResult";
        createInstance = false;
        QName receiveResultPortType = new QName("services",
                "AsyncBPELServiceCallback");
        // create receive and set parameters
        //
        Receive receiveResult = new ReceiveImpl();
        receiveResult.setName(receiveName);
        receiveResult.setPartnerLink(servicePartnerLink);
        receiveResult.setOperation(operationName);
        receiveResult.setVariable(responseVariable);
        // test the receive element
        //
        assertNotNull(receiveResult);
        assertEquals(receiveName, receiveResult.getName());
        assertEquals(servicePartnerLink, receiveResult.getPartnerLink());
        assertEquals(operationName, receiveResult.getOperation());
        assertEquals(responseVariable, receiveResult.getVariable());
        assertEquals(createInstance, receiveResult.isCreateInstance());

        // compose the sequence
        //
        sequence.addActivity(receiveInput);
        sequence.addActivity(invoke);
        sequence.addActivity(receiveResult);
        // test the sequence
        //
        Collection sequenceActivities = sequence.getActivities();
        assertEquals(sequenceActivities.size(), 3);
        Iterator iter = sequenceActivities.iterator();
        assertEquals(receiveInput, (Activity) iter.next());
        assertTrue(iter.hasNext());
        assertEquals(invoke, (Activity) iter.next());
        assertTrue(iter.hasNext());
        assertEquals(receiveResult, (Activity) iter.next());
        assertFalse(iter.hasNext());

        // create the process
        //
        String processName = "bexeeExample";
        Process process = new ProcessImpl();
        assertNotNull(process);
        process.setName(processName);
        process.setPartnerLinks(new PartnerLinksImpl());
        process.getPartnerLinks().addPartnerLink(clientPartnerLink);
        process.getPartnerLinks().addPartnerLink(servicePartnerLink);
        process.setVariables(new VariablesImpl());
        process.getVariables().addVariable(inputVariable);
        process.getVariables().addVariable(responseVariable);
        process.setActivity(sequence);
        // test the process
        //
        assertEquals(processName, process.getName());
        assertTrue(process.getPartnerLinks().getPartnerLinks().contains(
                clientPartnerLink));
        assertTrue(process.getPartnerLinks().getPartnerLinks().contains(
                servicePartnerLink));
        assertTrue(process.getVariables().getVariables()
                .contains(inputVariable));
        assertTrue(process.getVariables().getVariables().contains(
                responseVariable));
        assertEquals(sequence, process.getActivity());

        // test process double dispatch during initiation
        //
        Mock mockProcessController = new Mock(ProcessController.class);
        ProcessInstance processInstance = new ProcessInstance(null, null);

        mockProcessController.expects(once()).method("process").with(
                same(process), same(processInstance));
        mockProcessController.expects(once()).method("process").with(
                same(inputVariable), same(processInstance));
        mockProcessController.expects(once()).method("process").with(
                same(responseVariable), same(processInstance));
        mockProcessController.expects(once()).method("process").with(
                same(clientPartnerLink), same(processInstance));
        mockProcessController.expects(once()).method("process").with(
                same(servicePartnerLink), same(processInstance));
        mockProcessController.expects(once()).method("process").with(
                same(sequence), same(processInstance));
        mockProcessController.expects(once()).method("process").with(
                same(receiveInput), same(processInstance));
        mockProcessController.expects(once()).method("process").with(
                same(invoke), same(processInstance));
        mockProcessController.expects(once()).method("process").with(
                same(receiveResult), same(processInstance));

        try {
            process.accept((ProcessController) mockProcessController.proxy(),
                    processInstance);
            inputVariable.accept((ProcessController) mockProcessController
                    .proxy(), processInstance);
            responseVariable.accept((ProcessController) mockProcessController
                    .proxy(), processInstance);
            clientPartnerLink.accept((ProcessController) mockProcessController
                    .proxy(), processInstance);
            servicePartnerLink.accept((ProcessController) mockProcessController
                    .proxy(), processInstance);
            sequence.accept((ProcessController) mockProcessController.proxy(),
                    processInstance);
            receiveInput.accept((ProcessController) mockProcessController
                    .proxy(), processInstance);
            invoke.accept((ProcessController) mockProcessController.proxy(),
                    processInstance);
            receiveResult.accept((ProcessController) mockProcessController
                    .proxy(), processInstance);
        } catch (Exception e) {
            fail("Shoult not throw an Exception");

        }

        mockProcessController.verify();

    }
}