spinach 0.10.0 → 0.10.1

data/lib/spinach/reporter.rb

@@ -96,3 +96,4 @@ end
 
 require_relative 'reporter/stdout'
 require_relative 'reporter/progress'
+require_relative 'reporter/failure_file'

data/lib/spinach/reporter/failure_file.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+require_relative 'reporting'
+require 'pp'
+
+module Spinach
+  class Reporter
+    # The FailureFile reporter outputs failing scenarios to a temporary file, one per line.
+    #
+    class FailureFile < Reporter
+
+      # Initializes the output filename and the temporary directory.
+      #
+      def initialize(*args)
+        super(*args)
+
+        # Generate a unique filename for this test run, or use the supplied option
+        @filename = options[:failure_filename] || ENV['SPINACH_FAILURE_FILE'] || "tmp/spinach-failures_#{Time.now.strftime('%F_%H-%M-%S-%L')}.txt"
+
+        # Create the temporary directory where we will output our file, if necessary
+        Dir.mkdir('tmp', 0755) unless Dir.exist?('tmp')
+
+        # Collect an array of failing scenarios
+        @failing_scenarios = []
+      end
+
+      attr_reader :failing_scenarios, :filename
+
+      # Writes all failing scenarios to a file, unless our run was successful.
+      #
+      # @param [Boolean] success
+      #   Indicates whether the entire test run was successful
+      #
+      def after_run(success)
+        # Save our failed scenarios to a file
+        File.open(@filename, 'w') { |f| f.write @failing_scenarios.join("\n") } unless success
+      end
+
+      # Adds a failing step to the output buffer.
+      #
+      def on_failed_step(*args)
+        add_scenario(current_feature.filename, current_scenario.lines[0])
+      end
+
+      # Adds a step that has raised an error to the output buffer.
+      #
+      def on_error_step(*args)
+        add_scenario(current_feature.filename, current_scenario.lines[0])
+      end
+
+      private
+
+      # Adds a filename and line number to the output buffer, suitable for rerunning.
+      #
+      def add_scenario(filename, line)
+        @failing_scenarios << "#{filename}:#{line}"
+      end
+    end
+  end
+end

data/lib/spinach/rspec/mocks.rb

@@ -0,0 +1,18 @@
+# Inspired by cucumber/rspec/mocks
+require 'rspec/mocks'
+
+class Spinach::FeatureSteps
+  include RSpec::Mocks::ExampleMethods
+end
+
+Spinach.hooks.before_scenario do
+  RSpec::Mocks.setup
+end
+
+Spinach.hooks.after_scenario do
+  begin
+    RSpec::Mocks.verify
+  ensure
+    RSpec::Mocks.teardown
+  end
+end

data/lib/spinach/runner.rb

@@ -37,21 +37,14 @@ module Spinach
         Spinach.config.support_path
     end
 
-    # The feature files to run
-    attr_reader :filenames
-
-    # The default path where the steps are located
-    attr_reader :step_definitions_path
-
-    # The default path where the support files are located
-    attr_reader :support_path
-
     # Inits the reporter with a default one.
     #
     # @api public
-    def init_reporter
-      reporter = Support.constantize(Spinach.config[:reporter_class]).new(Spinach.config.reporter_options)
-      reporter.bind
+    def init_reporters
+      Spinach.config[:reporter_classes].each do |reporter_class|
+        reporter = Support.constantize(reporter_class).new(Spinach.config.reporter_options)
+        reporter.bind
+      end
     end
 
     # Runs this runner and outputs the results in a colorful manner.
@@ -63,36 +56,34 @@ module Spinach
     def run
       require_dependencies
       require_frameworks
-      init_reporter
+      init_reporters
 
-      Spinach.hooks.run_before_run
+      features = filenames.map do |filename|
+        file, *lines = filename.split(":") # little more complex than just a "filename"
 
-      successful = true
+        # FIXME Feature should be instantiated directly, not through an unrelated class method
+        feature          = Parser.open_file(file).parse
+        feature.filename = file
 
-      filenames.map! do |filename|
-        file, *lines = filename.split(":")
-        [file, lines]
+        feature.lines_to_run = lines if lines.any?
+
+        feature
       end
 
-      catch :fail do
-        filenames.each do |filename, lines|
-          lines = [nil] if lines.empty?
+      suite_passed = true
+
+      Spinach.hooks.run_before_run
 
-          feature = Parser.open_file(filename).parse
-          feature.filename = filename
-          feature.lines = lines
+      features.each do |feature|
+        feature_passed = FeatureRunner.new(feature).run
+        suite_passed &&= feature_passed
 
-          lines.each do |line|
-            success = FeatureRunner.new(feature, line).run
-            successful = false unless success
-            throw :fail if fail_fast? && !successful
-          end
-        end
+        break if fail_fast? && !feature_passed
       end
 
-      Spinach.hooks.run_after_run(successful)
+      Spinach.hooks.run_after_run(suite_passed)
 
-      successful
+      suite_passed
     end
 
     # Loads support files and step definitions, ensuring that env.rb is loaded

data/lib/spinach/runner/feature_runner.rb

@@ -10,14 +10,9 @@ module Spinach
       # @param [GherkinRuby::AST::Feature] feature
       #   The feature to run.
       #
-      # @param [#to_i] line
-      #   If a scenario line is passed, then only the scenario defined on that
-      #   line will be run.
-      #
       # @api public
-      def initialize(feature, line=nil)
+      def initialize(feature)
         @feature = feature
-        @line    = line.to_i if line
       end
 
       # @return [String]
@@ -25,7 +20,7 @@ module Spinach
       #
       # @api public
       def feature_name
-        @feature.name
+        feature.name
       end
 
       # @return [Array<GherkinRuby::AST::Scenario>]
@@ -33,7 +28,7 @@ module Spinach
       #
       # @api public
       def scenarios
-        @feature.scenarios
+        feature.scenarios
       end
 
       # Runs this feature.
@@ -43,52 +38,58 @@ module Spinach
       #
       # @api public
       def run
-        Spinach.hooks.run_before_feature @feature
+        Spinach.hooks.run_before_feature(feature)
+
         if Spinach.find_step_definitions(feature_name)
           run_scenarios!
         else
           undefined_steps!
         end
-        Spinach.hooks.run_after_feature @feature
+
+        Spinach.hooks.run_after_feature(feature)
+
+        # FIXME The feature & scenario runners should have the same structure.
+        #       They should either both return inverted failure or both return
+        #       raw success.
         !@failed
       end
 
       private
 
       def feature_tags
-        if @feature.respond_to?(:tags)
-          @feature.tags
+        if feature.respond_to?(:tags)
+          feature.tags
         else
           []
         end
       end
 
       def run_scenarios!
-        scenarios.each_with_index do |scenario, current_scenario_index|
-          if run_scenario?(scenario, current_scenario_index)
-            success = ScenarioRunner.new(scenario).run
-            @failed = true unless success
-            break if Spinach.config.fail_fast && @failed
-          end
+        scenarios_to_run.each do |scenario|
+          success = ScenarioRunner.new(scenario).run
+          @failed = true unless success
+
+          break if Spinach.config.fail_fast && @failed
         end
       end
 
-      def run_scenario?(scenario, current_scenario_index)
-        match_line(current_scenario_index) && 
-          TagsMatcher.match(feature_tags + scenario.tags)
-      end
+      def undefined_steps!
+        Spinach.hooks.run_on_undefined_feature(feature)
 
-      def match_line(current_scenario_index)
-        return true unless @line
-        return false if @line < scenarios[current_scenario_index].line
-        next_scenario = scenarios[current_scenario_index+1]
-        !next_scenario || @line < next_scenario.line
+        @failed = true
       end
 
+      def scenarios_to_run
+        feature.scenarios.select do |scenario|
+          has_a_tag_that_will_be_run = TagsMatcher.match(feature_tags + scenario.tags)
+          on_a_line_that_will_be_run = if feature.run_every_scenario?
+                                         true
+                                       else
+                                         (scenario.lines & feature.lines_to_run).any?
+                                       end
 
-      def undefined_steps!
-        Spinach.hooks.run_on_undefined_feature @feature
-        @failed = true
+          has_a_tag_that_will_be_run && on_a_line_that_will_be_run
+        end
       end
     end
   end

data/lib/spinach/runner/scenario_runner.rb

@@ -61,7 +61,7 @@ module Spinach
           end
           step_definitions.after_each
         end
-        raise "around_scenario hooks *must* yield" if !scenario_run && !@exception
+        raise Spinach::HookNotYieldException.new('around_scenario') if !scenario_run && !@exception
         Spinach.hooks.run_after_scenario @scenario, step_definitions
         !@exception
       end
@@ -74,8 +74,15 @@ module Spinach
       # @api semipublic
       def run_step(step)
         step_location = step_definitions.step_location_for(step.name)
-        step_definitions.execute(step)
+        step_run = false
+        Spinach.hooks.run_around_step step, step_definitions do
+          step_run = true
+          step_definitions.execute(step)
+        end
+        raise Spinach::HookNotYieldException.new('around_step') if !step_run
         Spinach.hooks.run_on_successful_step step, step_location, step_definitions
+      rescue Spinach::HookNotYieldException => e
+        raise e
       rescue *Spinach.config[:failure_exceptions] => e
         @exception = e
         Spinach.hooks.run_on_failed_step step, @exception, step_location, step_definitions

data/lib/spinach/scenario.rb

@@ -1,12 +1,13 @@
 module Spinach
   class Scenario
-    attr_accessor :line
+    attr_accessor :lines
     attr_accessor :name, :steps, :tags, :feature
 
     def initialize(feature)
       @feature = feature
       @steps   = []
       @tags    = []
+      @lines   = []
     end
   end
 end

data/lib/spinach/version.rb

@@ -1,4 +1,4 @@
 module Spinach
   # Spinach version.
-  VERSION = "0.10.0"
+  VERSION = "0.10.1"
 end

data/test/spinach/cli_test.rb

@@ -76,7 +76,15 @@ tags:
           Spinach.stubs(:config).returns(config)
           cli = Spinach::Cli.new([opt, 'progress'])
           cli.options
-          config.reporter_class.must_equal 'Spinach::Reporter::Progress'
+          config.reporter_classes.must_equal ['Spinach::Reporter::Progress']
+        end
+
+        it 'sets multiple reporter classes' do
+          config = Spinach::Config.new
+          Spinach.stubs(:config).returns(config)
+          cli = Spinach::Cli.new([opt, 'progress,stdout'])
+          cli.options
+          config.reporter_classes.must_equal ['Spinach::Reporter::Progress', 'Spinach::Reporter::Stdout']
         end
       end
     end

data/test/spinach/config_test.rb

@@ -16,14 +16,14 @@ describe Spinach::Config do
    end
  end
 
- describe '#reporter_class' do
+ describe '#reporter_classes' do
    it 'returns a default' do
-     subject[:reporter_class].must_equal "Spinach::Reporter::Stdout"
+     subject[:reporter_classes].must_equal ["Spinach::Reporter::Stdout"]
    end
 
    it 'can be overwritten' do
-     subject[:reporter_class] = "MyOwnReporter"
-     subject[:reporter_class].must_equal "MyOwnReporter"
+     subject[:reporter_classes] = ["MyOwnReporter"]
+     subject[:reporter_classes].must_equal ["MyOwnReporter"]
    end
  end
 

data/test/spinach/feature_test.rb

@@ -2,5 +2,32 @@ require 'test_helper'
 
 module Spinach
   describe Feature do
+    describe "#lines_to_run=" do
+      subject { Feature.new }
+
+      before { subject.lines_to_run = [4, 12] }
+
+      it 'writes lines_to_run' do
+        subject.lines_to_run.must_equal [4, 12]
+      end
+    end
+
+    describe '#run_every_scenario?' do
+      subject { Feature.new }
+
+      describe 'when no line constraints have been specified' do
+        it 'is true' do
+          subject.run_every_scenario?.must_equal true
+        end
+      end
+
+      describe 'when line constraints have been specified' do
+        before { subject.lines_to_run = [4, 12] }
+
+        it 'is false' do
+          subject.run_every_scenario?.must_equal false
+        end
+      end
+    end
   end
 end

data/test/spinach/hooks_test.rb

@@ -59,6 +59,24 @@ describe Spinach::Hooks do
       end
     end
 
+    describe "around_step" do
+      it "responds to around_step" do
+        subject.must_respond_to :around_step
+      end
+
+      it "executes the hook with params" do
+        array = []
+        block = Proc.new do |arg1, arg2|
+          array << arg1
+          array << arg2
+        end
+        subject.send(:around_step, &block)
+        subject.send("run_around_step", 1, 2) do
+        end
+        array.must_equal [1, 2]
+      end
+    end
+
     describe "#on_tag" do
       let(:scenario) do
         stub(tags: ['javascript', 'capture'])

data/test/spinach/parser/visitor_test.rb

@@ -63,7 +63,11 @@ module Spinach
 
       describe '#visit_Scenario' do
         before do
-          @steps = [stub_everything, stub_everything, stub_everything]
+          @steps = [
+            stub_everything(line: 4),
+            stub_everything(line: 5),
+            stub_everything(line: 6)
+          ]
           @tags  = [stub_everything, stub_everything, stub_everything]
           @node  = stub(
             tags:  @tags,
@@ -83,9 +87,9 @@ module Spinach
           visitor.feature.scenarios.first.name.must_equal 'Go shopping on Saturday morning'
         end
 
-        it 'sets the line' do
+        it 'sets the lines' do
           visitor.visit_Scenario(@node)
-          visitor.feature.scenarios.first.line.must_equal 3
+          visitor.feature.scenarios.first.lines.must_equal (3..6).to_a
         end
 
         it 'sets the tags' do