cucumber 2.0.0.beta.3 → 2.0.0

data/lib/cucumber/runtime/results.rb

@@ -1,64 +0,0 @@
-module Cucumber
-  class Runtime
-
-    class Results
-      def initialize(configuration)
-        @configuration = configuration
-
-        # Optimization - quicker lookup.
-        @inserted_steps = {}
-        @inserted_scenarios = {}
-      end
-
-      def configure(new_configuration)
-        @configuration = Configuration.parse(new_configuration)
-      end
-
-      def step_visited(step) #:nodoc:
-        step_id = step.object_id
-
-        unless @inserted_steps.has_key?(step_id)
-          @inserted_steps[step_id] = step
-          steps.push(step)
-        end
-      end
-
-      def scenario_visited(scenario) #:nodoc:
-        scenario_id = scenario.object_id
-
-        unless @inserted_scenarios.has_key?(scenario_id)
-          @inserted_scenarios[scenario_id] = scenario
-          scenarios.push(scenario)
-        end
-      end
-
-      def steps(status = nil) #:nodoc:
-        @steps ||= []
-        if(status)
-          @steps.select{|step| step.status == status}
-        else
-          @steps
-        end
-      end
-
-      def scenarios(status = nil) #:nodoc:
-        @scenarios ||= []
-        if(status)
-          @scenarios.select{|scenario| scenario.status == status}
-        else
-          @scenarios
-        end
-      end
-
-      def failure?
-        if @configuration.wip?
-          scenarios(:passed).any?
-        else
-          scenarios(:failed).any? || steps(:failed).any? ||
-          (@configuration.strict? && (steps(:undefined).any? || steps(:pending).any?))
-        end
-      end
-    end
-
-  end
-end

data/lib/cucumber/runtime/tag_limits/filter.rb

@@ -1,31 +0,0 @@
-require "cucumber/runtime/gated_receiver"
-
-module Cucumber
-  class Runtime
-    module TagLimits
-      class Filter
-        def initialize(tag_limits, receiver)
-          @gated_receiver = GatedReceiver.new(receiver)
-          @test_case_index = TestCaseIndex.new
-          @verifier = Verifier.new(tag_limits)
-        end
-
-        def test_case(test_case)
-          gated_receiver.test_case(test_case)
-          test_case_index.add(test_case)
-        end
-
-        def done
-          verifier.verify!(test_case_index)
-          gated_receiver.done
-        end
-
-        private
-
-        attr_reader :gated_receiver
-        attr_reader :test_case_index
-        attr_reader :verifier
-      end
-    end
-  end
-end

data/lib/cucumber/runtime/tag_limits.rb

@@ -1,15 +0,0 @@
-require "cucumber/runtime/tag_limits/test_case_index"
-require "cucumber/runtime/tag_limits/filter"
-require "cucumber/runtime/tag_limits/verifier"
-
-module Cucumber
-  class Runtime
-    module TagLimits
-      class TagLimitExceededError < StandardError
-        def initialize(*limit_breaches)
-          super(limit_breaches.map(&:to_s).join("\n"))
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/mappings_spec.rb

@@ -1,180 +0,0 @@
-require_relative "../../lib/cucumber/mappings"
-require 'cucumber/core'
-require 'cucumber/core/gherkin/writer'
-
-module Cucumber
-  class Mappings
-    describe Scenario do
-      include Core::Gherkin::Writer
-      include Core
-      let(:ruby)      { double.as_null_object }
-      let(:runtime)   do
-        double(
-          load_programming_language: ruby,
-          step_match: double
-        )
-      end
-      let(:mappings)  { Mappings.new(runtime) }
-      let(:report)    { double.as_null_object }
-
-      it "responds to #source_tag_names" do
-        define_gherkin do
-          feature 'test', tags: '@foo @bar' do
-            scenario 'test', tags: '@baz' do
-              step 'passing'
-            end
-          end
-        end
-
-        before do |scenario|
-          expect(scenario.source_tag_names).to eq %w(@foo @bar @baz)
-        end
-      end
-
-      describe "#failed?" do
-
-        it "is true if the test case is in a failed state" do
-          define_gherkin do
-            feature do
-              scenario do
-                step 'failing'
-              end
-            end
-          end
-
-          allow(runtime).to receive(:step_match) do |step_name|
-            if step_name == 'failing'
-              step_match = double
-              allow(step_match).to receive(:invoke) { fail }
-              step_match
-            else
-              raise Cucumber::Undefined
-            end
-          end
-
-          after do |test_case|
-            expect(test_case).to be_failed
-          end
-        end
-
-      end
-
-      describe "#scenario_outline" do
-
-        # TODO: is this actually desired behaviour?
-        it "throws a NoMethodError when the test case is from a scenario" do
-          define_gherkin do
-            feature do
-              scenario do
-                step 'passing'
-              end
-            end
-          end
-
-          before do |test_case|
-            expect{ test_case.scenario_outline }.to raise_error(NoMethodError)
-          end
-        end
-
-        it "points to self when the test case is from a scenario outline" do
-          define_gherkin do
-            feature do
-              scenario_outline 'outline' do
-                step 'passing'
-
-                examples 'examples' do
-                  row 'a'
-                  row '1'
-                end
-              end
-            end
-          end
-
-          before do |test_case|
-            expect(test_case.scenario_outline).to_not be_nil
-            expect(test_case.scenario_outline.name).to eq "Scenario Outline: outline, examples (row 1)"
-          end
-        end
-
-      end
-
-      describe "#outline?" do
-
-        it "returns false when the test case is from a scenario" do
-          define_gherkin do
-            feature do
-              scenario do
-                step 'passing'
-              end
-            end
-          end
-
-          before do |test_case|
-            expect(test_case).to_not be_an_outline
-          end
-        end
-
-        it "returns true when the test case is from a scenario" do
-          define_gherkin do
-            feature do
-              scenario_outline do
-                step 'passing'
-
-                examples 'examples' do
-                  row 'a'
-                  row '1'
-                end
-              end
-            end
-          end
-
-          before do |test_case|
-            expect(test_case).to be_an_outline
-          end
-        end
-
-      end
-      attr_accessor :gherkin_docs
-
-      def define_gherkin(&block)
-        self.gherkin_docs = [gherkin(&block)]
-      end
-
-      def before
-        # TODO: the complexity of this stubbing shows we need to clean up the interface
-        scenario_spy = nil
-        allow(ruby).to receive(:hooks_for) do |phase, scenario|
-          if phase == :before
-            hook = double
-            expect(hook).to receive(:invoke) do |phase, scenario|
-              scenario_spy = scenario
-            end
-            [hook]
-          else
-            []
-          end
-        end
-        execute gherkin_docs, mappings, report
-        yield scenario_spy
-      end
-
-      def after
-        # TODO: the complexity of this stubbing shows we need to clean up the interface
-        scenario_spy = nil
-        allow(ruby).to receive(:hooks_for) do |phase, scenario|
-          if phase == :after
-            hook = double
-            expect(hook).to receive(:invoke) do |phase, scenario|
-              scenario_spy = scenario
-            end
-            [hook]
-          else
-            []
-          end
-        end
-        execute gherkin_docs, mappings, report
-        yield scenario_spy
-      end
-    end
-  end
-end