cucumber 2.0.0.rc.4 → 4.0.0.rc.2

data/lib/cucumber/wire_support/wire_exception.rb

@@ -1,32 +0,0 @@
-module Cucumber
-  module WireSupport
-    # Proxy for an exception that occured at the remote end of the wire
-    class WireException < StandardError
-      module CanSetName
-        attr_writer :exception_name
-        def to_s
-          @exception_name
-        end
-      end
-
-      def initialize(args, config)
-        super args['message']
-        if args['exception']
-          self.class.extend(CanSetName)
-          self.class.exception_name = "#{args['exception']} from #{config}"
-        end
-        if args['backtrace']
-          @backtrace = if args['backtrace'].is_a?(String)
-              args['backtrace'].split("\n") # TODO: change cuke4nuke to pass an array instead of a big string
-            else
-              args['backtrace']
-            end
-        end
-      end
-
-      def backtrace
-        @backtrace || super
-      end
-    end
-  end
-end

data/lib/cucumber/wire_support/wire_language.rb

@@ -1,68 +0,0 @@
-require 'multi_json'
-require 'socket'
-require 'cucumber/wire_support/connection'
-require 'cucumber/wire_support/configuration'
-require 'cucumber/wire_support/wire_packet'
-require 'cucumber/wire_support/wire_exception'
-require 'cucumber/wire_support/wire_step_definition'
-
-module Cucumber
-  module WireSupport
-
-    # The wire-protocol (language independent) implementation of the programming
-    # language API.
-    class WireLanguage
-      include LanguageSupport::LanguageMethods
-
-      def initialize(_=nil)
-        @connections = []
-      end
-
-      def load_code_file(wire_file)
-        config = Configuration.from_file(wire_file)
-        @connections << Connection.new(config)
-      end
-
-      def snippet_text(code_keyword, step_name, multiline_arg, snippet_type)
-        snippets = @connections.map do |remote|
-          remote.snippet_text(code_keyword, step_name, MultilineArgClassName.new(multiline_arg).to_s)
-        end
-        snippets.flatten.join("\n")
-      end
-
-      def step_matches(step_name, formatted_step_name)
-        @connections.map{ |c| c.step_matches(step_name, formatted_step_name)}.flatten
-      end
-
-      def begin_scenario(scenario)
-        @connections.each { |c| c.begin_scenario(scenario) }
-        @current_scenario = scenario
-      end
-
-      def end_scenario
-        scenario = @current_scenario
-        @connections.each { |c| c.end_scenario(scenario) }
-        @current_scenario = nil
-      end
-
-      class MultilineArgClassName
-        def initialize(arg)
-          arg.describe_to(self)
-          @result = ""
-        end
-
-        def data_table(*)
-          @result = "Cucumber::MultilineArgument::DataTable"
-        end
-
-        def doc_string(*)
-          @result = "Cucumber::MultilineArgument::DocString"
-        end
-
-        def to_s
-          @result
-        end
-      end
-    end
-  end
-end

data/lib/cucumber/wire_support/wire_packet.rb

@@ -1,34 +0,0 @@
-require 'multi_json'
-
-module Cucumber
-  module WireSupport
-    # Represents the packet of data sent over the wire as JSON data, containing
-    # a message and a hash of arguments
-    class WirePacket
-      class << self
-        def parse(raw)
-          attributes = MultiJson.load(raw.strip)
-          message = attributes[0]
-          params  = attributes[1]
-          new(message, params)
-        end
-      end
-
-      attr_reader :message, :params
-
-      def initialize(message, params = nil)
-        @message, @params = message, params
-      end
-
-      def to_json
-        packet = [@message]
-        packet << @params if @params
-        MultiJson.dump(packet)
-      end
-
-      def handle_with(handler)
-        handler.send("handle_#{@message}", @params)
-      end
-    end
-  end
-end

data/lib/cucumber/wire_support/wire_protocol.rb

@@ -1,43 +0,0 @@
-require 'cucumber/wire_support/wire_protocol/requests'
-
-module Cucumber
-  module WireSupport
-    module WireProtocol
-      def step_matches(name_to_match, name_to_report)
-        handler = Requests::StepMatches.new(self)
-        handler.execute(name_to_match, name_to_report)
-      end
-
-      def snippet_text(step_keyword, step_name, multiline_arg_class_name)
-        handler = Requests::SnippetText.new(self)
-        handler.execute(step_keyword, step_name, multiline_arg_class_name)
-      end
-
-      def invoke(step_definition_id, args)
-        handler = Requests::Invoke.new(self)
-        handler.execute(step_definition_id, args)
-      end
-
-      def diff_failed
-        handler = Requests::DiffFailed.new(self)
-        handler.execute
-      end
-
-      def diff_ok
-        handler = Requests::DiffOk.new(self)
-        handler.execute
-      end
-
-      def begin_scenario(scenario)
-        handler = Requests::BeginScenario.new(self)
-        handler.execute(scenario)
-      end
-
-      def end_scenario(scenario)
-        handler = Requests::EndScenario.new(self)
-        handler.execute(scenario)
-      end
-
-    end
-  end
-end

data/lib/cucumber/wire_support/wire_protocol/requests.rb

@@ -1,133 +0,0 @@
-require 'cucumber/wire_support/request_handler'
-require 'gherkin/formatter/argument'
-
-module Cucumber
-  module WireSupport
-    module WireProtocol
-      module Requests
-        class StepMatches < RequestHandler
-          def execute(name_to_match, name_to_report)
-            @name_to_match, @name_to_report = name_to_match, name_to_report
-            request_params = {
-              :name_to_match => name_to_match
-            }
-            super(request_params)
-          end
-
-          def handle_success(params)
-            params.map do |raw_step_match|
-              create_step_match(raw_step_match)
-            end
-          end
-
-          alias :handle_step_matches :handle_success
-
-          private
-
-          def create_step_match(raw_step_match)
-            step_definition = WireStepDefinition.new(@connection, raw_step_match)
-            step_args = raw_step_match['args'].map do |raw_arg|
-              Gherkin::Formatter::Argument.new(raw_arg['pos'], raw_arg['val'])
-            end
-            step_match(step_definition, step_args)
-          end
-
-          def step_match(step_definition, step_args)
-            StepMatch.new(step_definition, @name_to_match, @name_to_report, step_args)
-          end
-        end
-
-        class SnippetText < RequestHandler
-          def execute(step_keyword, step_name, multiline_arg_class_name)
-            request_params = {
-              :step_keyword => step_keyword,
-              :step_name => step_name,
-              :multiline_arg_class => multiline_arg_class_name
-            }
-            super(request_params)
-          end
-
-          def handle_success(snippet_text)
-            snippet_text
-          end
-
-          alias :handle_snippet_text :handle_success
-        end
-
-        class Invoke < RequestHandler
-          def execute(step_definition_id, args)
-            request_params = {
-              :id => step_definition_id,
-              :args => args
-            }
-            super(request_params)
-          end
-
-          def handle_pending(message)
-            raise Pending, message || "TODO"
-          end
-
-          def handle_diff!(tables)
-            # TODO: figure out if / how we could get a location for a table from the wire (or make a null location)
-            location = Core::Ast::Location.new(__FILE__, __LINE__)
-            table1 = table(tables[0], location)
-            table2 = table(tables[1], location)
-            table1.diff!(table2)
-          end
-
-          def handle_diff(tables)
-            begin
-              handle_diff!(tables)
-            rescue Cucumber::MultilineArgument::DataTable::Different
-              @connection.diff_failed
-            end
-            @connection.diff_ok
-          end
-
-          alias :handle_step_failed :handle_fail
-
-          private
-
-          def table(data, location)
-            Cucumber::MultilineArgument.from_core(Core::Ast::DataTable.new(data, location))
-          end
-        end
-
-        class DiffFailed < RequestHandler
-          alias :handle_step_failed :handle_fail
-        end
-
-        class DiffOk < RequestHandler
-          alias :handle_step_failed :handle_fail
-        end
-
-        module Tags
-          def clean_tag_names(scenario)
-            scenario.tags.map { |tag| tag.name.gsub(/^@/, '') }.sort
-          end
-
-          def request_params(scenario)
-            return nil unless scenario.tags.any?
-            { "tags" => clean_tag_names(scenario) }
-          end
-        end
-
-        class BeginScenario < RequestHandler
-          include Tags
-
-          def execute(scenario)
-            super(request_params(scenario))
-          end
-        end
-
-        class EndScenario < RequestHandler
-          include Tags
-
-          def execute(scenario)
-            super(request_params(scenario))
-          end
-        end
-      end
-    end
-  end
-end

data/lib/cucumber/wire_support/wire_step_definition.rb

@@ -1,19 +0,0 @@
-module Cucumber
-  module WireSupport
-    class WireStepDefinition
-      attr_reader :regexp_source, :file_colon_line
-
-      def initialize(connection, data)
-        @connection = connection
-        @id              = data['id']
-        @regexp_source   = data['regexp'] || "Unknown"
-        @file_colon_line = data['source'] || "Unknown"
-      end
-
-      def invoke(args)
-        @connection.invoke(@id, args)
-      end
-
-    end
-  end
-end

data/spec/cucumber/cli/configuration_spec.rb

@@ -1,503 +0,0 @@
-require 'spec_helper'
-require 'yaml'
-
-module Cucumber
-module Cli
-  describe Configuration do
-    module ExposesOptions
-      attr_reader :options
-    end
-
-    def given_cucumber_yml_defined_as(hash_or_string)
-      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 given_the_following_files(*files)
-      allow(File).to receive(:directory?) { true }
-      allow(File).to receive(:file?) { true }
-      allow(Dir).to receive(:[]) { files }
-    end
-
-    before(:each) do
-      allow(File).to receive(:exist?) { false } # Meaning, no cucumber.yml exists
-      allow(Kernel).to receive(:exit)
-    end
-
-    def config
-      @config ||= Configuration.new(@out = StringIO.new, @error = StringIO.new).extend(ExposesOptions)
-    end
-
-    def reset_config
-      @config = nil
-    end
-
-    attr_reader :out, :error
-
-    it "requires env.rb files first" do
-      given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
-
-      config.parse!(%w{--require /features})
-
-      expect(config.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
-      given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
-
-      config.parse!(%w{--require /features --dry-run})
-
-      expect(config.support_to_load).to eq [
-        "/features/support/a_file.rb"
-      ]
-    end
-
-    it "requires files 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")
-
-      config.parse!(%w{--require /features})
-
-      expect(config.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")
-
-        config.parse!(%w{--require /features --exclude a_file.rb})
-
-        expect(config.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")
-
-        config.parse!(%w{--require /features --exclude foo[df] --exclude blah})
-
-        expect(config.all_files_to_load).to eq [
-          "/features/support/bar.rb",
-          "/features/support/fooz.rb"
-        ]
-      end
-    end
-
-    it "uses the default profile when no profile is defined" do
-      given_cucumber_yml_defined_as({'default' => '--require some_file'})
-
-      config.parse!(%w{--format progress})
-
-      expect(config.options[:require]).to include('some_file')
-    end
-
-    context '--profile' do
-      include RSpec::WorkInProgress
-
-      it "expands args from profiles in the cucumber.yml file" do
-        given_cucumber_yml_defined_as({'bongo' => '--require from/yml'})
-
-        config.parse!(%w{--format progress --profile bongo})
-
-        expect(config.options[:formats]).to eq [['progress', out]]
-        expect(config.options[:require]).to eq ['from/yml']
-      end
-
-      it "expands args from the default profile when no flags are provided" do
-        given_cucumber_yml_defined_as({'default' => '--require from/yml'})
-
-        config.parse!([])
-
-        expect(config.options[:require]).to eq ['from/yml']
-      end
-
-      it "allows --strict to be set by a profile" do
-        given_cucumber_yml_defined_as({'bongo' => '--strict'})
-
-        config.parse!(%w{--profile bongo})
-
-        expect(config.options[:strict]).to be true
-      end
-
-      it "parses ERB syntax in the cucumber.yml file" do
-        given_cucumber_yml_defined_as("---\ndefault: \"<%=\"--require some_file\"%>\"\n")
-
-        config.parse!([])
-
-        expect(config.options[:require]).to include('some_file')
-      end
-
-      it "parses ERB in cucumber.yml that makes uses nested ERB sessions" do
-        given_cucumber_yml_defined_as(<<ERB_YML)
-<%= ERB.new({'standard' => '--require some_file'}.to_yaml).result %>
-<%= ERB.new({'enhanced' => '--require other_file'}.to_yaml).result %>
-ERB_YML
-
-        config.parse!(%w(-p standard))
-
-        expect(config.options[:require]).to include('some_file')
-      end
-
-      it "provides a helpful error message when a specified profile does not exists in cucumber.yml" do
-        given_cucumber_yml_defined_as({'default' => '--require from/yml', 'html_report' =>  '--format html'})
-
-        expected_message = <<-END_OF_MESSAGE
-Could not find profile: 'i_do_not_exist'
-
-Defined profiles in cucumber.yml:
-  * default
-  * html_report
-END_OF_MESSAGE
-
-        expect(-> { config.parse!(%w{--profile i_do_not_exist}) }).to raise_error(ProfileNotFound, expected_message)
-      end
-
-      it "allows profiles to be defined in arrays" do
-        given_cucumber_yml_defined_as({'foo' => ['-f','progress']})
-
-        config.parse!(%w{--profile foo})
-
-        expect(config.options[:formats]).to eq [['progress', out]]
-      end
-
-      it "disregards default STDOUT formatter defined in profile when another is passed in (via cmd line)" do
-        given_cucumber_yml_defined_as({'foo' => %w[--format pretty]})
-        config.parse!(%w{--format progress --profile foo})
-
-        expect(config.options[:formats]).to eq [['progress', out]]
-      end
-
-      ["--no-profile", "-P"].each do |flag|
-        context 'when none is specified with #{flag}' do
-          it "disables profiles" do
-            given_cucumber_yml_defined_as({'default' => '-v --require file_specified_in_default_profile.rb'})
-
-            config.parse!("#{flag} --require some_file.rb".split(" "))
-
-            expect(config.options[:require]).to eq ['some_file.rb']
-          end
-
-          it "notifies the user that the profiles are being disabled" do
-            given_cucumber_yml_defined_as({'default' => '-v'})
-
-            config.parse!("#{flag} --require some_file.rb".split(" "))
-
-            expect(out.string).to match /Disabling profiles.../
-          end
-        end
-      end
-
-      it "issues a helpful error message when a specified profile exists but is nil or blank" do
-        [nil, '   '].each do |bad_input|
-          given_cucumber_yml_defined_as({'foo' => bad_input})
-
-          expected_error = /The 'foo' profile in cucumber.yml was blank.  Please define the command line arguments for the 'foo' profile in cucumber.yml./
-
-          expect(-> { config.parse!(%w{--profile foo}) }).to raise_error(expected_error)
-        end
-      end
-
-      it "issues a helpful error message when no YAML file exists and a profile is specified" do
-        expect(File).to receive(:exist?).with('cucumber.yml') { false }
-
-        expected_error = /cucumber\.yml was not found/
-
-        expect(-> { config.parse!(%w{--profile i_do_not_exist}) }).to raise_error(expected_error)
-      end
-
-      it "issues a helpful error message when cucumber.yml is blank or malformed" do
-          expected_error_message = /cucumber\.yml was found, but was blank or malformed. Please refer to cucumber's documentation on correct profile usage./
-
-        ['', 'sfsadfs', "--- \n- an\n- array\n", "---dddfd"].each do |bad_input|
-          given_cucumber_yml_defined_as(bad_input)
-
-          expect(-> { config.parse!([]) }).to raise_error(expected_error_message)
-
-          reset_config
-        end
-      end
-
-      it "issues a helpful error message when cucumber.yml can not be parsed" do
-        expected_error_message = /cucumber.yml was found, but could not be parsed. Please refer to cucumber's documentation on correct profile usage./
-
-        given_cucumber_yml_defined_as("input that causes an exception in YAML loading")
-
-        expect(YAML).to receive(:load).and_raise(ArgumentError)
-        expect(-> { config.parse!([]) }).to raise_error(expected_error_message)
-      end
-
-      it "issues a helpful error message when cucumber.yml can not be parsed by ERB" do
-        expected_error_message = /cucumber.yml was found, but could not be parsed with ERB.  Please refer to cucumber's documentation on correct profile usage./
-        given_cucumber_yml_defined_as("<% this_fails %>")
-
-        expect(-> { config.parse!([]) }).to raise_error(expected_error_message)
-      end
-    end
-
-    it "accepts --dry-run option" do
-      config.parse!(%w{--dry-run})
-
-      expect(config.options[:dry_run]).to be true
-    end
-
-    it "accepts --no-source option" do
-      config.parse!(%w{--no-source})
-
-      expect(config.options[:source]).to be false
-    end
-
-    it "accepts --no-snippets option" do
-      config.parse!(%w{--no-snippets})
-
-      expect(config.options[:snippets]).to be false
-    end
-
-    it "sets snippets and source to false with --quiet option" do
-      config.parse!(%w{--quiet})
-
-      expect(config.options[:snippets]).to be false
-      expect(config.options[:source]).to be false
-    end
-
-    it "accepts --verbose option" do
-      config.parse!(%w{--verbose})
-
-      expect(config.options[:verbose]).to be true
-    end
-
-    it "accepts --out option" do
-      config.parse!(%w{--out jalla.txt})
-
-      expect(config.formats).to eq [['pretty', 'jalla.txt']]
-    end
-
-    it "accepts multiple --out options" do
-      config.parse!(%w{--format progress --out file1 --out file2})
-
-      expect(config.formats).to eq [['progress', 'file2']]
-    end
-
-    it "accepts multiple --format options and put the STDOUT one first so progress is seen" do
-      config.parse!(%w{--format pretty --out pretty.txt --format progress})
-
-      expect(config.formats).to eq [['progress', out], ['pretty', 'pretty.txt']]
-    end
-
-    it "does not accept multiple --format options when both use implicit STDOUT" do
-      expect(-> { config.parse!(%w{--format pretty --format progress}) }).to raise_error("All but one formatter must use --out, only one can print to each stream (or STDOUT)")
-    end
-
-    it "accepts same --format options with implicit STDOUT, and keep only one" do
-      config.parse!(%w{--format pretty --format pretty})
-
-      expect(config.formats).to eq [["pretty", out]]
-    end
-
-    it "does not accept multiple --out streams pointing to the same place" do
-      expect(-> { config.parse!(%w{--format pretty --out file1 --format progress --out file1}) }).to raise_error("All but one formatter must use --out, only one can print to each stream (or STDOUT)")
-    end
-
-    it "associates --out to previous --format" do
-      config.parse!(%w{--format progress --out file1 --format profile --out file2})
-
-      expect(config.formats).to eq [["progress", "file1"], ["profile" ,"file2"]]
-    end
-
-    it "accepts same --format options with same --out streams and keep only one" do
-      config.parse!(%w{--format html --out file --format pretty --format html --out file})
-
-      expect(config.formats).to eq [["pretty", out], ["html", "file"]]
-    end
-
-    it "accepts same --format options with different --out streams" do
-      config.parse!(%w{--format html --out file1 --format html --out file2})
-
-      expect(config.formats).to eq [["html", "file1"], ["html", "file2"]]
-    end
-
-    it "accepts --color option" do
-      expect(Cucumber::Term::ANSIColor).to receive(:coloring=).with(true)
-
-      config.parse!(['--color'])
-    end
-
-    it "accepts --no-color option" do
-      expect(Cucumber::Term::ANSIColor).to receive(:coloring=).with(false)
-
-      config = Configuration.new(StringIO.new)
-      config.parse!(['--no-color'])
-    end
-
-    describe "--backtrace" do
-      before do
-        Cucumber.use_full_backtrace = false
-      end
-
-      it "shows full backtrace when --backtrace is present" do
-        Main.new(['--backtrace'])
-        begin
-          expect("x").to eq "y"
-        rescue RSpec::Expectations::ExpectationNotMetError => e
-          expect(e.backtrace[0]).not_to eq "#{__FILE__}:#{__LINE__ - 2}"
-        end
-      end
-
-      after do
-        Cucumber.use_full_backtrace = false
-      end
-    end
-
-    it "accepts multiple --name options" do
-      config.parse!(['--name', "User logs in", '--name', "User signs up"])
-
-      expect(config.options[:name_regexps]).to include(/User logs in/)
-      expect(config.options[:name_regexps]).to include(/User signs up/)
-    end
-
-    it "accepts multiple -n options" do
-      config.parse!(['-n', "User logs in", '-n', "User signs up"])
-
-      expect(config.options[:name_regexps]).to include(/User logs in/)
-      expect(config.options[:name_regexps]).to include(/User signs up/)
-    end
-
-    it "preserves the order of the feature files" do
-      config.parse!(%w{b.feature c.feature a.feature})
-
-      expect(config.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"] }
-
-      config.parse!(%w{feature_directory/})
-
-      expect(config.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"] }
-
-      config.parse!(%w{})
-
-      expect(config.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 cucumber space.feature:134 domain folder/cuke.feature:1 domain folder/different cuke:4:5" )
-
-      config.parse!(%w{@rerun.txt})
-
-      expect(config.feature_files).to eq [
-        "cucumber.feature:1:3",
-        "cucumber space.feature:134",
-        "domain folder/cuke.feature:1",
-        "domain folder/different cuke:4:5"]
-    end
-
-    it "should allow specifying environment variables on the command line" do
-      config.parse!(["foo=bar"])
-
-      expect(ENV["foo"]).to eq "bar"
-      expect(config.feature_files).not_to include('foo=bar')
-    end
-
-    it "allows specifying environment variables in profiles" do
-      given_cucumber_yml_defined_as({'selenium' => 'RAILS_ENV=selenium'})
-      config.parse!(["--profile", "selenium"])
-
-      expect(ENV["RAILS_ENV"]).to eq "selenium"
-      expect(config.feature_files).not_to include('RAILS_ENV=selenium')
-    end
-
-    describe "#tag_expression" do
-      include RSpec::WorkInProgress
-
-      it "returns an empty expression when no tags are specified" do
-        config.parse!([])
-
-        expect(config.tag_expression).to be_empty
-      end
-
-      it "returns an expression when tags are specified" do
-        config.parse!(['--tags','@foo'])
-
-        expect(config.tag_expression).not_to be_empty
-      end
-    end
-
-    describe '#tag_limits' do
-      it "returns an empty hash when no limits are specified" do
-        config.parse!([])
-
-        expect(config.tag_limits).to eq({ })
-      end
-
-      it "returns a hash of limits when limits are specified" do
-        config.parse!(['--tags','@foo:1'])
-
-        expect(config.tag_limits).to eq({ "@foo" => 1 })
-      end
-    end
-
-    describe "#dry_run?" do
-      it "returns true when --dry-run was specified on in the arguments" do
-        config.parse!(['--dry-run'])
-
-        expect(config.dry_run?).to be true
-      end
-
-      it "returns true when --dry-run was specified in yaml file" do
-        given_cucumber_yml_defined_as({'default' => '--dry-run'})
-        config.parse!([])
-
-        expect(config.dry_run?).to be true
-      end
-
-      it "returns false by default" do
-        config.parse!([])
-
-        expect(config.dry_run?).to be false
-      end
-    end
-
-    describe "#snippet_type" do
-      it "returns the snippet type when it was set" do
-        config.parse!(["--snippet-type", "classic"])
-
-        expect(config.snippet_type).to eq :classic
-      end
-
-      it "returns the snippet type when it was set with shorthand option" do
-        config.parse!(["-I", "classic"])
-
-        expect(config.snippet_type).to eq :classic
-      end
-
-      it "returns the default snippet type if it was not set" do
-        config.parse!([])
-
-        expect(config.snippet_type).to eq :regexp
-      end
-    end
-  end
-end
-end