cucumber 2.0.0.beta.3 → 2.0.0.beta.4

data/spec/cucumber/{runtime → filters}/gated_receiver_spec.rb

@@ -1,7 +1,7 @@
-require "cucumber/runtime/gated_receiver"
+require "cucumber/filters/gated_receiver"
 
-describe Cucumber::Runtime::GatedReceiver do
-  subject(:gated_receiver) { Cucumber::Runtime::GatedReceiver.new(receiver) }
+describe Cucumber::Filters::GatedReceiver do
+  subject(:gated_receiver) { Cucumber::Filters::GatedReceiver.new(receiver) }
 
   let(:receiver) { double(:receiver) }
   let(:test_cases){ [double(:test_case), double(:test_case)] }

data/spec/cucumber/{runtime → filters}/tag_limits/test_case_index_spec.rb

@@ -1,7 +1,7 @@
-require "cucumber/runtime/tag_limits"
+require "cucumber/filters/tag_limits"
 
-describe Cucumber::Runtime::TagLimits::TestCaseIndex do
-  subject(:index) { Cucumber::Runtime::TagLimits::TestCaseIndex.new }
+describe Cucumber::Filters::TagLimits::TestCaseIndex do
+  subject(:index) { Cucumber::Filters::TagLimits::TestCaseIndex.new }
 
   let(:test_cases) do
     [

data/spec/cucumber/{runtime → filters}/tag_limits/verifier_spec.rb

@@ -1,8 +1,8 @@
-require "cucumber/runtime/tag_limits"
+require "cucumber/filters/tag_limits"
 
-describe Cucumber::Runtime::TagLimits::Verifier do
+describe Cucumber::Filters::TagLimits::Verifier do
   describe "#verify!" do
-    subject(:verifier) { Cucumber::Runtime::TagLimits::Verifier.new(tag_limits) }
+    subject(:verifier) { Cucumber::Filters::TagLimits::Verifier.new(tag_limits) }
     let(:test_case_index) { double(:test_case_index) }
 
     context "the tag counts exceed the tag limits" do
@@ -28,7 +28,7 @@ describe Cucumber::Runtime::TagLimits::Verifier do
         expect {
           verifier.verify!(test_case_index)
         }.to raise_error(
-          Cucumber::Runtime::TagLimits::TagLimitExceededError,
+          Cucumber::Filters::TagLimitExceededError,
           "@exceed_me occurred 2 times, but the limit was set to 1\n" +
           "  path/to/some.feature:3\n" +
           "  path/to/some/other.feature:8"

data/spec/cucumber/{runtime/tag_limits/filter_spec.rb → filters/tag_limits_spec.rb}

@@ -1,7 +1,7 @@
-require "cucumber/runtime/tag_limits"
+require "cucumber/filters/tag_limits"
 
-describe Cucumber::Runtime::TagLimits::Filter do
-  subject(:filter) { Cucumber::Runtime::TagLimits::Filter.new(tag_limits, receiver) }
+describe Cucumber::Filters::TagLimits do
+  subject(:filter) { Cucumber::Filters::TagLimits.new(tag_limits, receiver) }
 
   let(:tag_limits) { double(:tag_limits) }
   let(:receiver) { double(:receiver) }
@@ -11,8 +11,8 @@ describe Cucumber::Runtime::TagLimits::Filter do
   let(:test_case) { double(:test_case) }
 
   before do
-    allow(Cucumber::Runtime::GatedReceiver).to receive(:new).with(receiver) { gated_receiver }
-    allow(Cucumber::Runtime::TagLimits::TestCaseIndex).to receive(:new) { test_case_index }
+    allow(Cucumber::Filters::GatedReceiver).to receive(:new).with(receiver) { gated_receiver }
+    allow(Cucumber::Filters::TagLimits::TestCaseIndex).to receive(:new) { test_case_index }
   end
 
   describe "#test_case" do
@@ -36,7 +36,7 @@ describe Cucumber::Runtime::TagLimits::Filter do
     let(:verifier) { double(:verifier) }
 
     before do
-      allow(Cucumber::Runtime::TagLimits::Verifier).to receive(:new).with(tag_limits) { verifier }
+      allow(Cucumber::Filters::TagLimits::Verifier).to receive(:new).with(tag_limits) { verifier }
       allow(gated_receiver).to receive(:done)
     end
 

data/spec/cucumber/formatter/debug_spec.rb

@@ -28,542 +28,51 @@ 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
+after_test_step
+before_test_step
+after_test_step
+before_test_step
+after_test_step
+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
+before_test_step
+after_test_step
+before_test_step
+after_test_step
+before_test_step
+after_test_step
+after_steps
+after_feature_element
+after_test_case
+after_feature
 after_features
+done
 EXPECTED
             end
           end
         end
     end
+
   end
 end