cucumber 3.0.1 → 3.0.2

data/spec/cucumber/formatter/progress_spec.rb

@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'cucumber/formatter/spec_helper'
-require 'cucumber/formatter/progress'
-require 'cucumber/cli/options'
-
-module Cucumber
-  module Formatter
-    describe Progress do
-      extend SpecHelperDsl
-      include SpecHelper
-
-      before(:each) do
-        Cucumber::Term::ANSIColor.coloring = false
-        @out = StringIO.new
-        @formatter = Progress.new(actual_runtime.configuration.with_options(out_stream: @out))
-      end
-
-      describe 'given a single feature' do
-        before(:each) do
-          run_defined_feature
-        end
-
-        describe 'with a scenario' do
-          define_feature <<-FEATURE
-            Feature: Banana party
-
-              Scenario: Monkey eats banana
-                Given there are bananas
-          FEATURE
-
-          it 'outputs the undefined step' do
-            expect(@out.string).to include "U\n"
-          end
-        end
-
-        describe 'with a background' do
-          define_feature <<-FEATURE
-            Feature: Banana party
-
-              Background: 
-                Given a tree
-
-              Scenario: Monkey eats banana
-                Given there are bananas
-          FEATURE
-
-          it 'outputs the two undefined steps' do
-            expect(@out.string).to include "UU\n"
-          end
-        end
-
-        describe 'with a scenario outline' do
-          define_feature <<-FEATURE
-            Feature: Fud Pyramid
-
-              Scenario Outline: Monkey eats a balanced diet
-                Given there are <Things>
-
-                Examples: Fruit
-                 | Things  |
-                 | apples  |
-                 | bananas |
-                Examples: Vegetables
-                 | Things   |
-                 | broccoli |
-                 | carrots  |
-          FEATURE
-
-          it 'outputs each undefined step' do
-            expect(@out.string).to include "UUUU\n"
-          end
-
-          it 'has 4 undefined scenarios' do
-            expect(@out.string).to include '4 scenarios (4 undefined)'
-          end
-
-          it 'has 4 undefined steps' do
-            expect(@out.string).to include '4 steps (4 undefined)'
-          end
-
-        end
-
-        describe 'with hooks' do
-
-          describe 'all hook passes' do
-            define_feature <<-FEATURE
-          Feature:
-            Scenario:
-              Given this step passes
-          FEATURE
-
-            define_steps do
-              Before do
-              end
-              AfterStep do
-              end
-              After do
-              end
-              Given(/^this step passes$/) {}
-            end
-
-            it 'only steps generate output' do
-              lines = <<-OUTPUT
-              .
-              1 scenario (1 passed)
-              1 step (1 passed)
-              OUTPUT
-              lines.split("\n").each do |line|
-                expect(@out.string).to include line.strip
-              end
-            end
-          end
-
-          describe 'with a failing before hook' do
-            define_feature <<-FEATURE
-          Feature:
-            Scenario:
-              Given this step passes
-          FEATURE
-
-            define_steps do
-              Before do
-                fail 'hook failed'
-              end
-              Given(/^this step passes$/) {}
-            end
-
-            it 'the failing hook generate output' do
-              lines = <<-OUTPUT
-              F-
-              1 scenario (1 failed)
-              1 step (1 skipped)
-              OUTPUT
-              lines.split("\n").each do |line|
-                expect(@out.string).to include line.strip
-              end
-            end
-          end
-
-          describe 'with a failing after hook' do
-            define_feature <<-FEATURE
-          Feature:
-            Scenario:
-              Given this step passes
-          FEATURE
-
-            define_steps do
-              After do
-                fail 'hook failed'
-              end
-              Given(/^this step passes$/) {}
-            end
-
-            it 'the failing hook generate output' do
-              lines = <<-OUTPUT
-              .F
-              1 scenario (1 failed)
-              1 step (1 passed)
-              OUTPUT
-              lines.split("\n").each do |line|
-                expect(@out.string).to include line.strip
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/formatter/rerun_spec.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/formatter/rerun'
-require 'cucumber/core'
-require 'cucumber/core/gherkin/writer'
-require 'cucumber/core/filter'
-require 'support/standard_step_actions'
-require 'cucumber/configuration'
-
-module Cucumber
-  module Formatter
-    describe Rerun do
-      include Cucumber::Core::Gherkin::Writer
-      include Cucumber::Core
-
-      let(:config) { Cucumber::Configuration.new(out_stream: io) }
-      let(:io) { StringIO.new }
-
-      # after_test_case
-      context 'when 2 scenarios fail in the same file' do
-        it 'Prints the locations of the failed scenarios' do
-          gherkin = gherkin('foo.feature') do
-            feature do
-              scenario do
-                step 'failing'
-              end
-
-              scenario do
-                step 'failing'
-              end
-
-              scenario do
-                step 'passing'
-              end
-            end
-          end
-          Rerun.new(config)
-          execute [gherkin], [StandardStepActions.new], config.event_bus
-          config.event_bus.test_run_finished
-
-          expect( io.string ).to eq 'foo.feature:3:6'
-        end
-      end
-
-      context 'with failures in multiple files' do
-        it 'prints the location of the failed scenarios in each file' do
-          foo = gherkin('foo.feature') do
-            feature do
-              scenario do
-                step 'failing'
-              end
-
-              scenario do
-                step 'failing'
-              end
-
-              scenario do
-                step 'passing'
-              end
-            end
-          end
-
-          bar = gherkin('bar.feature') do
-            feature do
-              scenario do
-                step 'failing'
-              end
-            end
-          end
-
-          Rerun.new(config)
-          execute [foo, bar], [StandardStepActions.new], config.event_bus
-          config.event_bus.test_run_finished
-
-          expect(io.string).to eq 'foo.feature:3:6\nbar.feature:3'
-        end
-      end
-
-      context 'when there are no failing scenarios' do
-        it 'prints nothing' do
-          gherkin = gherkin('foo.feature') do
-            feature do
-              scenario do
-                step 'passing'
-              end
-            end
-          end
-
-          Rerun.new(config)
-          execute [gherkin], [StandardStepActions.new], config.event_bus
-          config.event_bus.test_run_finished
-
-          expect(io.string).to eq ''
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/formatter/spec_helper.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-module Cucumber
-  module Formatter
-    module SpecHelperDsl
-      attr_reader :feature_content, :step_defs, :feature_filename
-
-      def define_feature(string, feature_file = 'spec.feature')
-        @feature_content = string
-        @feature_filename = feature_file
-      end
-
-      def define_steps(&block)
-        @step_defs = block
-      end
-    end
-
-    require 'cucumber/core'
-    module SpecHelper
-      include Core
-
-      def run_defined_feature
-        define_steps
-        actual_runtime.visitor = report
-
-        receiver = Test::Runner.new(event_bus)
-        filters = [
-          Filters::ActivateSteps.new(
-            StepMatchSearch.new(actual_runtime.support_code.registry.method(:step_matches), actual_runtime.configuration),
-            actual_runtime.configuration
-          ),
-          Filters::ApplyAfterStepHooks.new(actual_runtime.support_code),
-          Filters::ApplyBeforeHooks.new(actual_runtime.support_code),
-          Filters::ApplyAfterHooks.new(actual_runtime.support_code),
-          Filters::ApplyAroundHooks.new(actual_runtime.support_code),
-          Filters::PrepareWorld.new(actual_runtime)
-        ]
-        compile [gherkin_doc], receiver, filters
-        event_bus.test_run_finished
-      end
-
-      require 'cucumber/formatter/legacy_api/adapter'
-      def report
-        @report ||= LegacyApi::Adapter.new(
-          Fanout.new([@formatter]),
-          actual_runtime.results,
-          actual_runtime.configuration)
-      end
-
-      require 'cucumber/core/gherkin/document'
-      def gherkin_doc
-        Core::Gherkin::Document.new(self.class.feature_filename, gherkin)
-      end
-
-      def gherkin
-        self.class.feature_content || raise('No feature content defined!')
-      end
-
-      def runtime
-        @runtime_facade ||= LegacyApi::RuntimeFacade.new(actual_runtime.results, actual_runtime.support_code, actual_runtime.configuration)
-      end
-
-      def actual_runtime
-        @runtime ||= Runtime.new(options)
-      end
-
-      def event_bus
-        actual_runtime.configuration.event_bus
-      end
-
-      def define_steps
-        step_defs = self.class.step_defs
-
-        return unless step_defs
-        dsl = Object.new
-        dsl.extend Glue::Dsl
-        dsl.instance_exec &step_defs
-      end
-
-      def options
-        {}
-      end
-    end
-  end
-end

data/spec/cucumber/glue/proto_world_spec.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'cucumber/formatter/spec_helper'
-require 'cucumber/formatter/pretty'
-
-module Cucumber
-  module Glue
-    describe ProtoWorld do
-
-      let(:runtime) { double('runtime') }
-      let(:language) { double('language') }
-      let(:world) { Object.new.extend(ProtoWorld.for(runtime, language)) }
-
-      describe '#table' do
-        it 'produces Ast::Table by #table' do
-          expect(world.table(%{
-        | account | description | amount |
-        | INT-100 | Taxi        | 114    |
-        | CUC-101 | Peeler      | 22     |
-          })).to be_kind_of(MultilineArgument::DataTable)
-        end
-      end
-
-      describe 'Handling puts in step definitions' do
-        extend Cucumber::Formatter::SpecHelperDsl
-        include Cucumber::Formatter::SpecHelper
-
-        before(:each) do
-          Cucumber::Term::ANSIColor.coloring = false
-          @out = StringIO.new
-          @formatter = Cucumber::Formatter::Pretty.new(runtime, @out, {})
-          run_defined_feature
-        end
-
-        describe 'when modifying the printed variable after the call to puts' do
-          define_feature <<-FEATURE
-        Feature: Banana party
-
-          Scenario: Monkey eats banana
-            When puts is called twice for the same variable
-          FEATURE
-
-          define_steps do
-            When(/^puts is called twice for the same variable$/) do
-              foo = String.new('a')
-              puts foo
-              foo.upcase!
-              puts foo
-            end
-          end
-
-          it 'prints the variable value at the time puts was called' do
-            expect(@out.string).to include <<OUTPUT
-    When puts is called twice for the same variable
-      a
-      A
-OUTPUT
-          end
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/glue/registry_and_more_spec.rb

@@ -1,213 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'cucumber/glue/registry_and_more'
-
-module Cucumber
-  module Glue
-    describe StepDefinition do
-      let(:user_interface) { double('user interface') }
-      let(:registry)       { support_code.registry }
-      let(:support_code) do
-        Cucumber::Runtime::SupportCode.new(user_interface)
-      end
-      let(:dsl) do
-        registry
-        Object.new.extend(Glue::Dsl)
-      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
-
-          registry.load_code_file('tmp.rb')
-          expect($foo).to eq 1
-
-          a_file_called('tmp.rb') do
-            '$foo = 2'
-          end
-
-          registry.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
-          registry.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
-            registry.begin_scenario(nil)
-            raise 'Should fail'
-          rescue Glue::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\/glue\/registry_and_more_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)
-          registry.begin_scenario(double('scenario').as_null_object)
-          class << registry.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(registry.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/glue/registry_and_more_spec.rb:\\d+:in `World'
-spec/cucumber/glue/registry_and_more_spec.rb:\\d+:in `World'
-
-Use Ruby modules instead to extend your worlds. See the Cucumber::Glue::Dsl#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(Glue::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)
-          registry.begin_scenario(double('scenario').as_null_object)
-          class << registry.current_world
-            extend RSpec::Matchers
-            expect(included_modules.inspect).to match(/ModuleOne/)
-          end
-          expect(registry.current_world.class).to eq Object
-          expect(registry.current_world).to respond_to(:method_one)
-
-          expect(registry.current_world.module_two.class).to eq Object
-          expect(registry.current_world.module_two).to respond_to(:method_two)
-
-          expect(registry.current_world.module_three.class).to eq Object
-          expect(registry.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)
-          registry.begin_scenario(double('scenario').as_null_object)
-          class << registry.current_world
-            extend RSpec::Matchers
-          end
-          expect(registry.current_world.inspect).to match(/ModuleOne/)
-          expect(registry.current_world.inspect).to include('ModuleTwo (as module_two)')
-          expect(registry.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)
-          registry.begin_scenario(double('scenario').as_null_object)
-          class << registry.current_world
-            extend RSpec::Matchers
-          end
-          expect(registry.current_world.namespace).to respond_to(:method_one)
-          expect(registry.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)
-          registry.begin_scenario(double('scenario').as_null_object)
-          class << registry.current_world
-            extend RSpec::Matchers
-          end
-          expect(registry.current_world.namespace).to respond_to(:method_one)
-          expect(registry.current_world.namespace.method_one).to eql(-1)
-        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(registry.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(registry.hooks_for(:around, scenario)).to eq [a]
-        end
-      end
-    end
-  end
-end