* Copyright 2006-2010 the original author or authors.

*

* 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.

*/

* @author Christoph Deppisch

*/

    private Endpoint endpoint = EasyMock.createMock(Endpoint.class);

    private SelectiveConsumer consumer = EasyMock.createMock(SelectiveConsumer.class);

    private EndpointConfiguration endpointConfiguration = EasyMock.createMock(EndpointConfiguration.class);

   

    private DomXmlMessageValidator validator = new DomXmlMessageValidator();

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

  public void testReceiveMessageWithMessagePayloadData() {

    ReceiveMessageAction receiveAction = new ReceiveMessageAction();

    receiveAction.setEndpoint(endpoint);

   

    TestActor testActor = new TestActor();

        testActor.setName("TESTACTOR");

       

        receiveAction.setActor(testActor);

       

    receiveAction.setValidator(validator);

    PayloadTemplateMessageBuilder controlMessageBuilder = new PayloadTemplateMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        controlMessageBuilder.setPayloadData("<TestRequest><Message>Hello World!</Message></TestRequest>");

   

        Message controlMessage = new DefaultMessage("<TestRequest><Message>Hello World!</Message></TestRequest>");

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

   

    List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        receiveAction.execute(context);

   

    verify(endpoint, consumer, endpointConfiguration);

  }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageWithMessagePayloadResource() {

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

       

        receiveAction.setValidator(validator);

        PayloadTemplateMessageBuilder controlMessageBuilder = new PayloadTemplateMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        controlMessageBuilder.setPayloadResourcePath("classpath:com/consol/citrus/actions/test-request-payload.xml");

       

        final Message controlMessage = new DefaultMessage("<TestRequest><Message>Hello World!</Message></TestRequest>");

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

       

        List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        receiveAction.execute(context);

        verify(endpoint, consumer, endpointConfiguration);

    }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageWithMessageBuilderScriptData() {

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

        receiveAction.setValidator(validator);

        StringBuilder sb = new StringBuilder();

        sb.append("markupBuilder.TestRequest(){\n");

        sb.append("Message('Hello World!')\n");

        sb.append("}");

       

        receiveAction.setValidator(validator);

        GroovyScriptMessageBuilder controlMessageBuilder = new GroovyScriptMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        controlMessageBuilder.setScriptData(sb.toString());

       

        Message controlMessage = new DefaultMessage("<TestRequest><Message>Hello World!</Message></TestRequest>");

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

       

        List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        receiveAction.execute(context);

        verify(endpoint, consumer, endpointConfiguration);

    }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageWithMessageBuilderScriptDataVariableSupport() {

        context.setVariable("text", "Hello World!");

       

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

        receiveAction.setValidator(validator);

        StringBuilder sb = new StringBuilder();

        sb.append("markupBuilder.TestRequest(){\n");

        sb.append("Message('${text}')\n");

        sb.append("}");

       

        receiveAction.setValidator(validator);

        GroovyScriptMessageBuilder controlMessageBuilder = new GroovyScriptMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        controlMessageBuilder.setScriptData(sb.toString());

       

        Message controlMessage = new DefaultMessage("<TestRequest><Message>Hello World!</Message></TestRequest>");

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

       

        List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        receiveAction.execute(context);

        verify(endpoint, consumer, endpointConfiguration);

    }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageWithMessageBuilderScriptResource() {

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

        receiveAction.setValidator(validator);

        receiveAction.setValidator(validator);

        GroovyScriptMessageBuilder controlMessageBuilder = new GroovyScriptMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        controlMessageBuilder.setScriptResourcePath("classpath:com/consol/citrus/actions/test-request-payload.groovy");

       

        final Message controlMessage = new DefaultMessage("<TestRequest><Message>Hello World!</Message></TestRequest>");

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

       

        List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        receiveAction.execute(context);

        verify(endpoint, consumer, endpointConfiguration);

    }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageWithMessagePayloadDataVariablesSupport() {

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

        receiveAction.setValidator(validator);

        PayloadTemplateMessageBuilder controlMessageBuilder = new PayloadTemplateMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        controlMessageBuilder.setPayloadData("<TestRequest><Message>${myText}</Message></TestRequest>");

       

        context.setVariable("myText", "Hello World!");

       

        Message controlMessage = new DefaultMessage("<TestRequest><Message>Hello World!</Message></TestRequest>");

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

       

        List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        receiveAction.execute(context);

        verify(endpoint, consumer, endpointConfiguration);

    }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageWithMessagePayloadResourceVariablesSupport() {

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

        receiveAction.setValidator(validator);

        receiveAction.setValidator(validator);

        PayloadTemplateMessageBuilder controlMessageBuilder = new PayloadTemplateMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        controlMessageBuilder.setPayloadResourcePath("classpath:com/consol/citrus/actions/test-request-payload-with-variables.xml");

       

        context.setVariable("myText", "Hello World!");

       

        final Message controlMessage = new DefaultMessage("<TestRequest><Message>Hello World!</Message></TestRequest>");

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

       

        List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        receiveAction.execute(context);

        verify(endpoint, consumer, endpointConfiguration);

    }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageWithMessagePayloadResourceFunctionsSupport() {

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

        receiveAction.setValidator(validator);

        receiveAction.setValidator(validator);

        PayloadTemplateMessageBuilder controlMessageBuilder = new PayloadTemplateMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        controlMessageBuilder.setPayloadResourcePath("classpath:com/consol/citrus/actions/test-request-payload-with-functions.xml");

       

        final Message controlMessage = new DefaultMessage("<TestRequest><Message>Hello World!</Message></TestRequest>");

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

       

        List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        receiveAction.execute(context);

        verify(endpoint, consumer, endpointConfiguration);

    }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageOverwriteMessageElementsXPath() {

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

        receiveAction.setValidator(validator);

        PayloadTemplateMessageBuilder controlMessageBuilder = new PayloadTemplateMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        controlMessageBuilder.setPayloadData("<TestRequest><Message>?</Message></TestRequest>");

       

        Map<String, String> overwriteElements = new HashMap<String, String>();

        overwriteElements.put("/TestRequest/Message", "Hello World!");

       

        XpathMessageConstructionInterceptor interceptor = new XpathMessageConstructionInterceptor(overwriteElements);

        controlMessageBuilder.add(interceptor);

       

        Message controlMessage = new DefaultMessage("<TestRequest><Message>Hello World!</Message></TestRequest>");

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

       

        List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        receiveAction.execute(context);

        verify(endpoint, consumer, endpointConfiguration);

    }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageOverwriteMessageElementsDotNotation() {

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

        receiveAction.setValidator(validator);

        PayloadTemplateMessageBuilder controlMessageBuilder = new PayloadTemplateMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        controlMessageBuilder.setPayloadData("<TestRequest><Message>?</Message></TestRequest>");

       

        Map<String, String> overwriteElements = new HashMap<String, String>();

        overwriteElements.put("TestRequest.Message", "Hello World!");

       

        XpathMessageConstructionInterceptor interceptor = new XpathMessageConstructionInterceptor(overwriteElements);

        controlMessageBuilder.add(interceptor);

       

        Message controlMessage = new DefaultMessage("<TestRequest><Message>Hello World!</Message></TestRequest>");

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

       

        List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        receiveAction.execute(context);

        verify(endpoint, consumer, endpointConfiguration);

    }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageOverwriteMessageElementsXPathWithNamespaces() {

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

        receiveAction.setValidator(validator);

       

        PayloadTemplateMessageBuilder controlMessageBuilder = new PayloadTemplateMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        controlMessageBuilder.setPayloadData("<ns0:TestRequest xmlns:ns0=\"http://citrusframework.org/unittest\">" +

                "<ns0:Message>?</ns0:Message></ns0:TestRequest>");

       

        Map<String, String> overwriteElements = new HashMap<String, String>();

        overwriteElements.put("/ns0:TestRequest/ns0:Message", "Hello World!");

        XpathMessageConstructionInterceptor interceptor = new XpathMessageConstructionInterceptor(overwriteElements);

        controlMessageBuilder.add(interceptor);

       

        Message controlMessage = new DefaultMessage("<ns0:TestRequest xmlns:ns0=\"http://citrusframework.org/unittest\">" +

                "<ns0:Message>Hello World!</ns0:Message></ns0:TestRequest>");

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

        validationContext.setSchemaValidation(false);

       

        List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        receiveAction.execute(context);

        verify(endpoint, consumer, endpointConfiguration);

    }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageOverwriteMessageElementsXPathWithNestedNamespaces() {

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

        receiveAction.setValidator(validator);

       

        PayloadTemplateMessageBuilder controlMessageBuilder = new PayloadTemplateMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        controlMessageBuilder.setPayloadData("<ns0:TestRequest xmlns:ns0=\"http://citrusframework.org/unittest\">" +

                "<ns1:Message xmlns:ns1=\"http://citrusframework.org/unittest/message\">?</ns1:Message></ns0:TestRequest>");

       

        Map<String, String> overwriteElements = new HashMap<String, String>();

        overwriteElements.put("/ns0:TestRequest/ns1:Message", "Hello World!");

        XpathMessageConstructionInterceptor interceptor = new XpathMessageConstructionInterceptor(overwriteElements);

        controlMessageBuilder.add(interceptor);

       

        Message controlMessage = new DefaultMessage("<ns0:TestRequest xmlns:ns0=\"http://citrusframework.org/unittest\">" +

                "<ns1:Message xmlns:ns1=\"http://citrusframework.org/unittest/message\">Hello World!</ns1:Message></ns0:TestRequest>");

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

        validationContext.setSchemaValidation(false);

       

        List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        receiveAction.execute(context);

        verify(endpoint, consumer, endpointConfiguration);

    }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageOverwriteMessageElementsXPathWithDefaultNamespaces() {

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

        receiveAction.setValidator(validator);

       

        PayloadTemplateMessageBuilder controlMessageBuilder = new PayloadTemplateMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        controlMessageBuilder.setPayloadData("<TestRequest xmlns=\"http://citrusframework.org/unittest\">" +

                "<Message>?</Message></TestRequest>");

       

        Map<String, String> overwriteElements = new HashMap<String, String>();

        overwriteElements.put("/:TestRequest/:Message", "Hello World!");

        XpathMessageConstructionInterceptor interceptor = new XpathMessageConstructionInterceptor(overwriteElements);

        controlMessageBuilder.add(interceptor);

       

        Message controlMessage = new DefaultMessage("<TestRequest xmlns=\"http://citrusframework.org/unittest\"><Message>Hello World!</Message></TestRequest>");

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

        validationContext.setSchemaValidation(false);

       

        List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        receiveAction.execute(context);

        verify(endpoint, consumer, endpointConfiguration);

    }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageWithMessageHeaders() {

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

        receiveAction.setValidator(validator);

        PayloadTemplateMessageBuilder controlMessageBuilder = new PayloadTemplateMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        controlMessageBuilder.setPayloadData("<TestRequest><Message>Hello World!</Message></TestRequest>");

        Map<String, Object> headers = new HashMap<String, Object>();

        headers.put("Operation", "sayHello");

        controlMessageBuilder.setMessageHeaders(headers);

        Map<String, Object> controlHeaders = new HashMap<String, Object>();

        controlHeaders.put("Operation", "sayHello");

        Message controlMessage = new DefaultMessage("<TestRequest><Message>Hello World!</Message></TestRequest>", controlHeaders);

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

       

        List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        receiveAction.execute(context);

        verify(endpoint, consumer, endpointConfiguration);

    }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageWithMessageHeadersVariablesSupport() {

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

        receiveAction.setValidator(validator);

        PayloadTemplateMessageBuilder controlMessageBuilder = new PayloadTemplateMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        controlMessageBuilder.setPayloadData("<TestRequest><Message>Hello World!</Message></TestRequest>");

        context.setVariable("myOperation", "sayHello");

       

        Map<String, Object> headers = new HashMap<String, Object>();

        headers.put("Operation", "${myOperation}");

        controlMessageBuilder.setMessageHeaders(headers);

       

        Map<String, Object> controlHeaders = new HashMap<String, Object>();

        controlHeaders.put("Operation", "sayHello");

        Message controlMessage = new DefaultMessage("<TestRequest><Message>Hello World!</Message></TestRequest>", controlHeaders);

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

       

        List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        receiveAction.execute(context);

        verify(endpoint, consumer, endpointConfiguration);

    }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageWithUnknownVariablesInMessageHeaders() {

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

        receiveAction.setValidator(validator);

        PayloadTemplateMessageBuilder controlMessageBuilder = new PayloadTemplateMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        controlMessageBuilder.setPayloadData("<TestRequest><Message>Hello World!</Message></TestRequest>");

        Map<String, Object> headers = new HashMap<String, Object>();

        headers.put("Operation", "${myOperation}");

        controlMessageBuilder.setMessageHeaders(headers);

       

        Map<String, Object> controlHeaders = new HashMap<String, Object>();

        controlHeaders.put("Operation", "sayHello");

        Message controlMessage = new DefaultMessage("<TestRequest><Message>Hello World!</Message></TestRequest>", controlHeaders);

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

       

        List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        try {

            receiveAction.execute(context);

        } catch(CitrusRuntimeException e) {

            Assert.assertEquals(e.getMessage(), "Unknown variable 'myOperation'");

            return;

        }

        verify(endpoint, consumer, endpointConfiguration);

    }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageWithUnknownVariableInMessagePayload() {

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

        receiveAction.setValidator(validator);

        PayloadTemplateMessageBuilder controlMessageBuilder = new PayloadTemplateMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        controlMessageBuilder.setPayloadData("<TestRequest><Message>${myText}</Message></TestRequest>");

       

        Message controlMessage = new DefaultMessage("<TestRequest><Message>Hello World!</Message></TestRequest>");

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

       

        List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        try {

            receiveAction.execute(context);

        } catch(CitrusRuntimeException e) {

            Assert.assertEquals(e.getMessage(), "Unknown variable 'myText'");

            return;

        }

        verify(endpoint, consumer, endpointConfiguration);

    }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageWithExtractVariablesFromHeaders() {

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

        receiveAction.setValidator(validator);

        PayloadTemplateMessageBuilder controlMessageBuilder = new PayloadTemplateMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        controlMessageBuilder.setPayloadData("<TestRequest><Message>Hello World!</Message></TestRequest>");

        Map<String, String> headers = new HashMap<String, String>();

        headers.put("Operation", "myOperation");

       

        MessageHeaderVariableExtractor headerVariableExtractor = new MessageHeaderVariableExtractor();

        headerVariableExtractor.setHeaderMappings(headers);

        List<VariableExtractor> variableExtractors = new ArrayList<VariableExtractor>();

        variableExtractors.add(headerVariableExtractor);

        receiveAction.addVariableExtractors(headerVariableExtractor);

       

        Map<String, Object> controlHeaders = new HashMap<String, Object>();

        controlHeaders.put("Operation", "sayHello");

        Message controlMessage = new DefaultMessage("<TestRequest><Message>Hello World!</Message></TestRequest>", controlHeaders);

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

       

        List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        receiveAction.execute(context);

       

        Assert.assertNotNull(context.getVariable("myOperation"));

        Assert.assertEquals(context.getVariable("myOperation"), "sayHello");

        verify(endpoint, consumer, endpointConfiguration);

    }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageWithValidateMessageElementsFromMessageXPath() {

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

        receiveAction.setValidator(validator);

        PayloadTemplateMessageBuilder controlMessageBuilder = new PayloadTemplateMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        Map<String, String> messageElements = new HashMap<String, String>();

        messageElements.put("/TestRequest/Message", "Hello World!");

        validationContext.setPathValidationExpressions(messageElements);

       

        Message controlMessage = new DefaultMessage("<TestRequest><Message>Hello World!</Message></TestRequest>");

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

       

        List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        receiveAction.execute(context);

        verify(endpoint, consumer, endpointConfiguration);

    }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageWithValidateMessageElementsXPathDefaultNamespaceSupport() {

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

        receiveAction.setValidator(validator);

        PayloadTemplateMessageBuilder controlMessageBuilder = new PayloadTemplateMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        Map<String, String> messageElements = new HashMap<String, String>();

        messageElements.put("/:TestRequest/:Message", "Hello World!");

        validationContext.setPathValidationExpressions(messageElements);

       

        Message controlMessage = new DefaultMessage("<TestRequest  xmlns=\"http://citrusframework.org/unittest\">" +

                "<Message>Hello World!</Message></TestRequest>");

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

        validationContext.setSchemaValidation(false);

       

        List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        receiveAction.execute(context);

        verify(endpoint, consumer, endpointConfiguration);

    }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageWithValidateMessageElementsXPathNamespaceSupport() {

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

        receiveAction.setValidator(validator);

        PayloadTemplateMessageBuilder controlMessageBuilder = new PayloadTemplateMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        Map<String, String> messageElements = new HashMap<String, String>();

        messageElements.put("/ns0:TestRequest/ns0:Message", "Hello World!");

        validationContext.setPathValidationExpressions(messageElements);

       

        Message controlMessage = new DefaultMessage("<ns0:TestRequest xmlns:ns0=\"http://citrusframework.org/unittest\">" +

                "<ns0:Message>Hello World!</ns0:Message></ns0:TestRequest>");

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

        validationContext.setSchemaValidation(false);

       

        List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        receiveAction.execute(context);

        verify(endpoint, consumer, endpointConfiguration);

    }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageWithValidateMessageElementsXPathNestedNamespaceSupport() {

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

        receiveAction.setValidator(validator);

        PayloadTemplateMessageBuilder controlMessageBuilder = new PayloadTemplateMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        Map<String, String> messageElements = new HashMap<String, String>();

        messageElements.put("/ns0:TestRequest/ns1:Message", "Hello World!");

        validationContext.setPathValidationExpressions(messageElements);

       

        Message controlMessage = new DefaultMessage("<ns0:TestRequest xmlns:ns0=\"http://citrusframework.org/unittest\">" +

                "<ns1:Message xmlns:ns1=\"http://citrusframework.org/unittest/message\">Hello World!</ns1:Message></ns0:TestRequest>");

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

        validationContext.setSchemaValidation(false);

       

        List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        receiveAction.execute(context);

        verify(endpoint, consumer, endpointConfiguration);

    }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageWithValidateMessageElementsXPathNamespaceBindings() {

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

        receiveAction.setValidator(validator);

        PayloadTemplateMessageBuilder controlMessageBuilder = new PayloadTemplateMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

       

        Map<String, String> messageElements = new HashMap<String, String>();

        messageElements.put("/pfx:TestRequest/pfx:Message", "Hello World!");

        validationContext.setPathValidationExpressions(messageElements);

       

        Map<String, String> namespaces = new HashMap<String, String>();

        namespaces.put("pfx", "http://citrusframework.org/unittest");

        validationContext.setNamespaces(namespaces);

       

        Message controlMessage = new DefaultMessage("<ns0:TestRequest xmlns:ns0=\"http://citrusframework.org/unittest\">" +

                "<ns0:Message>Hello World!</ns0:Message></ns0:TestRequest>");

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();

        expect(endpoint.getActor()).andReturn(null).anyTimes();

        replay(endpoint, consumer, endpointConfiguration);

        validationContext.setSchemaValidation(false);

       

        List<ValidationContext> validationContexts = new ArrayList<ValidationContext>();

        validationContexts.add(validationContext);

        receiveAction.setValidationContexts(validationContexts);

        receiveAction.execute(context);

        verify(endpoint, consumer, endpointConfiguration);

    }

   

    @Test

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public void testReceiveMessageWithExtractVariablesFromMessageXPath() {

        ReceiveMessageAction receiveAction = new ReceiveMessageAction();

        receiveAction.setEndpoint(endpoint);

        receiveAction.setValidator(validator);

        PayloadTemplateMessageBuilder controlMessageBuilder = new PayloadTemplateMessageBuilder();

        XmlMessageValidationContext validationContext = new XmlMessageValidationContext();

        validationContext.setMessageBuilder(controlMessageBuilder);

        controlMessageBuilder.setPayloadData("<TestRequest><Message>Hello World!</Message></TestRequest>");

        Map<String, String> extractMessageElements = new HashMap<String, String>();

        extractMessageElements.put("/TestRequest/Message", "messageVar");

       

        XpathPayloadVariableExtractor variableExtractor = new XpathPayloadVariableExtractor();

        variableExtractor.setxPathExpressions(extractMessageElements);

        receiveAction.addVariableExtractors(variableExtractor);

       

        Message controlMessage = new DefaultMessage("<TestRequest><Message>Hello World!</Message></TestRequest>");

        reset(endpoint, consumer, endpointConfiguration);

        expect(endpoint.createConsumer()).andReturn(consumer).anyTimes();

        expect(endpoint.getEndpointConfiguration()).andReturn(endpointConfiguration).anyTimes();

        expect(endpointConfiguration.getTimeout()).andReturn(5000L).anyTimes();

        expect(consumer.receive(anyObject(TestContext.class), anyLong())).andReturn(controlMessage).once();