cucumber 2.0.0.rc.5 → 4.0.0.rc.3

data/spec/cucumber/rb_support/rb_transform_spec.rb

@@ -1,46 +0,0 @@
-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/regexp_argument_matcher_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-require 'cucumber/rb_support/regexp_argument_matcher'
-
-module Cucumber
-  module RbSupport
-    describe RegexpArgumentMatcher do
-      include RSpec::WorkInProgress
-
-      it "creates 2 arguments" do
-        arguments = RegexpArgumentMatcher.arguments_from(/I (\w+) (\w+)/, "I like fish")
-
-        expect(arguments.map{|argument| [argument.val, argument.offset]}).to eq [["like", 2], ["fish", 7]]
-      end
-
-      it "creates 2 arguments when first group is optional" do
-        arguments = RegexpArgumentMatcher.arguments_from(/should( not)? be flashed '([^']*?)'$/, "I should be flashed 'Login failed.'")
-
-        expect(arguments.map{|argument| [argument.val, argument.offset]}).to eq [[nil, nil], ["Login failed.", 21]]
-      end
-    end
-  end
-end

data/spec/cucumber/rb_support/snippet_spec.rb

@@ -1,137 +0,0 @@
-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::Core::Ast::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::Core::Ast::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,83 +0,0 @@
-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
-
-    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)
-      }
-      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
-    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

data/spec/cucumber/runtime/for_programming_languages_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-module Cucumber
-  describe Runtime::ForProgrammingLanguages do
-
-    let(:user_interface)  { double('user interface') }
-    subject               { Runtime::SupportCode.new(user_interface,{}) }
-    let(:runtime_facade)  { Runtime::ForProgrammingLanguages.new(subject, user_interface) }
-
-    describe "#doc_string" do
-
-      it 'defaults to a blank content-type' do
-        str = runtime_facade.doc_string('DOC')
-        expect(str).to be_kind_of(MultilineArgument::DocString)
-        expect(str.content_type).to eq('')
-      end
-
-      it 'can have a content type' do
-        str = runtime_facade.doc_string('DOC','ruby')
-        expect(str.content_type).to eq('ruby')
-      end
-
-    end
-
-    describe "#table" do
-
-      it 'produces Ast::Table by #table' do
-        expect(runtime_facade.table(%{
-      | account | description | amount |
-      | INT-100 | Taxi        | 114    |
-      | CUC-101 | Peeler      | 22     |
-        })).to be_kind_of(MultilineArgument::DataTable)
-      end
-    end
-  end
-end

data/spec/cucumber/runtime/support_code_spec.rb

@@ -1,123 +0,0 @@
-require 'spec_helper'
-
-module Cucumber
-  describe Runtime::SupportCode do
-    let(:user_interface) { double('user interface') }
-    subject { Runtime::SupportCode.new(user_interface, options) }
-    let(:options) { {} }
-    let(:dsl) do
-      @rb = subject.load_programming_language('rb')
-      Object.new.extend(RbSupport::RbDsl)
-    end
-
-    it "formats step names" do
-      dsl.Given(/it (.*) in (.*)/) { |what, month| }
-      dsl.Given(/nope something else/) { |what, month| }
-
-      format = subject.step_match("it snows in april").format_args("[%s]")
-
-      expect(format).to eq "it [snows] in [april]"
-    end
-
-    it "caches step match results" do
-      dsl.Given(/it (.*) in (.*)/) { |what, month| }
-
-      step_match = subject.step_match("it snows in april")
-
-      expect(@rb).not_to receive(:step_matches)
-      second_step_match = subject.step_match("it snows in april")
-
-      expect(step_match).to equal(second_step_match)
-    end
-
-    describe "resolving step defintion matches" do
-
-      it "raises Ambiguous error with guess hint when multiple step definitions match" do
-        expected_error = %{Ambiguous match of "Three blind mice":
-
-spec/cucumber/runtime/support_code_spec.rb:\\d+:in `/Three (.*) mice/'
-spec/cucumber/runtime/support_code_spec.rb:\\d+:in `/Three blind (.*)/'
-
-You can run again with --guess to make Cucumber be more smart about it
-}
-        dsl.Given(/Three (.*) mice/) {|disability|}
-        dsl.Given(/Three blind (.*)/) {|animal|}
-
-        expect(-> {
-          subject.step_match("Three blind mice")
-        }).to raise_error(Ambiguous, /#{expected_error}/)
-      end
-
-      describe "when --guess is used" do
-        let(:options) { {:guess => true} }
-
-        it "does not show --guess hint" do
-        expected_error = %{Ambiguous match of "Three cute mice":
-
-spec/cucumber/runtime/support_code_spec.rb:\\d+:in `/Three (.*) mice/'
-spec/cucumber/runtime/support_code_spec.rb:\\d+:in `/Three cute (.*)/'
-
-}
-          dsl.Given(/Three (.*) mice/) {|disability|}
-          dsl.Given(/Three cute (.*)/) {|animal|}
-
-          expect(-> {
-            subject.step_match("Three cute mice")
-          }).to raise_error(Ambiguous, /#{expected_error}/)
-        end
-
-        it "does not raise Ambiguous error when multiple step definitions match" do
-          dsl.Given(/Three (.*) mice/) {|disability|}
-          dsl.Given(/Three (.*)/) {|animal|}
-
-          expect(-> {
-            subject.step_match("Three blind mice")
-          }).not_to raise_error
-        end
-
-        it "does not raise NoMethodError when guessing from multiple step definitions with nil fields" do
-          dsl.Given(/Three (.*) mice( cannot find food)?/) {|disability, is_disastrous|}
-          dsl.Given(/Three (.*)?/) {|animal|}
-
-          expect(-> {
-            subject.step_match("Three blind mice")
-          }).not_to raise_error
-        end
-
-        it "picks right step definition when an equal number of capture groups" do
-          right = dsl.Given(/Three (.*) mice/) {|disability|}
-          wrong = dsl.Given(/Three (.*)/) {|animal|}
-
-          expect(subject.step_match("Three blind mice").step_definition).to eq right
-        end
-
-        it "picks right step definition when an unequal number of capture groups" do
-          right = dsl.Given(/Three (.*) mice ran (.*)/) {|disability|}
-          wrong = dsl.Given(/Three (.*)/) {|animal|}
-
-          expect(subject.step_match("Three blind mice ran far").step_definition).to eq right
-        end
-
-        it "picks most specific step definition when an unequal number of capture groups" do
-          general       = dsl.Given(/Three (.*) mice ran (.*)/) {|disability|}
-          specific      = dsl.Given(/Three blind mice ran far/) do; end
-          more_specific = dsl.Given(/^Three blind mice ran far$/) do; end
-
-          expect(subject.step_match("Three blind mice ran far").step_definition).to eq more_specific
-        end
-      end
-
-      it "raises Undefined error when no step definitions match" do
-        expect(-> {
-          subject.step_match("Three blind mice")
-        }).to raise_error(Undefined)
-      end
-
-      # http://railsforum.com/viewtopic.php?pid=93881
-      it "does not raise Redundant unless it's really redundant" do
-        dsl.Given(/^(.*) (.*) user named '(.*)'$/) {|a,b,c|}
-        dsl.Given(/^there is no (.*) user named '(.*)'$/) {|a,b|}
-      end
-    end
-  end
-end