spinach 0.0.6 → 0.1.0

data/test/spinach/runner/feature_test.rb

@@ -1,24 +1,17 @@
 require_relative '../../test_helper'
 
 describe Spinach::Runner::Feature do
-  before do
-    @filename = 'feature/a_cool_feature.feature'
-    @reporter = stub_everything
-    @feature = Spinach::Runner::Feature.new(@filename, @reporter)
-  end
+  let(:filename) { 'feature/a_cool_feature.feature' }
+  let(:feature) { Spinach::Runner::Feature.new(filename) }
 
   describe '#initialize' do
     it 'initializes the given filename' do
-      @feature.filename.must_equal @filename
-    end
-
-    it 'initializes the given reporter' do
-      @feature.reporter.must_equal @reporter
+      feature.filename.must_equal filename
     end
 
     it 'initalizes the given scenario line' do
       @filename = 'feature/a_cool_feature.feature:12'
-      @feature = Spinach::Runner::Feature.new(@filename, @reporter)
+      @feature = Spinach::Runner::Feature.new(@filename)
 
       @feature.instance_variable_get(:@scenario_line).must_equal '12'
     end
@@ -26,77 +19,69 @@ describe Spinach::Runner::Feature do
 
   describe '#feature' do
     it 'finds the feature given a feature name' do
-      feature = stub_everything
-      @feature.stubs(feature_name: 'A cool feature')
-      Spinach.expects(:find_feature).with('A cool feature').returns(feature)
-      @feature.feature
+      @feature = stub_everything
+      feature.stubs(feature_name: 'A cool feature')
+
+      Spinach.expects(:find_feature).with('A cool feature').returns(@feature)
+      feature.feature
     end
   end
 
   describe '#data' do
     it 'returns the parsed data' do
-      parsed_data = {'name' => 'A cool feature'}
-      parser = stub(:parse => parsed_data)
+      parsed_data = {name: 'A cool feature'}
+      parser = stub(parse: parsed_data)
       Spinach::Parser.expects(:new).returns(parser)
-      @feature.data.must_equal parsed_data
+      feature.data.must_equal parsed_data
     end
   end
 
   describe '#scenarios' do
     it 'returns the parsed scenarios' do
-      @feature.stubs(data: {'elements' => [1, 2, 3]})
-      @feature.scenarios.must_equal [1,2,3]
+      feature.stubs(data: {'elements' => [1, 2, 3]})
+      feature.scenarios.must_equal [1,2,3]
     end
   end
 
   describe '#run' do
     before do
-      @feature.stubs(data: {
+      feature.stubs(data: {
         'name' => 'A cool feature',
         'elements' => [{'keyword'=>'Scenario', 'name'=>'Basic guess', 'line'=>6, 'description'=>'', 'type'=>'scenario'},
                        {'keyword'=>'Scenario', 'name'=>'Basic guess II', 'line'=>12, 'description'=>'', 'type'=>'scenario'},
                        {'keyword'=>'Scenario', 'name'=>'Basic guess III', 'line'=>18, 'description'=>'', 'type'=>'scenario'}]
       })
-      @feature.stubs(feature: stub_everything)
-    end
-
-    it 'reports' do
-      Spinach::Runner::Scenario.stubs(new: stub_everything)
-
-      @reporter.expects(:feature).with('A cool feature')
-      @feature.run
+      feature.stubs(feature: stub_everything)
     end
 
     it 'calls the steps as expected' do
       seq = sequence('feature')
+      feature.feature.expects(:run_hook).with(:before, kind_of(Hash))
       3.times do
-        @feature.feature.expects(:before).in_sequence(seq)
         Spinach::Runner::Scenario.
           expects(:new).
           returns(stub_everything).
           in_sequence(seq)
-        @feature.feature.expects(:after).in_sequence(seq)
       end
-      @feature.run
+      feature.feature.expects(:run_hook).with(:after, kind_of(Hash))
+      feature.run
     end
 
-    it "returns true if the execution succeeds" do
-      @feature.stubs(reporter: stub_everything)
+    it 'returns true if the execution succeeds' do
       Spinach::Runner::Scenario.any_instance.
-        expects(run: nil).times(3)
-      @feature.run.must_equal true
+        expects(run: true).times(3)
+      feature.run.must_equal true
     end
 
-    it "returns false if the execution fails" do
-      @feature.stubs(reporter: stub_everything)
+    it 'returns false if the execution fails' do
       Spinach::Runner::Scenario.any_instance.
-        expects(run: stub_everything).times(3)
-      @feature.run.must_equal false
+        expects(run: false).times(3)
+      feature.run.must_equal false
     end
 
     it 'calls only the given scenario' do
       @filename = 'feature/a_cool_feature.feature:12'
-      @feature = Spinach::Runner::Feature.new(@filename, @reporter)
+      @feature = Spinach::Runner::Feature.new(@filename)
       @feature.stubs(data: {
         'name' => 'A cool feature',
         'elements' => [{'keyword'=>'Scenario', 'name'=>'Basic guess', 'line'=>6, 'description'=>'', 'type'=>'scenario'},
@@ -108,15 +93,5 @@ describe Spinach::Runner::Feature do
       Spinach::Runner::Scenario.expects(:new).with(anything, anything, @feature.scenarios[1], anything).once.returns(stub_everything)
       @feature.run
     end
-
-    it "calls an error summary if there are any failures" do
-      failure = stub('failure')
-      scenario = stub(run: failure)
-      Spinach::Runner::Scenario.stubs(:new).returns scenario
-
-      @reporter.expects(:error_summary).with [failure, failure, failure]
-
-      @feature.run
-    end
   end
 end

data/test/spinach/runner/scenario_test.rb

@@ -1,8 +1,8 @@
 require_relative '../../test_helper'
 
 describe Spinach::Runner::Scenario do
-  before do
-    @data = {
+  let(:data) do
+    {
       'name' => 'A cool scenario',
       'steps' => [
         {'keyword' => 'Given', 'name' => 'I herd you like steps'},
@@ -10,68 +10,97 @@ describe Spinach::Runner::Scenario do
         {'keyword' => 'Then', 'name' => 'I go step by step'}
       ]
     }
-    @feature = stub_everything
-    @feature_name = "My feature"
-    @reporter = stub_everything
-    @scenario = Spinach::Runner::Scenario.new(@feature_name, @feature, @data, @reporter)
   end
 
-  describe '#initialize' do
-    it 'initializes a scenario name' do
-      @scenario.name.must_equal 'A cool scenario'
-    end
+  let(:feature) { stub_everything }
+  let(:feature_name) { 'My feature' }
+  let(:scenario) { Spinach::Runner::Scenario.new(feature_name, feature, data) }
 
+  describe '#initialize' do
     it 'lists all the steps' do
-      @scenario.steps.count.must_equal 3
-    end
-
-    it 'sets the reporter' do
-      @scenario.reporter.must_equal @reporter
+      scenario.steps.count.must_equal 3
     end
 
     it 'sets the feature' do
-      @scenario.feature.must_equal @feature
+      scenario.feature.must_equal feature
     end
   end
 
   describe '#run' do
     it 'calls the appropiate feature steps' do
-      @feature.expects(:execute_step).with('I herd you like steps')
-      @feature.expects(:execute_step).with('I test steps')
-      @feature.expects(:execute_step).with('I go step by step')
-      @scenario.run
+      feature.expects(:execute_step).with('I herd you like steps')
+      feature.expects(:execute_step).with('I test steps')
+      feature.expects(:execute_step).with('I go step by step')
+      scenario.run
     end
 
     describe 'when throwing exceptions' do
       it 'rescues a MiniTest::Assertion' do
-        @feature.expects(:execute_step).raises(MiniTest::Assertion)
-        @reporter.expects(:step).with(anything, anything, :failure)
-        @scenario.run
+        feature.expects(:execute_step).raises(MiniTest::Assertion)
+        scenario.expects(:run_hook).with(:before_run, has_value("A cool scenario"))
+        scenario.expects(:run_hook).with(:after_run, has_value("A cool scenario"))
+        scenario.expects(:run_hook).with(
+          :on_failed_step, anything, anything, anything)
+        scenario.expects(:run_hook).with(
+          :on_skipped_step, anything, anything).twice
+        scenario.run
       end
 
       it 'rescues a Spinach::StepNotDefinedException' do
-        @feature.expects(:execute_step).raises(Spinach::StepNotDefinedException.new('foo', 'bar'))
-        @reporter.expects(:step).with(anything, anything, :undefined_step)
-        @scenario.run
+        feature.expects(:execute_step).raises(
+          Spinach::StepNotDefinedException.new('foo', 'bar'))
+        scenario.expects(:run_hook).with(:before_run, has_value("A cool scenario"))
+        scenario.expects(:run_hook).with(:after_run, has_value("A cool scenario"))
+        scenario.expects(:run_hook).with(
+          :on_undefined_step, anything, anything, anything)
+        scenario.expects(:run_hook).with(
+          :on_skipped_step, anything, anything).twice
+        scenario.run
       end
 
       it 'rescues any other error' do
-        @feature.expects(:execute_step).raises
-        @reporter.expects(:step).with(anything, anything, :error)
-        @scenario.run
+        feature.expects(:execute_step).raises
+        scenario.expects(:run_hook).with(:after_run, has_value("A cool scenario"))
+        scenario.expects(:run_hook).with(:before_run, has_value("A cool scenario"))
+        scenario.expects(:run_hook).with(
+          :on_error_step, anything, anything, anything)
+        scenario.expects(:run_hook).with(
+          :on_skipped_step, anything, anything).twice
+        scenario.run
       end
 
-      it "returns an failure" do
-        @feature.expects(:execute_step).raises(MiniTest::Assertion)
-        @scenario.run.wont_equal nil
+      it 'returns an failure' do
+        feature.expects(:execute_step).raises(MiniTest::Assertion)
+        scenario.run.wont_equal nil
       end
-
     end
 
     it 'runs a step' do
-      @reporter.expects(:step).with(anything, anything, :success).times(3)
-      @scenario.run.must_equal nil
+      feature.expects(:execute_step).with(anything).times(3)
+      scenario.run.must_equal true
     end
 
+    describe 'hooks' do
+      it 'fires up the scenario hooks' do
+        feature.expects(:execute_step).raises(Spinach::StepNotDefinedException.new('foo', 'bar'))
+        feature.expects(:run_hook).with(:before_scenario, has_value("A cool scenario"))
+        feature.expects(:run_hook).with(:after_scenario, has_value("A cool scenario"))
+        scenario.run
+      end
+
+      it 'fires up the step hooks' do
+        feature.expects(:execute_step).raises(Spinach::StepNotDefinedException.new('foo', 'bar'))
+        %w{before_step after_step}.each do |hook|
+          feature.expects(:run_hook).with(
+            hook.to_sym, kind_of(Hash))
+          feature.expects(:run_hook).with(
+            hook.to_sym, kind_of(Hash))
+          feature.expects(:run_hook).with(
+            hook.to_sym, kind_of(Hash))
+        end
+
+        scenario.run
+      end
+    end
   end
 end

data/test/spinach/runner_test.rb

@@ -1,61 +1,70 @@
 require_relative '../test_helper'
 
 describe Spinach::Runner do
-  before do
-    @filenames =
-      %w{features/cool_feature.feature features/great_feature.feature}
+   let(:filenames) { %w{features/cool_feature.feature features/great_feature.feature} }
+   let(:runner) { Spinach::Runner.new(filenames) }
 
-    @runner = Spinach::Runner.new(@filenames)
-  end
-  describe "#initialize" do
-    it "sets the filenames" do
-      @runner.filenames.must_equal @filenames
+  describe '#initialize' do
+    it 'sets the filenames' do
+      runner.filenames.must_equal filenames
     end
-    describe "step_definitions_path" do
-      it "sets a default" do
-        @runner.step_definitions_path.must_be_kind_of String
+
+    describe 'step_definitions_path' do
+      it 'sets a default' do
+        runner.step_definitions_path.must_be_kind_of String
       end
-      it "can be overriden" do
-        @runner = Spinach::Runner.new(
+
+      it 'can be overriden' do
+        runner = Spinach::Runner.new(
           @filename, step_definitions_path: 'spinach/step_definitions'
         )
-        @runner.step_definitions_path.must_equal 'spinach/step_definitions'
+        runner.step_definitions_path.must_equal 'spinach/step_definitions'
       end
     end
-    describe "support_path" do
-      it "sets a default" do
-        @runner.support_path.must_be_kind_of String
+
+    describe 'support_path' do
+      it 'sets a default' do
+        runner.support_path.must_be_kind_of String
       end
-      it "can be overriden" do
-        @runner = Spinach::Runner.new(
+
+      it 'can be overriden' do
+        runner = Spinach::Runner.new(
           @filename, support_path: 'spinach/environment'
         )
-        @runner.support_path.must_equal 'spinach/environment'
+        runner.support_path.must_equal 'spinach/environment'
       end
     end
   end
-  describe "#reporter" do
-    it "returns a default reporter" do
-      @runner.reporter.wont_equal nil
-    end
-  end
-  describe "#run" do
+
+  describe '#run' do
     before do
       @feature = stub
-      @runner.stubs(reporter: stub_everything)
-      @filenames.each do |filename|
+      filenames.each do |filename|
         Spinach::Runner::Feature.expects(:new).
           with(filename, anything).
           returns(@feature)
       end
     end
-    it "instantiates a new Feature and runs it with every file" do
+
+    it 'instantiates a new Feature and runs it with every file' do
       @feature.stubs(run: true)
-      @runner.run.must_equal true
+      runner.run.must_equal true
     end
-    it "returns false if it fails" do
+
+    it 'returns false if it fails' do
       @feature.stubs(run: false)
-      @runner.run
+      runner.run
+    end
+  end
+  describe '#require_dependencies' do
+    it 'requires support files and step definitions' do
+      runner.stubs(
+        support_files: ['a', 'b'], step_definition_files: ['c', 'd']
+      )
+      %w{a b c d}.each do |file|
+        runner.expects(:require).with(file)
+      end
+      runner.require_dependencies
     end
   end
 end

data/test/spinach/support_test.rb

@@ -7,26 +7,18 @@ describe Spinach::Support do
     end
 
     it 'downcases the given value' do
-      ActiveSupport::Inflector.expects(:camelize).with('value').returns('value')
-
-      Spinach::Support.camelize('VALUE').must_equal 'value'
+      Spinach::Support.camelize('VALUE').must_equal 'Value'
     end
 
     it 'squeezes the spaces for the given value' do
-      ActiveSupport::Inflector.expects(:camelize).with('feature_name').returns('FeatureName')
-
       Spinach::Support.camelize('feature  name').must_equal 'FeatureName'
     end
 
     it 'strips the given value' do
-      ActiveSupport::Inflector.expects(:camelize).with('value').returns('value')
-
-      Spinach::Support.camelize('  value  ').must_equal 'value'
+      Spinach::Support.camelize('  value  ').must_equal 'Value'
     end
 
     it 'strips the given value' do
-      ActiveSupport::Inflector.expects(:camelize).with('feature_name').returns('FeatureName')
-
       Spinach::Support.camelize('feature name').must_equal 'FeatureName'
     end
   end

data/test/spinach_test.rb

@@ -2,25 +2,25 @@ require_relative 'test_helper'
 
 describe Spinach do
   before do
-    @feature1 = OpenStruct.new(feature_name: "User authentication")
-    @feature2 = OpenStruct.new(feature_name: "Slip management")
-    @feature3 = OpenStruct.new(feature_name: "File attachments")
-    @feature4 = OpenStruct.new(name: "UserSendsAMessage")
+    @feature1 = OpenStruct.new(feature_name: 'User authentication')
+    @feature2 = OpenStruct.new(feature_name: 'Slip management')
+    @feature3 = OpenStruct.new(feature_name: 'File attachments')
+    @feature4 = OpenStruct.new(name: 'UserSendsAMessage')
     [@feature1, @feature2, @feature3, @feature4].each do |feature|
       Spinach.features << feature
     end
   end
 
-  describe "#features" do
-    it "returns all the loaded features" do
+  describe '#features' do
+    it 'returns all the loaded features' do
       Spinach.features.must_include @feature1
       Spinach.features.must_include @feature2
       Spinach.features.must_include @feature3
     end
   end
 
-  describe "#reset_features" do
-    it "resets the features to a pristine state" do
+  describe '#reset_features' do
+    it 'resets the features to a pristine state' do
       Spinach.reset_features
       [@feature1, @feature3, @feature3].each do |feature|
         Spinach.features.wont_include feature
@@ -28,14 +28,14 @@ describe Spinach do
     end
   end
 
-  describe "#find_feature" do
-    it "finds a feature by name" do
-      Spinach.find_feature("User authentication").must_equal @feature1
-      Spinach.find_feature("Slip management").must_equal @feature2
-      Spinach.find_feature("File attachments").must_equal @feature3
+  describe '#find_feature' do
+    it 'finds a feature by name' do
+      Spinach.find_feature('User authentication').must_equal @feature1
+      Spinach.find_feature('Slip management').must_equal @feature2
+      Spinach.find_feature('File attachments').must_equal @feature3
     end
 
-    describe "when a feature class does no set a feature_name" do
+    describe 'when a feature class does no set a feature_name' do
       it 'guesses the feature class from the feature name' do
         Spinach.find_feature('User sends a message').must_equal @feature4
       end

data/test/test_helper.rb

@@ -1,17 +1,26 @@
 gem 'minitest'
-require 'minitest/unit'
+
+if ENV['COVERAGE']
+  require 'simplecov'
+
+  SimpleCov.start do
+    add_filter '/test/'
+    add_filter '/features/'
+  end
+end
+
+require 'minitest/spec'
 require 'minitest/autorun'
 require 'mocha'
 require 'ostruct'
 require 'purdytest'
+require 'stringio'
+require 'pry'
 
 require 'spinach'
 require 'spinach/capybara'
 
-require 'stringio'
-
 module Kernel
-
   def capture_stdout
     out = StringIO.new
     $stdout = out
@@ -20,5 +29,4 @@ module Kernel
   ensure
     $stdout = STDOUT
   end
-
 end