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

data/spec/cucumber/project_initializer_spec.rb

@@ -1,87 +0,0 @@
-require 'spec_helper'
-require 'tmpdir'
-
-module Cucumber
-  describe ProjectInitializer, :isolated_home => true do
-    let(:command_line_config) { ProjectInitializer.new }
-
-    before do
-      allow(command_line_config).to receive(:puts)
-    end
-
-    context "no files created" do
-      around(:example) do |example|
-
-        dir = Dir.mktmpdir
-        original_dir = Dir.pwd
-        begin
-          FileUtils.cd dir
-          example.call
-        ensure
-          FileUtils.cd original_dir
-          FileUtils.rm_rf dir
-        end
-      end
-
-      it "should create features directory" do
-        expect(command_line_config).to receive(:puts).with %r(^\s+create\s+features$)
-        command_line_config.run
-      end
-
-      it "should create step_definitions directory" do
-        expect(command_line_config).to receive(:puts).with %r(^\s+create\s+features/step_definitions$)
-        command_line_config.run
-      end
-
-      it "should create support directory" do
-        expect(command_line_config).to receive(:puts).with %r(^\s+create\s+features/support$)
-        command_line_config.run
-      end
-
-      it "should create env.rb directory" do
-        expect(command_line_config).to receive(:puts).with %r(^\s+create\s+features/support/env.rb$)
-        command_line_config.run
-      end
-
-    end
-
-    context "files created" do
-      around(:example) do |example|
-        dir = Dir.mktmpdir
-        FileUtils.mkdir_p "#{dir}/features"
-        FileUtils.mkdir_p "#{dir}/features/step_definitions"
-        FileUtils.mkdir_p "#{dir}/features/support"
-        FileUtils.touch "#{dir}/features/support/env.rb"
-        original_dir = Dir.pwd
-        begin
-          FileUtils.cd dir
-          example.call
-        ensure
-          FileUtils.cd original_dir
-          FileUtils.rm_rf dir
-        end
-      end
-
-      it "should not create features directory" do
-        expect(command_line_config).to receive(:puts).with %r(^\s+exist\s+features$)
-        command_line_config.run
-      end
-
-      it "should not create step_definitions directory" do
-        expect(command_line_config).to receive(:puts).with %r(^\s+exist\s+features/step_definitions$)
-        command_line_config.run
-      end
-
-      it "should not create support directory" do
-        expect(command_line_config).to receive(:puts).with %r(^\s+exist\s+features/support$)
-        command_line_config.run
-      end
-
-      it "should not create env.rb directory" do
-        expect(command_line_config).to receive(:puts).with %r(^\s+exist\s+features/support/env.rb$)
-        command_line_config.run
-      end
-
-    end
-  end
-end

data/spec/cucumber/rake/forked_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-require 'cucumber/rake/task'
-require 'rake'
-
-module Cucumber
-  module Rake
-    describe Task::ForkedCucumberRunner do
-      let(:libs) { ['lib'] }
-      let(:binary) { Cucumber::BINARY }
-      let(:cucumber_opts) { ['--cuke-option'] }
-      let(:feature_files) { ['./some.feature'] }
-
-      context "when running with bundler" do
-        let(:bundler) { true }
-
-        subject { Task::ForkedCucumberRunner.new(
-            libs, binary, cucumber_opts, bundler, feature_files) }
-
-        it "does use bundler if bundler is set to true" do
-          expect(subject.use_bundler).to be true
-        end
-
-        it "uses bundle exec to find cucumber and libraries" do
-          expect(subject.cmd).to eq [Cucumber::RUBY_BINARY,
-            '-S',
-            'bundle',
-            'exec',
-            'cucumber',
-            '--cuke-option'] + feature_files
-        end
-      end
-
-      context "when running without bundler" do
-        let(:bundler) { false }
-
-        subject { Task::ForkedCucumberRunner.new(
-            libs, binary, cucumber_opts, bundler, feature_files) }
-
-        it "does not use bundler if bundler is set to false" do
-          expect(subject.use_bundler).to be false
-        end
-
-        it "uses well known cucumber location and specified libraries" do
-          expect(subject.cmd).to eq [Cucumber::RUBY_BINARY,
-            "-I",
-            "\"lib\"",
-            "\"#{Cucumber::BINARY }\"",
-            "--cuke-option"] + feature_files
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/rb_support/rb_language_spec.rb

@@ -1,279 +0,0 @@
-require 'spec_helper'
-require 'cucumber/rb_support/rb_language'
-
-module Cucumber
-  module RbSupport
-    describe RbStepDefinition do
-      let(:user_interface) { double('user interface') }
-      let(:rb)             { support_code.load_programming_language('rb')}
-      let(:support_code) do
-        Cucumber::Runtime::SupportCode.new(user_interface, {})
-      end
-      let(:dsl) do
-        rb
-        Object.new.extend(RbSupport::RbDsl)
-      end
-
-      describe "snippets" do
-        let(:snippet) { double.as_null_object }
-
-        it "creates a regexp Snippet class by default" do
-          expect(Snippet::Regexp).to receive(:new) { snippet }
-
-          rb.snippet_text('Given', 'A "string" with 4 spaces', nil)
-        end
-
-        it "creates a regexp Snippet class explicitly" do
-          expect(Snippet::Regexp).to receive(:new) { snippet }
-
-          rb.snippet_text('Given', 'A "string" with 4 spaces', nil, :regexp)
-        end
-
-        it "creates a classic Snippet class" do
-          expect(Snippet::Classic).to receive(:new) { snippet }
-
-          rb.snippet_text('Given', 'A "string" with 4 spaces', nil, :classic)
-        end
-
-        it "creates a percent Snippet class" do
-          expect(Snippet::Percent).to receive(:new) { snippet }
-
-          rb.snippet_text('Given', 'A "string" with 4 spaces', nil, :percent)
-        end
-
-        it "passes all parameters to Snippet contructor" do
-          code_keyword, pattern, multiline_argument_class = double, double, double
-
-          expect(Snippet::Regexp).to receive(:new).with(code_keyword, pattern, multiline_argument_class)
-
-          rb.snippet_text(code_keyword, pattern, multiline_argument_class)
-        end
-
-        it "renders the snippet" do
-          allow(Snippet::Regexp).to receive(:new) { snippet }
-          expect(snippet).to receive(:to_s)
-
-          rb.snippet_text('Given', 'A "string" with 4 spaces', nil)
-        end
-      end
-
-      describe "#load_code_file" do
-        after do
-          FileUtils.rm_rf('tmp.rb')
-        end
-
-        def a_file_called(name)
-          File.open('tmp.rb', 'w') do |f|
-            f.puts yield
-          end
-        end
-
-        it "re-loads the file when called multiple times" do
-          a_file_called('tmp.rb') do
-            "$foo = 1"
-          end
-
-          rb.load_code_file('tmp.rb')
-          expect($foo).to eq 1
-
-          a_file_called('tmp.rb') do
-            "$foo = 2"
-          end
-
-          rb.load_code_file('tmp.rb')
-
-          expect($foo).to eq 2
-        end
-      end
-
-      describe "Handling the World" do
-        it "raises an error if the world is nil" do
-          dsl.World {}
-
-          begin
-            rb.begin_scenario(nil)
-            raise "Should fail"
-          rescue RbSupport::NilWorld => e
-            expect(e.message).to eq "World procs should never return nil"
-            expect(e.backtrace.length).to eq 1
-            expect(e.backtrace[0]).to match(/spec\/cucumber\/rb_support\/rb_language_spec\.rb\:\d+\:in `World'/)
-          end
-        end
-
-        module ModuleOne
-        end
-
-        module ModuleTwo
-        end
-
-        class ClassOne
-        end
-
-        it "implicitlys extend world with modules" do
-          dsl.World(ModuleOne, ModuleTwo)
-          rb.begin_scenario(double('scenario').as_null_object)
-          class << rb.current_world
-            extend RSpec::Matchers
-
-            expect(included_modules.inspect).to match(/ModuleOne/) # Workaround for RSpec/Ruby 1.9 issue with namespaces
-            expect(included_modules.inspect).to match(/ModuleTwo/)
-          end
-          expect(rb.current_world.class).to eq Object
-        end
-
-        it "raises error when we try to register more than one World proc" do
-          expected_error = %{You can only pass a proc to #World once, but it's happening
-in 2 places:
-
-spec/cucumber/rb_support/rb_language_spec.rb:\\d+:in `World'
-spec/cucumber/rb_support/rb_language_spec.rb:\\d+:in `World'
-
-Use Ruby modules instead to extend your worlds. See the Cucumber::RbSupport::RbDsl#World RDoc
-or http://wiki.github.com/cucumber/cucumber/a-whole-new-world.
-
-}
-          dsl.World { Hash.new }
-
-          expect(-> {
-            dsl.World { Array.new }
-          }).to raise_error(RbSupport::MultipleWorld, /#{expected_error}/)
-        end
-      end
-
-      describe "step argument transformations" do
-        describe "without capture groups" do
-          it "complains when registering with a with no transform block" do
-            expect(-> {
-              dsl.Transform('^abc$')
-            }).to raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
-          end
-
-          it "complains when registering with a zero-arg transform block" do
-            expect(-> {
-              dsl.Transform('^abc$') {42}
-            }).to raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
-          end
-
-          it "complains when registering with a splat-arg transform block" do
-            expect(-> {
-              dsl.Transform('^abc$') {|*splat| 42 }
-            }).to raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
-          end
-
-          it "complains when transforming with an arity mismatch" do
-            expect(-> {
-              dsl.Transform('^abc$') {|one, two| 42 }
-              rb.execute_transforms(['abc'])
-            }).to raise_error(Cucumber::ArityMismatchError)
-          end
-
-          it "allows registering a regexp pattern that yields the step_arg matched" do
-            dsl.Transform(/^ab*c$/) {|arg| 42}
-
-            expect(rb.execute_transforms(['ab'])).to eq ['ab']
-            expect(rb.execute_transforms(['ac'])).to eq [42]
-            expect(rb.execute_transforms(['abc'])).to eq [42]
-            expect(rb.execute_transforms(['abbc'])).to eq [42]
-          end
-
-          it "transforms times" do
-            require 'time'
-            dsl.Transform(/^(\d\d-\d\d-\d\d\d\d)$/) do |arg|
-              Time.parse(arg)
-            end
-            expect(rb.execute_transforms(['10-0E-1971'])).to eq ['10-0E-1971']
-            expect(rb.execute_transforms(['10-03-1971'])).to eq [Time.parse('10-03-1971')]
-          end
-        end
-
-        describe "with capture groups" do
-          it "complains when registering with a with no transform block" do
-            expect(-> {
-              dsl.Transform('^a(.)c$')
-            }).to raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
-          end
-
-          it "complains when registering with a zero-arg transform block" do
-            expect(-> {
-              dsl.Transform('^a(.)c$') { 42 }
-            }).to raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
-          end
-
-          it "complains when registering with a splat-arg transform block" do
-            expect(-> {
-              dsl.Transform('^a(.)c$') {|*splat| 42 }
-            }).to raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
-          end
-
-          it "complains when transforming with an arity mismatch" do
-            expect(-> {
-              dsl.Transform('^a(.)c$') {|one, two| 42 }
-              rb.execute_transforms(['abc'])
-            }).to raise_error(Cucumber::ArityMismatchError)
-          end
-
-          it "allows registering a regexp pattern that yields capture groups" do
-            dsl.Transform(/^shape: (.+), color: (.+)$/) do |shape, color|
-              {shape.to_sym => color.to_sym}
-            end
-
-            expect(rb.execute_transforms(['shape: circle, color: blue'])).to eq [{:circle => :blue}]
-            expect(rb.execute_transforms(['shape: square, color: red'])).to eq [{:square => :red}]
-            expect(rb.execute_transforms(['not shape: square, not color: red'])).to eq ['not shape: square, not color: red']
-          end
-        end
-
-        it "allows registering a string pattern" do
-          dsl.Transform('^ab*c$') {|arg| 42}
-
-          expect(rb.execute_transforms(['ab'])).to eq ['ab']
-          expect(rb.execute_transforms(['ac'])).to eq [42]
-          expect(rb.execute_transforms(['abc'])).to eq [42]
-          expect(rb.execute_transforms(['abbc'])).to eq [42]
-        end
-
-        it "gives match priority to transforms defined last" do
-          dsl.Transform(/^transform_me$/) {|arg| :foo }
-          dsl.Transform(/^transform_me$/) {|arg| :bar }
-          dsl.Transform(/^transform_me$/) {|arg| :baz }
-
-          expect(rb.execute_transforms(['transform_me'])).to eq [:baz]
-        end
-
-        it "allows registering a transform which returns nil" do
-          dsl.Transform('^ac$') {|arg| nil}
-
-          expect(rb.execute_transforms(['ab'])).to eq ['ab']
-          expect(rb.execute_transforms(['ac'])).to eq [nil]
-        end
-      end
-
-      describe "hooks" do
-        it "finds before hooks" do
-          fish = dsl.Before('@fish'){}
-          meat = dsl.Before('@meat'){}
-
-          scenario = double('Scenario')
-
-          expect(scenario).to receive(:accept_hook?).with(fish) { true }
-          expect(scenario).to receive(:accept_hook?).with(meat) { false }
-          expect(rb.hooks_for(:before, scenario)).to eq [fish]
-        end
-
-        it "finds around hooks" do
-          a = dsl.Around do |scenario, block|
-          end
-
-          b = dsl.Around('@tag') do |scenario, block|
-          end
-
-          scenario = double('Scenario')
-
-          expect(scenario).to receive(:accept_hook?).with(a) { true }
-          expect(scenario).to receive(:accept_hook?).with(b) { false }
-          expect(rb.hooks_for(:around, scenario)).to eq [a]
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/rb_support/rb_step_definition_spec.rb

@@ -1,170 +0,0 @@
-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.load_programming_language('rb') }
-      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)
-        support_code.step_match(text)
-      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 "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