mobiusloop 0.1.2

data/spec/cucumber/formatter/debug_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'cucumber/formatter/spec_helper'
+require 'cucumber/formatter/debug'
+require 'cucumber/cli/options'
+
+module Cucumber
+  module Formatter
+    describe Debug do
+      extend SpecHelperDsl
+      include SpecHelper
+
+        before(:each) do
+          Cucumber::Term::ANSIColor.coloring = false
+          @out = StringIO.new
+          @formatter = Debug.new(runtime, @out, {})
+        end
+
+        describe "given a single feature" do
+          before(:each) { run_defined_feature }
+
+          describe "with a scenario" do
+            define_feature <<-FEATURE
+          Feature: Banana party
+
+            Scenario: Monkey eats banana
+              Given there are bananas
+            FEATURE
+
+            it "outputs the events as expected" do
+              expect(@out.string).to eq(<<EXPECTED)
+before_test_case
+before_features
+before_feature
+before_tags
+after_tags
+feature_name
+before_test_step
+after_test_step
+before_test_step
+before_feature_element
+before_tags
+after_tags
+scenario_name
+before_steps
+before_step
+before_step_result
+step_name
+after_step_result
+after_step
+after_test_step
+after_steps
+after_feature_element
+after_test_case
+after_feature
+after_features
+done
+EXPECTED
+            end
+          end
+        end
+    end
+
+  end
+end

data/spec/cucumber/formatter/duration_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'cucumber/formatter/duration'
+
+module Cucumber
+  module Formatter
+    describe Duration do
+      include Duration
+
+      it "formats ms" do
+        expect(format_duration(0.002103)).to eq '0m0.002s'
+      end
+
+      it "formats m" do
+        expect(format_duration(61.002503)).to eq'1m1.003s'
+      end
+
+      it "formats h" do
+        expect(format_duration(3661.002503)).to eq '61m1.003s'
+      end
+    end
+  end
+end

data/spec/cucumber/formatter/event_bus_report_spec.rb

@@ -0,0 +1,88 @@
+require 'cucumber/configuration'
+require 'cucumber/runtime'
+require 'cucumber/formatter/spec_helper'
+require 'cucumber/formatter/event_bus_report'
+
+module Cucumber
+  module Formatter
+    describe EventBusReport do
+      extend SpecHelperDsl
+      include SpecHelper
+
+      context "With no options" do
+        let(:config) { Cucumber::Configuration.new }
+
+        before(:each) do
+          @formatter = EventBusReport.new(config)
+        end
+
+        describe "given a single feature" do
+
+          describe "a scenario with a single passing step" do
+            define_feature <<-FEATURE
+          Feature:
+            Scenario: Test Scenario
+              Given passing
+            FEATURE
+
+            define_steps do
+              Given(/pass/) {}
+            end
+
+            it "emits a BeforeTestCase event" do
+              received_event = nil
+              config.on_event Cucumber::Events::BeforeTestCase do |event|
+                received_event = event
+              end
+              run_defined_feature
+              expect(received_event.test_case.name).to eq "Test Scenario"
+            end
+
+            it "emits a BeforeTestStep event" do
+              received_event = nil
+              config.on_event Cucumber::Events::BeforeTestStep do |event|
+                received_event = event
+              end
+              run_defined_feature
+              expect(received_event.test_case.name).to eq "Test Scenario"
+              expect(received_event.test_step.name).to eq "passing"
+            end
+
+            it "emits an AfterTestStep event with a passed result" do
+              received_event = nil
+              config.on_event Cucumber::Events::AfterTestStep do |event|
+                received_event = event
+              end
+              run_defined_feature
+              expect(received_event.test_case.name).to eq "Test Scenario"
+              expect(received_event.test_step.name).to eq "passing"
+              expect(received_event.result).to be_passed
+            end
+
+            it "emits an AfterTestCase event with a passed result" do
+              received_event = nil
+              config.on_event Cucumber::Events::AfterTestCase do |event|
+                received_event = event
+              end
+              run_defined_feature
+              expect(received_event.test_case.name).to eq "Test Scenario"
+              expect(received_event.result).to be_passed
+            end
+
+            it "emits a Done event when the test run is finished" do
+              received_event = nil
+              config.on_event Cucumber::Events::FinishedTesting do |event|
+                received_event = event
+              end
+              run_defined_feature
+              expect(received_event).not_to be_nil
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+
+

data/spec/cucumber/formatter/fail_fast_spec.rb

@@ -0,0 +1,88 @@
+require 'cucumber/formatter/fail_fast'
+require 'cucumber/core'
+require 'cucumber/core/gherkin/writer'
+require 'cucumber/core/test/result'
+require 'cucumber/core/filter'
+require 'cucumber/core/ast'
+require 'cucumber'
+require 'support/standard_step_actions'
+
+module Cucumber::Formatter
+  describe FailFast do 
+    include Cucumber::Core
+    include Cucumber::Core::Gherkin::Writer
+
+    let(:configuration) { Cucumber::Configuration.new }
+    before { FailFast.new(configuration) }
+    let(:report) { EventBusReport.new(configuration) }
+
+    context 'failing scenario' do 
+      before(:each) do 
+        @gherkin = gherkin('foo.feature') do 
+          feature do 
+            scenario do 
+              step 'failing'
+            end
+
+            scenario do 
+              step 'failing'
+            end
+          end
+        end
+      end
+
+      after(:each) do 
+        Cucumber.wants_to_quit = false
+      end
+
+      it 'sets Cucumber.wants_to_quit' do 
+        execute([@gherkin], report, [StandardStepActions.new])
+        expect(Cucumber.wants_to_quit).to be true
+      end
+    end
+
+    context 'passing scenario' do 
+      before(:each) do 
+        @gherkin = gherkin('foo.feature') do 
+          feature do 
+            scenario do 
+              step 'passing'
+            end
+          end
+        end
+      end
+
+      it 'doesn\'t set Cucumber.wants_to_quit' do 
+        execute([@gherkin], report, [StandardStepActions.new])
+        expect(Cucumber.wants_to_quit).to be_falsey
+      end
+    end
+
+    context 'undefined scenario' do
+      before(:each) do 
+        @gherkin = gherkin('foo.feature') do 
+          feature do 
+            scenario do 
+              step 'undefined'
+            end
+          end
+        end
+      end
+
+      it 'doesn\'t set Cucumber.wants_to_quit' do 
+        execute([@gherkin], report, [StandardStepActions.new])
+        expect(Cucumber.wants_to_quit).to be_falsey
+      end
+
+      context 'in strict mode' do
+        let(:configuration) { Cucumber::Configuration.new strict: true }
+
+        it 'sets Cucumber.wants_to_quit' do 
+          execute([@gherkin], report, [StandardStepActions.new])
+          expect(Cucumber.wants_to_quit).to be_truthy
+        end
+      end
+    end
+
+  end
+end

data/spec/cucumber/formatter/html_spec.rb

@@ -0,0 +1,538 @@
+require 'spec_helper'
+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
+
+      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, 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
+        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/) }
+        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') }
+          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 ["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(: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 ["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