cucumber 2.0.0.beta.3 → 2.0.0

data/lib/cucumber/runtime/support_code.rb

@@ -1,5 +1,8 @@
 require 'cucumber/constantize'
 require 'cucumber/runtime/for_programming_languages'
+require 'cucumber/runtime/step_hooks'
+require 'cucumber/runtime/before_hooks'
+require 'cucumber/runtime/after_hooks'
 
 module Cucumber
 
@@ -7,7 +10,6 @@ module Cucumber
 
     class SupportCode
 
-      # TODO: figure out a way to move this to the core. We'd need to have access to the mappings to pass those in.
       require 'forwardable'
       class StepInvoker
         include Gherkin::Rubify
@@ -21,7 +23,7 @@ module Cucumber
 
         def step(step)
           location = Core::Ast::Location.of_caller
-          @support_code.invoke(step.name, multiline_arg(step, location))
+          @support_code.invoke_dynamic_step(step.name, multiline_arg(step, location))
         end
 
         def eof
@@ -56,14 +58,24 @@ module Cucumber
       #     Given I have 8 cukes in my belly
       #     Then I should not be thirsty
       #   })
-      def invoke_steps(steps_text, i18n, file_colon_line)
+      def invoke_dynamic_steps(steps_text, i18n, file_colon_line)
         file, line = file_colon_line.split(':')
         parser = Gherkin::Parser::Parser.new(StepInvoker.new(self), true, 'steps', false, i18n.iso_code)
         parser.parse(steps_text, file, line.to_i)
       end
 
-      def invoke(step_name, multiline_argument, location=nil)
-        step_match(step_name).invoke(multiline_argument)
+      # @api private
+      # This allows users to attempt to find, match and execute steps
+      # from code as the features are running, as opposed to regular
+      # steps which are compiled into test steps before execution.
+      #
+      # These are commonly called nested steps.
+      def invoke_dynamic_step(step_name, multiline_argument, location=nil)
+        begin
+          step_match(step_name).invoke(multiline_argument)
+        rescue Undefined => exception
+          raise UndefinedDynamicStep, step_name
+        end
       end
 
       # Loads and registers programming language implementation.
@@ -121,6 +133,59 @@ module Cucumber
         end.flatten
       end
 
+      def find_match(test_step)
+        begin
+          match = step_match(test_step.name)
+        rescue Cucumber::Undefined
+          return NoStepMatch.new(test_step.source.last, test_step.name)
+        end
+        if @configuration.dry_run?
+          return SkippingStepMatch.new
+        end
+        match
+      end
+
+      def find_after_step_hooks(test_case)
+        ruby = load_programming_language('rb')
+        scenario = RunningTestCase.new(test_case)
+
+        action_blocks = ruby.hooks_for(:after_step, scenario).map do |hook|
+          ->(*args) { hook.invoke('AfterStep', args) }
+        end
+        StepHooks.new action_blocks
+      end
+
+      def apply_before_hooks(test_case)
+        ruby = load_programming_language('rb')
+        scenario = RunningTestCase.new(test_case)
+
+        action_blocks = ruby.hooks_for(:before, scenario).map do |hook|
+          ->(result) { hook.invoke('Before', scenario.with_result(result)) }
+        end
+        BeforeHooks.new(action_blocks).apply_to(test_case)
+      end
+
+      def apply_after_hooks(test_case)
+        ruby = load_programming_language('rb')
+        scenario = RunningTestCase.new(test_case)
+
+        action_blocks = ruby.hooks_for(:after, scenario).map do |hook|
+          ->(result) { hook.invoke('After', scenario.with_result(result)) }
+        end
+        AfterHooks.new(action_blocks).apply_to(test_case)
+      end
+
+      def find_around_hooks(test_case)
+        ruby = load_programming_language('rb')
+        scenario = RunningTestCase.new(test_case)
+
+        ruby.hooks_for(:around, scenario).map do |hook|
+          Hooks.around_hook(test_case.source) do |run_scenario|
+            hook.invoke('Around', scenario, &run_scenario)
+          end
+        end
+      end
+
       def step_match(step_name, name_to_report=nil) #:nodoc:
         @match_cache ||= {}
 

data/lib/cucumber/runtime.rb

@@ -9,6 +9,8 @@ require 'cucumber/load_path'
 require 'cucumber/language_support/language_methods'
 require 'cucumber/formatter/duration'
 require 'cucumber/file_specs'
+require 'cucumber/filters'
+require 'cucumber/formatter/fanout'
 
 module Cucumber
   module FixRuby21Bug9285
@@ -30,14 +32,12 @@ module Cucumber
   end
 
   class FeatureFolderNotFoundException < FileException
-    include FixRuby21Bug9285 if Cucumber::RUBY_2_1
+    include FixRuby21Bug9285 if Cucumber::RUBY_2_1 || Cucumber::RUBY_2_2
   end
 
   require 'cucumber/core'
   require 'cucumber/runtime/user_interface'
-  require 'cucumber/runtime/results'
   require 'cucumber/runtime/support_code'
-  require 'cucumber/runtime/tag_limits'
   class Runtime
     attr_reader :results, :support_code, :configuration
 
@@ -46,17 +46,15 @@ module Cucumber
     include Runtime::UserInterface
 
     def initialize(configuration = Configuration.default)
-      @current_scenario = nil
       @configuration = Configuration.parse(configuration)
       @support_code = SupportCode.new(self, @configuration)
-      @results = Results.new(@configuration)
+      @results = Formatter::LegacyApi::Results.new
     end
 
-    # Allows you to take an existing runtime and change it's configuration
+    # Allows you to take an existing runtime and change its configuration
     def configure(new_configuration)
       @configuration = Configuration.parse(new_configuration)
       @support_code.configure(@configuration)
-      @results.configure(@configuration)
     end
 
     def load_programming_language(language)
@@ -68,7 +66,8 @@ module Cucumber
       fire_after_configuration_hook
       self.visitor = report
 
-      execute features, mappings, report, filters
+      receiver = Test::Runner.new(report)
+      compile features, receiver, filters
     end
 
     def features_paths
@@ -79,10 +78,6 @@ module Cucumber
       @configuration.dry_run?
     end
 
-    def step_visited(step) #:nodoc:
-      @results.step_visited(step)
-    end
-
     def scenarios(status = nil)
       @results.scenarios(status)
     end
@@ -103,53 +98,12 @@ module Cucumber
       @support_code.snippet_text(::Gherkin::I18n.code_keyword_for(step_keyword), step_name, multiline_arg)
     end
 
-    def with_hooks(scenario, skip_hooks=false)
-      around(scenario, skip_hooks) do
-        before_and_after(scenario, skip_hooks) do
-          yield scenario
-        end
-      end
-    end
-
-    def around(scenario, skip_hooks=false, &block) #:nodoc:
-      if skip_hooks
-        yield
-        return
-      end
-
-      @support_code.around(scenario, block)
-    end
-
-    def before_and_after(scenario, skip_hooks=false) #:nodoc:
-      before(scenario) unless skip_hooks
-      yield scenario
-      after(scenario) unless skip_hooks
-      record_result scenario
-    end
-
-    def record_result(scenario)
-      @results.scenario_visited(scenario)
-    end
-
     def begin_scenario(scenario)
       @support_code.fire_hook(:begin_scenario, scenario)
     end
 
-    def before(scenario) #:nodoc:
-      return if dry_run? || @current_scenario
-      @current_scenario = scenario
-      @support_code.fire_hook(:before, scenario)
-    end
-
-    def after(scenario) #:nodoc:
-      @current_scenario = nil
-      return if dry_run?
-      @support_code.fire_hook(:after, scenario)
-    end
-
-    def after_step #:nodoc:
-      return if dry_run?
-      @support_code.fire_hook(:execute_after_step, @current_scenario)
+    def end_scenario(scenario)
+      @support_code.fire_hook(:end_scenario)
     end
 
     def unknown_programming_language?
@@ -159,8 +113,7 @@ module Cucumber
     # Returns Ast::DocString for +string_without_triple_quotes+.
     #
     def doc_string(string_without_triple_quotes, content_type='', line_offset=0)
-      file, line = *caller[0].split(':')[0..1]
-      location = Core::Ast::Location.new(file, line)
+      location = Core::Ast::Location.of_caller
       Core::Ast::DocString.new(string_without_triple_quotes, content_type, location)
     end
 
@@ -223,74 +176,65 @@ module Cucumber
       end
     end
 
-    require 'cucumber/mappings'
-    def mappings
-      @mappings = Mappings.for(self)
+    require 'cucumber/formatter/legacy_api/adapter'
+    require 'cucumber/formatter/legacy_api/runtime_facade'
+    require 'cucumber/formatter/legacy_api/results'
+    require 'cucumber/formatter/ignore_missing_messages'
+    require 'cucumber/core/report/summary'
+    def report
+      @report ||= Formatter::Fanout.new([summary_report] + formatters)
     end
 
-    require 'cucumber/reports/legacy_formatter'
-    def report
-      @report ||= Cucumber::Reports::LegacyFormatter.new(self, @configuration.formatters(self))
+    def summary_report
+      @summary_report ||= Core::Report::Summary.new
+    end
+
+    def formatters
+      @formatters ||= @configuration.formatter_factories { |factory, path_or_io, options|
+        results = Formatter::LegacyApi::Results.new
+        runtime_facade = Formatter::LegacyApi::RuntimeFacade.new(results, @support_code, @configuration)
+        formatter = factory.new(runtime_facade, path_or_io, options)
+        Formatter::LegacyApi::Adapter.new(
+          Formatter::IgnoreMissingMessages.new(formatter),
+          results, @support_code, @configuration)
+      }
     end
 
+    def failure?
+      if @configuration.wip?
+        summary_report.test_cases.total_passed > 0
+      else
+        summary_report.test_cases.total_failed > 0 || summary_report.test_steps.total_failed > 0 ||
+          (@configuration.strict? && (summary_report.test_steps.total_undefined > 0 || summary_report.test_steps.total_pending > 0))
+      end
+    end
+    public :failure?
+
     require 'cucumber/core/test/filters'
     def filters
       tag_expressions = @configuration.tag_expressions
       name_regexps = @configuration.name_regexps
       tag_limits = @configuration.tag_limits
       [].tap do |filters|
-        filters << [Cucumber::Runtime::Randomizer, [@configuration.seed]] if @configuration.randomize?
-        filters << [Cucumber::Runtime::TagLimits::Filter, [tag_limits]] if tag_limits.any?
-        filters << [Cucumber::Core::Test::TagFilter, [tag_expressions]]
-        filters << [Cucumber::Core::Test::NameFilter, [name_regexps]]
-        filters << [Cucumber::Core::Test::LocationsFilter, [filespecs.locations]]
-        filters << [Quit, []]
-      end
-    end
-
-    class Randomizer
-      def initialize(seed, receiver)
-        @receiver = receiver
-        @test_cases = []
-        @seed = seed
-      end
-
-      def test_case(test_case)
-        @test_cases << test_case
-      end
-
-      def done
-        shuffled_test_cases.each do |test_case|
-          test_case.describe_to(@receiver)
+        filters << Filters::Randomizer.new(@configuration.seed) if @configuration.randomize?
+        filters << Filters::TagLimits.new(tag_limits) if tag_limits.any?
+        filters << Cucumber::Core::Test::TagFilter.new(tag_expressions)
+        filters << Cucumber::Core::Test::NameFilter.new(name_regexps)
+        filters << Cucumber::Core::Test::LocationsFilter.new(filespecs.locations)
+        filters << Filters::Quit.new
+        filters << Filters::ActivateSteps.new(@support_code)
+        @configuration.filters.each do |filter|
+          filters << filter
         end
-        @receiver.done
-      end
-
-      private
-
-      def shuffled_test_cases
-        @test_cases.shuffle(random: Random.new(seed))
-      end
-
-      attr_reader :seed
-      private :seed
-    end
-
-    class Quit
-      def initialize(receiver)
-        @receiver = receiver
-      end
-
-      def test_case(test_case)
-        unless Cucumber.wants_to_quit
-          test_case.describe_to @receiver
+        unless configuration.dry_run?
+          filters << Filters::ApplyAfterStepHooks.new(@support_code)
+          filters << Filters::ApplyBeforeHooks.new(@support_code)
+          filters << Filters::ApplyAfterHooks.new(@support_code)
+          filters << Filters::ApplyAroundHooks.new(@support_code)
+          # need to do this last so it becomes the first test step
+          filters << Filters::PrepareWorld.new(self)
         end
       end
-
-      def done
-        @receiver.done
-        self
-      end
     end
 
     def load_step_definitions

data/lib/cucumber/step_match.rb

@@ -1,3 +1,5 @@
+require 'cucumber/multiline_argument'
+
 module Cucumber
   class StepMatch #:nodoc:
     attr_reader :step_definition, :step_arguments
@@ -12,15 +14,21 @@ module Cucumber
     end
 
     def args
-      @step_arguments.map{|g| g.val.freeze }
+      @step_arguments.map{|g| g.val }
     end
 
     def name
       @name_to_report
     end
 
+    def activate(test_step)
+      test_step.with_action do
+        invoke(MultilineArgument.from_core(test_step.source.last.multiline_arg))
+      end
+    end
+
     def invoke(multiline_arg)
-      all_args = args.dup
+      all_args = deep_clone_args
       multiline_arg.append_to(all_args)
       @step_definition.invoke(all_args)
     end
@@ -80,6 +88,17 @@ module Cucumber
     def inspect #:nodoc:
       sprintf("#<%s:0x%x>", self.class, self.object_id)
     end
+
+    private
+    def deep_clone_args
+      Marshal.load( Marshal.dump( args ) )
+    end
+  end
+
+  class SkippingStepMatch
+    def activate(test_step)
+      return test_step.with_action { raise Core::Test::Result::Skipped.new }
+    end
   end
 
   class NoStepMatch #:nodoc:
@@ -110,5 +129,10 @@ module Cucumber
     def step_arguments
       []
     end
+
+    def activate(test_step)
+      # noop
+      return test_step
+    end
   end
 end

data/lib/cucumber.rb

@@ -1,7 +1,5 @@
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
-
 require 'yaml'
+require 'cucumber/encoding'
 require 'cucumber/platform'
 require 'cucumber/runtime'
 require 'cucumber/cli/main'
@@ -22,5 +20,11 @@ module Cucumber
     def logger=(logger)
       @log = logger
     end
+
+    def deprecate(class_name, method, message)
+      return self # deprecation warnings will come in v2.1
+      called_by = caller[1]
+      warn("Deprecated: #{class_name}##{method} #{message}. Caller: #{called_by}")
+    end
   end
 end

data/spec/cucumber/cli/configuration_spec.rb

@@ -398,7 +398,22 @@ END_OF_MESSAGE
       expect(config.feature_files).to eq ["cucumber.feature"]
     end
 
-    it "allows specifying environment variables on the command line" do
+    it "gets the feature files from the rerun file" do
+      allow(File).to receive(:directory?).and_return(false)
+      allow(File).to receive(:file?).and_return(true)
+      allow(IO).to receive(:read).and_return(
+        "cucumber.feature:1:3 cucumber space.feature:134 domain folder/cuke.feature:1 domain folder/different cuke:4:5" )
+
+      config.parse!(%w{@rerun.txt})
+
+      expect(config.feature_files).to eq [
+        "cucumber.feature:1:3",
+        "cucumber space.feature:134",
+        "domain folder/cuke.feature:1",
+        "domain folder/different cuke:4:5"]
+    end
+
+    it "should allow specifying environment variables on the command line" do
       config.parse!(["foo=bar"])
 
       expect(ENV["foo"]).to eq "bar"

data/spec/cucumber/cli/profile_loader_spec.rb

@@ -31,6 +31,16 @@ module Cucumber
 
         expect(loader.args_from('default')).to eq ['--format','ugly','features/sync_imap_mailbox.feature:16:22']
       end
+
+      it "treats percent sign as ERB code block after YAML directive" do
+        yml = <<-HERE
+---
+% x = '--format "pretty" features/sync_imap_mailbox.feature:16:22'
+default: <%= x %>
+        HERE
+        given_cucumber_yml_defined_as yml
+        expect(loader.args_from('default')).to eq ['--format','pretty','features/sync_imap_mailbox.feature:16:22']
+      end
     end
   end
 end

data/spec/cucumber/core_ext/instance_exec_spec.rb

@@ -0,0 +1,4 @@
+require 'cucumber/core_ext/instance_exec'
+
+describe 'cucumber_instance_exec' do
+end

data/spec/cucumber/file_specs_spec.rb

@@ -4,6 +4,7 @@ module Cucumber
   describe FileSpecs do
     let(:file_specs) { FileSpecs.new(["features/foo.feature:1:2:3", "features/bar.feature:4:5:6"]) }
     let(:locations) { file_specs.locations }
+    let(:files) { file_specs.files }
 
     it "parses locations from multiple files" do
       expect(locations.length).to eq 6
@@ -18,8 +19,6 @@ module Cucumber
     end
 
     it "parses file names from multiple file specs" do
-      files = file_specs.files
-
       expect(files.length).to eq 2
       expect(files).to eq [
         "features/foo.feature",
@@ -27,6 +26,15 @@ module Cucumber
       ]
     end
 
+    context "when files are not unique" do
+      let(:file_specs) { FileSpecs.new(["features/foo.feature:4", "features/foo.feature:34"]) }
+
+      it "parses unique file names" do
+        expect(files.length).to eq 1
+        expect(files).to eq ["features/foo.feature"]
+      end
+    end
+
     context "when no line number is specified" do
       let(:file_specs) { FileSpecs.new(["features/foo.feature", "features/bar.feature:34"]) }
 
@@ -37,5 +45,16 @@ module Cucumber
         ]
       end
     end
+
+    context "when the same file is referenced more than once" do
+      let(:file_specs) { FileSpecs.new(["features/foo.feature:10", "features/foo.feature:1"]) }
+
+      it "returns locations in the order specified" do
+        expect(locations).to eq [
+          Cucumber::Core::Ast::Location.new("features/foo.feature", 10),
+          Cucumber::Core::Ast::Location.new("features/foo.feature", 1),
+        ]
+      end
+    end
   end
 end

data/spec/cucumber/filters/activate_steps_spec.rb

@@ -0,0 +1,57 @@
+require 'cucumber/filters/activate_steps'
+require 'cucumber/core/gherkin/writer'
+require 'cucumber/core'
+
+describe Cucumber::Filters::ActivateSteps do
+  include Cucumber::Core::Gherkin::Writer
+  include Cucumber::Core
+
+  let(:step_definitions) { double(find_match: step_match) }
+  let(:step_match) { double(activate: activated_test_step) }
+  let(:activated_test_step) { double }
+  let(:receiver) { double.as_null_object }
+
+  context "a scenario with a single step" do
+    let(:doc) do
+      gherkin do
+        feature do
+          scenario do
+            step 'a passing step'
+          end
+        end
+      end
+    end
+
+    it "activates each step" do
+      expect(step_match).to receive(:activate) do |test_step|
+        expect(test_step.name).to eq 'a passing step'
+      end
+      compile [doc], receiver, [Cucumber::Filters::ActivateSteps.new(step_definitions)]
+    end
+  end
+
+  context "a scenario outline" do
+    let(:doc) do
+      gherkin do
+        feature do
+          scenario_outline do
+            step 'a <status> step'
+
+            examples do
+              row 'status'
+              row 'passing'
+            end
+          end
+        end
+      end
+    end
+
+    it "activates each step" do
+      expect(step_match).to receive(:activate) do |test_step|
+        expect(test_step.name).to eq 'a passing step'
+      end
+      compile [doc], receiver, [Cucumber::Filters::ActivateSteps.new(step_definitions)]
+    end
+  end
+
+end

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