cucumber 1.3.10 → 2.0.0

data/spec/cucumber/formatter/html_spec.rb

@@ -3,10 +3,10 @@ require 'cucumber/formatter/spec_helper'
 require 'cucumber/formatter/html'
 require 'nokogiri'
 require 'cucumber/rb_support/rb_language'
+require 'rspec/mocks'
 
 module Cucumber
   module Formatter
-
     describe Html do
       extend SpecHelperDsl
       include SpecHelper
@@ -20,12 +20,42 @@ module Cucumber
 
       before(:each) do
         @out = StringIO.new
-        @formatter = Html.new(step_mother, @out, {})
-        step_mother.visitor = @formatter
+        @formatter = Html.new(runtime, @out, {})
+      end
+
+      it "does not raise an error when visiting a blank feature name" do
+        expect(-> {
+          @formatter.feature_name("Feature", "")
+        }).not_to raise_error
       end
 
-      it "should not raise an error when visiting a blank feature name" do
-        lambda { @formatter.feature_name("Feature", "") }.should_not raise_error
+      describe "when writing the report to a file" do
+        before(:each) do
+          allow(@out).to receive(:respond_to?).with(:path, false).and_return(true)
+          expect(@out).to receive(:respond_to?).with(:path).and_return(true)
+          expect(@out).to receive(:path).and_return('out/file.html')
+          run_defined_feature
+          @doc = Nokogiri.HTML(@out.string)
+        end
+
+        describe "with a step that embeds a snapshot" do
+          define_steps do
+            Given(/snap/) { 
+              RSpec::Mocks.allow_message(File, :file?) { true }
+              embed('out/snapshot.jpeg', 'image/jpeg')
+            }
+          end
+
+          define_feature(<<-FEATURE)
+          Feature:
+            Scenario:
+              Given snap
+            FEATURE
+
+          it "converts the snapshot path to a relative path" do
+            expect(@doc.css('.embed img').first.attributes['src'].to_s).to eq "snapshot.jpeg"
+          end
+        end
       end
 
       describe "given a single feature" do
@@ -43,7 +73,7 @@ module Cucumber
           FEATURE
 
           it "should output a main container div" do
-            @out.string.should =~ /\<div class="cucumber"\>/
+            expect(@out.string).to match(/\<div class="cucumber"\>/)
           end
         end
 
@@ -51,20 +81,24 @@ module Cucumber
           define_feature <<-FEATURE
             # Healthy
             Feature: Foo
+              Scenario:
+                Given passing
           FEATURE
 
-          it { @out.string.should =~ /^\<!DOCTYPE/ }
-          it { @out.string.should =~ /\<\/html\>$/ }
-          it { @doc.should have_css_node('.feature .comment', /Healthy/) }
+          it { expect(@out.string).to match(/^\<!DOCTYPE/) }
+          it { expect(@out.string).to match(/\<\/html\>$/) }
+          it { expect(@doc).to have_css_node('.feature .comment', /Healthy/) }
         end
 
         describe "with a tag" do
           define_feature <<-FEATURE
             @foo
             Feature: can't have standalone tag :)
+              Scenario:
+                Given passing
           FEATURE
 
-          it { @doc.should have_css_node('.feature .tag', /foo/) }
+          it { expect(@doc).to have_css_node('.feature .tag', /foo/) }
         end
 
         describe "with a narrative" do
@@ -73,10 +107,13 @@ module Cucumber
               In order to find my inner monkey
               As a human
               I must eat bananas
+
+              Scenario:
+                Given passing
           FEATURE
 
-          it { @doc.should have_css_node('.feature h2', /Bananas/) }
-          it { @doc.should have_css_node('.feature .narrative', /must eat bananas/) }
+          it { expect(@doc).to have_css_node('.feature h2', /Bananas/) }
+          it { expect(@doc).to have_css_node('.feature .narrative', /must eat bananas/) }
         end
 
         describe "with a background" do
@@ -85,9 +122,12 @@ module Cucumber
 
             Background:
               Given there are bananas
+
+            Scenario:
+              When the monkey eats a banana
           FEATURE
 
-          it { @doc.should have_css_node('.feature .background', /there are bananas/) }
+          it { expect(@doc).to have_css_node('.feature .background', /there are bananas/) }
         end
 
         describe "with a scenario" do
@@ -98,8 +138,8 @@ module Cucumber
               Given there are bananas
           FEATURE
 
-          it { @doc.should have_css_node('.feature h3', /Monkey eats banana/) }
-          it { @doc.should have_css_node('.feature .scenario .step', /there are bananas/) }
+          it { expect(@doc).to have_css_node('.feature h3', /Monkey eats banana/) }
+          it { expect(@doc).to have_css_node('.feature .scenario .step', /there are bananas/) }
         end
 
         describe "with a scenario outline" do
@@ -119,11 +159,11 @@ module Cucumber
                | carrots  |
           FEATURE
 
-          it { @doc.should have_css_node('.feature .scenario.outline h4', /Fruit/) }
-          it { @doc.should have_css_node('.feature .scenario.outline h4', /Vegetables/) }
-          it { @doc.css('.feature .scenario.outline h4').length.should == 2}
-          it { @doc.should have_css_node('.feature .scenario.outline table', //) }
-          it { @doc.should have_css_node('.feature .scenario.outline table td', /carrots/) }
+          it { expect(@doc).to have_css_node('.feature .scenario.outline h4', /Fruit/) }
+          it { expect(@doc).to have_css_node('.feature .scenario.outline h4', /Vegetables/) }
+          it { expect(@doc.css('.feature .scenario.outline h4').length).to eq 2}
+          it { expect(@doc).to have_css_node('.feature .scenario.outline table', //) }
+          it { expect(@doc).to have_css_node('.feature .scenario.outline table td', /carrots/) }
         end
 
         describe "with a step with a py string" do
@@ -137,7 +177,7 @@ module Cucumber
                """
           FEATURE
 
-          it { @doc.should have_css_node('.feature .scenario .val', /foo/) }
+          it { expect(@doc).to have_css_node('.feature .scenario .val', /foo/) }
         end
 
         describe "with a multiline step arg" do
@@ -154,8 +194,8 @@ module Cucumber
                | bar  |
           FEATURE
 
-          it { @doc.should have_css_node('.feature .scenario table td', /foo/) }
-          it { @out.string.include?('makeYellow(\'scenario_1\')').should be_false }
+          it { expect(@doc).to have_css_node('.feature .scenario table td', /foo/) }
+          it { expect(@out.string.include?('makeYellow(\'scenario_1\')')).to be false }
         end
 
         describe "with a table in the background and the scenario" do
@@ -172,7 +212,7 @@ module Cucumber
                | g | h |
           FEATURE
 
-          it { @doc.css('td').length.should == 8 }
+          it { expect(@doc.css('td').length).to eq 8 }
         end
 
         describe "with a py string in the background and the scenario" do
@@ -191,8 +231,8 @@ module Cucumber
                 """
           FEATURE
 
-          it { @doc.css('.feature .background pre.val').length.should == 1 }
-          it { @doc.css('.feature .scenario pre.val').length.should == 1 }
+          it { expect(@doc.css('.feature .background pre.val').length).to eq 1 }
+          it { expect(@doc.css('.feature .scenario pre.val').length).to eq 1 }
         end
 
         describe "with a step that fails in the scenario" do
@@ -207,8 +247,8 @@ module Cucumber
               Given boo
             FEATURE
 
-          it { @doc.should have_css_node('.feature .scenario .step.failed .message', /eek/) }
-          it { @doc.should have_css_node('.feature .scenario .step.failed .message', /StandardError/) }
+          it { expect(@doc).to have_css_node('.feature .scenario .step.failed .message', /eek/) }
+          it { expect(@doc).to have_css_node('.feature .scenario .step.failed .message', /StandardError/) }
         end
 
         describe "with a step that fails in the background" do
@@ -224,18 +264,63 @@ module Cucumber
               Given yay
             FEATURE
 
-          it { @doc.should have_css_node('.feature .background .step.failed', /eek/) }
-          it { @out.string.should_not include('makeRed(\'scenario_0\')') }
-          it { @out.string.should include('makeRed(\'background_0\')') }
-          it { @doc.should_not have_css_node('.feature .scenario .step.failed', //) }
-          it { @doc.should have_css_node('.feature .scenario .step.undefined', /yay/) }
-          it { @doc.should have_css_node('.feature .background .backtrace', //) }
-          it { @doc.should_not have_css_node('.feature .scenario .backtrace', //) }
+          it { expect(@doc).to have_css_node('.feature .background .step.failed', /eek/) }
+          it { expect(@out.string).not_to include('makeRed(\'scenario_0\')') }
+          it { expect(@out.string).to include('makeRed(\'background_0\')') }
+          it { expect(@doc).not_to have_css_node('.feature .scenario .step.failed', //) }
+          it { expect(@doc).to have_css_node('.feature .scenario .step.undefined', /yay/) }
+          it { expect(@doc).to have_css_node('.feature .background .backtrace', //) }
+          it { expect(@doc).not_to have_css_node('.feature .scenario .backtrace', //) }
         end
 
         describe "with a step that embeds a snapshot" do
           define_steps do
-            Given(/snap/) { embed('snapshot.jpeg', 'image/jpeg') }
+            Given(/snap/) { 
+              RSpec::Mocks.allow_message(File, :file?) { true }
+              embed('snapshot.jpeg', 'image/jpeg')
+            }
+          end
+
+          define_feature(<<-FEATURE)
+          Feature:
+            Scenario:
+              Given snap
+            FEATURE
+
+          it { expect(@doc.css('.embed img').first.attributes['src'].to_s).to eq "snapshot.jpeg" }
+        end
+        
+        describe "with a step that embeds a text" do
+          define_steps do
+            Given(/log/) { embed('log.txt', 'text/plain') }
+          end
+
+          define_feature(<<-FEATURE)
+          Feature:
+            Scenario:
+              Given log
+            FEATURE
+
+          it { expect(@doc.at('a#text_0')['href'].to_s).to eq "log.txt" }
+        end
+
+        describe "with a step that embeds a snapshot content manually" do
+          define_steps do
+            Given(/snap/) { embed('data:image/png;base64,YWJj', 'image/png') }
+          end
+
+          define_feature(<<-FEATURE)
+          Feature:
+            Scenario:
+              Given snap
+            FEATURE
+
+          it { expect(@doc.css('.embed img').first.attributes['src'].to_s).to eq "data:image/png;base64,YWJj" }
+        end
+
+        describe "with a step that embeds a snapshot content" do
+          define_steps do
+            Given(/snap/) { embed('YWJj', 'image/png;base64') }
           end
 
           define_feature(<<-FEATURE)
@@ -244,7 +329,7 @@ module Cucumber
               Given snap
             FEATURE
 
-          it { @doc.css('.embed img').first.attributes['src'].to_s.should == "snapshot.jpeg" }
+          it { expect(@doc.css('.embed img').first.attributes['src'].to_s).to eq "data:image/png;base64,YWJj" }
         end
 
         describe "with an undefined Given step then an undefined And step" do
@@ -255,11 +340,120 @@ module Cucumber
               And another undefined step
             FEATURE
 
-          it { @doc.css('pre').map { |pre| /^(Given|And)/.match(pre.text)[1] }.should == ["Given", "Given"] }
+          it { expect(@doc.css('pre').map { |pre| /^(Given|And)/.match(pre.text)[1] }).to eq ["Given", "Given"] }
+        end
+
+        describe "with an undefined When step then an undefined And step" do
+          define_feature(<<-FEATURE)
+          Feature:
+            Scenario:
+              Given some undefined step
+              When a different undefined step
+              And another undefined step
+            FEATURE
+
+          it { expect(@doc.css('pre').map { |pre| /^(Given|When|And)/.match(pre.text)[1] }).to eq ["Given", "When", "When"] }
+        end
+
+        describe "with an passing Then step and an undefined And step" 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 { expect(@doc.css('pre').map { |pre| /^(Given|Then)/.match(pre.text)[1] }).to eq ["Then"] }
+        end
+
+        describe "with a output from hooks" do
+          describe "in a scenario" do
+            define_feature <<-FEATURE
+          Feature:
+            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 'should have ccs nodes ".step.message" for all the hooks' do
+              expect(@doc.css('.step.message').length).to eq 3
+              expect(@doc.css('.step.message')[0].text).to eq "Before hook"
+              expect(@doc.css('.step.message')[1].text).to eq "AfterStep hook"
+              expect(@doc.css('.step.message')[2].text).to eq "After hook"
+            end
+          end
+
+          describe "in a scenario outline" do
+            define_feature <<-FEATURE
+          Feature:
+            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 { expect(@doc).to have_css_node('.message', /Before hook, AfterStep hook, After hook/) }
+          end
+        end
+      end
+      context "in --expand mode" do
+        let(:runtime)   { Runtime.new({:expand => true})}
+        before(:each) do
+          @out = StringIO.new
+          @formatter = Html.new(runtime, @out, {})
+          run_defined_feature
+          @doc = Nokogiri.HTML(@out.string)
         end
+        describe "with undefined * steps in a Scenario Outline" do
+          define_feature <<-FEATURE
+          Feature:
+            Scenario Outline:
+              * this step is <status>
+              Then this step passes
+              Examples:
+              |  status   |
+              | undefined |
+              | undefined |
+            FEATURE
 
+            define_steps do
+              Given(/^this step passes$/) {}
+            end
+
+          it { expect(@doc.css('pre').map { |pre| /^(Given|Then|When)/.match(pre.text)[1] }).to eq ["Given", "Given"] }
+        end
       end
     end
   end
 end
-

data/spec/cucumber/formatter/interceptor_spec.rb

@@ -5,16 +5,17 @@ module Cucumber::Formatter
   describe Interceptor::Pipe do
     let(:pipe) do
       pipe = double('original pipe')
-      pipe.stub(:instance_of?).and_return(true)
+
+      allow(pipe).to receive(:instance_of?) { true }
+
       pipe
     end
 
     describe '#wrap!' do
-      it 'should raise an ArgumentError if its not passed :stderr/:stdout' do
+      it 'raises an ArgumentError if its not passed :stderr/:stdout' do
         expect {
           Interceptor::Pipe.wrap(:nonsense)
         }.to raise_error(ArgumentError)
-
       end
 
       context 'when passed :stderr' do
@@ -22,10 +23,11 @@ module Cucumber::Formatter
           @stderr = $stdout
         end
 
-        it 'should wrap $stderr' do
+        it 'wraps $stderr' do
           wrapped = Interceptor::Pipe.wrap(:stderr)
-          $stderr.should be_instance_of Interceptor::Pipe
-          $stderr.should be wrapped
+
+          expect($stderr).to be_instance_of Interceptor::Pipe
+          expect($stderr).to be wrapped
         end
 
         after :each do
@@ -38,10 +40,11 @@ module Cucumber::Formatter
           @stdout = $stdout
         end
 
-        it 'should wrap $stdout' do
+        it 'wraps $stdout' do
           wrapped = Interceptor::Pipe.wrap(:stdout)
-          $stdout.should be_instance_of Interceptor::Pipe
-          $stdout.should be wrapped
+
+          expect($stdout).to be_instance_of Interceptor::Pipe
+          expect($stdout).to be wrapped
         end
 
         after :each do
@@ -56,34 +59,36 @@ module Cucumber::Formatter
         @wrapped = Interceptor::Pipe.wrap(:stdout)
       end
 
-      it 'should raise an ArgumentError if it wasn\'t passed :stderr/:stdout' do
+      it 'raises an ArgumentError if it wasn\'t passed :stderr/:stdout' do
         expect {
           Interceptor::Pipe.unwrap!(:nonsense)
         }.to raise_error(ArgumentError)
       end
 
-      it 'should reset $stdout when #unwrap! is called' do
+      it 'resets $stdout when #unwrap! is called' do
         interceptor = Interceptor::Pipe.unwrap! :stdout
-        interceptor.should be_instance_of Interceptor::Pipe
-        $stdout.should_not be interceptor
+
+        expect(interceptor).to be_instance_of Interceptor::Pipe
+        expect($stdout).not_to be interceptor
       end
 
-      it 'should noop if $stdout or $stderr has been overwritten' do
+      it 'noops if $stdout or $stderr has been overwritten' do
         $stdout = StringIO.new
         pipe = Interceptor::Pipe.unwrap! :stdout
-        pipe.should == $stdout
+        expect(pipe).to eq $stdout
 
         $stderr = StringIO.new
         pipe = Interceptor::Pipe.unwrap! :stderr
-        pipe.should == $stderr
+        expect(pipe).to eq $stderr
       end
 
-      it 'should disable the pipe bypass' do
+      it 'disables the pipe bypass' do
         buffer = '(::)'
         Interceptor::Pipe.unwrap! :stdout
 
-        @wrapped.should_receive(:write).with(buffer)
-        @wrapped.buffer.should_not_receive(:<<)
+        expect(@wrapped).to receive(:write).with(buffer)
+        expect(@wrapped.buffer).not_to receive(:<<)
+
         @wrapped.write(buffer)
       end
 
@@ -96,33 +101,35 @@ module Cucumber::Formatter
       let(:buffer) { 'Some stupid buffer' }
       let(:pi) { Interceptor::Pipe.new(pipe) }
 
-      it 'should write arguments to the original pipe' do
-        pipe.should_receive(:write).with(buffer).and_return(buffer.size)
-        pi.write(buffer).should == buffer.size
+      it 'writes arguments to the original pipe' do
+        expect(pipe).to receive(:write).with(buffer) { buffer.size }
+        expect(pi.write(buffer)).to eq buffer.size
       end
 
-      it 'should add the buffer to its stored output' do
-        pipe.stub(:write)
+      it 'adds the buffer to its stored output' do
+        allow(pipe).to receive(:write)
+
         pi.write(buffer)
-        pi.buffer.should_not be_empty
-        pi.buffer.first.should == buffer
+
+        expect(pi.buffer).not_to be_empty
+        expect(pi.buffer.first).to eq buffer
       end
     end
 
     describe '#method_missing' do
       let(:pi) { Interceptor::Pipe.new(pipe) }
 
-      it 'should pass #tty? to the original pipe' do
-        pipe.should_receive(:tty?).and_return(true)
-        pi.tty?.should be true
+      it 'passes #tty? to the original pipe' do
+        expect(pipe).to receive(:tty?) { true }
+        expect(pi.tty?).to be true
       end
     end
 
     describe '#respond_to' do
       let(:pi) { Interceptor::Pipe.wrap(:stderr) }
 
-      it 'should respond to all methods $stderr has' do
-        $stderr.methods.each { |m| pi.respond_to?(m).should be true }
+      it 'responds to all methods $stderr has' do
+        $stderr.methods.each { |m| expect(pi.respond_to?(m)).to be true }
       end
     end
   end