cucumber 2.0.0.beta.3 → 2.0.0

data/spec/cucumber/formatter/debug_spec.rb

@@ -28,542 +28,37 @@ module Cucumber
 
             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_feature_element
-      before_tags
-      after_tags
-      scenario_name
-      before_steps
-        before_step
-          before_step_result
-            step_name
-          after_step_result
-        after_step
-      after_steps
-    after_feature_element
-  after_feature
-after_features
-EXPECTED
-            end
-          end
-
-          describe "with a scenario with multiple steps" do
-            define_feature <<-FEATURE
-          Feature: Banana party
-
-            Scenario:
-              Given there are bananas
-              And there are berries
-            FEATURE
-
-            it "outputs the events as expected" do
-              expect(@out.string).to eq(<<EXPECTED)
-before_features
-  before_feature
-    before_tags
-    after_tags
-    feature_name
-    before_feature_element
-      before_tags
-      after_tags
-      scenario_name
-      before_steps
-        before_step
-          before_step_result
-            step_name
-          after_step_result
-        after_step
-        before_step
-          before_step_result
-            step_name
-          after_step_result
-        after_step
-      after_steps
-    after_feature_element
-  after_feature
-after_features
-EXPECTED
-            end
-          end
-
-          describe "with 2 scenarios" do
-            define_feature <<-FEATURE
-          Feature: Banana party
-
-            Scenario: Monkey eats banana
-              Given there are bananas
-
-            Scenario: Monkey is hungry
-              Given there are no bananas
-            FEATURE
-
-            it "outputs the events as expected" do
-              expect(@out.string).to eq(<<EXPECTED)
-before_features
-  before_feature
-    before_tags
-    after_tags
-    feature_name
-    before_feature_element
-      before_tags
-      after_tags
-      scenario_name
-      before_steps
-        before_step
-          before_step_result
-            step_name
-          after_step_result
-        after_step
-      after_steps
-    after_feature_element
-    before_feature_element
-      before_tags
-      after_tags
-      scenario_name
-      before_steps
-        before_step
-          before_step_result
-            step_name
-          after_step_result
-        after_step
-      after_steps
-    after_feature_element
-  after_feature
-after_features
-EXPECTED
-            end
-          end
-
-          describe "with a background" do
-            define_feature <<-FEATURE
-          Feature:
-
-            Background:
-              Given there is a tree
-
-            Scenario:
-              Given there are bananas
-            FEATURE
-
-            it "outputs the events as expected" do
-              pending("legacy cucumber fires extra step events") if ENV['USE_LEGACY']
-              expect(@out.string).to eq(<<EXPECTED)
-before_features
-  before_feature
-    before_tags
-    after_tags
-    feature_name
-    before_background
-      background_name
-      before_steps
-        before_step
-          before_step_result
-            step_name
-          after_step_result
-        after_step
-      after_steps
-    after_background
-    before_feature_element
-      before_tags
-      after_tags
-      scenario_name
-      before_steps
-        before_step
-          before_step_result
-            step_name
-          after_step_result
-        after_step
-      after_steps
-    after_feature_element
-  after_feature
-after_features
-EXPECTED
-            end
-          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 "outputs the events as expected" do
-              expect(@out.string).to eq(<<EXPECTED)
-before_features
-  before_feature
-    before_tags
-    after_tags
-    feature_name
-    before_feature_element
-      before_tags
-      after_tags
-      scenario_name
-      before_steps
-        before_step
-          before_step_result
-            step_name
-          after_step_result
-        after_step
-      after_steps
-      before_examples_array
-        before_examples
-          examples_name
-          before_outline_table
-            before_table_row
-              before_table_cell
-                table_cell_value
-              after_table_cell
-            after_table_row
-            before_table_row
-              before_table_cell
-                table_cell_value
-              after_table_cell
-            after_table_row
-            before_table_row
-              before_table_cell
-                table_cell_value
-              after_table_cell
-            after_table_row
-          after_outline_table
-        after_examples
-        before_examples
-          examples_name
-          before_outline_table
-            before_table_row
-              before_table_cell
-                table_cell_value
-              after_table_cell
-            after_table_row
-            before_table_row
-              before_table_cell
-                table_cell_value
-              after_table_cell
-            after_table_row
-            before_table_row
-              before_table_cell
-                table_cell_value
-              after_table_cell
-            after_table_row
-          after_outline_table
-        after_examples
-      after_examples_array
-    after_feature_element
-  after_feature
-after_features
-EXPECTED
-              end
-            end
-
-          describe "with a scenario outline with a pystring" do
-            define_feature <<-FEATURE
-          Feature:
-            Scenario Outline: Monkey eats a balanced diet
-              Given a multiline string:
-                """
-                Monkeys eat <things>
-                """
-
-              Examples:
-               | things |
-               | apples |
-            FEATURE
-
-            it "outputs the events as expected" do
-              expect(@out.string).to eq(<<EXPECTED)
-before_features
-  before_feature
-    before_tags
-    after_tags
-    feature_name
-    before_feature_element
-      before_tags
-      after_tags
-      scenario_name
-      before_steps
-        before_step
-          before_step_result
-            step_name
-            before_multiline_arg
-              doc_string
-            after_multiline_arg
-          after_step_result
-        after_step
-      after_steps
-      before_examples_array
-        before_examples
-          examples_name
-          before_outline_table
-            before_table_row
-              before_table_cell
-                table_cell_value
-              after_table_cell
-            after_table_row
-            before_table_row
-              before_table_cell
-                table_cell_value
-              after_table_cell
-            after_table_row
-          after_outline_table
-        after_examples
-      after_examples_array
-    after_feature_element
-  after_feature
-after_features
-EXPECTED
-            end
-          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 "displays the events as expected" do
-              expect(@out.string).to eq(<<EXPECTED)
-before_features
-  before_feature
-    before_tags
-    after_tags
-    feature_name
-    before_feature_element
-      before_tags
-      after_tags
-      scenario_name
-      before_steps
-        before_step
-          before_step_result
-            step_name
-            before_multiline_arg
-              doc_string
-            after_multiline_arg
-          after_step_result
-        after_step
-      after_steps
-    after_feature_element
-  after_feature
-after_features
-EXPECTED
-            end
-          end
-
-          describe "with a multiline step arg" do
-            define_feature <<-FEATURE
-          Feature: Traveling circus
-
-            Scenario: Monkey goes to town
-              Given there are monkeys:
-               | name |
-               | foo  |
-               | bar  |
-            FEATURE
-
-            it "displays the events as expected" do
-              expect(@out.string).to eq(<<EXPECTED)
-before_features
-  before_feature
-    before_tags
-    after_tags
-    feature_name
-    before_feature_element
-      before_tags
-      after_tags
-      scenario_name
-      before_steps
-        before_step
-          before_step_result
-            step_name
-            before_multiline_arg
-              before_table_row
-                before_table_cell
-                  table_cell_value
-                after_table_cell
-              after_table_row
-              before_table_row
-                before_table_cell
-                  table_cell_value
-                after_table_cell
-              after_table_row
-              before_table_row
-                before_table_cell
-                  table_cell_value
-                after_table_cell
-              after_table_row
-            after_multiline_arg
-          after_step_result
-        after_step
-      after_steps
-    after_feature_element
-  after_feature
-after_features
-EXPECTED
-            end
-          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 "displays the table for the background" do
-              pending("legacy cucumber fires extra step events") if ENV['USE_LEGACY']
-              expect(@out.string).to eq(<<EXPECTED)
-before_features
-  before_feature
-    before_tags
-    after_tags
-    feature_name
-    before_background
-      background_name
-      before_steps
-        before_step
-          before_step_result
-            step_name
-            before_multiline_arg
-              before_table_row
-                before_table_cell
-                  table_cell_value
-                after_table_cell
-                before_table_cell
-                  table_cell_value
-                after_table_cell
-              after_table_row
-              before_table_row
-                before_table_cell
-                  table_cell_value
-                after_table_cell
-                before_table_cell
-                  table_cell_value
-                after_table_cell
-              after_table_row
-            after_multiline_arg
-          after_step_result
-        after_step
-      after_steps
-    after_background
-    before_feature_element
-      before_tags
-      after_tags
-      scenario_name
-      before_steps
-        before_step
-          before_step_result
-            step_name
-            before_multiline_arg
-              before_table_row
-                before_table_cell
-                  table_cell_value
-                after_table_cell
-                before_table_cell
-                  table_cell_value
-                after_table_cell
-              after_table_row
-              before_table_row
-                before_table_cell
-                  table_cell_value
-                after_table_cell
-                before_table_cell
-                  table_cell_value
-                after_table_cell
-              after_table_row
-            after_multiline_arg
-          after_step_result
-        after_step
-      after_steps
-    after_feature_element
-  after_feature
-after_features
-EXPECTED
-            end
-          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 "displays the background py string" do
-              pending("legacy cucumber fires extra step events") if ENV['USE_LEGACY']
-              expect(@out.string).to eq(<<EXPECTED)
-before_features
-  before_feature
-    before_tags
-    after_tags
-    feature_name
-    before_background
-      background_name
-      before_steps
-        before_step
-          before_step_result
-            step_name
-            before_multiline_arg
-              doc_string
-            after_multiline_arg
-          after_step_result
-        after_step
-      after_steps
-    after_background
-    before_feature_element
-      before_tags
-      after_tags
-      scenario_name
-      before_steps
-        before_step
-          before_step_result
-            step_name
-            before_multiline_arg
-              doc_string
-            after_multiline_arg
-          after_step_result
-        after_step
-      after_steps
-    after_feature_element
-  after_feature
+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/html_spec.rb

@@ -29,6 +29,35 @@ module Cucumber
         }).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
@@ -313,6 +342,117 @@ module Cucumber
 
           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