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

data/spec/cucumber/cli/main_spec.rb

@@ -1,105 +0,0 @@
-require 'spec_helper'
-require 'yaml'
-require 'gherkin/formatter/model'
-
-module Cucumber
-  module Cli
-    describe Main do
-      before(:each) do
-        allow(File).to receive(:exist?) { false } # When Configuration checks for cucumber.yml
-        allow(Dir).to receive(:[]) { [] } # to prevent cucumber's features dir to being laoded
-      end
-
-      let(:args)   { [] }
-      let(:stdin)  { StringIO.new }
-      let(:stdout) { StringIO.new }
-      let(:stderr) { StringIO.new }
-      let(:kernel) { double(:kernel) }
-      subject { Main.new(args, stdin, stdout, stderr, kernel)}
-
-      describe "#execute!" do
-        context "passed an existing runtime" do
-          let(:existing_runtime) { double('runtime').as_null_object }
-
-          def do_execute
-            subject.execute!(existing_runtime)
-          end
-
-          it "configures that runtime" do
-            expected_configuration = double('Configuration').as_null_object
-
-            allow(Configuration).to receive(:new) { expected_configuration }
-            expect(existing_runtime).to receive(:configure).with(expected_configuration)
-            expect(kernel).to receive(:exit).with(1)
-
-            do_execute
-          end
-
-          it "uses that runtime for running and reporting results" do
-            expected_results = double('results', :failure? => true)
-
-            expect(existing_runtime).to receive(:run!)
-            allow(existing_runtime).to receive(:results) { expected_results }
-            expect(kernel).to receive(:exit).with(1)
-
-            do_execute
-          end
-        end
-
-        context "interrupted with ctrl-c" do
-          after do
-            Cucumber.wants_to_quit = false
-          end
-
-          it "registers as a failure" do
-            results = double('results', :failure? => false)
-
-            allow_any_instance_of(Runtime).to receive(:run!)
-            allow_any_instance_of(Runtime).to receive(:results) { results }
-
-            Cucumber.wants_to_quit = true
-
-            expect(kernel).to receive(:exit).with(1)
-
-            subject.execute!
-          end
-        end
-      end
-
-      describe "--format with class" do
-        describe "in module" do
-          let(:double_module) { double('module') }
-          let(:formatter) { double('formatter') }
-
-          it "resolves each module until it gets Formatter class" do
-            cli = Main.new(%w{--format ZooModule::MonkeyFormatterClass}, stdin, stdout, stderr, kernel)
-
-            allow(Object).to receive(:const_defined?) { true }
-            allow(double_module).to receive(:const_defined?) { true }
-
-            expect(Object).to receive(:const_get).with('ZooModule', false) { double_module }
-            expect(double_module).to receive(:const_get).with('MonkeyFormatterClass', false) { double('formatter class', :new => formatter) }
-
-            expect(kernel).to receive(:exit).with(0)
-
-            cli.execute!
-          end
-        end
-      end
-
-      [ProfilesNotDefinedError, YmlLoadError, ProfileNotFound].each do |exception_klass|
-        it "rescues #{exception_klass}, prints the message to the error stream" do
-          configuration = double('configuration')
-
-          allow(Configuration).to receive(:new) { configuration }
-          allow(configuration).to receive(:parse!).and_raise(exception_klass.new("error message"))
-          allow(kernel).to receive(:exit).with(1)
-
-          subject.execute!
-
-          expect(stderr.string).to eq "error message\n"
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/cli/options_spec.rb

@@ -1,335 +0,0 @@
-require 'spec_helper'
-require 'yaml'
-require 'cucumber/cli/options'
-
-module Cucumber
-  module Cli
-    describe Options do
-
-      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
-
-      before(:each) do
-        allow(File).to receive(:exist?) { false } # Meaning, no cucumber.yml exists
-        allow(Kernel).to receive(:exit)
-      end
-
-      def output_stream
-        @output_stream ||= StringIO.new
-      end
-
-      def error_stream
-        @error_stream ||= StringIO.new
-      end
-
-      def options
-        @options ||= Options.new(output_stream, error_stream)
-      end
-
-      def prepare_args(args)
-        args.is_a?(Array) ? args : args.split(' ')
-      end
-
-      describe 'parsing' do
-
-        def when_parsing(args)
-          yield
-          options.parse!(prepare_args(args))
-        end
-
-        def after_parsing(args)
-          options.parse!(prepare_args(args))
-          yield
-        end
-
-        context '-r or --require' do
-          it "collects all specified files into an array" do
-            after_parsing('--require some_file.rb -r another_file.rb') do
-              expect(options[:require]).to eq ['some_file.rb', 'another_file.rb']
-            end
-          end
-        end
-
-        context '--i18n' do
-          context "with LANG specified as 'help'" do
-            include RSpec::WorkInProgress
-
-            it "lists all known langues" do
-              when_parsing '--i18n help' do
-                expect(Kernel).to receive(:exit)
-              end
-            end
-
-            it "exits the program" do
-              when_parsing('--i18n help') { expect(Kernel).to receive(:exit) }
-            end
-          end
-        end
-
-        context '-f FORMAT or --format FORMAT' do
-          it "defaults the output for the formatter to the output stream (STDOUT)" do
-            after_parsing('-f pretty') { expect(options[:formats]).to eq [['pretty', output_stream]] }
-          end
-        end
-
-        context '-o [FILE|DIR] or --out [FILE|DIR]' do
-          it "defaults the formatter to 'pretty' when not specified earlier" do
-            after_parsing('-o file.txt') { expect(options[:formats]).to eq [['pretty', 'file.txt']] }
-          end
-          it "sets the output for the formatter defined immediatly before it" do
-            after_parsing('-f profile --out file.txt -f pretty -o file2.txt') do
-              expect(options[:formats]).to eq [['profile', 'file.txt'], ['pretty', 'file2.txt']]
-            end
-          end
-        end
-
-        context '-t TAGS --tags TAGS' do
-          it "designates tags prefixed with ~ as tags to be excluded" do
-            after_parsing('--tags ~@foo,@bar') { expect(options[:tag_expressions]).to eq ['~@foo,@bar'] }
-          end
-
-          it "stores tags passed with different --tags seperately" do
-            after_parsing('--tags @foo --tags @bar') { expect(options[:tag_expressions]).to eq ['@foo', '@bar'] }
-          end
-        end
-
-        context '-n NAME or --name NAME' do
-          it "stores the provided names as regular expressions" do
-            after_parsing('-n foo --name bar') { expect(options[:name_regexps]).to eq [/foo/,/bar/] }
-          end
-        end
-
-        context '-e PATTERN or --exclude PATTERN' do
-          it "stores the provided exclusions as regular expressions" do
-            after_parsing('-e foo --exclude bar') { expect(options[:excludes]).to eq [/foo/,/bar/] }
-          end
-        end
-
-        context '-l LINES or --lines LINES' do
-          it "adds line numbers to args" do
-            options.parse!(%w{-l24 FILE})
-
-            expect(options.instance_variable_get(:@args)).to eq ['FILE:24']
-          end
-        end
-
-        context '-p PROFILE or --profile PROFILE' do
-          it "uses the default profile passed in during initialization if none are specified by the user" do
-            given_cucumber_yml_defined_as({'default' => '--require some_file'})
-
-            options = Options.new(output_stream, error_stream, :default_profile => 'default')
-            options.parse!(%w{--format progress})
-
-            expect(options[:require]).to include('some_file')
-          end
-
-          it "merges all uniq values from both cmd line and the profile" do
-            given_cucumber_yml_defined_as('foo' => %w[--verbose])
-            options.parse!(%w[--wip --profile foo])
-
-            expect(options[:wip]).to be true
-            expect(options[:verbose]).to be true
-          end
-
-          it "gives precendene to the origianl options' paths" do
-            given_cucumber_yml_defined_as('foo' => %w[features])
-            options.parse!(%w[my.feature -p foo])
-
-            expect(options[:paths]).to eq %w[my.feature]
-          end
-
-          it "combines the require files of both" do
-            given_cucumber_yml_defined_as('bar' => %w[--require features -r dog.rb])
-            options.parse!(%w[--require foo.rb -p bar])
-
-            expect(options[:require]).to eq %w[foo.rb features dog.rb]
-          end
-
-          it "combines the tag names of both" do
-            given_cucumber_yml_defined_as('baz' => %w[-t @bar])
-            options.parse!(%w[--tags @foo -p baz])
-
-            expect(options[:tag_expressions]).to eq ["@foo", "@bar"]
-          end
-
-          it "only takes the paths from the original options, and disgregards the profiles" do
-            given_cucumber_yml_defined_as('baz' => %w[features])
-            options.parse!(%w[my.feature -p baz])
-
-            expect(options[:paths]).to eq ['my.feature']
-          end
-
-          it "uses the paths from the profile when none are specified originally" do
-            given_cucumber_yml_defined_as('baz' => %w[some.feature])
-            options.parse!(%w[-p baz])
-
-            expect(options[:paths]).to eq ['some.feature']
-          end
-
-          it "combines environment variables from the profile but gives precendene to cmd line args" do
-            given_cucumber_yml_defined_as('baz' => %w[FOO=bar CHEESE=swiss])
-            options.parse!(%w[-p baz CHEESE=cheddar BAR=foo])
-
-            expect(options[:env_vars]).to eq({ 'BAR' => 'foo', 'FOO' => 'bar', 'CHEESE' => 'cheddar' })
-          end
-
-          it "disregards STDOUT formatter defined in profile when another is passed in (via cmd line)" do
-            given_cucumber_yml_defined_as({'foo' => %w[--format pretty]})
-            options.parse!(%w{--format progress --profile foo})
-
-            expect(options[:formats]).to eq [['progress', output_stream]]
-          end
-
-          it "includes any non-STDOUT formatters from the profile" do
-            given_cucumber_yml_defined_as({'html' => %w[--format html -o features.html]})
-            options.parse!(%w{--format progress --profile html})
-
-            expect(options[:formats]).to eq [['progress', output_stream], ['html', 'features.html']]
-          end
-
-          it "does not include STDOUT formatters from the profile if there is a STDOUT formatter in command line" do
-            given_cucumber_yml_defined_as({'html' => %w[--format html -o features.html --format pretty]})
-            options.parse!(%w{--format progress --profile html})
-
-            expect(options[:formats]).to eq [['progress', output_stream], ['html', 'features.html']]
-          end
-
-          it "includes any STDOUT formatters from the profile if no STDOUT formatter was specified in command line" do
-            given_cucumber_yml_defined_as({'html' => %w[--format html]})
-            options.parse!(%w{--format rerun -o rerun.txt --profile html})
-
-            expect(options[:formats]).to eq [['html', output_stream], ['rerun', 'rerun.txt']]
-          end
-
-          it "assumes all of the formatters defined in the profile when none are specified on cmd line" do
-            given_cucumber_yml_defined_as({'html' => %w[--format progress --format html -o features.html]})
-            options.parse!(%w{--profile html})
-
-            expect(options[:formats]).to eq [['progress', output_stream], ['html', 'features.html']]
-          end
-
-          it "only reads cucumber.yml once" do
-            original_parse_count = $cucumber_yml_read_count
-            $cucumber_yml_read_count = 0
-
-            begin
-              given_cucumber_yml_defined_as(<<-END
-              <% $cucumber_yml_read_count += 1 %>
-              default: --format pretty
-              END
-              )
-              options = Options.new(output_stream, error_stream, :default_profile => 'default')
-              options.parse!(%w(-f progress))
-
-              expect($cucumber_yml_read_count).to eq 1
-            ensure
-              $cucumber_yml_read_count = original_parse_count
-            end
-          end
-
-          it "respects --quiet when defined in the profile" do
-            given_cucumber_yml_defined_as('foo' => '-q')
-            options.parse!(%w[-p foo])
-
-            expect(options[:snippets]).to be false
-            expect(options[:source]).to be false
-          end
-        end
-
-        context '-P or --no-profile' do
-          it "disables profiles" do
-            given_cucumber_yml_defined_as({'default' => '-v --require file_specified_in_default_profile.rb'})
-
-            after_parsing("-P --require some_file.rb") do
-              expect(options[:require]).to eq ['some_file.rb']
-            end
-          end
-
-          it "notifies the user that the profiles are being disabled" do
-            given_cucumber_yml_defined_as({'default' => '-v'})
-
-            after_parsing("--no-profile --require some_file.rb") do
-              expect(output_stream.string).to match(/Disabling profiles.../)
-            end
-          end
-        end
-
-        context '-b or --backtrace' do
-          it "turns on cucumber's full backtrace" do
-            when_parsing("-b") do
-              expect(Cucumber).to receive(:use_full_backtrace=).with(true)
-            end
-          end
-        end
-
-        context '--version' do
-          it "displays Cucumber's version" do
-            after_parsing('--version') do
-              expect(output_stream.string).to match(/#{Cucumber::VERSION}/)
-            end
-          end
-
-          it "exits the program" do
-            when_parsing('--version') { expect(Kernel).to receive(:exit) }
-          end
-        end
-
-        context 'environment variables (i.e. MODE=webrat)' do
-          it "places all of the environment variables into a hash" do
-            after_parsing('MODE=webrat FOO=bar') do
-              expect(options[:env_vars]).to eq({ 'MODE' => 'webrat', 'FOO' => 'bar' })
-            end
-          end
-        end
-
-        it "assigns any extra arguments as paths to features" do
-          after_parsing('-f pretty my_feature.feature my_other_features') do
-            expect(options[:paths]).to eq ['my_feature.feature', 'my_other_features']
-          end
-        end
-
-        it "does not mistake environment variables as feature paths" do
-          after_parsing('my_feature.feature FOO=bar') do
-            expect(options[:paths]).to eq ['my_feature.feature']
-          end
-        end
-
-        context '--snippet-type' do
-          it "parses the snippet type argument" do
-            after_parsing('--snippet-type classic') do
-              expect(options[:snippet_type]).to eq :classic
-            end
-          end
-        end
-      end
-
-      describe "dry-run" do
-        it "has the default value for snippets" do
-          given_cucumber_yml_defined_as({'foo' => %w[--dry-run]})
-          options.parse!(%w{--dry-run})
-
-          expect(options[:snippets]).to be true
-        end
-
-        it "sets snippets to false when no-snippets provided after dry-run" do
-          given_cucumber_yml_defined_as({'foo' => %w[--dry-run --no-snippets]})
-          options.parse!(%w{--dry-run --no-snippets})
-
-          expect(options[:snippets]).to be false
-        end
-
-        it "sets snippets to false when no-snippets provided before dry-run" do
-          given_cucumber_yml_defined_as({'foo' => %w[--no-snippet --dry-run]})
-          options.parse!(%w{--no-snippets --dry-run})
-
-          expect(options[:snippets]).to be false
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/cli/profile_loader_spec.rb

@@ -1,46 +0,0 @@
-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