cucumber 3.0.0 → 3.1.0

data/spec/cucumber/formatter/html_spec.rb

@@ -1,543 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'cucumber/formatter/spec_helper'
-require 'cucumber/formatter/html'
-require 'nokogiri'
-require 'cucumber/glue/registry_and_more'
-require 'rspec/mocks'
-
-module Cucumber
-  module Formatter
-    describe Html do
-      extend SpecHelperDsl
-      include SpecHelper
-
-      RSpec::Matchers.define :have_css_node do |css, regexp|
-        match do |doc|
-          nodes = doc.css(css)
-          nodes.detect{ |node| node.text =~ regexp }
-        end
-      end
-
-      before(:each) do
-        @out = StringIO.new
-        @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
-
-      describe 'when writing the report to a file' do
-        before(:each) do
-          allow(@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
-        before(:each) do
-          run_defined_feature
-          @doc = Nokogiri.HTML(@out.string)
-        end
-
-        describe 'basic feature' do
-          define_feature <<-FEATURE
-            Feature: Bananas
-              In order to find my inner monkey
-              As a human
-              I must eat bananas
-          FEATURE
-
-          it 'should output a main container div' do
-            expect(@out.string).to match(/\<div class="cucumber"\>/)
-          end
-        end
-
-        describe 'with a comment' do
-          define_feature <<-FEATURE
-            # Healthy
-            Feature: Foo
-              Scenario:
-                Given passing
-          FEATURE
-
-          it { expect(@out.string).to match(/^\<!DOCTYPE/) }
-          it { expect(@out.string).to match(/\<\/html\>$/) }
-
-          it 'nests the comment within the feature' do
-            expect(@doc).to have_css_node('.feature .comment', /Healthy/)
-          end
-
-          it 'properly closes the comment' do
-            expect(@out.string).to match(%r{<pre class="comment"># Healthy<br/></pre>})
-          end
-        end
-
-        describe 'with a comment at scenario level' do
-          define_feature <<-FEATURE
-            Feature: Foo
-              # Healthy Scenario
-              Scenario:
-                Given passing
-          FEATURE
-
-          it { expect(@doc).to have_css_node('.scenario .comment', /Healthy Scenario/) }
-        end
-
-        describe 'with a tag' do
-          define_feature <<-FEATURE
-            @foo
-            Feature: can't have standalone tag :)
-              Scenario:
-                Given passing
-          FEATURE
-
-          it { expect(@doc).to have_css_node('.feature .tag', /foo/) }
-        end
-
-        describe 'with a narrative' do
-          define_feature <<-FEATURE
-            Feature: Bananas
-              In order to find my inner monkey
-              As a human
-              I must eat bananas
-
-              Scenario:
-                Given passing
-          FEATURE
-
-          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
-          define_feature <<-FEATURE
-            Feature: Bananas
-
-            Background:
-              Given there are bananas
-
-            Scenario:
-              When the monkey eats a banana
-          FEATURE
-
-          it { expect(@doc).to have_css_node('.feature .background', /there are bananas/) }
-        end
-
-        describe 'with a scenario' do
-          define_feature <<-FEATURE
-          Feature: Banana party
-
-            Scenario: Monkey eats banana
-              Given there are bananas
-          FEATURE
-
-          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
-          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 { 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
-          define_feature <<-FEATURE
-          Feature: Traveling circus
-
-            Scenario: Monkey goes to town
-              Given there is a monkey called:
-               """
-               foo
-               """
-          FEATURE
-
-          it { expect(@doc).to have_css_node('.feature .scenario .val', /foo/) }
-        end
-
-        describe 'with a multiline step arg' do
-          define_steps do
-            Given(/there are monkeys:/) { |table| }
-          end
-          define_feature <<-FEATURE
-          Feature: Traveling circus
-
-            Scenario: Monkey goes to town
-              Given there are monkeys:
-               | name |
-               | foo  |
-               | bar  |
-          FEATURE
-
-          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
-          define_feature <<-FEATURE
-          Feature: accountant monkey
-
-            Background:
-              Given table:
-                | a | b |
-                | c | d |
-            Scenario:
-              Given another table:
-               | e | f |
-               | g | h |
-          FEATURE
-
-          it { expect(@doc.css('td').length).to eq 8 }
-        end
-
-        describe 'with a py string in the background and the scenario' do
-          define_feature <<-FEATURE
-          Feature: py strings
-
-            Background:
-              Given stuff:
-                """
-                foo
-                """
-            Scenario:
-              Given more stuff:
-                """
-                bar
-                """
-          FEATURE
-
-          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
-          define_steps do
-            Given(/boo/) { raise StandardError, 'eek'.freeze }
-          end
-
-          define_feature(<<-FEATURE)
-          Feature: Animal Cruelty
-
-            Scenario: Monkey gets a fright
-              Given boo
-            FEATURE
-
-          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/) }
-          it 'has the backtrace embeded in the output once and only once' do
-            html_str = @doc.to_s
-            expect(html_str).not_to match(%r{<pre\b.*html_spec.rb:.*html_spec.rb:.*</pre>}m)
-            expect(html_str).to match(%r{<pre\b.*html_spec.rb:.*</pre>}m)
-          end
-        end
-
-        describe 'with a step that fails in the background' do
-          define_steps do
-            Given(/boo/) { raise 'eek' }
-          end
-
-          define_feature(<<-FEATURE)
-          Feature: shouting
-            Background:
-              Given boo
-            Scenario:
-              Given yay
-            FEATURE
-
-          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
-
-        context 'with a before hook that fails' do
-          describe 'in a scenario' do
-            define_steps do
-              Before { raise 'eek' }
-              Given(/yay/) {}
-            end
-
-            define_feature(<<-FEATURE)
-            Feature: shouting
-              Scenario:
-                Given yay
-              FEATURE
-
-            it { expect(@out.string).to include('makeRed(\'scenario_1\')') }
-            it { expect(@doc).not_to have_css_node('.feature .scenario .step.failed', //) }
-            it { expect(@doc).to have_css_node('.feature .scenario .step.skipped', /yay/) }
-          end
-
-          describe 'in a scenario outline' do
-            define_steps do
-              Before { raise 'eek' }
-              Given(/yay/) {}
-            end
-
-            define_feature(<<-FEATURE)
-            Feature: shouting
-              Scenario Outline:
-                Given <step>
-                Examples:
-                | step |
-                | yay  |
-              FEATURE
-
-            it { expect(@out.string).to include('makeRed(\'scenario_1\')') }
-            it { expect(@doc).not_to have_css_node('.feature .scenario .step.failed', //) }
-            it { expect(@doc).to have_css_node('.feature .scenario .step.skipped', /yay/) }
-          end
-
-        end
-
-        describe 'with a step that embeds a snapshot' do
-          define_steps do
-            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', 'foo') }
-          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)
-          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 an undefined Given step then an undefined And step' do
-          define_feature(<<-FEATURE)
-          Feature:
-            Scenario:
-              Given some undefined step
-              And another undefined step
-            FEATURE
-
-          it { expect(@doc.css('pre').map { |pre| /^(Given|And)/.match(pre.text)[1] }).to eq %w(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 %w(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(:options)   { { expand: true } }
-        before(:each) do
-          @out = StringIO.new
-          @formatter = Html.new(runtime, @out, {:expand => true})
-          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 %w(Given Given) }
-        end
-
-        describe 'with a scenario outline and a before hook that fails' do
-          define_steps do
-            Before { raise 'eek' }
-            Given(/yay/) {}
-          end
-
-          define_feature(<<-FEATURE)
-          Feature: shouting
-            Scenario Outline:
-              Given <step>
-              Examples:
-              | step |
-              | yay  |
-            FEATURE
-
-          it { expect(@out.string).to include('makeRed(\'scenario_1\')') }
-          it { expect(@out.string).to include('makeRed(\'scenario_1_1\')') }
-          it { expect(@doc).not_to have_css_node('.feature .scenario .step.failed', //) }
-          it { expect(@doc).to have_css_node('.feature .scenario .step.skipped', /yay/) }
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/formatter/interceptor_spec.rb

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'cucumber/formatter/interceptor'
-
-module Cucumber::Formatter
-  describe Interceptor::Pipe do
-    let(:pipe) do
-      pipe = double('original pipe')
-
-      allow(pipe).to receive(:instance_of?) { true }
-
-      pipe
-    end
-
-    describe '#wrap!' 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
-        before :each do
-          @stderr = $stdout
-        end
-
-        it 'wraps $stderr' do
-          wrapped = Interceptor::Pipe.wrap(:stderr)
-
-          expect($stderr).to be_instance_of Interceptor::Pipe
-          expect($stderr).to be wrapped
-        end
-
-        after :each do
-          $stderr = @stderr
-        end
-      end
-
-      context 'when passed :stdout' do
-        before :each do
-          @stdout = $stdout
-        end
-
-        it 'wraps $stdout' do
-          wrapped = Interceptor::Pipe.wrap(:stdout)
-
-          expect($stdout).to be_instance_of Interceptor::Pipe
-          expect($stdout).to be wrapped
-        end
-
-        after :each do
-          $stdout = @stdout
-        end
-      end
-    end
-
-    describe '#unwrap!' do
-      before :each do
-        @stdout = $stdout
-        @wrapped = Interceptor::Pipe.wrap(:stdout)
-      end
-
-      it 'raises an ArgumentError if it wasn\'t passed :stderr/:stdout' do
-        expect {
-          Interceptor::Pipe.unwrap!(:nonsense)
-        }.to raise_error(ArgumentError)
-      end
-
-      it 'resets $stdout when #unwrap! is called' do
-        interceptor = Interceptor::Pipe.unwrap! :stdout
-
-        expect(interceptor).to be_instance_of Interceptor::Pipe
-        expect($stdout).not_to be interceptor
-      end
-
-      it 'noops if $stdout or $stderr has been overwritten' do
-        $stdout = StringIO.new
-        pipe = Interceptor::Pipe.unwrap! :stdout
-        expect(pipe).to eq $stdout
-
-        $stderr = StringIO.new
-        pipe = Interceptor::Pipe.unwrap! :stderr
-        expect(pipe).to eq $stderr
-      end
-
-      it 'disables the pipe bypass' do
-        buffer = '(::)'
-        Interceptor::Pipe.unwrap! :stdout
-
-        expect(@wrapped).to receive(:write).with(buffer)
-        expect(@wrapped.buffer).not_to receive(:<<)
-
-        @wrapped.write(buffer)
-      end
-
-      after :each do
-        $stdout = @stdout
-      end
-    end
-
-    describe '#write' do
-      let(:buffer) { 'Some stupid buffer' }
-      let(:pi) { Interceptor::Pipe.new(pipe) }
-
-      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 'adds the buffer to its stored output' do
-        allow(pipe).to receive(:write)
-
-        pi.write(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 '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 'responds to all methods $stderr has' do
-        $stderr.methods.each { |m| expect(pi.respond_to?(m)).to be true }
-      end
-    end
-  end
-end