cucumber 1.3.10 → 2.0.0

data/spec/cucumber/formatter/progress_spec.rb

@@ -1,38 +1,85 @@
 require 'spec_helper'
+require 'cucumber/formatter/spec_helper'
 require 'cucumber/formatter/progress'
+require 'cucumber/cli/options'
 
 module Cucumber
   module Formatter
     describe Progress do
+      extend SpecHelperDsl
+      include SpecHelper
 
       before(:each) do
         Cucumber::Term::ANSIColor.coloring = false
         @out = StringIO.new
-        progress = Cucumber::Formatter::Progress.new(double("step mother"), @out, {})
-        @visitor = Cucumber::Ast::TreeWalker.new(nil, [progress])
+        @formatter = Progress.new(runtime, @out, {})
       end
 
-      describe "visiting a table cell value without a status" do
-        it "should take the status from the last run step" do
-          @visitor.visit_step_result('', '', nil, :failed, nil, 10, nil, nil)
-          outline_table = double()
-          outline_table.should_receive(:accept) do |visitor|
-            visitor.visit_table_cell_value('value', nil)
+      describe "given a single feature" do
+        before(:each) do
+          run_defined_feature
+        end
+
+        describe "with a scenario" do
+          define_feature <<-FEATURE
+            Feature: Banana party
+
+              Scenario: Monkey eats banana
+                Given there are bananas
+          FEATURE
+
+          it "outputs the undefined step" do
+            expect(@out.string).to include "U\n"
           end
-          @visitor.visit_outline_table(outline_table)
+        end
 
-          @out.string.should == "FF"
+        describe "with a background" do
+          define_feature <<-FEATURE
+            Feature: Banana party
+
+              Background: 
+                Given a tree
+
+              Scenario: Monkey eats banana
+                Given there are bananas
+          FEATURE
+
+          it "outputs the two undefined steps" do
+            expect(@out.string).to include "UU\n"
+          end
         end
-      end
 
-      describe "visiting a table cell which is a table header" do
-        it "should not output anything" do
-          @visitor.visit_table_cell_value('value', :skipped_param)
+        describe "with a scenario outline" do
+          define_feature <<-FEATURE
+            Feature: Fud Pyramid
+
+              Scenario Outline: Monkey eats a balanced diet
+                Given there are <Things>
+
+                Examples: Fruit
+                 | Things  |
+                 | apples  |
+                 | bananas |
+                Examples: Vegetables
+                 | Things   |
+                 | broccoli |
+                 | carrots  |
+          FEATURE
+
+          it "outputs each undefined step" do
+            expect(@out.string).to include "UUUU\n"
+          end
+
+          it "has 4 undefined scenarios" do
+            expect(@out.string).to include "4 scenarios (4 undefined)"
+          end
+
+          it "has 4 undefined steps" do
+            expect(@out.string).to include "4 steps (4 undefined)"
+          end
 
-          @out.string.should == ""
         end
       end
-
     end
   end
 end

data/spec/cucumber/formatter/rerun_spec.rb

@@ -0,0 +1,107 @@
+require 'cucumber/formatter/rerun'
+require 'cucumber/core'
+require 'cucumber/core/gherkin/writer'
+require 'cucumber/core/filter'
+
+module Cucumber::Formatter
+  describe Rerun do
+    include Cucumber::Core::Gherkin::Writer
+    include Cucumber::Core
+
+    # after_test_case
+    context 'when 2 scenarios fail in the same file' do
+      class WithSteps < Cucumber::Core::Filter.new
+        def test_case(test_case)
+          test_steps = test_case.test_steps.map do |step|
+            case step.name
+            when /fail/
+              step.with_action { raise Failure }
+            when /pass/
+              step.with_action {}
+            else
+              step
+            end
+          end
+
+          test_case.with_steps(test_steps).describe_to(receiver)
+        end
+      end
+
+      it 'Prints the locations of the failed scenarios' do
+        gherkin = gherkin('foo.feature') do
+          feature do
+            scenario do
+              step 'failing'
+            end
+
+            scenario do
+              step 'failing'
+            end
+
+            scenario do
+              step 'passing'
+            end
+          end
+        end
+        io = StringIO.new
+        report = Rerun.new(double, io, double)
+
+        execute [gherkin], report, [WithSteps.new]
+
+        expect( io.string ).to eq 'foo.feature:3:6'
+      end
+    end
+
+    context 'with failures in multiple files' do
+      it 'prints the location of the failed scenarios in each file' do
+        foo = gherkin('foo.feature') do
+          feature do
+            scenario do
+              step 'failing'
+            end
+
+            scenario do
+              step 'failing'
+            end
+
+            scenario do
+              step 'passing'
+            end
+          end
+        end
+
+        bar = gherkin('bar.feature') do
+          feature do
+            scenario do
+              step 'failing'
+            end
+          end
+        end
+
+        io = StringIO.new
+        report = Rerun.new(double, io, double)
+
+        execute [foo, bar], report, [WithSteps.new]
+
+        expect(io.string).to eq 'foo.feature:3:6 bar.feature:3'
+      end
+    end
+
+    context 'when there are no failing scenarios' do
+      it 'prints nothing' do
+        gherkin = gherkin('foo.feature') do
+          feature do
+            scenario do
+              step 'passing'
+            end
+          end
+        end
+
+        io = StringIO.new
+        report = Rerun.new(double, io, double)
+
+        execute [gherkin], report, [WithSteps.new]
+      end
+    end
+  end
+end

data/spec/cucumber/formatter/spec_helper.rb

@@ -1,6 +1,5 @@
 module Cucumber
   module Formatter
-
     module SpecHelperDsl
       attr_reader :feature_content, :step_defs, :feature_filename
 
@@ -14,35 +13,51 @@ module Cucumber
       end
     end
 
+    require 'cucumber/core'
     module SpecHelper
+      include Core
+
       def run_defined_feature
         define_steps
-        features = load_features(self.class.feature_content || raise("No feature content defined!"))
-        run(features)
+        runtime.visitor = report
+
+        receiver = Test::Runner.new(report)
+        filters = [
+          Filters::ActivateSteps.new(runtime.support_code),
+          Filters::ApplyAfterStepHooks.new(runtime.support_code),
+          Filters::ApplyBeforeHooks.new(runtime.support_code),
+          Filters::ApplyAfterHooks.new(runtime.support_code),
+          Filters::ApplyAroundHooks.new(runtime.support_code),
+          Filters::PrepareWorld.new(runtime)
+        ]
+        compile [gherkin_doc], receiver, filters
+      end
+
+      require 'cucumber/formatter/legacy_api/adapter'
+      def report
+        @report ||= LegacyApi::Adapter.new(
+          Fanout.new([@formatter]),
+          runtime.results,
+          runtime.support_code,
+          runtime.configuration)
       end
 
-      def step_mother
-        @step_mother ||= Runtime.new
+      require 'cucumber/core/gherkin/document'
+      def gherkin_doc
+        Core::Gherkin::Document.new(self.class.feature_filename, gherkin)
       end
 
-      def load_features(content)
-        feature_file = FeatureFile.new(self.class.feature_filename, content)
-        features = Ast::Features.new
-        filters = []
-        feature = feature_file.parse(filters, {})
-        features.add_feature(feature) if feature
-        features
+      def gherkin
+        self.class.feature_content || raise("No feature content defined!")
       end
 
-      def run(features)
-        configuration = Cucumber::Configuration.default
-        tree_walker = Cucumber::Ast::TreeWalker.new(step_mother, [@formatter], configuration)
-        tree_walker.visit_features(features)
+      def runtime
+        @runtime ||= Runtime.new
       end
 
       def define_steps
         return unless step_defs = self.class.step_defs
-        rb = step_mother.load_programming_language('rb')
+        rb = runtime.load_programming_language('rb')
         dsl = Object.new
         dsl.extend RbSupport::RbDsl
         dsl.instance_exec &step_defs

data/spec/cucumber/hooks_spec.rb

@@ -0,0 +1,30 @@
+require 'cucumber/hooks'
+module Cucumber::Hooks
+  shared_examples_for 'a source node' do
+    it "responds to name" do
+      expect( subject.name ).to be_a(String)
+    end
+
+    it "responds to location" do
+      expect( subject.location ).to eq(location)
+    end
+
+    it "responds to match_locations?" do
+      expect( subject.match_locations? [location] ).to be_truthy
+      expect( subject.match_locations? [] ).to be_falsey
+    end
+  end
+
+  require 'cucumber/core/ast/location'
+  describe BeforeHook do
+    subject { BeforeHook.new(location) }
+    let(:location) { Cucumber::Core::Ast::Location.new('hooks.rb', 1) }
+    it_behaves_like 'a source node'
+  end
+
+  describe AfterHook do
+    subject { AfterHook.new(location) }
+    let(:location) { Cucumber::Core::Ast::Location.new('hooks.rb', 1) }
+    it_behaves_like 'a source node'
+  end
+end