cucumber-core 0.2.0 → 1.0.0.beta.1

data/lib/cucumber/core/test/mapper.rb

@@ -1,55 +1,137 @@
 require 'cucumber/initializer'
+require 'cucumber/core/test/hooks'
+
 module Cucumber
   module Core
     module Test
       class Mapper
-        include Cucumber.initializer(:mappings, :runner)
+        include Cucumber.initializer(:mapping_definition, :receiver)
 
         def test_case(test_case, &descend)
-          mapper = CaseMapper.new(mappings)
+          hook_factory = HookFactory.new(test_case.source)
+          mapper = CaseMapper.new(mapping_definition)
+          test_case.describe_to mapping_definition, CaseMapper::DSL.new(mapper, hook_factory)
           descend.call(mapper)
-          test_case.with_steps(mapper.test_steps).describe_to(runner)
+          test_case.
+            with_steps(mapper.before_hooks + mapper.test_steps + mapper.after_hooks).
+            with_around_hooks(mapper.around_hooks).
+            describe_to(receiver)
           self
         end
 
         def done
-          runner.done
+          receiver.done
           self
         end
 
+        private
+
         class CaseMapper
-          include Cucumber.initializer(:mappings)
+          include Cucumber.initializer(:mapping_definition)
 
-          attr_reader :test_steps
+          def test_step(test_step)
+            hook_factory = HookFactory.new(test_step.source)
+            mapper = StepMapper.new(test_step)
+            test_step.describe_to mapping_definition, StepMapper::DSL.new(mapper, hook_factory)
+            test_steps.push(*[mapper.test_step] + mapper.after_step_hooks)
+            self
+          end
 
-          def initialize(*)
-            super
-            @test_steps = []
+          def test_steps
+            @test_steps ||= []
           end
 
-          def test_step(test_step)
-            mapper = StepMapper.new(test_step)
-            test_step.describe_to(mappings, mapper)
-            test_steps << mapper.mapped_test_step
+          def around_hooks
+            @around_hooks ||= []
+          end
+
+          def before_hooks
+            @before_hooks ||= []
+          end
+
+          def after_hooks
+            @after_hooks ||= []
           end
 
+          # Passed to users in the mappings to add hooks to a scenario
+          class DSL
+            include Cucumber.initializer(:mapper, :hook_factory)
+
+            # Run this block of code before the scenario
+            def before(&block)
+              mapper.before_hooks << hook_factory.before(block)
+              self
+            end
+
+            # Run this block of code after the scenario
+            def after(&block)
+              mapper.after_hooks << hook_factory.after(block)
+              self
+            end
+
+            # Run this block of code around the scenario, with a yield in the block executing the scenario
+            def around(&block)
+              mapper.around_hooks << Hooks::AroundHook.new(&block)
+              self
+            end
+
+          end
         end
 
         class StepMapper
           include Cucumber.initializer(:test_step)
 
-          attr_reader :mapped_test_step
+          attr_accessor :test_step
 
-          def initialize(*)
-            super
-            @mapped_test_step = test_step
+          def after_step_hooks
+            @after_step_hooks ||= []
           end
 
-          def map(&block)
-            @mapped_test_step = test_step.map(&block)
+          # Passed to users in the mappings to define and add hooks to a step
+          class DSL
+            include Cucumber.initializer(:mapper, :hook_factory)
+
+            # Define the step with a block of code to be executed
+            def map(&block)
+              mapper.test_step = mapper.test_step.with_mapping(&block)
+              self
+            end
+
+            # Define a block of code to be run after the step
+            def after(&block)
+              mapper.after_step_hooks << hook_factory.after_step(block)
+              self
+            end
+
+          end
+        end
+
+        class HookFactory
+          include Cucumber.initializer(:source)
+
+          def after(block)
+            build_hook_step(block, Hooks::AfterHook, Test::UnskippableMapping)
+          end
+
+          def before(block)
+            build_hook_step(block, Hooks::BeforeHook, Test::UnskippableMapping)
+          end
+
+          def after_step(block)
+            build_hook_step(block, Hooks::AfterStepHook, Test::Mapping)
+          end
+
+          private
+
+          def build_hook_step(block, hook_type, mapping_type)
+            mapping = mapping_type.new(&block)
+            hook = hook_type.new(mapping.location)
+            Step.new(source + [hook], mapping)
           end
+
         end
 
+
       end
     end
   end

data/lib/cucumber/core/test/mapping.rb

@@ -1,6 +1,7 @@
 require 'cucumber/core/test/result'
 require 'cucumber/core/test/timer'
 require 'cucumber/core/test/result'
+require 'cucumber/core/ast/location'
 
 module Cucumber
   module Core
@@ -21,12 +22,20 @@ module Cucumber
           @timer.start
           @block.call
           passed
-        rescue Result::Pending => exception
-          pending(exception)
+        rescue Result::Raisable => exception
+          exception.with_duration(@timer.duration)
         rescue Exception => exception
           failed(exception)
         end
 
+        def location
+          Ast::Location.new(*@block.source_location)
+        end
+
+        def inspect
+          "<#{self.class}: #{location}>"
+        end
+
         private
 
         def passed
@@ -40,9 +49,11 @@ module Cucumber
         def skipped
           Result::Skipped.new
         end
+      end
 
-        def pending(exception)
-          exception.with_duration(@timer.duration)
+      class UnskippableMapping < Mapping
+        def skip
+          execute
         end
       end
 

data/lib/cucumber/core/test/result.rb

@@ -5,6 +5,9 @@ module Cucumber
   module Core
     module Test
       module Result
+
+        # Defines predicate methods on a result class with only the given one
+        # returning true
         def self.status_queries(status)
           Module.new do
             [:passed, :failed, :undefined, :unknown, :skipped, :pending].each do |possible_status|
@@ -15,7 +18,8 @@ module Cucumber
           end
         end
 
-        Unknown = Class.new do
+        # Null object for results. Represents the state where we haven't run anything yet
+        class Unknown
           include Result.status_queries :unknown
 
           def describe_to(visitor, *args)
@@ -24,7 +28,7 @@ module Cucumber
         end
 
         class Passed
-          include Result.status_queries :passed
+          include Result.status_queries(:passed)
           include Cucumber.initializer(:duration)
           attr_reader :duration
 
@@ -45,7 +49,7 @@ module Cucumber
         end
 
         class Failed
-          include Result.status_queries :failed
+          include Result.status_queries(:failed)
           include Cucumber.initializer(:duration, :exception)
           attr_reader :duration, :exception
 
@@ -72,52 +76,54 @@ module Cucumber
 
         end
 
-        Undefined = Class.new do
-          include Result.status_queries :undefined
-          include Cucumber.initializer(:duration)
-          attr_reader :duration
+        # Base class for exceptions that can be raised in a step defintion causing 
+        # the step to have that result.
+        class Raisable < StandardError
+          attr_reader :message, :duration
 
-          def initialize(duration = 0)
-            super
+          def initialize(message = "", duration = :unknown, backtrace = nil)
+            @message, @duration = message, duration
+            super(message)
+            set_backtrace(backtrace) if backtrace
+          end
+
+          def with_duration(new_duration)
+            self.class.new(message, new_duration, backtrace)
           end
+        end
+
+        class Undefined < Raisable
+          include Result.status_queries :undefined
 
           def describe_to(visitor, *args)
             visitor.undefined(*args)
+            visitor.duration(duration, *args) unless duration == :unknown
             self
           end
 
           def to_s
-            "✗"
+            "?"
           end
 
-          def with_duration(new_duration)
-            self.class.new(new_duration)
-          end
         end
 
-        Skipped = Class.new do
+        class Skipped < Raisable
           include Result.status_queries :skipped
 
           def describe_to(visitor, *args)
             visitor.skipped(*args)
+            visitor.duration(duration, *args) unless duration == :unknown
             self
           end
 
           def to_s
             "-"
           end
+
         end
 
-        class Pending < StandardError
+        class Pending < Raisable
           include Result.status_queries :pending
-          attr_reader :message, :duration
-
-          def initialize(message, duration = :unknown, backtrace=nil)
-            raise ArgumentError unless message
-            @message, @duration = message, duration
-            super(message)
-            set_backtrace(backtrace) if backtrace
-          end
 
           def describe_to(visitor, *args)
             visitor.pending(self, *args)
@@ -128,12 +134,18 @@ module Cucumber
           def to_s
             "P"
           end
-
-          def with_duration(new_duration)
-            self.class.new(message, new_duration, backtrace)
-          end
         end
 
+        #
+        # An object that responds to the description protocol from the results
+        # and collects summary information.
+        #
+        # e.g. 
+        #     summary = Result::Summary.new
+        #     Result::Passed.new(0).describe_to(summary)
+        #     puts summary.total_passed
+        #     => 1
+        #
         class Summary
           attr_reader :total_failed,
             :total_passed,

data/lib/cucumber/core/test/runner.rb

@@ -5,116 +5,111 @@ module Cucumber
   module Core
     module Test
       class Runner
-        module StepRunner
-          class Default
-            def initialize
-              @timer = Timer.new.start
-            end
-
-            def execute(test_step)
-              status.execute(test_step, self)
-            end
+        class StepRunner
+          def initialize
+            @timer = Timer.new.start
+            @status = Status::Unknown.new(Result::Unknown.new)
+          end
 
-            def result
-              status.result(@timer.duration)
-            end
+          def execute(test_step)
+            status.execute(test_step, self)
+          end
 
-            def failed(step_result)
-              @status = Failing.new(step_result)
-              self
-            end
+          def result
+            status.result(@timer.duration)
+          end
 
-            def passed(step_result)
-              @status = Passing.new
-              self
-            end
+          def failed(step_result)
+            @status = Status::Failing.new(step_result)
+            self
+          end
 
-            def pending(message, step_result)
-              @status = Pending.new(step_result)
-              self
-            end
+          def passed(step_result)
+            @status = Status::Passing.new(step_result)
+            self
+          end
 
-            def undefined(step_result)
-              failed(step_result)
-              self
-            end
+          def pending(message, step_result)
+            @status = Status::Pending.new(step_result)
+            self
+          end
 
-            def exception(step_exception, step_result)
-              self
-            end
+          def skipped(step_result)
+            @status = Status::Skipping.new(step_result)
+            self
+          end
 
-            def duration(step_duration, step_result)
-              self
-            end
+          def undefined(step_result)
+            failed(step_result)
+            self
+          end
 
-            private
+          def exception(step_exception, step_result)
+            self
+          end
 
-            def status
-              @status ||= Unknown.new
-            end
+          def duration(step_duration, step_result)
+            self
           end
 
-          class DryRun
-            def execute(test_step)
-              step_result = test_step.skip
-              @case_result = Result::Undefined.new if step_result.undefined?
-              step_result
-            end
+          attr_reader :status
+          private :status
 
-            def result
-              @case_result ||= Result::Skipped.new
-            end
-          end
+          module Status
+            class Base
+              include Cucumber.initializer(:step_result)
+
+              def execute(test_step, monitor)
+                result = test_step.execute
+                result.describe_to(monitor, result)
+              end
 
-          class Unknown
-            def execute(test_step, monitor)
-              result = test_step.execute
-              result.describe_to(monitor, result)
+              def result
+                raise NoMethodError, "Override me"
+              end
             end
 
-            def result(duration)
-              Result::Unknown.new
+            class Unknown < Base
+              def result(duration)
+                Result::Unknown.new
+              end
             end
-          end
 
-          class Passing < Unknown
-            def result(duration)
-              Result::Passed.new(duration)
+            class Passing < Base
+              def result(duration)
+                Result::Passed.new(duration)
+              end
             end
-          end
 
-          Failing = Struct.new(:step_result) do
-            def execute(test_step, monitor)
-              test_step.skip
+            class Failing < Base
+              def execute(test_step, monitor)
+                test_step.skip
+              end
+
+              def result(duration)
+                step_result.with_duration(duration)
+              end
             end
 
-            def result(duration)
-              step_result.with_duration(duration)
+            Pending = Class.new(Failing)
+
+            class Skipping < Failing
+              def result(duration)
+                step_result.with_duration(duration)
+              end
             end
           end
-
-          Pending = Class.new(Failing)
         end
 
-        STEP_RUNNER_STRATEGY = {
-          default: StepRunner::Default,
-          dry_run: StepRunner::DryRun
-        }
-
-        attr_reader :report, :step_runner_class
-        private :report, :step_runner_class
-        def initialize(report, run_options = {})
+        attr_reader :report
+        private :report
+        def initialize(report)
           @report = report
-
-          run_mode = run_options.fetch(:run_mode) { :default }
-          @step_runner_class = STEP_RUNNER_STRATEGY.fetch(run_mode) do
-            raise ArgumentError, "No strategy for run mode: #{run_mode.inspect}"
-          end
         end
 
         def test_case(test_case, &descend)
           report.before_test_case(test_case)
-          descend.call
+          descend.call(self)
           report.after_test_case(test_case, current_case_result)
           @current_step_runner = nil
         end
@@ -141,7 +136,7 @@ module Cucumber
         end
 
         def current_step_runner
-          @current_step_runner ||= step_runner_class.new
+          @current_step_runner ||= StepRunner.new
         end
       end
     end