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

data/spec/cucumber/project_initializer_spec.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-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,54 +0,0 @@
-# frozen_string_literal: true
-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/rake/task_spec.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'cucumber/rake/task'
-require 'rake'
-
-module Cucumber
-  module Rake
-    describe Task do
-
-      describe "#cucumber_opts" do
-        before { subject.cucumber_opts = opts }
-
-        context "when set via array" do
-          let(:opts) { %w[ foo bar ] }
-          it { expect(subject.cucumber_opts).to be opts }
-        end
-
-        context "when set via space-delimited string" do
-          let(:opts) { "foo bar" }
-          it { expect(subject.cucumber_opts).to eq %w[ foo bar ] }
-        end
-      end
-
-      describe "#cucumber_opts_with_profile" do
-        before do
-          subject.cucumber_opts = opts
-          subject.profile = profile
-        end
-
-        context "with cucumber_opts" do
-          let(:opts) { %w[ foo bar ] }
-
-          context "without profile" do
-            let(:profile) { nil }
-
-            it "should return just cucumber_opts" do
-              expect(subject.cucumber_opts_with_profile).to be opts
-            end
-          end
-
-          context "with profile" do
-            let(:profile) { "fancy" }
-
-            it "should combine opts and profile into an array, prepending --profile option" do
-              expect(subject.cucumber_opts_with_profile).to eq %w[ foo bar --profile fancy ]
-            end
-          end
-
-          context "with multiple profiles" do
-            let(:profile) { %w[ fancy pants ] }
-
-            it "should combine opts and each profile into an array, prepending --profile option" do
-              expect(subject.cucumber_opts_with_profile).to eq %w[ foo bar --profile fancy --profile pants ]
-            end
-          end
-        end
-
-        context "without cucumber_opts" do
-          let(:opts) { nil }
-
-          context "without profile" do
-            let(:profile) { nil }
-
-            it { expect(subject.cucumber_opts_with_profile).to eq [] }
-          end
-
-          context "with profile" do
-            let(:profile) { "fancy" }
-
-            it "should combine opts and profile into an array, prepending --profile option" do
-              expect(subject.cucumber_opts_with_profile).to eq %w[ --profile fancy ]
-            end
-          end
-
-          context "with multiple profiles" do
-            let(:profile) { %w[ fancy pants ] }
-
-            it "should combine opts and each profile into an array, prepending --profile option" do
-              expect(subject.cucumber_opts_with_profile).to eq %w[ --profile fancy --profile pants ]
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/rb_support/rb_language_spec.rb

@@ -1,321 +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(:rb)             { support_code.ruby }
-      let(:support_code) do
-        Cucumber::Runtime::SupportCode.new(user_interface)
-      end
-      let(:dsl) do
-        rb
-        Object.new.extend(RbSupport::RbDsl)
-      end
-
-      describe "#load_code_file" do
-        after do
-          FileUtils.rm_rf('tmp.rb')
-          FileUtils.rm_rf('docs.md')
-        end
-
-        def a_file_called(name)
-          File.open(name, '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
-
-        it "only loads ruby files" do
-          a_file_called("docs.md") do
-            "yo"
-          end
-          rb.load_code_file('docs.md')
-        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 'Handling namespaced World' do
-        module ModuleOne
-          def method_one
-            1
-          end
-        end
-
-        module ModuleMinusOne
-          def method_one
-            -1
-          end
-        end
-
-        module ModuleTwo
-          def method_two
-            2
-          end
-        end
-
-        module ModuleThree
-          def method_three
-            3
-          end
-        end
-
-        it 'extends the world with namespaces' do
-          dsl.World(ModuleOne, module_two: ModuleTwo, module_three: ModuleThree)
-          rb.begin_scenario(double('scenario').as_null_object)
-          class << rb.current_world
-            extend RSpec::Matchers
-            expect(included_modules.inspect).to match(/ModuleOne/)
-          end
-          expect(rb.current_world.class).to eq Object
-          expect(rb.current_world).to respond_to(:method_one)
-
-          expect(rb.current_world.module_two.class).to eq Object
-          expect(rb.current_world.module_two).to respond_to(:method_two)
-
-          expect(rb.current_world.module_three.class).to eq Object
-          expect(rb.current_world.module_three).to respond_to(:method_three)
-        end
-
-        it 'allows to inspect the included modules' do
-          dsl.World(ModuleOne, module_two: ModuleTwo, module_three: ModuleThree)
-          rb.begin_scenario(double('scenario').as_null_object)
-          class << rb.current_world
-            extend RSpec::Matchers
-          end
-          expect(rb.current_world.inspect).to match(/ModuleOne/)
-          expect(rb.current_world.inspect).to include('ModuleTwo (as module_two)')
-          expect(rb.current_world.inspect).to include('ModuleThree (as module_three)')
-        end
-
-        it 'merges methods when assigning different modules to the same namespace' do
-          dsl.World(namespace: ModuleOne)
-          dsl.World(namespace: ModuleTwo)
-          rb.begin_scenario(double('scenario').as_null_object)
-          class << rb.current_world
-            extend RSpec::Matchers
-          end
-          expect(rb.current_world.namespace).to respond_to(:method_one)
-          expect(rb.current_world.namespace).to respond_to(:method_two)
-        end
-
-        it 'resolves conflicts when assigning different modules to the same namespace' do
-          dsl.World(namespace: ModuleOne)
-          dsl.World(namespace: ModuleMinusOne)
-          rb.begin_scenario(double('scenario').as_null_object)
-          class << rb.current_world
-            extend RSpec::Matchers
-          end
-          expect(rb.current_world.namespace).to respond_to(:method_one)
-          expect(rb.current_world.namespace.method_one).to eql(-1)
-        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