cucumber 2.0.0.beta.3 → 2.0.0

data/spec/cucumber/formatter/pretty_spec.rb

@@ -21,6 +21,19 @@ module Cucumber
             run_defined_feature
           end
 
+          describe "with a scenario with no steps" do
+            define_feature <<-FEATURE
+          Feature: Banana party
+
+            Scenario: Monkey eats banana
+            FEATURE
+
+            it "outputs the scenario name" do
+              expect(@out.string).to include "Scenario: Monkey eats banana"
+            end
+          end
+
+
           describe "with a scenario" do
             define_feature <<-FEATURE
           Feature: Banana party
@@ -263,6 +276,96 @@ OUTPUT
       """
       bar
       """
+OUTPUT
+            end
+          end
+
+          describe "with output from hooks" do
+            define_feature <<-FEATURE
+          Feature:
+            Scenario:
+              Given this step passes
+            Scenario Outline:
+              Given this step <status>
+              Examples:
+              | status |
+              | passes  |
+            FEATURE
+
+            define_steps do
+              Before do
+                puts "Before hook"
+              end
+              AfterStep do
+                puts "AfterStep hook"
+              end
+              After do
+                puts "After hook"
+              end
+              Given(/^this step passes$/) {}
+            end
+
+            it "displays hook output appropriately " do
+              expect( @out.string ).to include <<OUTPUT
+Feature: 
+
+  Scenario: 
+      Before hook
+    Given this step passes
+      AfterStep hook
+      After hook
+
+  Scenario Outline: 
+    Given this step <status>
+
+    Examples: 
+      | status |
+      | passes |  Before hook, AfterStep hook, After hook
+
+2 scenarios (2 passed)
+2 steps (2 passed)
+OUTPUT
+            end
+          end
+
+          describe "with background and output from hooks" do
+            define_feature <<-FEATURE
+          Feature:
+            Background:
+              Given this step passes
+            Scenario:
+              Given this step passes
+            FEATURE
+
+            define_steps do
+              Before do
+                puts "Before hook"
+              end
+              AfterStep do
+                puts "AfterStep hook"
+              end
+              After do
+                puts "After hook"
+              end
+              Given(/^this step passes$/) {}
+            end
+
+            it "displays hook output appropriately " do
+              expect( @out.string ).to include <<OUTPUT
+Feature: 
+
+  Background: 
+      Before hook
+    Given this step passes
+      AfterStep hook
+
+  Scenario: 
+    Given this step passes
+      AfterStep hook
+      After hook
+
+1 scenario (1 passed)
+2 steps (2 passed)
 OUTPUT
             end
           end
@@ -444,7 +547,6 @@ OUTPUT
 
       context "In --expand mode" do
         let(:runtime)   { Runtime.new({:expand => true})}
-        let(:mappings)  { Mappings.new(runtime) }
         before(:each) do
           Cucumber::Term::ANSIColor.coloring = false
           @out = StringIO.new
@@ -491,12 +593,49 @@ OUTPUT
               end
             end
           end
+
+          describe "with a scenario outline in en-lol" do
+            define_feature <<-FEATURE
+          # language: en-lol
+          OH HAI: STUFFING
+
+            MISHUN SRSLY: CUCUMBR
+              I CAN HAZ IN TEH BEGINNIN <BEGINNIN> CUCUMBRZ
+              WEN I EAT <EAT> CUCUMBRZ
+              DEN I HAS <EAT> CUCUMBERZ IN MAH BELLY
+              AN IN TEH END <KTHXBAI> CUCUMBRZ KTHXBAI
+
+              EXAMPLZ:
+               | BEGINNIN | EAT | KTHXBAI |
+               |    3     |  2  |    1    |
+            FEATURE
+
+            it "outputs localized text" do
+              lines = <<-OUTPUT
+          OH HAI: STUFFING
+
+            MISHUN SRSLY: CUCUMBR
+              I CAN HAZ IN TEH BEGINNIN <BEGINNIN> CUCUMBRZ
+              WEN I EAT <EAT> CUCUMBRZ
+              DEN I HAS <EAT> CUCUMBERZ IN MAH BELLY
+              AN IN TEH END <KTHXBAI> CUCUMBRZ KTHXBAI
+              EXAMPLZ:
+                MISHUN: | 3 | 2 | 1 |
+                  I CAN HAZ IN TEH BEGINNIN 3 CUCUMBRZ
+                  WEN I EAT 2 CUCUMBRZ
+                  DEN I HAS 2 CUCUMBERZ IN MAH BELLY
+                  AN IN TEH END 1 CUCUMBRZ KTHXBAI
+              OUTPUT
+              lines.split("\n").each do |line|
+                expect(@out.string).to include line.strip
+              end
+            end
+          end
         end
       end
 
       context "In --expand mode with --source as an option" do
         let(:runtime)   { Runtime.new({:expand => true})}
-        let(:mappings)  { Mappings.new(runtime) }
         before(:each) do
           Cucumber::Term::ANSIColor.coloring = false
           @out = StringIO.new
@@ -572,6 +711,113 @@ OUTPUT
           end
         end
       end
+
+      context "snippets contain relevant keyword replacements" do
+
+        before(:each) do
+          Cucumber::Term::ANSIColor.coloring = false
+          @out = StringIO.new
+          @formatter = Pretty.new(runtime, @out, {snippets: true})
+          run_defined_feature
+        end
+
+        describe "With a scenario that has undefined steps" do
+          define_feature <<-FEATURE
+          Feature: Banana party
+
+            Scenario: many monkeys eat many things
+              Given there are bananas and apples
+              And other monkeys are around
+              When one monkey eats a banana
+              And the other monkeys eat all the apples
+              Then bananas remain
+              But there are no apples left
+            FEATURE
+
+          it "containes snippets with 'And' or 'But' replaced by previous step name" do
+            expect(@out.string).to include("Given(/^there are bananas and apples$/)")
+            expect(@out.string).to include("Given(/^other monkeys are around$/)")
+            expect(@out.string).to include("When(/^one monkey eats a banana$/)")
+            expect(@out.string).to include("When(/^the other monkeys eat all the apples$/)")
+            expect(@out.string).to include("Then(/^bananas remain$/)")
+            expect(@out.string).to include("Then(/^there are no apples left$/)")
+          end
+        end
+
+        describe "With a scenario that uses * and 'But'" do
+          define_feature <<-FEATURE
+          Feature: Banana party
+
+            Scenario: many monkeys eat many things
+              * there are bananas and apples
+              * other monkeys are around
+              When one monkey eats a banana
+              * the other monkeys eat all the apples
+              Then bananas remain
+              * there are no apples left
+          FEATURE
+          it "replaces the first step with 'Given'" do
+            expect(@out.string).to include("Given(/^there are bananas and apples$/)")
+          end
+          it "uses actual keywords as the 'previous' keyword for future replacements" do
+            expect(@out.string).to include("Given(/^other monkeys are around$/)")
+            expect(@out.string).to include("When(/^the other monkeys eat all the apples$/)")
+            expect(@out.string).to include("Then(/^there are no apples left$/)")
+          end
+        end
+
+        describe "With a scenario where the only undefined step uses 'And'" do
+          define_feature <<-FEATURE
+          Feature:
+
+            Scenario:
+              Given this step passes
+              Then this step passes
+              And this step is undefined
+          FEATURE
+          define_steps do
+            Given(/^this step passes$/) {}
+          end
+          it "uses actual keyword of the previous passing step for the undefined step" do
+            expect(@out.string).to include("Then(/^this step is undefined$/)")
+          end
+        end
+
+        describe "With scenarios where the first step is undefined and uses '*'" do
+          define_feature <<-FEATURE
+          Feature:
+
+            Scenario:
+              * this step is undefined
+              Then this step passes
+
+            Scenario:
+              * this step is also undefined
+              Then this step passes
+          FEATURE
+          define_steps do
+            Given(/^this step passes$/) {}
+          end
+          it "uses 'Given' as actual keyword the step in each scenario" do
+            expect(@out.string).to include("Given(/^this step is undefined$/)")
+            expect(@out.string).to include("Given(/^this step is also undefined$/)")
+          end
+        end
+
+        describe "with a scenario in en-lol" do
+          define_feature <<-FEATURE
+          # language: en-lol
+          OH HAI: STUFFING
+
+            MISHUN: CUCUMBR
+              I CAN HAZ IN TEH BEGINNIN CUCUMBRZ
+              AN I EAT CUCUMBRZ
+            FEATURE
+          it "uses actual keyword of the previous passing step for the undefined step" do
+            expect(@out.string).to include("ICANHAZ(/^I EAT CUCUMBRZ$/)")
+          end
+        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

@@ -20,17 +20,26 @@ module Cucumber
       def run_defined_feature
         define_steps
         runtime.visitor = report
-        execute [gherkin_doc], mappings, report
-      end
 
-      require 'cucumber/mappings'
-      def mappings
-        @mappings ||= Mappings.new
+        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/reports/legacy_formatter'
+      require 'cucumber/formatter/legacy_api/adapter'
       def report
-        @report ||= Cucumber::Reports::LegacyFormatter.new runtime, [@formatter]
+        @report ||= LegacyApi::Adapter.new(
+          Fanout.new([@formatter]),
+          runtime.results,
+          runtime.support_code,
+          runtime.configuration)
       end
 
       require 'cucumber/core/gherkin/document'
@@ -43,7 +52,7 @@ module Cucumber
       end
 
       def runtime
-        mappings.runtime
+        @runtime ||= Runtime.new
       end
 
       def define_steps

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