src/test/java/org/apache/commons/scxml2/io/SCXMLReaderTest.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.commons.scxml2.io;

import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

import javax.xml.stream.XMLStreamException;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogConfigurationException;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.logging.impl.LogFactoryImpl;
import org.apache.commons.logging.impl.SimpleLog;
import org.apache.commons.scxml2.ActionExecutionContext;
import org.apache.commons.scxml2.SCXMLExpressionException;
import org.apache.commons.scxml2.SCXMLTestHelper;
import org.apache.commons.scxml2.io.SCXMLReader.Configuration;
import org.apache.commons.scxml2.model.Action;
import org.apache.commons.scxml2.model.CustomAction;
import org.apache.commons.scxml2.model.Data;
import org.apache.commons.scxml2.model.Datamodel;
import org.apache.commons.scxml2.model.EnterableState;
import org.apache.commons.scxml2.model.ExternalContent;
import org.apache.commons.scxml2.model.Final;
import org.apache.commons.scxml2.model.ModelException;
import org.apache.commons.scxml2.model.SCXML;
import org.apache.commons.scxml2.model.Send;
import org.apache.commons.scxml2.model.State;
import org.apache.commons.scxml2.model.Transition;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.w3c.dom.Node;

/**
 * Unit tests {@link org.apache.commons.scxml2.io.SCXMLReader}.
 */
public class SCXMLReaderTest {

    private static String oldLogFactoryProperty;

    private Log scxmlReaderLog;

    @BeforeClass
    public static void beforeClass() {
        oldLogFactoryProperty = System.getProperty(LogFactory.FACTORY_PROPERTY);
        System.setProperty(LogFactory.FACTORY_PROPERTY, RecordingLogFactory.class.getName());
    }

    @AfterClass
    public static void afterClass() {
        if (oldLogFactoryProperty == null) {
            System.clearProperty(LogFactory.FACTORY_PROPERTY);
        } else {
            System.setProperty(LogFactory.FACTORY_PROPERTY, oldLogFactoryProperty);
        }
    }

    /**
     * Set up instance variables required by this test case.
     */
    @Before
    public void before() {
        scxmlReaderLog = LogFactory.getLog(SCXMLReader.class);
        clearRecordedLogMessages();
    }

    /**
     * Test the implementation
     */    
    @Test
    public void testSCXMLReaderMicrowave03Sample() throws Exception {
        SCXML scxml = SCXMLTestHelper.parse("org/apache/commons/scxml2/env/jexl/microwave-03.xml");
        Assert.assertNotNull(scxml);
        Assert.assertNotNull(serialize(scxml));
    }
    
    @Test
    public void testSCXMLReaderMicrowave04Sample() throws Exception {
        SCXML scxml = SCXMLTestHelper.parse("org/apache/commons/scxml2/env/jexl/microwave-04.xml");
        Assert.assertNotNull(scxml);
        Assert.assertNotNull(serialize(scxml));
    }
    
    @Test
    public void testSCXMLReaderTransitions01Sample() throws Exception {
        SCXML scxml = SCXMLTestHelper.parse("org/apache/commons/scxml2/transitions-01.xml");
        Assert.assertNotNull(scxml);
        Assert.assertNotNull(serialize(scxml));
    }
    
    @Test
    public void testSCXMLReaderPrefix01Sample() throws Exception {
        SCXML scxml = SCXMLTestHelper.parse("org/apache/commons/scxml2/prefix-01.xml");
        Assert.assertNotNull(scxml);
        Assert.assertNotNull(serialize(scxml));
    }
    
    @Test
    public void testSCXMLReaderSend01Sample() throws Exception {
        SCXML scxml = SCXMLTestHelper.parse("org/apache/commons/scxml2/send-01.xml");
        State ten = (State) scxml.getInitialTransition().getTargets().iterator().next();
        Assert.assertEquals("ten", ten.getId());
        List<Transition> ten_done = ten.getTransitionsList("done.state.ten");
        Assert.assertEquals(1, ten_done.size());
        Transition ten2twenty = ten_done.get(0);
        List<Action> actions = ten2twenty.getActions();
        Assert.assertEquals(1, actions.size());
        Send send = (Send) actions.get(0);
        Assert.assertEquals("send1", send.getId());
        /* Serialize
        scxmlAsString = serialize(scxml);
        Assert.assertNotNull(scxmlAsString);
        String expectedFoo2Serialization =
            "<foo xmlns=\"http://my.test.namespace\" id=\"foo2\">"
            + "<prompt xmlns=\"http://foo.bar.com/vxml3\">This is just"
            + " an example.</prompt></foo>";
        Assert.assertFalse(scxmlAsString.indexOf(expectedFoo2Serialization) == -1);
        */
    }
    
    @Test
    public void testSCXMLReaderInitialAttr() throws Exception {
        SCXML scxml = SCXMLTestHelper.parse("org/apache/commons/scxml2/io/scxml-initial-attr.xml");
        Assert.assertNotNull(scxml);
        Assert.assertNotNull(serialize(scxml));
        Final foo = (Final) scxml.getInitialTransition().getTargets().iterator().next();
        Assert.assertEquals("foo", foo.getId());
    }

    @Test
    public void testSCXMLValidTransitionTargets() throws Exception {
        // ModelUpdater will fail on invalid transition targets
        SCXMLTestHelper.parse(SCXMLTestHelper.getResource("org/apache/commons/scxml2/io/scxml-valid-transition-targets-test.xml"));
    }

    @Test(expected=org.apache.commons.scxml2.model.ModelException.class)
    public void testSCXMLInValidTransitionTargets1() throws Exception {
        // ModelUpdater will fail on invalid transition targets
        SCXMLTestHelper.parse(SCXMLTestHelper.getResource("org/apache/commons/scxml2/io/scxml-invalid-transition-targets-test1.xml"));
    }

    @Test(expected=org.apache.commons.scxml2.model.ModelException.class)
    public void testSCXMLInValidTransitionTargets2() throws Exception {
        // ModelUpdater will fail on invalid transition targets
        SCXMLTestHelper.parse(SCXMLTestHelper.getResource("org/apache/commons/scxml2/io/scxml-invalid-transition-targets-test2.xml"));
    }

    @Test
    public void testSCXMLReaderCustomActionWithBodyTextSample() throws Exception {
        List<CustomAction> cas = new ArrayList<CustomAction>();
        CustomAction ca = new CustomAction("http://my.custom-actions.domain",
            "action", MyAction.class);
        cas.add(ca);
        SCXML scxml = SCXMLTestHelper.parse("org/apache/commons/scxml2/io/custom-action-body-test-1.xml", cas);
        EnterableState state = (EnterableState) scxml.getInitialTransition().getTargets().iterator().next();
        Assert.assertEquals("actions", state.getId());
        List<Action> actions = state.getOnEntries().get(0).getActions();
        Assert.assertEquals(1, actions.size());
        MyAction my = (MyAction) actions.get(0);
        Assert.assertNotNull(my);
        Assert.assertTrue(my.getExternalNodes().size() > 0);
    }

    @Test
    public void testSCXMLReaderWithInvalidElements() throws Exception {
        // In the default lenient/verbose mode (strict == false && silent == false),
        // the model exception should be just logged without a model exception.
        Configuration configuration = new Configuration();
        SCXML scxml = SCXMLReader.read(SCXMLTestHelper.getResource("org/apache/commons/scxml2/io/scxml-with-invalid-elems.xml"),
                        configuration);
        Assert.assertNotNull(scxml);
        Assert.assertNotNull(serialize(scxml));
        Final foo = (Final) scxml.getInitialTransition().getTargets().iterator().next();
        Assert.assertEquals("foo", foo.getId());
        Datamodel dataModel = scxml.getDatamodel();
        Assert.assertNotNull(dataModel);
        List<Data> dataList = dataModel.getData();
        Assert.assertEquals(1, dataList.size());
        Assert.assertEquals("time", dataList.get(0).getId());
        assertContainsRecordedLogMessage("Ignoring unknown or invalid element <baddata> in namespace \"http://www.w3.org/2005/07/scxml\" as child of <datamodel>");
        assertContainsRecordedLogMessage("Ignoring unknown or invalid element <baddata> in namespace \"http://www.example.com/scxml\" as child of <datamodel>");
        assertContainsRecordedLogMessage("Ignoring unknown or invalid element <trace> in namespace \"http://www.w3.org/2005/07/scxml\" as child of <onentry>");
        assertContainsRecordedLogMessage("Ignoring unknown or invalid element <onbeforeexit> in namespace \"http://www.w3.org/2005/07/scxml\" as child of <final>");

        // In the lenient/silent mode (strict == false && silent == true),
        // no model exception is logged.
        clearRecordedLogMessages();
        scxml = null;
        configuration = new Configuration();
        configuration.setStrict(false);
        configuration.setSilent(true);
        scxml = SCXMLReader.read(SCXMLTestHelper.getResource("org/apache/commons/scxml2/io/scxml-with-invalid-elems.xml"),
                configuration);
        Assert.assertNotNull(scxml);
        Assert.assertNotNull(serialize(scxml));
        foo = (Final) scxml.getInitialTransition().getTargets().iterator().next();
        Assert.assertEquals("foo", foo.getId());
        dataModel = scxml.getDatamodel();
        Assert.assertNotNull(dataModel);
        dataList = dataModel.getData();
        Assert.assertEquals(1, dataList.size());
        Assert.assertEquals("time", dataList.get(0).getId());
        assertNotContainsRecordedLogMessage("Ignoring unknown or invalid element <baddata> in namespace \"http://www.w3.org/2005/07/scxml\" as child of <datamodel>");
        assertNotContainsRecordedLogMessage("Ignoring unknown or invalid element <baddata> in namespace \"http://www.example.com/scxml\" as child of <datamodel>");
        assertNotContainsRecordedLogMessage("Ignoring unknown or invalid element <trace> in namespace \"http://www.w3.org/2005/07/scxml\" as child of <onentry>");
        assertNotContainsRecordedLogMessage("Ignoring unknown or invalid element <onbeforeexit> in namespace \"http://www.w3.org/2005/07/scxml\" as child of <final>");

        // In strict/verbose mode (strict == true && silent == false), it should fail to read the model and catch a model exception
        // with warning logs because of the invalid <baddata> element.
        clearRecordedLogMessages();
        scxml = null;
        configuration = new Configuration();
        configuration.setStrict(true);
        configuration.setSilent(false);
        try {
            scxml = SCXMLReader.read(SCXMLTestHelper.getResource("org/apache/commons/scxml2/io/scxml-with-invalid-elems.xml"),
                    configuration);
            Assert.fail("In strict mode, it should have thrown a model exception.");
        } catch (ModelException e) {
            Assert.assertTrue(e.getMessage().contains("Ignoring unknown or invalid element <baddata>"));
        }
        assertContainsRecordedLogMessage("Ignoring unknown or invalid element <baddata> in namespace \"http://www.w3.org/2005/07/scxml\" as child of <datamodel>");
        assertContainsRecordedLogMessage("Ignoring unknown or invalid element <baddata> in namespace \"http://www.example.com/scxml\" as child of <datamodel>");
        assertContainsRecordedLogMessage("Ignoring unknown or invalid element <trace> in namespace \"http://www.w3.org/2005/07/scxml\" as child of <onentry>");
        assertContainsRecordedLogMessage("Ignoring unknown or invalid element <onbeforeexit> in namespace \"http://www.w3.org/2005/07/scxml\" as child of <final>");

        // In strict/silent mode (strict == true && silent == true), it should fail to read the model and catch a model exception
        // without warning logs because of the invalid <baddata> element.
        clearRecordedLogMessages();
        scxml = null;
        configuration = new Configuration();
        configuration.setStrict(true);
        configuration.setSilent(true);
        try {
            scxml = SCXMLReader.read(SCXMLTestHelper.getResource("org/apache/commons/scxml2/io/scxml-with-invalid-elems.xml"),
                    configuration);
            Assert.fail("In strict mode, it should have thrown a model exception.");
        } catch (ModelException e) {
            Assert.assertTrue(e.getMessage().contains("Ignoring unknown or invalid element <baddata>"));
        }
        assertNotContainsRecordedLogMessage("Ignoring unknown or invalid element <baddata> in namespace \"http://www.w3.org/2005/07/scxml\" as child of <datamodel>");
        assertNotContainsRecordedLogMessage("Ignoring unknown or invalid element <baddata> in namespace \"http://www.example.com/scxml\" as child of <datamodel>");
        assertNotContainsRecordedLogMessage("Ignoring unknown or invalid element <trace> in namespace \"http://www.w3.org/2005/07/scxml\" as child of <onentry>");
        assertNotContainsRecordedLogMessage("Ignoring unknown or invalid element <onbeforeexit> in namespace \"http://www.w3.org/2005/07/scxml\" as child of <final>");
    }

    @Test
    public void testSCXMLReaderGroovyClosure() throws Exception {
        SCXML scxml = SCXMLTestHelper.parse("org/apache/commons/scxml2/env/groovy/groovy-closure.xml");
        Assert.assertNotNull(scxml);
        Assert.assertNotNull(scxml.getGlobalScript());
        String scxmlAsString = serialize(scxml);
        Assert.assertNotNull(scxmlAsString);
        scxml = SCXMLTestHelper.parse(new StringReader(scxmlAsString), null);
        Assert.assertNotNull(scxml);
        Assert.assertNotNull(scxml.getGlobalScript());
    }

    private String serialize(final SCXML scxml) throws IOException, XMLStreamException {
        String scxmlAsString = SCXMLWriter.write(scxml);
        Assert.assertNotNull(scxmlAsString);
        return scxmlAsString;
    }

    private void assertContainsRecordedLogMessage(final String message) {
        if (scxmlReaderLog instanceof RecordingSimpleLog) {
            Assert.assertTrue(((RecordingSimpleLog) scxmlReaderLog).containsMessage(
                    "Ignoring unknown or invalid element <baddata> in namespace \"http://www.w3.org/2005/07/scxml\" as child of <datamodel>"));
        }
    }

    private void assertNotContainsRecordedLogMessage(final String message) {
        if (scxmlReaderLog instanceof RecordingSimpleLog) {
            Assert.assertFalse(((RecordingSimpleLog) scxmlReaderLog).containsMessage(
                    "Ignoring unknown or invalid element <baddata> in namespace \"http://www.w3.org/2005/07/scxml\" as child of <datamodel>"));
        }
    }

    private void clearRecordedLogMessages() {
        if (scxmlReaderLog instanceof RecordingSimpleLog) {
            ((RecordingSimpleLog) scxmlReaderLog).clearMessages();
        }
    }

    public static class MyAction extends Action implements ExternalContent {
        private static final long serialVersionUID = 1L;

        private List<Node> nodes = new ArrayList<Node>();

        @Override
        public void execute(ActionExecutionContext exctx) throws ModelException, SCXMLExpressionException {
            // Not relevant to test
        }

        @Override
        public List<Node> getExternalNodes() {
            return nodes;
        }

    }

    /**
     * Custom LogFactory implementation to capture log messages for logging verification.
     */
    public static class RecordingLogFactory extends LogFactoryImpl {
        @Override
        protected Log newInstance(String name) throws LogConfigurationException {
            return new RecordingSimpleLog(name);
        }
    }

    /**
     * Custom Simple Log implemenation capturing log messages
     */
    public static class RecordingSimpleLog extends SimpleLog {

        private static final long serialVersionUID = 1L;

        private List<String> messages = new LinkedList<String>();

        public RecordingSimpleLog(String name) {
            super(name);
        }

        /**
         * Clear all the recorded log messages.
         */
        public void clearMessages() {
            messages.clear();
        }

        /**
         * Return true if msg is found in any recorded log messages.
         * @param msg
         * @return
         */
        public boolean containsMessage(final String msg) {
            for (String message : messages) {
                if (message.contains(msg)) {
                    return true;
                }
            }
            return false;
        }

        @Override
        protected boolean isLevelEnabled(int logLevel) {
            return (logLevel >= LOG_LEVEL_INFO);
        }

        @Override
        protected void log(int type, Object message, Throwable t) {
            super.log(type, message, t);
            messages.add(message.toString());
        }
    }
}