Grand unified theory of hooks

src/main/java/com/greghaskins/spectrum/AbstractSupplyingHook.java

@@ -0,0 +1,53 @@
+package com.greghaskins.spectrum;
+
+import static com.greghaskins.spectrum.Spectrum.assertSpectrumInTestMode;
+
+/**
+ * A base class for supplying hooks to use. Override before or after. Return the singleton
+ * value from the before method.
+ * You can use this to write any plugin which needs to make a value visible to the specs.
+ * This is not the only way to achieve that - you can also build from {@link SupplyingHook}
+ * but this captures the template for a complex hook.
+ */
+public abstract class AbstractSupplyingHook<T> extends Variable<T> implements SupplyingHook<T> {
+  /**
+   * Override this to supply behaviour for before the block is run.
+   * @return the value that the singleton will store to supply
+   */
+  protected abstract T before();
+
+  /**
+   * Override this to supply behaviour for after the block is run.
+   */
+  protected void after() {}
+
+  /**
+   * Template method for a hook which supplies.
+   * @param block the inner block that will be run
+   * @throws Throwable on error
+   */
+  @Override
+  public void acceptOrThrow(Block block) throws Throwable {
+    try {
+      set(before());
+      block.run();
+    } finally {
+      try {
+        after();
+      } finally {
+        clear();
+      }
+    }
+  }
+
+  @Override
+  public T get() {
+    assertSpectrumInTestMode();
+
+    return super.get();
+  }
+
+  private void clear() {
+    set(null);
+  }
+}

src/main/java/com/greghaskins/spectrum/CompositeTest.java

@@ -0,0 +1,46 @@
+package com.greghaskins.spectrum;
+
+import com.greghaskins.spectrum.internal.Child;
+import com.greghaskins.spectrum.internal.FailureDetectingRunListener;
+import com.greghaskins.spectrum.internal.Parent;
+import com.greghaskins.spectrum.model.TaggingFilterCriteria;
+
+import org.junit.runner.Description;
+import org.junit.runner.notification.RunNotifier;
+
+/**
+ * Subclass of {@link Suite} that represent the fact that some tests are composed
+ * of interrelated steps which add up to a single test.
+ */
+final class CompositeTest extends Suite {
+  /**
+   * Constructs a Composite Test, which is a suite run as an atomic test.
+   * @param description of the test
+   * @param parent parent suite
+   * @param tagging tagging state to inherit from parent
+   */
+  CompositeTest(final Description description, final Parent parent,
+      final TaggingFilterCriteria tagging) {
+    super(description, parent, CompositeTest::abortOnFailureChildRunner, tagging);
+  }
+
+  @Override
+  public boolean isAtomic() {
+    return true;
+  }
+
+  private static void abortOnFailureChildRunner(final Suite suite, final RunNotifier runNotifier) {
+    FailureDetectingRunListener listener = new FailureDetectingRunListener();
+    runNotifier.addListener(listener);
+    try {
+      for (Child child : suite.children) {
+        if (listener.hasFailedYet()) {
+          child.ignore();
+        }
+        suite.runChild(child, runNotifier);
+      }
+    } finally {
+      runNotifier.removeListener(listener);
+    }
+  }
+}

src/main/java/com/greghaskins/spectrum/Configuration.java

@@ -1,5 +1,9 @@
 package com.greghaskins.spectrum;
 
+/**
+ * Allows the injection of suite configuration during test definition. A wrapper for the
+ * suite which exposes configurables.
+ */
 public class Configuration {
 
   private final Suite suite;

src/main/java/com/greghaskins/spectrum/Hook.java

@@ -0,0 +1,11 @@
+package com.greghaskins.spectrum;
+
+/**
+ * A hook allows you to inject functionality before and/or after a {@link Block}.
+ * Just implement the {@link ThrowingConsumer#acceptOrThrow(Object)} method and
+ * call {@link Block#run()} within your implementation.
+ * If your hook is going to provide an object to the running test, then implement
+ * {@link SupplyingHook} or subclass {@link AbstractSupplyingHook}.
+ */
+public interface Hook extends ThrowingConsumer<Block> {
+}

src/main/java/com/greghaskins/spectrum/Spec.java

@@ -1,5 +1,9 @@
 package com.greghaskins.spectrum;
 
+import com.greghaskins.spectrum.internal.Child;
+import com.greghaskins.spectrum.internal.NotifyingBlock;
+import com.greghaskins.spectrum.internal.Parent;
+
 import org.junit.runner.Description;
 import org.junit.runner.notification.RunNotifier;
 
@@ -52,4 +56,9 @@ public void focus() {
   public void ignore() {
     this.ignored = true;
   }
+
+  @Override
+  public boolean isAtomic() {
+    return true;
+  }
 }