cucumber 3.0.0.pre.1 → 4.0.0.rc.4

data/spec/cucumber/rb_support/rb_step_definition_spec.rb

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'cucumber/rb_support/rb_language'
-
-module Cucumber
-  module RbSupport
-    describe RbStepDefinition do
-      let(:user_interface) { double('user interface') }
-      let(:support_code)   { Cucumber::Runtime::SupportCode.new(user_interface) }
-      let(:rb)             { support_code.ruby }
-      let(:scenario)       { double('scenario', iso_code: 'en').as_null_object }
-      let(:dsl) do
-        rb
-        Object.new.extend(Cucumber::RbSupport::RbDsl)
-      end
-
-      before do
-        rb.begin_scenario(scenario)
-        $inside = nil
-      end
-
-      def run_step(text)
-        step_match(text).invoke(MultilineArgument::None.new)
-      end
-
-      def step_match(text)
-        StepMatchSearch.new(rb.method(:step_matches), Configuration.default).call(text).first
-      end
-
-      it "allows calling of other steps" do
-        dsl.Given(/Outside/) do
-          step "Inside"
-        end
-        dsl.Given(/Inside/) do
-          $inside = true
-        end
-
-        run_step "Outside"
-
-        expect($inside).to be true
-      end
-
-      it "allows calling of other steps with inline arg" do
-        dsl.Given(/Outside/) do
-          location = Core::Ast::Location.new(__FILE__, __LINE__)
-          step "Inside", table([['inside']])
-        end
-        dsl.Given(/Inside/) do |t|
-          $inside = t.raw[0][0]
-        end
-
-        run_step "Outside"
-
-        expect($inside).to eq 'inside'
-      end
-
-      context "mapping to world methods" do
-        it "calls a method on the world when specified with a symbol" do
-          expect(rb.current_world).to receive(:with_symbol)
-
-          dsl.Given(/With symbol/, :with_symbol)
-
-          run_step "With symbol"
-        end
-
-        it "calls a method on a specified object" do
-          target = double('target')
-
-          allow(rb.current_world).to receive(:target) { target }
-
-          dsl.Given(/With symbol on block/, :with_symbol, :on => lambda { target })
-
-          expect(target).to receive(:with_symbol)
-
-          run_step "With symbol on block"
-        end
-
-        it "calls a method on a specified world attribute" do
-          target = double('target')
-
-          allow(rb.current_world).to receive(:target) { target }
-
-          dsl.Given(/With symbol on symbol/, :with_symbol, :on => :target)
-
-          expect(target).to receive(:with_symbol)
-
-          run_step "With symbol on symbol"
-        end
-
-        it "has the correct location" do
-          dsl.Given /With symbol/, :with_symbol
-          expect(step_match("With symbol").file_colon_line).to eq "spec/cucumber/rb_support/rb_step_definition_spec.rb:#{__LINE__-1}"
-        end
-      end
-
-      it "raises UndefinedDynamicStep when inside step is not defined" do
-        dsl.Given(/Outside/) do
-          step 'Inside'
-        end
-
-        expect(-> {
-          run_step "Outside"
-        }).to raise_error(Cucumber::UndefinedDynamicStep)
-      end
-
-      it "raises UndefinedDynamicStep when an undefined step is parsed dynamically" do
-        dsl.Given(/Outside/) do
-          steps %{
-            Given Inside
-          }
-        end
-
-        expect(-> {
-          run_step "Outside"
-        }).to raise_error(Cucumber::UndefinedDynamicStep)
-      end
-
-      it "raises UndefinedDynamicStep when an undefined step with doc string is parsed dynamically" do
-        dsl.Given(/Outside/) do
-          steps %{
-            Given Inside
-            """
-            abc
-            """
-          }
-        end
-
-        expect(-> {
-          run_step "Outside"
-        }).to raise_error(Cucumber::UndefinedDynamicStep)
-      end
-
-      it "raises UndefinedDynamicStep when an undefined step with data table is parsed dynamically" do
-        dsl.Given(/Outside/) do
-          steps %{
-            Given Inside
-             | a |
-             | 1 |
-          }
-        end
-
-        expect(-> {
-          run_step "Outside"
-        }).to raise_error(Cucumber::UndefinedDynamicStep)
-      end
-
-      it "allows forced pending" do
-        dsl.Given(/Outside/) do
-          pending("Do me!")
-        end
-
-        expect(-> {
-          run_step "Outside"
-        }).to raise_error(Cucumber::Pending, "Do me!")
-      end
-
-      it "raises ArityMismatchError when the number of capture groups differs from the number of step arguments" do
-        dsl.Given(/No group: \w+/) do |arg|
-        end
-
-        expect(-> {
-          run_step "No group: arg"
-        }).to raise_error(Cucumber::ArityMismatchError)
-      end
-
-      it "does not modify the step_match arg when arg is modified in a step" do
-        dsl.Given(/My car is (.*)/) do |colour|
-          colour << "xxx"
-        end
-
-        step_name = "My car is white"
-        step_args = step_match(step_name).args
-
-        expect(-> {
-          run_step step_name
-        }).not_to change{ step_args.first }
-      end
-
-      it "allows puts" do
-        expect(user_interface).to  receive(:puts).with('wasup')
-        dsl.Given(/Loud/) do
-          puts 'wasup'
-        end
-        run_step "Loud"
-      end
-
-      it "recognizes $arg style captures" do
-        arg_value = "wow!"
-        dsl.Given "capture this: $arg" do |arg|
-          expect(arg).to eq arg_value
-        end
-        run_step "capture this: wow!"
-      end
-
-      it "has a JSON representation of the signature" do
-        expect(RbStepDefinition.new(rb, /I CAN HAZ (\d+) CUKES/i, lambda{}, {}).to_hash).to eq({ 'source' => "I CAN HAZ (\\d+) CUKES", 'flags' => 'i' })
-      end
-    end
-  end
-end

data/spec/cucumber/rb_support/rb_transform_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'cucumber/rb_support/rb_transform'
-
-module Cucumber
-  module RbSupport
-    describe RbTransform do
-      def transform(regexp)
-        RbTransform.new(nil, regexp, lambda { |a| })
-      end
-
-      describe "#to_s" do
-        it "does not touch positive lookahead captures" do
-          expect(transform(/^xy(?=z)/).to_s).to eq "xy(?=z)"
-        end
-
-        it "does not touch negative lookahead captures" do
-          expect(transform(/^xy(?!z)/).to_s).to eq "xy(?!z)"
-        end
-
-        it "does not touch positive lookbehind captures" do
-          expect(transform(/^xy(?<=z)/).to_s).to eq "xy(?<=z)"
-        end
-
-        it "does not touch negative lookbehind captures" do
-          expect(transform(/^xy(?<!z)/).to_s).to eq "xy(?<!z)"
-        end
-
-        it "converts named captures" do
-          expect(transform(/^(?<str>xyz)/).to_s).to eq "(?:<str>xyz)"
-        end
-
-        it "converts captures groups to non-capture groups" do
-          expect(transform(/(a|b)bc/).to_s).to eq "(?:a|b)bc"
-        end
-
-        it "leaves non capture groups alone" do
-          expect(transform(/(?:a|b)bc/).to_s).to eq "(?:a|b)bc"
-        end
-
-        it "strips away anchors" do
-          expect(transform(/^xyz$/).to_s).to eq "xyz"
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/rb_support/rb_world_spec.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'cucumber/formatter/spec_helper'
-require 'cucumber/formatter/pretty'
-
-module Cucumber
-  module RbSupport
-    describe RbWorld do
-      extend Cucumber::Formatter::SpecHelperDsl
-      include Cucumber::Formatter::SpecHelper
-
-      describe 'Handling puts in step definitions' do
-        before(:each) do
-          Cucumber::Term::ANSIColor.coloring = false
-          @out = StringIO.new
-          @formatter = Cucumber::Formatter::Pretty.new(runtime, @out, {})
-          run_defined_feature
-        end
-
-        describe 'when modifying the printed variable after the call to puts' do
-          define_feature <<-FEATURE
-        Feature: Banana party
-
-          Scenario: Monkey eats banana
-            When puts is called twice for the same variable
-          FEATURE
-
-          define_steps do
-            When(/^puts is called twice for the same variable$/) do
-              foo = String.new('a')
-              puts foo
-              foo.upcase!
-              puts foo
-            end
-          end
-
-          it 'prints the variable value at the time puts was called' do
-            expect( @out.string ).to include <<OUTPUT
-    When puts is called twice for the same variable
-      a
-      A
-OUTPUT
-          end
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/rb_support/snippet_spec.rb

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'cucumber/rb_support/snippet'
-
-module Cucumber
-  module RbSupport
-    describe Snippet do
-      let(:code_keyword) { "Given" }
-
-      before do
-        @pattern = 'we have a missing step'
-        @multiline_argument = Core::Ast::EmptyMultilineArgument.new
-      end
-
-      let(:snippet) do
-        snippet_class.new(code_keyword, @pattern, @multiline_argument)
-      end
-
-      def unindented(s)
-        s.split("\n")[1..-2].join("\n").indent(-10)
-      end
-
-      describe Snippet::Regexp do
-        let(:snippet_class) { Snippet::Regexp }
-        let(:snippet_text) { snippet.to_s }
-
-        it "wraps snippet patterns in parentheses" do
-          @pattern = 'A "string" with 4 spaces'
-
-          expect(snippet_text).to eq unindented(%{
-          Given(/^A "([^"]*)" with (\\d+) spaces$/) do |arg1, arg2|
-            pending # Write code here that turns the phrase above into concrete actions
-          end
-          })
-        end
-
-        it "recognises numbers in name and make according regexp" do
-          @pattern = 'Cloud 9 yeah'
-
-          expect(snippet_text).to eq unindented(%{
-          Given(/^Cloud (\\d+) yeah$/) do |arg1|
-            pending # Write code here that turns the phrase above into concrete actions
-          end
-          })
-        end
-
-        it "recognises a mix of ints, strings and why not a table too" do
-          @pattern = 'I have 9 "awesome" cukes in 37 "boxes"'
-          @multiline_argument = Core::Ast::DataTable.new([[]], Core::Ast::Location.new(''))
-
-          expect(snippet_text).to eq unindented(%{
-          Given(/^I have (\\d+) "([^"]*)" cukes in (\\d+) "([^"]*)"$/) do |arg1, arg2, arg3, arg4, table|
-            # table is a Cucumber::MultilineArgument::DataTable
-            pending # Write code here that turns the phrase above into concrete actions
-          end
-          })
-        end
-
-        it "recognises quotes in name and make according regexp" do
-          @pattern = 'A "first" arg'
-
-          expect(snippet_text).to eq unindented(%{
-          Given(/^A "([^"]*)" arg$/) do |arg1|
-            pending # Write code here that turns the phrase above into concrete actions
-          end
-          })
-        end
-
-        it "recognises several quoted words in name and make according regexp and args" do
-          @pattern = 'A "first" and "second" arg'
-
-          expect(snippet_text).to eq unindented(%{
-          Given(/^A "([^"]*)" and "([^"]*)" arg$/) do |arg1, arg2|
-            pending # Write code here that turns the phrase above into concrete actions
-          end
-          })
-        end
-
-        it "does not use quote group when there are no quotes" do
-          @pattern = 'A first arg'
-
-          expect(snippet_text).to eq unindented(%{
-          Given(/^A first arg$/) do
-            pending # Write code here that turns the phrase above into concrete actions
-          end
-          })
-        end
-
-        it "is helpful with tables" do
-          @pattern = 'A "first" arg'
-          @multiline_argument = Core::Ast::DataTable.new([[]], Core::Ast::Location.new(""))
-
-          expect(snippet_text).to eq unindented(%{
-          Given(/^A "([^"]*)" arg$/) do |arg1, table|
-            # table is a Cucumber::MultilineArgument::DataTable
-            pending # Write code here that turns the phrase above into concrete actions
-          end
-          })
-        end
-
-        it "is helpful with doc string" do
-          @pattern = 'A "first" arg'
-          @multiline_argument = MultilineArgument.from("", Core::Ast::Location.new(""))
-
-          expect(snippet_text).to eq unindented(%{
-          Given(/^A "([^"]*)" arg$/) do |arg1, string|
-            pending # Write code here that turns the phrase above into concrete actions
-          end
-          })
-        end
-      end
-
-      describe Snippet::Classic do
-        let(:snippet_class) { Snippet::Classic }
-
-        it "renders snippet as unwrapped regular expression" do
-          expect(snippet.to_s).to eq unindented(%{
-          Given /^we have a missing step$/ do
-            pending # Write code here that turns the phrase above into concrete actions
-          end
-          })
-        end
-      end
-
-      describe Snippet::Percent do
-        let(:snippet_class) { Snippet::Percent }
-
-        it "renders snippet as percent-style regular expression" do
-          expect(snippet.to_s).to eq unindented(%{
-          Given %r{^we have a missing step$} do
-            pending # Write code here that turns the phrase above into concrete actions
-          end
-          })
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/running_test_case_spec.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/running_test_case'
-require 'cucumber/core'
-require 'cucumber/core/gherkin/writer'
-
-module Cucumber
-  describe RunningTestCase do
-    include Core
-    include Core::Gherkin::Writer
-
-    attr_accessor :wrapped_test_case, :core_test_case
-
-    let(:result) { double(:result, to_sym: :status_symbol) }
-
-    before do
-      receiver = double.as_null_object
-      allow(receiver).to receive(:test_case) { |core_test_case|
-        self.core_test_case = core_test_case
-        self.wrapped_test_case = RunningTestCase.new(core_test_case).with_result(result)
-      }
-      compile [gherkin_doc], receiver
-    end
-
-    context "for a regular scenario" do
-      let(:gherkin_doc) do
-        gherkin do
-          feature "feature name" do
-            scenario "scenario name" do
-              step "passing"
-            end
-          end
-        end
-      end
-
-      it "sets the scenario name correctly" do
-        expect(wrapped_test_case.name).to eq "scenario name"
-      end
-
-      it "sets the feature name correctly" do
-        expect(wrapped_test_case.feature.name).to eq "feature name"
-      end
-
-      it "exposes properties of the test_case" do
-        expect(wrapped_test_case.location).to eq core_test_case.location
-        expect(wrapped_test_case.source).to eq core_test_case.source
-        expect(wrapped_test_case.keyword).to eq core_test_case.keyword
-      end
-
-      it "exposes properties of the result" do
-        expect(wrapped_test_case.status).to eq result.to_sym
-      end
-    end
-
-    context "for a failed scenario" do
-      let(:gherkin_doc) do
-        gherkin do
-          feature "feature name" do
-            scenario "scenario name" do
-              step "failed"
-            end
-          end
-        end
-      end
-
-      let(:exception) { StandardError.new }
-
-      before do
-        self.wrapped_test_case = self.wrapped_test_case.with_result(Core::Test::Result::Failed.new(0, exception))
-      end
-
-      it "is failed?" do
-        expect(wrapped_test_case.failed?).to be_truthy
-      end
-
-      it "exposes the exception" do
-        expect(wrapped_test_case.exception).to eq exception
-      end
-    end
-
-    context "for a passing scenario" do
-      let(:gherkin_doc) do
-        gherkin do
-          feature "feature name" do
-            scenario "scenario name" do
-              step "passing"
-            end
-          end
-        end
-      end
-
-      before do
-        self.wrapped_test_case = self.wrapped_test_case.with_result(Core::Test::Result::Passed.new(0))
-      end
-
-      it "is not failed?" do
-        expect(wrapped_test_case.failed?).to be_falsey
-      end
-
-      it "#exception is nil" do
-        expect(wrapped_test_case.exception).to be_nil
-      end
-    end
-
-    context "for a scenario outline" do
-      let(:gherkin_doc) do
-        gherkin do
-          feature "feature name" do
-            scenario_outline "scenario outline name" do
-              step "passing with <arg1> <arg2>"
-
-              examples "examples name" do
-                row "arg1", "arg2"
-                row "a", "b"
-              end
-            end
-          end
-        end
-      end
-
-      it "sets the test case's name correctly" do
-        expect(wrapped_test_case.name).to eq "scenario outline name, examples name (#1)"
-      end
-
-      it "sets the feature name correctly" do
-        expect(wrapped_test_case.feature.name).to eq "feature name"
-      end
-
-      it "exposes properties of the test_case" do
-        expect(wrapped_test_case.location).to eq core_test_case.location
-        expect(wrapped_test_case.source).to eq core_test_case.source
-        expect(wrapped_test_case.keyword).to eq core_test_case.keyword
-      end
-
-      it "exposes the examples table row cell values" do
-        expect(wrapped_test_case.cell_values).to eq ["a", "b"]
-      end
-
-    end
-  end
-end