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

data/spec/cucumber/cli/profile_loader_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'yaml'
-
-module Cucumber
-  module Cli
-    describe ProfileLoader do
-      def given_cucumber_yml_defined_as(hash_or_string)
-        allow(Dir).to receive(:glob).with('{,.config/,config/}cucumber{.yml,.yaml}') { ['cucumber.yml'] }
-        allow(File).to receive(:exist?) { true }
-
-        cucumber_yml = hash_or_string.is_a?(Hash) ? hash_or_string.to_yaml : hash_or_string
-
-        allow(IO).to receive(:read).with('cucumber.yml') { cucumber_yml }
-      end
-
-      def loader
-        ProfileLoader.new
-      end
-
-      it "treats backslashes as literals in rerun.txt when on Windows (JRuby or MRI)" do
-        given_cucumber_yml_defined_as({'default' => '--format "pretty" features\sync_imap_mailbox.feature:16:22'})
-        if(Cucumber::WINDOWS)
-          expect(loader.args_from('default')).to eq ['--format','pretty','features\sync_imap_mailbox.feature:16:22']
-        else
-          expect(loader.args_from('default')).to eq ['--format','pretty','featuressync_imap_mailbox.feature:16:22']
-        end
-      end
-
-      it "treats forward slashes as literals" do
-        given_cucumber_yml_defined_as({'default' => '--format "ugly" features/sync_imap_mailbox.feature:16:22'})
-
-        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/cli/rerun_spec.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-module Cucumber
-  module Cli
-    describe RerunFile do
-
-      let(:rerun_file) { RerunFile.new('@rerun.txt') }
-
-      it "expects rerun files to have a leading @" do
-        allow(File).to receive(:file?) { true }
-        expect(RerunFile.can_read?('rerun.txt')).to eq false
-        expect(RerunFile.can_read?('@rerun.txt')).to eq true
-      end
-
-      it "does not treat directories as rerun files" do
-        allow(File).to receive(:file?) { false }
-        expect(RerunFile.can_read?('@rerun.txt')).to eq false
-      end
-
-      it "removes leading @ character from filename" do
-        expect(rerun_file.path).to eq 'rerun.txt'
-      end
-
-      context "rerun file containing single feature" do
-        before(:each) do
-          allow(IO).to receive(:read).and_return("cucumber.feature")
-        end
-
-        it "produces an array containing a single feature file path" do
-          expect(rerun_file.features).to eq %w(cucumber.feature)
-        end
-      end
-
-      context "contains multiple features on multiple lines" do
-        before(:each) do
-          allow(IO).to receive(:read).and_return("cucumber.feature\nfoo.feature")
-        end
-
-        it "produces an array containing multiple feature file paths" do
-          expect(rerun_file.features).to eq %w(cucumber.feature foo.feature)
-        end
-      end
-
-      context "contains multiple features on same line" do
-        before(:each) do
-          allow(IO).to receive(:read).and_return("cucumber.feature foo.feature")
-        end
-
-        it "produces an array containing multiple feature file paths" do
-          expect(rerun_file.features).to eq %w(cucumber.feature foo.feature)
-        end
-      end
-
-      context "contains multiple scenarios on same line" do
-        before(:each) do
-          allow(IO).to receive(:read).and_return("cucumber.feature:8 foo.feature:8:16")
-        end
-
-        it "produces an array containing multiple feature file paths with scenario lines" do
-          expect(rerun_file.features).to eq %w(cucumber.feature:8 foo.feature:8:16)
-        end
-      end
-
-      context "contains features with spaces in file names" do
-        before(:each) do
-          allow(IO).to receive(:read).and_return("cucumber test.feature:8 foo.feature:8:16")
-        end
-
-        it "produces an array containing multiple feature file paths with scenario lines" do
-          expect(rerun_file.features).to eq ['cucumber test.feature:8', 'foo.feature:8:16']
-        end
-      end
-
-      context "contains multiple scenarios without spaces between them" do
-        before(:each) do
-          allow(IO).to receive(:read).and_return("cucumber test.feature:8foo.feature:8:16")
-        end
-
-        it "produces an array containing multiple feature file paths with scenario lines" do
-          expect(rerun_file.features).to eq ['cucumber test.feature:8', 'foo.feature:8:16']
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/configuration_spec.rb

@@ -1,148 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-module Cucumber
-  describe Configuration do
-    describe ".default" do
-      subject { Configuration.default }
-
-      it "has an autoload_code_paths containing the standard support and step_definitions folders" do
-        expect(subject.autoload_code_paths).to include('features/support')
-        expect(subject.autoload_code_paths).to include('features/step_definitions')
-      end
-    end
-
-    describe "with custom user options" do
-      let(:user_options) { { :autoload_code_paths => ['foo/bar/baz'] } }
-      subject { Configuration.new(user_options) }
-
-      it "allows you to override the defaults" do
-        expect(subject.autoload_code_paths).to eq ['foo/bar/baz']
-      end
-    end
-
-    context "selecting files to load" do
-
-      def given_the_following_files(*files)
-        allow(File).to receive(:directory?) { true }
-        allow(File).to receive(:file?) { true }
-        allow(Dir).to receive(:[]) { files }
-      end
-
-      it "requires env.rb files first" do
-        configuration = Configuration.new
-        given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
-
-        expect(configuration.support_to_load).to eq [
-          "/features/support/env.rb",
-          "/features/support/a_file.rb"
-        ]
-      end
-
-      it "does not require env.rb files when dry run" do
-        configuration = Configuration.new(dry_run: true)
-        given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
-
-        expect(configuration.support_to_load).to eq [
-          "/features/support/a_file.rb"
-        ]
-      end
-
-      it "requires step defs in vendor/{plugins,gems}/*/cucumber/*.rb" do
-        given_the_following_files("/vendor/gems/gem_a/cucumber/bar.rb",
-                                  "/vendor/plugins/plugin_a/cucumber/foo.rb")
-
-        configuration = Configuration.new
-
-        expect(configuration.step_defs_to_load).to eq [
-          "/vendor/gems/gem_a/cucumber/bar.rb",
-          "/vendor/plugins/plugin_a/cucumber/foo.rb"
-        ]
-      end
-
-      describe "--exclude" do
-
-        it "excludes a ruby file from requiring when the name matches exactly" do
-          given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
-
-          configuration = Configuration.new(excludes: [/a_file.rb/])
-
-          expect(configuration.all_files_to_load).to eq [
-            "/features/support/env.rb"
-          ]
-        end
-
-        it "excludes all ruby files that match the provided patterns from requiring" do
-          given_the_following_files("/features/support/foof.rb","/features/support/bar.rb",
-                                    "/features/support/food.rb","/features/blah.rb",
-                                    "/features/support/fooz.rb")
-
-          configuration = Configuration.new(excludes: [/foo[df]/, /blah/])
-
-          expect(configuration.all_files_to_load).to eq [
-            "/features/support/bar.rb",
-            "/features/support/fooz.rb"
-          ]
-        end
-      end
-
-    end
-
-    context "selecting feature files" do
-
-      it "preserves the order of the feature files" do
-        configuration = Configuration.new(paths: %w{b.feature c.feature a.feature})
-
-        expect(configuration.feature_files).to eq ["b.feature", "c.feature", "a.feature"]
-      end
-
-      it "searchs for all features in the specified directory" do
-        allow(File).to receive(:directory?) { true }
-        allow(Dir).to receive(:[]).with("feature_directory/**/*.feature") { ["cucumber.feature"] }
-
-        configuration = Configuration.new(paths: %w{feature_directory/})
-
-        expect(configuration.feature_files).to eq ["cucumber.feature"]
-      end
-
-      it "defaults to the features directory when no feature file are provided" do
-        allow(File).to receive(:directory?) { true }
-        allow(Dir).to receive(:[]).with("features/**/*.feature") { ["cucumber.feature"] }
-
-        configuration = Configuration.new(paths: [])
-
-        expect(configuration.feature_files).to eq ["cucumber.feature"]
-      end
-
-      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\ncucumber.feature:5 cucumber.feature:10\n"\
-          "domain folder/different cuke.feature:134 domain folder/cuke.feature:1\n"\
-          "domain folder/different cuke.feature:4:5 bar.feature")
-
-        configuration = Configuration.new(paths: %w{@rerun.txt})
-
-        expect(configuration.feature_files).to eq [
-          "cucumber.feature:1:3",
-          "cucumber.feature:5",
-          "cucumber.feature:10",
-          "domain folder/different cuke.feature:134",
-          "domain folder/cuke.feature:1",
-          "domain folder/different cuke.feature:4:5",
-          "bar.feature"]
-      end
-    end
-
-    describe "#with_options" do
-      it "returns a copy of the configuration with new options" do
-        old_out_stream = double('Old out_stream')
-        new_out_stream = double('New out_stream')
-        config = Configuration.new(out_stream: old_out_stream).with_options(out_stream: new_out_stream)
-        expect(config.out_stream).to eq new_out_stream
-      end
-    end
-
-  end
-end

data/spec/cucumber/constantize_spec.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-module Html end
-
-module Cucumber
-  describe Constantize do
-    include Constantize
-
-    it "loads html formatter" do
-      clazz = constantize('Cucumber::Formatter::Html')
-
-      expect(clazz.name).to eq 'Cucumber::Formatter::Html'
-    end
-
-    it "fails to load a made up class" do
-      expect { constantize('My::MadeUp::ClassName') }.to raise_error(LoadError)
-    end
-  end
-end

data/spec/cucumber/core_ext/instance_exec_spec.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core_ext/instance_exec'
-
-describe 'cucumber_instance_exec' do
-end

data/spec/cucumber/file_specs_spec.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/file_specs'
-
-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
-      expect(locations).to eq [
-        Cucumber::Core::Ast::Location.new("features/foo.feature", 1),
-        Cucumber::Core::Ast::Location.new("features/foo.feature", 2),
-        Cucumber::Core::Ast::Location.new("features/foo.feature", 3),
-        Cucumber::Core::Ast::Location.new("features/bar.feature", 4),
-        Cucumber::Core::Ast::Location.new("features/bar.feature", 5),
-        Cucumber::Core::Ast::Location.new("features/bar.feature", 6),
-      ]
-    end
-
-    it "parses file names from multiple file specs" do
-      expect(files.length).to eq 2
-      expect(files).to eq [
-        "features/foo.feature",
-        "features/bar.feature",
-      ]
-    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"]) }
-
-      it "returns a wildcard location for that file" do
-        expect(locations).to eq [
-          Cucumber::Core::Ast::Location.new("features/foo.feature"),
-          Cucumber::Core::Ast::Location.new("features/bar.feature", 34),
-        ]
-      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

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-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_match) { double(activate: activated_test_step) }
-  let(:activated_test_step) { double }
-  let(:receiver) { double.as_null_object }
-  let(:filter) { Cucumber::Filters::ActivateSteps.new(step_match_search, configuration) }
-  let(:step_match_search) { Proc.new { [step_match] } }
-  let(:configuration) { double(dry_run?: false, notify: nil) }
-
-  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, [filter]
-    end
-
-    it "notifies with a StepMatch event" do
-      expect(configuration).to receive(:notify) do |message, test_step, step_match|
-        expect(message).to eq :step_match
-        expect(test_step.name).to eq 'a passing step'
-        expect(step_match).to eq step_match
-      end
-      compile [doc], receiver, [filter]
-    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, [filter]
-    end
-  end
-
-  context "undefined step" do
-    let(:step_match_search) { Proc.new { [] } }
-
-    let(:doc) do
-      gherkin do
-        feature do
-          scenario do
-            step 'an undefined step'
-          end
-        end
-      end
-    end
-
-    it "does not activate the step" do
-      expect(receiver).to receive(:test_case) do |test_case|
-        expect(test_case.test_steps[0].execute).to be_undefined
-      end
-      compile [doc], receiver, [filter]
-    end
-
-    it "does not notify" do
-      expect(configuration).not_to receive(:notify)
-      compile [doc], receiver, [filter]
-    end
-  end
-
-  context "dry run" do
-    let(:configuration) { double(dry_run?: true, notify: nil) }
-
-    let(:doc) do
-      gherkin do
-        feature do
-          scenario do
-            step 'a passing step'
-          end
-        end
-      end
-    end
-
-    it "activates each step with a skipping action" do
-      expect(receiver).to receive(:test_case) do |test_case|
-        expect(test_case.test_steps[0].execute).to be_skipped
-      end
-      compile [doc], receiver, [filter]
-    end
-
-    it "notifies with a StepMatch event" do
-      expect(configuration).to receive(:notify) do |message, test_step, step_match|
-        expect(message).to eq :step_match
-        expect(test_step.name).to eq 'a passing step'
-        expect(step_match).to eq step_match
-      end
-      compile [doc], receiver, [filter]
-    end
-  end
-
-  context "undefined step in a dry run" do
-    let(:step_match_search) { Proc.new { [] } }
-    let(:configuration) { double(dry_run?: true, notify: nil) }
-
-    let(:doc) do
-      gherkin do
-        feature do
-          scenario do
-            step 'an undefined step'
-          end
-        end
-      end
-    end
-
-    it "does not activate the step" do
-      expect(receiver).to receive(:test_case) do |test_case|
-        expect(test_case.test_steps[0].execute).to be_undefined
-      end
-      compile [doc], receiver, [filter]
-    end
-
-    it "does not notify" do
-      expect(configuration).not_to receive(:notify)
-      compile [doc], receiver, [filter]
-    end
-  end
-
-end