cucumber-core 0.1.0

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

@@ -0,0 +1,67 @@
+require 'cucumber/core/test/result'
+require 'cucumber/core/test/timer'
+require 'cucumber/core/test/result'
+
+module Cucumber
+  module Core
+    module Test
+
+      class Mapping
+        def initialize(&block)
+          raise ArgumentError, "Passing a block to execute the mapping is mandatory." unless block
+          @block = block
+          @timer = Timer.new
+        end
+
+        def skip
+          skipped
+        end
+
+        def execute
+          @timer.start
+          @block.call
+          passed
+        rescue Result::Pending => exception
+          pending(exception)
+        rescue Exception => exception
+          failed(exception)
+        end
+
+        private
+
+        def passed
+          Result::Passed.new(@timer.duration)
+        end
+
+        def failed(exception)
+          Result::Failed.new(@timer.duration, exception)
+        end
+
+        def skipped
+          Result::Skipped.new
+        end
+
+        def pending(exception)
+          exception.with_duration(@timer.duration)
+        end
+      end
+
+      class UndefinedMapping
+        def execute
+          undefined
+        end
+
+        def skip
+          undefined
+        end
+
+        private
+
+        def undefined
+          Result::Undefined.new
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,191 @@
+# encoding: UTF-8¬
+require 'cucumber/initializer'
+
+module Cucumber
+  module Core
+    module Test
+      module Result
+        def self.status_queries(status)
+          Module.new do
+            [:passed, :failed, :undefined, :unknown, :skipped, :pending].each do |possible_status|
+              define_method("#{possible_status}?") do
+                possible_status == status
+              end
+            end
+          end
+        end
+
+        Unknown = Class.new do
+          include Result.status_queries :unknown
+
+          def describe_to(visitor, *args)
+            self
+          end
+        end
+
+        class Passed
+          include Result.status_queries :passed
+          include Cucumber.initializer(:duration)
+          attr_reader :duration
+
+          def initialize(duration)
+            raise ArgumentError unless duration
+            super
+          end
+
+          def describe_to(visitor, *args)
+            visitor.passed(*args)
+            visitor.duration(duration, *args)
+            self
+          end
+
+          def to_s
+            "✓"
+          end
+        end
+
+        class Failed
+          include Result.status_queries :failed
+          include Cucumber.initializer(:duration, :exception)
+          attr_reader :duration, :exception
+
+          def initialize(duration, exception)
+            raise ArgumentError unless duration 
+            raise ArgumentError unless exception
+            super
+          end
+
+          def describe_to(visitor, *args)
+            visitor.failed(*args)
+            visitor.duration(duration, *args)
+            visitor.exception(exception, *args) if exception
+            self
+          end
+
+          def to_s
+            "✗"
+          end
+
+          def with_duration(new_duration)
+            self.class.new(new_duration, exception)
+          end
+
+        end
+
+        Undefined = Class.new do
+          include Result.status_queries :undefined
+          include Cucumber.initializer(:duration)
+          attr_reader :duration
+
+          def initialize(duration = 0)
+            super
+          end
+
+          def describe_to(visitor, *args)
+            visitor.undefined(*args)
+            self
+          end
+
+          def to_s
+            "✗"
+          end
+
+          def with_duration(new_duration)
+            self.class.new(new_duration)
+          end
+        end
+
+        Skipped = Class.new do
+          include Result.status_queries :skipped
+
+          def describe_to(visitor, *args)
+            visitor.skipped(*args)
+            self
+          end
+
+          def to_s
+            "-"
+          end
+        end
+
+        class Pending < StandardError
+          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)
+            visitor.duration(duration, *args) unless duration == :unknown
+            self
+          end
+
+          def to_s
+            "P"
+          end
+
+          def with_duration(new_duration)
+            self.class.new(message, new_duration, backtrace)
+          end
+        end
+
+        class Summary
+          attr_reader :total_failed,
+            :total_passed,
+            :total_skipped,
+            :total_undefined,
+            :exceptions,
+            :durations
+
+          def initialize
+            @total_failed =
+              @total_passed =
+              @total_skipped =
+              @total_undefined = 0
+            @exceptions = []
+            @durations = []
+          end
+
+          def failed(*args)
+            @total_failed += 1
+            self
+          end
+
+          def passed(*args)
+            @total_passed += 1
+            self
+          end
+
+          def skipped(*args)
+            @total_skipped +=1
+            self
+          end
+
+          def undefined(*args)
+            @total_undefined += 1
+            self
+          end
+
+          def exception(exception)
+            @exceptions << exception
+            self
+          end
+
+          def duration(duration)
+            @durations << duration
+            self
+          end
+
+          def total
+            total_passed + total_failed + total_skipped + total_undefined
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+require 'cucumber/initializer'
+require 'cucumber/core/test/timer'
+
+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
+
+            def result
+              status.result(@timer.duration)
+            end
+
+            def failed(step_result)
+              @status = Failing.new(step_result)
+              self
+            end
+
+            def passed(step_result)
+              @status = Passing.new
+              self
+            end
+
+            def pending(message, step_result)
+              @status = Pending.new(step_result)
+              self
+            end
+
+            def undefined(step_result)
+              failed(step_result)
+              self
+            end
+
+            def exception(step_exception, step_result)
+              self
+            end
+
+            def duration(step_duration, step_result)
+              self
+            end
+
+            private
+
+            def status
+              @status ||= Unknown.new
+            end
+          end
+
+          class DryRun
+            def execute(test_step)
+              step_result = test_step.skip
+              @case_result = Result::Undefined.new if step_result.undefined?
+              step_result
+            end
+
+            def result
+              @case_result ||= Result::Skipped.new
+            end
+          end
+
+          class Unknown
+            def execute(test_step, monitor)
+              result = test_step.execute
+              result.describe_to(monitor, result)
+            end
+
+            def result(duration)
+              Result::Unknown.new
+            end
+          end
+
+          class Passing < Unknown
+            def result(duration)
+              Result::Passed.new(duration)
+            end
+          end
+
+          Failing = Struct.new(:step_result) do
+            def execute(test_step, monitor)
+              test_step.skip
+            end
+
+            def result(duration)
+              step_result.with_duration(duration)
+            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 = {})
+          @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
+          report.after_test_case(test_case, current_case_result)
+          @current_step_runner = nil
+        end
+
+        def test_step(test_step)
+          report.before_test_step test_step
+          step_result = current_step_runner.execute(test_step)
+          report.after_test_step test_step, step_result
+        end
+
+        def around_hook(hook, &continue)
+          hook.call(continue)
+        end
+
+        def done
+          report.done
+          self
+        end
+
+        private
+
+        def current_case_result
+          current_step_runner.result
+        end
+
+        def current_step_runner
+          @current_step_runner ||= step_runner_class.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require 'cucumber/initializer'
+require 'cucumber/core/test/result'
+require 'cucumber/core/test/mapping'
+
+module Cucumber
+  module Core
+    module Test
+      class Step
+        include Cucumber.initializer(:source)
+
+        def initialize(source, mapping = Test::UndefinedMapping.new)
+          raise ArgumentError if source.any?(&:nil?)
+          @mapping = mapping
+          super(source)
+        end
+
+        def describe_to(visitor, *args)
+          visitor.test_step(self, *args)
+        end
+
+        def describe_source_to(visitor, *args)
+          source.each do |node|
+            node.describe_to(visitor, *args)
+          end
+        end
+
+        def name
+          step.name
+        end
+
+        def multiline_arg
+          step.multiline_arg
+        end
+
+        def skip
+          @mapping.skip
+        end
+
+        def execute
+          @mapping.execute
+        end
+
+        def map(&block)
+          self.class.new(source, Test::Mapping.new(&block))
+        end
+
+        def location
+          step.location
+        end
+
+        def match_locations?(queried_locations)
+          return true if queried_locations.include? location
+          source.any? { |s| s.match_locations?(queried_locations) }
+        end
+
+        def inspect
+          "#{self.class}: #{location}"
+        end
+
+        private
+
+        def step
+          source.last
+        end
+
+      end
+    end
+  end
+end