* Copyright 2011 DTO Labs, Inc. (http://dtolabs.com)

*

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

*/

* StepFirstWorkflowStrategyTests.java

*

* User: Greg Schueler <a href="mailto:greg@dtosolutions.com">greg@dtosolutions.com</a>

* Created: 3/25/11 9:30 AM

*

*/

    Framework testFramework;

    String testnode;

    private static final String TEST_PROJECT = "StepFirstWorkflowStrategyTests";

    public TestStepFirstWorkflowStrategy(String name) {

        super(name);

    }

    public static Test suite() {

        return new TestSuite(TestStepFirstWorkflowStrategy.class);

    }

    protected void setUp()  {

        super.setUp();

        testFramework = getFrameworkInstance();

        testnode=testFramework.getFrameworkNodeName();

        final FrameworkProject frameworkProject = testFramework.getFrameworkProjectMgr().createFrameworkProject(

            TEST_PROJECT);

        File resourcesfile = new File(frameworkProject.getNodesResourceFilePath());

        //copy test nodes to resources file

        try {

            FileUtils.copyFileStreams(new File("src/test/resources/com/dtolabs/rundeck/core/common/test-nodes1.xml"),

                resourcesfile);

        } catch (IOException e) {

            throw new RuntimeException("Caught Setup exception: " + e.getMessage(), e);

        }

    }

    protected void tearDown() throws Exception {

        super.tearDown();

        File projectdir = new File(getFrameworkProjectsBase(), TEST_PROJECT);

        FileUtils.deleteDir(projectdir);

    }

    public static void main(String args[]) {

        junit.textui.TestRunner.run(suite());

    }

    static class testWorkflowCmdItem implements NodeStepExecutionItem {

        private String type;

        int flag=-1;

        @Override

        public String toString() {

            return "testWorkflowCmdItem{" +

                   "type='" + type + '\'' +

                   ", flag=" + flag +

                   '}';

        }

        @Override

        public String getNodeStepType() {

            return type;

        }

        public String getType() {

            return "NodeDispatch";

        }

    }

    /*static class testWorkflowJobCmdItem extends testWorkflowCmdItem implements IWorkflowJobItem {

        private String jobIdentifier;

        public String getJobIdentifier() {

            return jobIdentifier;

        }

    }*/

    static class testListener implements ExecutionListenerOverride {

        public boolean isTerse() {

            return false;

        }

        public String getLogFormat() {

            return null;

        }

        public void log(int i, String s) {

            System.err.println(i + ": " + s);

        }

        @Override

        public void event(String eventType, String message, Map eventMeta) {

            System.err.println(eventType + ": " + message);

        }

        public FailedNodesListener getFailedNodesListener() {

            return null;

        }

        public void beginStepExecution(ExecutionContext context, StepExecutionItem item) {

        }

        public void finishStepExecution(StatusResult result, ExecutionContext context, StepExecutionItem item) {

        }

        public void beginNodeExecution(ExecutionContext context, String[] command, INodeEntry node) {

        }

        public void finishNodeExecution(NodeExecutorResult result, ExecutionContext context, String[] command,

                                        INodeEntry node) {

        }

        public void beginNodeDispatch(ExecutionContext context, StepExecutionItem item) {

        }

        public void beginNodeDispatch(ExecutionContext context, Dispatchable item) {

        }

        public void finishNodeDispatch(DispatcherResult result, ExecutionContext context, StepExecutionItem item) {

        }

        public void finishNodeDispatch(DispatcherResult result, ExecutionContext context, Dispatchable item) {

        }

        public void beginFileCopyFileStream(ExecutionContext context, InputStream input, INodeEntry node) {

        }

        public void beginFileCopyFile(ExecutionContext context, File input, INodeEntry node) {

        }

        public void beginFileCopyScriptContent(ExecutionContext context, String input, INodeEntry node) {

        }

        public void finishFileCopy(String result, ExecutionContext context, INodeEntry node) {

        }

        public void beginExecuteNodeStep(ExecutionContext context, NodeStepExecutionItem item, INodeEntry node) {

        }

        public void finishExecuteNodeStep(NodeStepResult result, ExecutionContext context, StepExecutionItem item,

                                          INodeEntry node) {

        }

        public BuildListener getBuildListener() {

            return null;

        }

        public ExecutionListenerOverride createOverride() {

            return this;

        }

        public void setTerse(boolean terse) {

        }

        public void setLogFormat(String format) {

        }

        public void setFailedNodesListener(FailedNodesListener listener) {

        }

    }

    static class testInterpreter implements NodeStepExecutor {

        List<StepExecutionItem> executionItemList = new ArrayList<StepExecutionItem>();

        List<ExecutionContext> executionContextList = new ArrayList<ExecutionContext>();

        List<INodeEntry> nodeEntryList = new ArrayList<INodeEntry>();

        int index = 0;

        List<NodeStepResult> resultList = new ArrayList<NodeStepResult>();

        boolean shouldThrowException = false;

        public NodeStepResult executeNodeStep(StepExecutionContext executionContext,

                                                 NodeStepExecutionItem executionItem, INodeEntry iNodeEntry) throws

                                                                                                     NodeStepException {

            executionItemList.add(executionItem);

            executionContextList.add(executionContext);

            nodeEntryList.add(iNodeEntry);

            if (shouldThrowException) {

                throw new NodeStepException("testInterpreter test exception",null,iNodeEntry.getNodename());

            }

            System.out.println("return index: (" + index + ") in size: " + resultList.size());

            return resultList.get(index++);

        }

    }

    static enum Reason implements FailureReason{

        Test

    }

        boolean success;

        int flag;

        INodeEntry node;

        testResult(boolean success, int flag) {

            super(null,success?null: TestStepFirstWorkflowStrategy.Reason.Test,success?null:"test failure",null);

            this.success = success;

            this.flag = flag;

        }

        @Override

        public Exception getException() {

            return null;

        }

        public boolean isSuccess() {

            return success;

        }

        @Override

        public String toString() {

            return "testResult{" +

                   "success=" + success +

                   ", flag=" + flag +

                   '}';

        }

        public INodeEntry getNode() {

            return node;

        }

    }

    public void testExecuteWorkflow() throws Exception {

        {

            final FrameworkProject frameworkProject = testFramework.getFrameworkProjectMgr().getFrameworkProject(

                TEST_PROJECT);

            final INodeSet nodes = frameworkProject.getNodeSet();

            assertNotNull(nodes);

            assertEquals(2, nodes.getNodes().size());

        }

        {

            //test empty workflow

            final NodeSet nodeset = new NodeSet();

            final WorkflowImpl workflow = new WorkflowImpl(new ArrayList<StepExecutionItem>(), 1, false,

                WorkflowStrategy.STEP_FIRST);

            final WorkflowExecutionItemImpl executionItem = new WorkflowExecutionItemImpl(workflow);

            final StepFirstWorkflowStrategy strategy = new StepFirstWorkflowStrategy(testFramework);

            final StepExecutionContext context =

                new ExecutionContextImpl.Builder()

                    .frameworkProject(TEST_PROJECT)

                    .user("user1")

                    .nodeSelector(nodeset)

                    .executionListener(new testListener())

                    .framework(testFramework)

                    .nodes(testFramework.filterNodeSet(nodeset, TEST_PROJECT, null))

                    .build();

            //setup testInterpreter for all command types

            final NodeStepExecutionService interpreterService = NodeStepExecutionService.getInstanceForFramework(

                testFramework);

            testInterpreter interpreterMock = new testInterpreter();

            interpreterService.registerInstance("exec", interpreterMock);

            interpreterService.registerInstance("script", interpreterMock);

            interpreterService.registerInstance(WorkflowExecutionItem.COMMAND_TYPE_NODE_FIRST, interpreterMock);

            interpreterService.registerInstance(WorkflowExecutionItem.COMMAND_TYPE_STEP_FIRST, interpreterMock);

            final WorkflowExecutionResult result = strategy.executeWorkflow(context, executionItem);

            assertNotNull(result);

            if (!result.isSuccess() && null != result.getException()) {

                result.getException().printStackTrace(System.err);

            }

            assertNull("threw exception: " + result.getException(), result.getException());

            assertTrue(result.isSuccess());

            assertEquals(0, interpreterMock.executionItemList.size());

        }

        {

            //test undefined workflow item

            final NodeSet nodeset = new NodeSet();

            final ArrayList<StepExecutionItem> commands = new ArrayList<StepExecutionItem>();

            commands.add(new testWorkflowCmdItem());

            final WorkflowImpl workflow = new WorkflowImpl(commands, 1, false, WorkflowStrategy.STEP_FIRST);

            final WorkflowExecutionItemImpl executionItem = new WorkflowExecutionItemImpl(workflow);

            final StepFirstWorkflowStrategy strategy = new StepFirstWorkflowStrategy(testFramework);

            final StepExecutionContext context =

                new ExecutionContextImpl.Builder()

                    .frameworkProject(TEST_PROJECT)

                    .user("user1")

                    .nodeSelector(nodeset.nodeSelectorWithDefaultAll())

                    .executionListener(new testListener())

                    .framework(testFramework)

                    .nodes(testFramework.filterNodeSet(nodeset.nodeSelectorWithDefaultAll(), TEST_PROJECT, null))

                    .build();

            //setup testInterpreter for all command types

            final NodeStepExecutionService interpreterService = NodeStepExecutionService.getInstanceForFramework(

                testFramework);

            testInterpreter interpreterMock = new testInterpreter();

            interpreterService.registerInstance("exec", interpreterMock);

            interpreterService.registerInstance("script", interpreterMock);

            interpreterService.registerInstance(WorkflowExecutionItem.COMMAND_TYPE_NODE_FIRST, interpreterMock);

            interpreterService.registerInstance(WorkflowExecutionItem.COMMAND_TYPE_STEP_FIRST, interpreterMock);

            final WorkflowExecutionResult result = strategy.executeWorkflow(context, executionItem);

            assertNotNull(result);

            if (!result.isSuccess() && null != result.getException()) {

                result.getException().printStackTrace(System.out);

            }

            assertFalse(result.isSuccess());

            assertEquals(0, interpreterMock.executionItemList.size());

            assertNotNull("threw exception: " + result.getException(), result.getException());

            assertTrue("threw exception: " + result.getException(),

                       result.getException() instanceof NullPointerException);

            assertEquals("threw exception: " + result.getException(),

                         "provider name was null for Service: WorkflowNodeStep",

                         result.getException().getMessage());

        }

        {

            //test script exec item

            final NodesSelector nodeset = SelectorUtils.singleNode(testFramework.getFrameworkNodeName());

            final ArrayList<StepExecutionItem> commands = new ArrayList<StepExecutionItem>();

            final StepExecutionItem testWorkflowCmdItem = new ScriptFileCommandBase(){

                @Override

                public String getScript() {

                    return "a command";

                }

            };

            commands.add(testWorkflowCmdItem);

            final WorkflowImpl workflow = new WorkflowImpl(commands, 1, false,

                WorkflowStrategy.STEP_FIRST);

            final WorkflowExecutionItemImpl executionItem = new WorkflowExecutionItemImpl(workflow);

            final StepFirstWorkflowStrategy strategy = new StepFirstWorkflowStrategy(testFramework);

            final StepExecutionContext context =

                new ExecutionContextImpl.Builder()

                    .frameworkProject(TEST_PROJECT)

                    .user("user1")

                    .nodeSelector(nodeset)

                    .executionListener(new testListener())

                    .framework(testFramework)

                    .nodes(testFramework.filterNodeSet(nodeset, TEST_PROJECT, null))

                    .build();

            //setup testInterpreter for all command types

            final NodeStepExecutionService interpreterService = NodeStepExecutionService.getInstanceForFramework(

                testFramework);

            testInterpreter interpreterMock = new testInterpreter();

            testInterpreter failMock = new testInterpreter();

            failMock.shouldThrowException = true;

            interpreterService.registerInstance("exec", failMock);

            interpreterService.registerInstance("script", interpreterMock);

            interpreterService.registerInstance(WorkflowExecutionItem.COMMAND_TYPE_NODE_FIRST, failMock);

            interpreterService.registerInstance(WorkflowExecutionItem.COMMAND_TYPE_STEP_FIRST, failMock);

            //set resturn result

            interpreterMock.resultList.add(new NodeStepResultImpl(null));

            final WorkflowExecutionResult result = strategy.executeWorkflow(context, executionItem);

            assertNotNull(result);

            if (!result.isSuccess() && null != result.getException()) {

                result.getException().printStackTrace(System.err);

            }

            assertNull("threw exception: " + result.getException(), result.getException());

            assertTrue(result.isSuccess());

            assertEquals(1, interpreterMock.executionItemList.size());

            final StepExecutionItem executionItem1 = interpreterMock.executionItemList.get(0);

            assertTrue("wrong class: " + executionItem1.getClass().getName(),

                executionItem1 instanceof ScriptFileCommandExecutionItem);

            ScriptFileCommandExecutionItem scriptItem = (ScriptFileCommandExecutionItem) executionItem1;

            assertEquals("a command", scriptItem.getScript());

            assertNull(scriptItem.getScriptAsStream());

            assertNull(scriptItem.getServerScriptFilePath());

            assertEquals(1, interpreterMock.executionContextList.size());

            final ExecutionContext executionContext = interpreterMock.executionContextList.get(0);

            assertEquals(TEST_PROJECT, executionContext.getFrameworkProject());

            assertNotNull(executionContext.getDataContext());

            assertNotNull(executionContext.getDataContext().get("node"));

            assertEquals(0, executionContext.getLoglevel());

            assertEquals("user1", executionContext.getUser());

            assertEquals("expected " + nodeset + ", but was " + executionContext.getNodeSelector(), nodeset,

                executionContext.getNodeSelector());

        }

        {

            //test command exec item

            final NodesSelector nodeset = SelectorUtils.singleNode(testFramework.getFrameworkNodeName());

            final ArrayList<StepExecutionItem> commands = new ArrayList<StepExecutionItem>();

            final StepExecutionItem testWorkflowCmdItem = new ExecCommandBase() {

                @Override

                public String[] getCommand() {

                    return new String[]{"a", "command"};

                }

            };

            commands.add(testWorkflowCmdItem);

            final WorkflowImpl workflow = new WorkflowImpl(commands, 1, false,

                WorkflowStrategy.STEP_FIRST);

            final WorkflowExecutionItemImpl executionItem = new WorkflowExecutionItemImpl(workflow);

            final StepFirstWorkflowStrategy strategy = new StepFirstWorkflowStrategy(testFramework);

            final StepExecutionContext context =

                new ExecutionContextImpl.Builder()

                    .frameworkProject(TEST_PROJECT)

                    .user("user1")

                    .nodeSelector(nodeset)

                    .executionListener(new testListener())

                    .framework(testFramework)

                    .nodes(testFramework.filterNodeSet(nodeset, TEST_PROJECT, null))

                    .build();

            //setup testInterpreter for all command types

            final NodeStepExecutionService interpreterService = NodeStepExecutionService.getInstanceForFramework(

                testFramework);

            testInterpreter interpreterMock = new testInterpreter();

            testInterpreter failMock = new testInterpreter();

            failMock.shouldThrowException = true;

            interpreterService.registerInstance("exec", interpreterMock);

            interpreterService.registerInstance("script", failMock);

            interpreterService.registerInstance(WorkflowExecutionItem.COMMAND_TYPE_NODE_FIRST, failMock);

            interpreterService.registerInstance(WorkflowExecutionItem.COMMAND_TYPE_STEP_FIRST, failMock);

            //set resturn result

            interpreterMock.resultList.add(new NodeStepResultImpl(null));

            final WorkflowExecutionResult result = strategy.executeWorkflow(context, executionItem);

            assertNotNull(result);

            if (!result.isSuccess() && null != result.getException()) {

                result.getException().printStackTrace(System.err);

            }

            assertNull("threw exception: " + result.getException(), result.getException());

            assertTrue(result.isSuccess());

            assertEquals(1, interpreterMock.executionItemList.size());

            final StepExecutionItem executionItem1 = interpreterMock.executionItemList.get(0);

            assertTrue("wrong class: " + executionItem1.getClass().getName(),

                executionItem1 instanceof ExecCommandExecutionItem);

            ExecCommandExecutionItem execItem = (ExecCommandExecutionItem) executionItem1;

            assertNotNull(execItem.getCommand());

            assertEquals(2, execItem.getCommand().length);

            assertEquals("a", execItem.getCommand()[0]);

            assertEquals("command", execItem.getCommand()[1]);

            assertEquals(1, interpreterMock.executionContextList.size());

            final ExecutionContext executionContext = interpreterMock.executionContextList.get(0);

            assertEquals(TEST_PROJECT, executionContext.getFrameworkProject());

            assertNotNull(executionContext.getDataContext());

            assertNotNull(executionContext.getDataContext().get("node"));

            assertEquals(0, executionContext.getLoglevel());

            assertEquals("user1", executionContext.getUser());

            assertEquals(nodeset, executionContext.getNodeSelector());

        }

    }

    public void testExecuteWorkflowThreeItems() throws Exception{

        {

            //test workflow of three successful items

            final NodesSelector nodeset = SelectorUtils.singleNode(testFramework.getFrameworkNodeName());

            final ArrayList<StepExecutionItem> commands = new ArrayList<StepExecutionItem>();

            final StepExecutionItem testWorkflowCmdItem = new ExecCommandBase() {

                @Override

                public String[] getCommand() {

                    return new String[]{"a", "2","command"};

                }

            };

            commands.add(testWorkflowCmdItem);

            final StepExecutionItem testWorkflowCmdItemScript = new ScriptFileCommandBase() {

                @Override

                public String getScript() {

                    return "a command";

                }

                @Override

                public String[] getArgs() {

                    return new String[]{"-testargs", "1"};

                }

            };

            commands.add(testWorkflowCmdItemScript);

            final StepExecutionItem testWorkflowCmdItemScript2 = new ScriptFileCommandBase() {

                @Override

                public String getServerScriptFilePath() {

                    return "/some/file/path";

                }

                @Override

                public String[] getArgs() {

                    return new String[]{"-testargs", "2"};

                }

            };

            commands.add(testWorkflowCmdItemScript2);

            final WorkflowImpl workflow = new WorkflowImpl(commands, 1, false,

                WorkflowStrategy.STEP_FIRST);

            final WorkflowExecutionItemImpl executionItem = new WorkflowExecutionItemImpl(workflow);

            final StepFirstWorkflowStrategy strategy = new StepFirstWorkflowStrategy(testFramework);

            final StepExecutionContext context =

                new ExecutionContextImpl.Builder()

                    .frameworkProject(TEST_PROJECT)

                    .user("user1")

                    .nodeSelector(nodeset)

                    .executionListener(new testListener())

                    .framework(testFramework)

                    .nodes(testFramework.filterNodeSet(nodeset, TEST_PROJECT, null))

                    .build();

            //setup testInterpreter for all command types

            final NodeStepExecutionService interpreterService = NodeStepExecutionService.getInstanceForFramework(

                testFramework);

            testInterpreter interpreterMock = new testInterpreter();

            testInterpreter failMock = new testInterpreter();

            failMock.shouldThrowException = true;

            interpreterService.registerInstance("exec", interpreterMock);

            interpreterService.registerInstance("script", interpreterMock);

            interpreterService.registerInstance(WorkflowExecutionItem.COMMAND_TYPE_NODE_FIRST, failMock);

            interpreterService.registerInstance(WorkflowExecutionItem.COMMAND_TYPE_STEP_FIRST, failMock);

            //set resturn results

            interpreterMock.resultList.add(new testResult(true, 0));

            interpreterMock.resultList.add(new testResult(true, 1));

            interpreterMock.resultList.add(new testResult(true, 2));

            final WorkflowExecutionResult result = strategy.executeWorkflow(context,executionItem);

            assertNotNull(result);

            if (!result.isSuccess() && null != result.getException()) {

                result.getException().printStackTrace(System.err);

            }

            assertNull("threw exception: " + result.getException(), result.getException());

            assertTrue(result.isSuccess());

            assertNotNull(result.getResultSet());

            final List<StepExecutionResult> test1 = result.getResultSet();

            assertEquals(3, test1.size());

            for (final int i : new int[]{0, 1, 2}) {

                final StepExecutionResult interpreterResult = test1.get(i);

                final DispatcherResult dr = NodeDispatchStepExecutor.extractDispatcherResult(interpreterResult);

                assertEquals(1, dr.getResults().size());

                final NodeStepResult nrs = dr.getResults().values().iterator().next();

                assertTrue("unexpected class: " + nrs.getClass(),

                           nrs instanceof testResult);

                testResult val = (testResult) nrs;

                assertTrue(val.isSuccess());

                assertEquals(i, val.flag);

            }

            assertEquals(3, interpreterMock.executionItemList.size());

            final StepExecutionItem executionItem1 = interpreterMock.executionItemList.get(0);

            assertTrue("wrong class: " + executionItem1.getClass().getName(),

                executionItem1 instanceof ExecCommandExecutionItem);

            ExecCommandExecutionItem execItem = (ExecCommandExecutionItem) executionItem1;

            assertNotNull(execItem.getCommand());

            assertEquals(3, execItem.getCommand().length);

            assertEquals("a", execItem.getCommand()[0]);

            assertEquals("2", execItem.getCommand()[1]);

            assertEquals("command", execItem.getCommand()[2]);

            final StepExecutionItem item2 = interpreterMock.executionItemList.get(1);

            assertTrue("wrong class: " + item2.getClass().getName(),

                item2 instanceof ScriptFileCommandExecutionItem);

            ScriptFileCommandExecutionItem scriptItem = (ScriptFileCommandExecutionItem) item2;

            assertEquals("a command", scriptItem.getScript());

            assertNull(scriptItem.getScriptAsStream());

            assertNull(scriptItem.getServerScriptFilePath());

            final StepExecutionItem item3 = interpreterMock.executionItemList.get(2);

            assertTrue("wrong class: " + item3.getClass().getName(),

                item2 instanceof ScriptFileCommandExecutionItem);

            ScriptFileCommandExecutionItem scriptItem2 = (ScriptFileCommandExecutionItem) item3;

            assertNull(scriptItem2.getScript());

            assertNull(scriptItem2.getScriptAsStream());

            assertEquals("/some/file/path", scriptItem2.getServerScriptFilePath());

            assertNotNull(scriptItem2.getArgs());

            assertEquals(2, scriptItem2.getArgs().length);

            assertEquals("-testargs", scriptItem2.getArgs()[0]);

            assertEquals("2", scriptItem2.getArgs()[1]);

            assertEquals(3, interpreterMock.executionContextList.size());

            for (final int i : new int[]{0, 1, 2}) {

                final ExecutionContext executionContext = interpreterMock.executionContextList.get(i);

                assertEquals("item "+i,TEST_PROJECT, executionContext.getFrameworkProject());

                assertNotNull("item " + i, executionContext.getDataContext());

                assertNotNull("item " + i, executionContext.getDataContext().get("node"));

                assertEquals("item " + i,0, executionContext.getLoglevel());

                assertEquals("item " + i,"user1", executionContext.getUser());

                assertEquals("item " + i,nodeset, executionContext.getNodeSelector());

            }

        }

    }

    public void testWorkflowFailNoKeepgoing() throws Exception{

        {

            //test a workflow with a failing item (1), with keepgoing=false

            final NodesSelector nodeset = SelectorUtils.singleNode(testFramework.getFrameworkNodeName());

            final ArrayList<StepExecutionItem> commands = new ArrayList<StepExecutionItem>();

            final StepExecutionItem testWorkflowCmdItem = new ExecCommandBase() {

                @Override

                public String[] getCommand() {

                    return new String[]{"a", "2", "command"};

                }

            };

            commands.add(testWorkflowCmdItem);

            final StepExecutionItem testWorkflowCmdItemScript = new ScriptFileCommandBase() {

                @Override

                public String getScript() {

                    return "a command";

                }

                @Override

                public String[] getArgs() {

                    return new String[]{"-testargs", "1"};

                }

            };

            commands.add(testWorkflowCmdItemScript);

            final StepExecutionItem testWorkflowCmdItemScript2 = new ScriptFileCommandBase() {

                @Override

                public String getServerScriptFilePath() {

                    return "/some/file/path";

                }

                @Override

                public String[] getArgs() {

                    return new String[]{"-testargs", "2"};

                }

            };

            commands.add(testWorkflowCmdItemScript2);

            final WorkflowImpl workflow = new WorkflowImpl(commands, 1, false,

                WorkflowStrategy.STEP_FIRST);

            workflow.setKeepgoing(false);

            final WorkflowExecutionItemImpl executionItem = new WorkflowExecutionItemImpl(workflow);

            final StepFirstWorkflowStrategy strategy = new StepFirstWorkflowStrategy(testFramework);

            final StepExecutionContext context =

                new ExecutionContextImpl.Builder()

                    .frameworkProject(TEST_PROJECT)

                    .user("user1")

                    .nodeSelector(nodeset)

                    .executionListener(new testListener())

                    .framework(testFramework)

                    .nodes(testFramework.filterNodeSet(nodeset, TEST_PROJECT, null))

                    .build();

            //setup testInterpreter for all command types

            final NodeStepExecutionService interpreterService = NodeStepExecutionService.getInstanceForFramework(

                testFramework);

            testInterpreter interpreterMock = new testInterpreter();

            testInterpreter failMock = new testInterpreter();

            failMock.shouldThrowException = true;

            interpreterService.registerInstance("exec", interpreterMock);

            interpreterService.registerInstance("script", interpreterMock);

            interpreterService.registerInstance(WorkflowExecutionItem.COMMAND_TYPE_NODE_FIRST, failMock);

            interpreterService.registerInstance(WorkflowExecutionItem.COMMAND_TYPE_STEP_FIRST, failMock);

            //set resturn results, fail on second item

            interpreterMock.resultList.add(new testResult(true, 0));

            interpreterMock.resultList.add(new testResult(false, 1));

            interpreterMock.resultList.add(new testResult(true, 2));

            final WorkflowExecutionResult result = strategy.executeWorkflow(context, executionItem);

            assertNotNull(result);

            if (null != result.getException()) {

                result.getException().printStackTrace(System.out);

            }

            assertFalse(result.isSuccess());

            assertNull("threw exception: " + result.getException(), result.getException());

            StepExecutionResult result1 = result.getResultSet().get(1);

            final DispatcherResult executionResult = NodeDispatchStepExecutor.extractDispatcherResult(result1);

            assertNotNull(executionResult.getResults());

            assertEquals(1, executionResult.getResults().size());

            assertNotNull(executionResult.getResults().get(testnode));

            final StatusResult testnode1 = executionResult.getResults().get(testnode);

            assertNotNull(testnode1);

            assertTrue(testnode1 instanceof testResult);

            testResult failResult = (testResult) testnode1;

            assertEquals(1, failResult.flag);

            assertNotNull(result.getResultSet());

            final List<StepExecutionResult> test1 = result.getResultSet();

            assertEquals(2, test1.size());

            for (final int i : new int[]{0, 1}) {

                final StepExecutionResult interpreterResult = test1.get(i);

                final DispatcherResult dr = NodeDispatchStepExecutor.extractDispatcherResult(interpreterResult);

                assertEquals(1, dr.getResults().size());

                final NodeStepResult nrs = dr.getResults().values().iterator().next();

                assertTrue("unexpected class: " + nrs.getClass(),

                           nrs instanceof testResult);

                testResult val = (testResult) nrs;

                assertEquals(i, val.flag);

                if(0==i){

                    assertTrue(val.isSuccess());

                }else{

                    assertFalse(val.isSuccess());

                }

            }

            assertEquals(2, interpreterMock.executionItemList.size());

            final StepExecutionItem executionItem1 = interpreterMock.executionItemList.get(0);

            assertTrue("wrong class: " + executionItem1.getClass().getName(),

                executionItem1 instanceof ExecCommandExecutionItem);

            ExecCommandExecutionItem execItem = (ExecCommandExecutionItem) executionItem1;

            assertNotNull(execItem.getCommand());

            assertEquals(3, execItem.getCommand().length);

            assertEquals("a", execItem.getCommand()[0]);

            assertEquals("2", execItem.getCommand()[1]);

            assertEquals("command", execItem.getCommand()[2]);

            final StepExecutionItem item2 = interpreterMock.executionItemList.get(1);

            assertTrue("wrong class: " + item2.getClass().getName(),

                item2 instanceof ScriptFileCommandExecutionItem);

            ScriptFileCommandExecutionItem scriptItem = (ScriptFileCommandExecutionItem) item2;

            assertEquals("a command", scriptItem.getScript());

            assertNull(scriptItem.getScriptAsStream());

            assertNull(scriptItem.getServerScriptFilePath());

            assertNotNull(scriptItem.getArgs());

            assertEquals(2, scriptItem.getArgs().length);

            assertEquals("-testargs", scriptItem.getArgs()[0]);

            assertEquals("1",scriptItem.getArgs()[1]);

            assertEquals(2, interpreterMock.executionContextList.size());

            for (final int i : new int[]{0, 1}) {

                final ExecutionContext executionContext = interpreterMock.executionContextList.get(i);

                assertEquals(TEST_PROJECT, executionContext.getFrameworkProject());

                assertNotNull(executionContext.getDataContext());

                assertNotNull(executionContext.getDataContext().get("node"));

                assertEquals(0, executionContext.getLoglevel());

                assertEquals("user1", executionContext.getUser());

                assertEquals(nodeset, executionContext.getNodeSelector());

            }

        }

    }

    public void testWorkflowFailYesKeepgoing() throws Exception{

        {

            //test a workflow with a failing item (1), with keepgoing=true

            final NodesSelector nodeset = SelectorUtils.singleNode(testFramework.getFrameworkNodeName());

            final ArrayList<StepExecutionItem> commands = new ArrayList<StepExecutionItem>();

            final StepExecutionItem testWorkflowCmdItem = new ExecCommandBase() {

                @Override

                public String[] getCommand() {

                    return new String[]{"a", "2", "command"};

                }

            };

            commands.add(testWorkflowCmdItem);

            final StepExecutionItem testWorkflowCmdItemScript = new ScriptFileCommandBase() {

                @Override

                public String getScript() {

                    return "a command";

                }

                @Override

                public String[] getArgs() {

                    return new String[]{"-testargs", "1"};

                }

            };

            commands.add(testWorkflowCmdItemScript);

            final StepExecutionItem testWorkflowCmdItemScript2 = new ScriptFileCommandBase() {

                @Override

                public String getServerScriptFilePath() {

                    return "/some/file/path";

                }

                @Override

                public String[] getArgs() {

                    return new String[]{"-testargs", "2"};

                }

            };

            commands.add(testWorkflowCmdItemScript2);

            final WorkflowImpl workflow = new WorkflowImpl(commands, 1, false,

                WorkflowStrategy.STEP_FIRST);

            workflow.setKeepgoing(true);

            final WorkflowExecutionItemImpl executionItem = new WorkflowExecutionItemImpl(workflow);

            final StepFirstWorkflowStrategy strategy = new StepFirstWorkflowStrategy(testFramework);

            final StepExecutionContext context =

                new ExecutionContextImpl.Builder()

                    .frameworkProject(TEST_PROJECT)

                    .user("user1")

                    .nodeSelector(nodeset)

                    .executionListener(new testListener())

                    .framework(testFramework)

                    .nodes(testFramework.filterNodeSet(nodeset,TEST_PROJECT,null))

                    .build();

            //setup testInterpreter for all command types

            final NodeStepExecutionService interpreterService = NodeStepExecutionService.getInstanceForFramework(

                testFramework);

            testInterpreter interpreterMock = new testInterpreter();

            testInterpreter failMock = new testInterpreter();

            failMock.shouldThrowException = true;

            interpreterService.registerInstance("exec", interpreterMock);

            interpreterService.registerInstance("script", interpreterMock);

            interpreterService.registerInstance(WorkflowExecutionItem.COMMAND_TYPE_NODE_FIRST, failMock);

            interpreterService.registerInstance(WorkflowExecutionItem.COMMAND_TYPE_STEP_FIRST, failMock);

            //set resturn results, fail on second item

            interpreterMock.resultList.add(new testResult(true, 0));

            interpreterMock.resultList.add(new testResult(false, 1));

            interpreterMock.resultList.add(new testResult(true, 2));

            final WorkflowExecutionResult result = strategy.executeWorkflow(context, executionItem);

            assertNotNull(result);

            if (!result.isSuccess() && null != result.getException()) {

                result.getException().printStackTrace(System.err);

            }

            assertFalse(result.isSuccess());

            assertNull("threw exception: " + result.getException(), result.getException());

            assertNotNull(result.getResultSet());

            final List<StepExecutionResult> test1 = result.getResultSet();

            assertEquals(3, test1.size());

            for (final int i : new int[]{0, 1, 2}) {

                final StepExecutionResult interpreterResult = test1.get(i);

                assertTrue(NodeDispatchStepExecutor.isWrappedDispatcherResult(interpreterResult));

                final DispatcherResult dr = NodeDispatchStepExecutor.extractDispatcherResult(interpreterResult);

                assertEquals(1, dr.getResults().size());

                final NodeStepResult nrs = dr.getResults().values().iterator().next();

                assertTrue("unexpected class: " + nrs.getClass(),

                           nrs instanceof testResult);

                testResult val = (testResult) nrs;

                assertEquals(i, val.flag);

                if (1 == i) {

                    assertFalse(val.isSuccess());

                } else {

                    assertTrue(val.isSuccess());

                }

            }