[Core] Add Before and AfterStep hooks

core/src/main/java/cucumber/api/HookType.java

@@ -1,7 +1,7 @@
 package cucumber.api;
 
 public enum HookType {
-    Before, After;
+    Before, After, AfterStep;
 
     @Override
     public String toString() {

core/src/main/java/cucumber/api/Result.java

@@ -2,11 +2,21 @@
 
 import java.io.PrintWriter;
 import java.io.StringWriter;
+import java.util.Comparator;
 
 public class Result {
+
+    public final static Comparator<Result> SEVERITY = new Comparator<Result>() {
+
+        @Override
+        public int compare(Result a, Result b) {
+            return a.status == b.status ? 0 : a.status.ordinal() > b.status.ordinal() ? 1 : -1;
+        }
+    };
+
     private static final long serialVersionUID = 1L;
 
-    private final Result.Type status;
+    private final Type status;
     private final Long duration;
     private final Throwable error;
     public static final Result SKIPPED = new Result(Result.Type.SKIPPED, null, null);
@@ -15,8 +25,8 @@ public enum Type {
         PASSED,
         SKIPPED,
         PENDING,
-        UNDEFINED,
         AMBIGUOUS,
+        UNDEFINED,
         FAILED;
 
         public static Type fromLowerCaseName(String lowerCaseName) {
@@ -85,4 +95,13 @@ private String getErrorMessage(Throwable error) {
         error.printStackTrace(printWriter);
         return stringWriter.getBuffer().toString();
     }
+
+    @Override
+    public String toString() {
+        return "Result{" +
+            "status=" + status +
+            ", duration=" + duration +
+            ", error=" + error +
+            '}';
+    }
 }

core/src/main/java/cucumber/api/TestCase.java

@@ -14,6 +14,10 @@ public class TestCase {
     private final PickleEvent pickleEvent;
     private final List<TestStep> testSteps;
     private final boolean dryRun;
+    public enum SkipStatus {
+        RUN_ALL,
+        SKIP_ALL_SKIPABLE
+    };
 
     /**
      * Creates a new instance of a test case.

core/src/main/java/cucumber/runner/UnskipableStep.java → core/src/main/java/cucumber/runner/HookStep.java

@@ -1,28 +1,21 @@
 package cucumber.runner;
 
 import cucumber.api.HookType;
-import cucumber.api.Result;
-import cucumber.api.Scenario;
 import cucumber.api.TestStep;
 import cucumber.runtime.DefinitionMatch;
 import gherkin.pickles.Argument;
 import gherkin.pickles.PickleStep;
 
 import java.util.List;
 
-public class UnskipableStep extends TestStep {
+public class HookStep extends TestStep {
     private final HookType hookType;
 
-    public UnskipableStep(HookType hookType, DefinitionMatch definitionMatch) {
+    public HookStep(HookType hookType, DefinitionMatch definitionMatch) {
         super(definitionMatch);
         this.hookType = hookType;
     }
 
-    protected Result.Type executeStep(String language, Scenario scenario, boolean skipSteps) throws Throwable {
-        definitionMatch.runStep(language, scenario);
-        return Result.Type.PASSED;
-    }
-
     @Override
     public boolean isHook() {
         return true;
@@ -57,4 +50,5 @@ public List<Argument> getStepArgument() {
     public HookType getHookType() {
         return hookType;
     }
+
 }

core/src/main/java/cucumber/runner/PickleTestStep.java

@@ -1,24 +1,51 @@
 package cucumber.runner;
 
 import cucumber.api.HookType;
+import cucumber.api.Result;
+import cucumber.api.Scenario;
 import cucumber.api.TestStep;
 import cucumber.runtime.DefinitionMatch;
 import cucumber.runtime.StepDefinitionMatch;
 import gherkin.pickles.Argument;
 import gherkin.pickles.PickleStep;
 
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
+import static cucumber.api.Result.SEVERITY;
+import static java.util.Collections.max;
+
 public class PickleTestStep extends TestStep {
-    private String uri;
-    private PickleStep step;
+    private final String uri;
+    private final PickleStep step;
+    private final List<TestStep> afterStepHooks;
 
     public PickleTestStep(String uri, PickleStep step, DefinitionMatch definitionMatch) {
+        this(uri, step, Collections.<TestStep>emptyList(), definitionMatch);
+    }
+
+    public PickleTestStep(String uri, PickleStep step, List<TestStep> afterStepHooks, DefinitionMatch definitionMatch) {
         super(definitionMatch);
         this.uri = uri;
         this.step = step;
+        this.afterStepHooks = afterStepHooks;
+    }
+
+    @Override
+    public Result run(EventBus bus, String language, Scenario scenario, boolean skipSteps) {
+        List<Result> results = new ArrayList<Result>();
+
+        results.add(super.run(bus, language, scenario, skipSteps));
+
+        for(TestStep after : afterStepHooks){
+            results.add(after.run(bus, language, scenario, skipSteps));
+        }
+
+        return max(results, SEVERITY);
     }
 
+
     @Override
     public boolean isHook() {
         return false;

core/src/main/java/cucumber/runner/Runner.java

@@ -127,27 +127,43 @@ private void addTestStepsForPickleSteps(List<TestStep> testSteps, PickleEvent pi
             } catch (Throwable t) {
                 match = new FailedStepInstantiationMatch(pickleEvent.uri, step, t);
             }
-            testSteps.add(new PickleTestStep(pickleEvent.uri, step, match));
+
+
+            List<TestStep> afterStepHooks = getAfterStepHooks(pickleEvent.pickle.getTags());
+            testSteps.add(new PickleTestStep(pickleEvent.uri, step, afterStepHooks, match));
         }
     }
 
     private void addTestStepsForBeforeHooks(List<TestStep> testSteps, List<PickleTag> tags) {
-        addTestStepsForHooks(testSteps, tags, glue.getBeforeHooks(), HookType.Before);
+        addTestStepsForScenarioHooks(testSteps, tags, glue.getBeforeHooks(), HookType.Before);
     }
 
     private void addTestStepsForAfterHooks(List<TestStep> testSteps, List<PickleTag> tags) {
-        addTestStepsForHooks(testSteps, tags, glue.getAfterHooks(), HookType.After);
+        addTestStepsForScenarioHooks(testSteps, tags, glue.getAfterHooks(), HookType.After);
     }
 
-    private void addTestStepsForHooks(List<TestStep> testSteps, List<PickleTag> tags,  List<HookDefinition> hooks, HookType hookType) {
+    private void addTestStepsForScenarioHooks(List<TestStep> testSteps, List<PickleTag> tags,  List<HookDefinition> hooks, HookType hookType) {
         for (HookDefinition hook : hooks) {
             if (hook.matches(tags)) {
-                TestStep testStep = new UnskipableStep(hookType, new HookDefinitionMatch(hook));
+                TestStep testStep = new UnskipableHookStep(hookType, new HookDefinitionMatch(hook));
                 testSteps.add(testStep);
             }
         }
     }
 
+    private List<TestStep> getAfterStepHooks(List<PickleTag> tags) {
+        List<TestStep> hooks = new ArrayList<TestStep>();
+
+        for (HookDefinition hook : glue.getAfterStepHooks()) {
+            if (hook.matches(tags)) {
+                TestStep testStep = new HookStep(HookType.AfterStep, new HookDefinitionMatch(hook));
+                hooks.add(testStep);
+            }
+        }
+
+        return hooks;
+    }
+
     private void buildBackendWorlds() {
         runtimeOptions.getPlugins(); // To make sure that the plugins are instantiated after
         // the features have been parsed but before the pickles starts to execute.

core/src/main/java/cucumber/runner/UnskipableHookStep.java

@@ -0,0 +1,21 @@
+package cucumber.runner;
+
+import cucumber.api.HookType;
+import cucumber.api.Result;
+import cucumber.api.Result.Type;
+import cucumber.api.Scenario;
+import cucumber.api.TestCase.SkipStatus;
+import cucumber.runtime.DefinitionMatch;
+
+public class UnskipableHookStep extends HookStep {
+
+    public UnskipableHookStep(HookType hookType, DefinitionMatch definitionMatch) {
+        super(hookType, definitionMatch);
+    }
+
+    @Override
+    protected Type executeStep(String language, Scenario scenario, boolean skipSteps) throws Throwable {
+        definitionMatch.runStep(language, scenario);
+        return Result.Type.PASSED;
+    }
+}

core/src/main/java/cucumber/runtime/Glue.java

@@ -17,10 +17,14 @@ public interface Glue {
 
     void addAfterHook(HookDefinition hookDefinition);
 
+    void addAfterStepHook(HookDefinition hookDefinition);
+
     List<HookDefinition> getBeforeHooks();
 
     List<HookDefinition> getAfterHooks();
 
+    List<HookDefinition> getAfterStepHooks();
+
     StepDefinitionMatch stepDefinitionMatch(String featurePath, PickleStep step);
 
     void reportStepDefinitions(StepDefinitionReporter stepDefinitionReporter);

core/src/main/java/cucumber/runtime/RuntimeGlue.java

@@ -16,6 +16,7 @@ public class RuntimeGlue implements Glue {
     final Map<String, StepDefinition> stepDefinitionsByPattern = new TreeMap<String, StepDefinition>();
     final List<HookDefinition> beforeHooks = new ArrayList<HookDefinition>();
     final List<HookDefinition> afterHooks = new ArrayList<HookDefinition>();
+    final List<HookDefinition> afterStepHooks = new ArrayList<HookDefinition>();
     final Map<String, CacheEntry> matchedStepDefinitionsCache = new HashMap<String, CacheEntry>();
     private final LocalizedXStreams localizedXStreams;
 
@@ -49,6 +50,12 @@ public void addAfterHook(HookDefinition hookDefinition) {
         Collections.sort(afterHooks, new HookComparator(false));
     }
 
+    @Override
+    public void addAfterStepHook(HookDefinition hookDefinition) {
+        afterStepHooks.add(hookDefinition);
+        Collections.sort(afterStepHooks, new HookComparator(false));
+    }
+
     @Override
     public List<HookDefinition> getBeforeHooks() {
         return beforeHooks;
@@ -59,6 +66,11 @@ public List<HookDefinition> getAfterHooks() {
         return afterHooks;
     }
 
+    @Override
+    public List<HookDefinition> getAfterStepHooks() {
+        return afterStepHooks;
+    }
+
     @Override
     public StepDefinitionMatch stepDefinitionMatch(String featurePath, PickleStep step) {
         String stepText = step.getText();

core/src/main/java/cucumber/runtime/ScenarioImpl.java

@@ -17,10 +17,10 @@
 import java.util.List;
 import java.util.Set;
 
-import static java.util.Arrays.asList;
+import static java.util.Collections.max;
 
 public class ScenarioImpl implements Scenario {
-    private static final List<Result.Type> SEVERITY = asList(Result.Type.PASSED, Result.Type.SKIPPED, Result.Type.PENDING, Result.Type.UNDEFINED, Result.Type.AMBIGUOUS, Result.Type.FAILED);
+
     private final List<Result> stepResults = new ArrayList<Result>();
     private final List<PickleTag> tags;
     private final String uri;
@@ -63,11 +63,8 @@ public Result.Type getStatus() {
         if (stepResults.isEmpty()) {
             return Result.Type.UNDEFINED;
         }
-        int pos = 0;
-        for (Result stepResult : stepResults) {
-            pos = Math.max(pos, SEVERITY.indexOf(stepResult.getStatus()));
-        }
-        return SEVERITY.get(pos);
+
+        return max(stepResults, Result.SEVERITY).getStatus();
     }
 
     @Override
@@ -110,15 +107,10 @@ public List<Integer> getLines() {
     }
 
     public Throwable getError() {
-        Throwable error = null;
-        int maxPos = 0;
-        for (Result stepResult : stepResults) {
-            int currentPos = SEVERITY.indexOf(stepResult.getStatus());
-            if (currentPos > maxPos) {
-                maxPos = currentPos;
-                error = stepResult.getError();
-            }
+        if(stepResults.isEmpty()){
+            return null;
         }
-        return error;
+
+        return max(stepResults, Result.SEVERITY).getError();
     }
 }

core/src/main/java/cucumber/runtime/formatter/JSONFormatter.java

@@ -283,10 +283,25 @@ private Map<String, Object> createHookStep(TestStep testStep) {
     }
 
     private void addHookStepToTestCaseMap(Map<String, Object> currentStepOrHookMap, HookType hookType) {
-        if (!currentTestCaseMap.containsKey(hookType.toString())) {
-            currentTestCaseMap.put(hookType.toString(), new ArrayList<Map<String, Object>>());
+        String hookName;
+        if (hookType.toString().contains("after"))
+            hookName = "after";
+        else
+            hookName = "before";
+
+        Map<String, Object> mapToAddTo;
+        if (hookType == HookType.After || hookType == HookType.Before) {
+            mapToAddTo = currentTestCaseMap;
+        }
+        else {
+            //get latest added step
+            mapToAddTo = currentStepsList.get(currentStepsList.size() - 1);
+        }
+
+        if (!mapToAddTo.containsKey(hookName)) {
+            mapToAddTo.put(hookName, new ArrayList<Map<String, Object>>());
         }
-        ((List<Map<String, Object>>)currentTestCaseMap.get(hookType.toString())).add(currentStepOrHookMap);
+        ((List<Map<String, Object>>)mapToAddTo.get(hookName)).add(currentStepOrHookMap);
     }
 
     private void addOutputToHookMap(String text) {

core/src/test/java/cucumber/api/ResultTest.java

@@ -2,11 +2,34 @@
 
 import org.junit.Test;
 
+import java.util.List;
+
+import static cucumber.api.Result.SEVERITY;
+import static java.util.Arrays.asList;
+import static java.util.Collections.sort;
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 
 public class ResultTest {
 
+    @Test
+    public void severity_from_low_to_high_is_passed_skipped_pending_undefined_ambiguous_failed() {
+        Result passed = new Result(Result.Type.PASSED, null, null);
+        Result skipped = new Result(Result.Type.SKIPPED, null, null);
+        Result pending = new Result(Result.Type.PENDING, null, null);
+        Result undefined = new Result(Result.Type.UNDEFINED, null, null);
+        Result ambiguous = new Result(Result.Type.AMBIGUOUS, null, null);
+        Result failed = new Result(Result.Type.FAILED, null, null);
+
+        List<Result> results = asList(pending, passed, skipped, failed, ambiguous, undefined);
+
+        sort(results, SEVERITY);
+
+        assertThat(results, equalTo(asList(passed, skipped, pending, ambiguous, undefined, failed)));
+    }
+
     @Test
     public void passed_result_is_always_ok() {
         Result passedResult = new Result(Result.Type.PASSED, null, null);