spinach 0.1.4 → 0.1.5

data/lib/spinach/runner.rb

@@ -1,11 +1,8 @@
-require 'hooks'
-
 module Spinach
   # Runner gets the parsed data from the feature and performs the actual calls
   # to the feature classes.
   #
   class Runner
-    include Hooks
 
     # The feature files to run
     attr_reader :filenames
@@ -16,9 +13,6 @@ module Spinach
     # The default path where the support files are located
     attr_reader :support_path
 
-    define_hook :before_run
-    define_hook :after_run
-
     # Initializes the runner with a parsed feature
     #
     # @param [Array<String>] filenames
@@ -62,16 +56,16 @@ module Spinach
       require_dependencies
       require_suites
 
-      run_hook :before_run
+      Spinach.hooks.run_before_run
 
       successful = true
 
       filenames.each do |filename|
-        success = Feature.new(filename).run
+        success = FeatureRunner.new(filename).run
         successful = false unless success
       end
 
-      run_hook :after_run, successful
+      Spinach.hooks.run_after_run(successful)
 
       successful
     end
@@ -113,5 +107,5 @@ module Spinach
   end
 end
 
-require_relative 'runner/feature'
-require_relative 'runner/scenario'
+require_relative 'runner/feature_runner'
+require_relative 'runner/scenario_runner'

data/lib/spinach/version.rb

@@ -1,4 +1,4 @@
 module Spinach
   # Spinach version.
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/lib/spinach.rb

@@ -1,5 +1,7 @@
 require_relative 'spinach/version'
 require_relative 'spinach/config'
+require_relative 'spinach/hookable'
+require_relative 'spinach/hooks'
 require_relative 'spinach/support'
 require_relative 'spinach/exceptions'
 require_relative 'spinach/runner'
@@ -23,22 +25,29 @@ require_relative 'spinach/generators'
 #     scenarios.
 #
 module Spinach
-  @@features = []
+  @@feature_steps = []
 
-  # @return [Array<Feature>]
+  # @return [Array<FeatureSteps>]
   #   All the registered features.
   #
   # @api public
-  def self.features
-    @@features
+  def self.feature_steps
+    @@feature_steps
   end
 
   # Resets Spinach to a pristine state, as if no feature was ever registered.
   # Mostly useful in Spinach's own testing.
   #
   # @api semipublic
-  def self.reset_features
-    @@features = []
+  def self.reset_feature_steps
+    @@feature_steps = []
+  end
+
+  # Returns a new hook object that will receive all the messages from the run
+  # and fire up the appropiate callbacks when needed.
+  #
+  def self.hooks
+    @@hooks ||= Hooks.new
   end
 
   # Finds a feature given a feature name.
@@ -46,10 +55,13 @@ module Spinach
   # @param [String] name
   #   The feature name.
   #
+  # @return [FeatureSteps]
+  #   the {FeatureSteps} class for the given feature name
+  #
   # @api public
-  def self.find_feature(name)
+  def self.find_feature_steps(name)
     klass = Spinach::Support.camelize(name)
-    @@features.detect do |feature|
+    feature_steps.detect do |feature|
       feature.feature_name.to_s == name.to_s ||
       feature.name == klass
     end || raise(Spinach::FeatureStepsNotFoundException, [klass, name])

data/spinach.gemspec

@@ -10,10 +10,7 @@ Gem::Specification.new do |gem|
   gem.homepage      = "http://github.com/codegram/spinach"
 
   gem.add_runtime_dependency 'gherkin'
-  gem.add_runtime_dependency 'minitest'
   gem.add_runtime_dependency 'colorize'
-  gem.add_runtime_dependency 'hooks'
-  gem.add_development_dependency 'purdytest'
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'mocha'
   gem.add_development_dependency 'sinatra'
@@ -23,6 +20,8 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'simplecov'
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'fakefs'
+  gem.add_development_dependency 'minitest'
+  gem.add_development_dependency 'turn'
 
   gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   gem.files         = `git ls-files`.split("\n")

data/test/spinach/capybara_test.rb

@@ -1,4 +1,5 @@
 require 'test_helper'
+require 'spinach'
 require 'spinach/capybara'
 require 'sinatra'
 
@@ -35,7 +36,7 @@ describe Spinach::FeatureSteps::Capybara do
   end
 
   it 'resets the capybara session after each scenario' do
-    @feature_runner = Spinach::Runner::Feature.new(
+    @feature_runner = Spinach::Runner::FeatureRunner.new(
       'a_feature.feature')
 
     @feature_runner.stubs(data: Spinach::Parser.new('
@@ -48,9 +49,9 @@ describe Spinach::FeatureSteps::Capybara do
           Then Goodbye
     ').parse).at_least_once
 
-    Spinach::Runner::Scenario.any_instance.stubs(feature: @feature)
+    Spinach::Runner::ScenarioRunner.any_instance.stubs(feature_steps: @feature)
 
-    Capybara.current_session.expects(:reset!).twice
+    Capybara.current_session.expects(:reset!).at_least_once
 
     @feature_runner.run
   end

data/test/spinach/cli_test.rb

@@ -49,7 +49,6 @@ describe Spinach::Cli do
       reporter.expects(:bind)
       Spinach::Reporter::Stdout.stubs(new: reporter)
       cli.init_reporter
-      Spinach.config.default_reporter.wont_equal nil
     end
   end
 

data/test/spinach/feature_steps_test.rb

@@ -10,13 +10,13 @@ describe Spinach::FeatureSteps do
   describe 'class methods' do
     describe '#inherited' do
       it 'registers any feature subclass' do
-        @feature1 = Class.new(Spinach::FeatureSteps)
-        @feature2 = Class.new(Spinach::FeatureSteps)
-        @feature3 = Class.new
+        @feature_steps1 = Class.new(Spinach::FeatureSteps)
+        @feature_steps2 = Class.new(Spinach::FeatureSteps)
+        @feature_steps3 = Class.new
 
-        Spinach.features.must_include @feature1
-        Spinach.features.must_include @feature2
-        Spinach.features.wont_include @feature3
+        Spinach.feature_steps.must_include @feature_steps1
+        Spinach.feature_steps.must_include @feature_steps2
+        Spinach.feature_steps.wont_include @feature_steps3
       end
     end
   end
@@ -46,21 +46,4 @@ describe Spinach::FeatureSteps do
     end
   end
 
-  describe 'Object#Feature' do
-    it 'creates a feature class' do
-      feature = Feature('Hola') do
-        attr_accessor :test
-        When 'Test' do
-          self.test = true
-        end
-      end
-
-      Spinach.features.must_include feature
-
-      instance = feature.new
-      instance.execute_step('Test')
-
-      instance.test.must_equal true
-    end
-  end
 end

data/test/spinach/generators/feature_generator_test.rb

@@ -73,7 +73,7 @@ module Spinach::Generators
       it "generates an entire feature_steps class definition" do
         result = subject.generate
         klass = eval(result)
-        feature_runner = Spinach::Runner::Feature.new(stub_everything)
+        feature_runner = Spinach::Runner::FeatureRunner.new(stub_everything)
         feature_runner.stubs(data: data)
         feature_runner.run.must_equal true
       end
@@ -97,7 +97,7 @@ module Spinach::Generators
           must_include 'features/steps/cheezburger_can_i_has.rb'
       end
     end
-    
+
     describe "#store" do
       it "stores the generated feature into a file" do
         FakeFS.activate!

data/test/spinach/generators_test.rb

@@ -22,8 +22,8 @@ describe Spinach::Generators do
     it "binds the generator to the missing feature hook" do
       subject.expects(:generate_feature).with(data)
       subject.bind
-      Spinach::Runner::Feature.new(stub_everything).run_hook :when_not_found, data
-      Spinach::Runner::Feature._when_not_found_callbacks = []
+      Spinach.hooks.run_on_undefined_feature data
+      Spinach.hooks.reset
     end
   end
 

data/test/spinach/hookable_test.rb

@@ -0,0 +1,59 @@
+require_relative '../test_helper'
+
+describe Spinach::Hookable do
+  subject do
+    Class.new do
+      include Spinach::Hookable
+    end.new
+  end
+
+  describe ".define_hook" do
+    it "defines a new hook" do
+      subject.class.hook :before_save
+      subject.must_respond_to :before_save
+    end
+  end
+
+  describe "hooking mechanism" do
+    describe "without params" do
+      it "adds a new hook to the queue" do
+        subject.add_hook(:before_save) do
+        end
+        (subject.hooks_for(:before_save).empty?).must_equal false
+      end
+
+      it "allows to run a hook" do
+        arbitrary_variable = false
+        subject.add_hook(:before_save) do
+          arbitrary_variable = true
+        end
+        subject.run_hook(:before_save)
+        arbitrary_variable.must_equal true
+      end
+    end
+
+    describe "with params" do
+      it "adds a new hook to the queue" do
+        subject.add_hook(:before_save) do |var1, var2|
+        end
+        (subject.hooks_for(:before_save).empty?).must_equal false
+      end
+
+      it "allows to run a hook" do
+        array = []
+        subject.add_hook(:before_save) do |var1, var2|
+          array << var1
+          array << var2
+        end
+        subject.run_hook(:before_save, 1, 2)
+        array.must_equal [1, 2]
+      end
+    end
+
+    describe "#reset_hooks" do
+      it "resets the hooks to a pristine state" do
+        subject.add_hook(:before_save)
+      end
+    end
+  end
+end

data/test/spinach/hooks_test.rb

@@ -0,0 +1,28 @@
+require_relative '../test_helper'
+
+describe Spinach::Hooks do
+  subject do
+    Spinach::Hooks.new
+  end
+
+  describe "hooks" do
+    %w{before_run after_run before_feature after_feature on_undefined_feature
+    before_scenario after_scenario before_step after_step on_successful_step
+    on_failed_step on_error_step on_undefined_step on_skipped_step}.each do |callback|
+      it "responds to #{callback}" do
+        subject.must_respond_to callback
+      end
+
+      it "executes the hook with params" do
+        array = []
+        block = Proc.new do |arg1, arg2|
+          array << arg1
+          array << arg2
+        end
+        subject.send(callback, &block)
+        subject.send("run_#{callback}", 1, 2)
+        array.must_equal [1, 2]
+      end
+    end
+  end
+end

data/test/spinach/reporter/stdout/error_reporting_test.rb

@@ -0,0 +1,265 @@
+# encoding: utf-8
+
+require_relative '../../../test_helper'
+
+describe Spinach::Reporter::Stdout do
+  let(:exception) { StandardError.new('Something went wrong') }
+
+  let(:error) do
+    [{'name' => 'My feature'},
+      {'name' => 'A scenario'},
+      {'keyword' => 'Keyword', 'name' => 'step name'},
+      exception]
+  end
+
+  let(:steps) do
+    [error]
+  end
+
+
+  before do
+    @out = StringIO.new
+    @error = StringIO.new
+    @reporter = Spinach::Reporter::Stdout.new(
+      output: @out,
+      error: @error
+    )
+  end
+
+  describe '#error_summary' do
+    it 'prints a summary with all the errors' do
+      @reporter.expects(:report_error_steps).once
+      @reporter.expects(:report_failed_steps).once
+      @reporter.expects(:report_undefined_steps).once
+      @reporter.expects(:report_undefined_features).once
+
+      @reporter.error_summary
+
+      @error.string.must_include 'Error summary'
+    end
+  end
+
+  describe '#run_summary' do
+    it 'prints a run summary' do
+      @reporter.run_summary
+
+      @out.string.must_include 'Steps Summary:'
+    end
+  end
+
+  describe '#report_error_steps' do
+    describe 'when some steps have raised an error' do
+      it 'outputs the errors' do
+        steps = [anything]
+        @reporter.stubs(:error_steps).returns(steps)
+        @reporter.expects(:report_errors).with('Errors', steps, :light_red)
+
+        @reporter.report_error_steps
+      end
+    end
+
+    describe 'when there are no error steps' do
+      it 'does nothing' do
+        @reporter.expects(:report_errors).never
+
+        @reporter.report_error_steps
+      end
+    end
+  end
+
+  describe '#report_failed_steps' do
+    describe 'when some steps have failed' do
+      it 'outputs the failing steps' do
+        steps = [anything]
+        @reporter.stubs(:failed_steps).returns(steps)
+        @reporter.expects(:report_errors).with('Failures', steps, :light_red)
+
+        @reporter.report_failed_steps
+      end
+    end
+
+    describe 'when there are no failed steps' do
+      it 'does nothing' do
+        @reporter.expects(:report_errors).never
+
+        @reporter.report_failed_steps
+      end
+    end
+  end
+
+  describe '#report_undefined_steps' do
+    describe 'when some steps have undefined' do
+      it 'outputs the failing steps' do
+        steps = [anything]
+        @reporter.stubs(:undefined_steps).returns(steps)
+        @reporter.expects(:report_errors).with('Undefined steps', steps, :yellow)
+
+        @reporter.report_undefined_steps
+      end
+    end
+
+    describe 'when there are no undefined steps' do
+      it 'does nothing' do
+        @reporter.expects(:report_errors).never
+
+        @reporter.report_undefined_steps
+      end
+    end
+  end
+
+  describe '#report_undefined_features' do
+    describe 'when some features are undefined' do
+      it 'outputs the undefined features' do
+        @reporter.undefined_features << {'name' => 'Undefined feature name'}
+        @reporter.report_undefined_features
+
+        @error.string.must_include "Undefined features (1)"
+        @error.string.must_include "Undefined feature name"
+      end
+    end
+
+    describe 'when there are no undefined features' do
+      it 'does nothing' do
+        error = @error.string.dup
+        @reporter.report_undefined_steps
+
+        error.must_equal @error.string
+      end
+    end
+  end
+
+  describe '#report_errors' do
+    describe 'when some steps have raised an error' do
+      it 'outputs a the banner with the number of steps given' do
+        @reporter.report_errors('Banner', steps, :blue)
+
+        @error.string.must_include 'Banner (1)'
+      end
+
+      it 'prints a summarized error' do
+        @reporter.report_errors('Banner', steps, :blue)
+
+        @error.string.must_include 'My feature :: A scenario :: Keyword step name'
+      end
+
+      it 'colorizes the output' do
+        String.any_instance.expects(:colorize).with(:blue).at_least_once
+
+        @reporter.report_errors('Banner', [], :blue)
+      end
+    end
+  end
+
+  describe '#report_error' do
+    it 'raises when given an unsupported format' do
+      proc {
+        @reporter.report_error(error, :nil)
+      }.must_raise RuntimeError, 'Format not defined'
+    end
+
+    it 'prints a summarized error by default' do
+      @reporter.expects(:summarized_error).with(error).returns('summarized error')
+
+      @reporter.report_error(error)
+
+      @error.string.must_include 'summarized error'
+    end
+
+    it 'prints a summarized error' do
+      @reporter.expects(:summarized_error).with(error).returns('summarized error')
+
+      @reporter.report_error(error, :summarized)
+
+      @error.string.must_include 'summarized error'
+    end
+
+    it 'prints a full error' do
+      @reporter.expects(:full_error).with(error).returns('full error')
+
+      @reporter.report_error(error, :full)
+
+      @error.string.must_include 'full error'
+    end
+  end
+
+  describe '#summarized_error' do
+    it 'prints the error' do
+      summary = @reporter.summarized_error(error)
+
+      summary.must_include 'My feature :: A scenario :: Keyword step name'
+    end
+
+    it 'colorizes the print' do
+      String.any_instance.expects(:red)
+
+      @reporter.summarized_error(error)
+    end
+
+    describe 'when given an undefined step exception' do
+      it 'prints the error in yellow' do
+        undefined_error = error
+        undefined_error.insert(3, Spinach::StepNotDefinedException.new(anything))
+
+        String.any_instance.expects(:yellow)
+
+        @reporter.summarized_error(error)
+      end
+    end
+  end
+
+  describe '#full_error' do
+    before do
+      @reporter.expects(:report_exception).with(exception).returns('Exception backtrace')
+    end
+
+    it 'returns the exception data' do
+      exception.expects(:backtrace).returns(['first backtrace line'])
+      output = @reporter.full_error(error)
+
+      output.must_include 'Exception backtrace'
+    end
+
+    it 'returns the first backtrace line' do
+      exception.expects(:backtrace).returns(['first backtrace line'])
+      output = @reporter.full_error(error)
+
+      output.must_include 'first backtrace line'
+    end
+
+    describe 'when the user wants to print the full backtrace' do
+      it 'prints the full backtrace' do
+        @reporter.stubs(:options).returns({backtrace: true})
+        exception.expects(:backtrace).returns(['first backtrace line', 'second backtrace line'])
+
+        output = @reporter.full_error(error)
+
+        output.must_include 'first backtrace line'
+        output.must_include 'second backtrace line'
+      end
+    end
+  end
+
+  describe '#report_exception' do
+    it 'returns the exception data' do
+      output = @reporter.report_exception(exception)
+
+      output.must_include 'Something went wrong'
+    end
+
+    it 'colorizes the print' do
+      String.any_instance.expects(:red)
+
+      @reporter.report_exception(exception)
+    end
+
+    describe 'when given an undefined step exception' do
+      it 'prints the error in yellow' do
+        undefined_exception = Spinach::StepNotDefinedException.new(anything)
+
+        String.any_instance.expects(:yellow)
+
+        @reporter.report_exception(undefined_exception)
+      end
+    end
+  end
+end