crspec 0.1.2 → 0.1.3

data/lib/crspec/example_group.rb

@@ -4,22 +4,28 @@ require_relative "expectations"
 require_relative "example"
 require_relative "mock/double"
 require_relative "configuration"
+require_relative "file_fixtures"
+require_relative "shared_examples"
 
 module Crspec
   class ExampleGroup
     include Expectations
     include Mock::DSL
+    include SharedDSL
 
-    attr_reader :description, :metadata, :parent, :examples, :children, :before_hooks, :after_hooks
+    attr_reader :description, :metadata, :parent, :examples, :children, :before_hooks, :after_hooks, :around_hooks
+    attr_accessor :described_module
 
     def initialize(description, metadata = {}, parent = nil)
       @description = description
+      @described_module = description.is_a?(Module) ? description : nil
       @metadata = metadata.freeze
       @parent = parent
       @examples = []
       @children = []
       @before_hooks = []
       @after_hooks = []
+      @around_hooks = []
       @let_blocks = {}
       @eager_lets = []
       @included_modules = []
@@ -31,24 +37,111 @@ module Crspec
       group
     end
 
-    def describe(description, metadata = {}, &block)
-      child = self.class.define(description, metadata, self, &block)
+    def describe(*args, **kwargs, &block)
+      metadata = kwargs.dup
+      metadata.merge!(args.pop) if args.last.is_a?(Hash)
+      described = args.first.is_a?(Module) ? args.first : nil
+      description = described && args.size == 1 ? described : args.map(&:to_s).join(" ")
+      child = self.class.new(description, metadata, self)
+      child.described_module = described
+      child.instance_eval(&block) if block
       @children << child
       child
     end
     alias context describe
 
+    def xdescribe(*args, **kwargs, &block)
+      child = describe(*args, **kwargs, &block)
+      child.mark_pending!
+      child
+    end
+    alias xcontext xdescribe
+
+    def fdescribe(*args, **kwargs, &block)
+      child = describe(*args, **kwargs, &block)
+      child.mark_focused!
+      child
+    end
+    alias fcontext fdescribe
+
     def it(description = nil, metadata = {}, &block)
-      example = Example.new(description || "unnamed example", metadata, self, block)
+      example = Example.new(description || "unnamed example", metadata, self, block,
+                            pending: pending?)
       @examples << example
       example
     end
     alias specify it
 
+    def xit(description = nil, metadata = {}, &block)
+      example = Example.new(description || "unnamed example", metadata, self, block,
+                            pending: true)
+      @examples << example
+      example
+    end
+    alias pending xit
+    alias skip xit
+
+    def fit(description = nil, metadata = {}, &block)
+      example = it(description, metadata, &block)
+      example.focused = true
+      example
+    end
+
+    def mark_pending!
+      @pending = true
+      @examples.each { |ex| ex.instance_variable_set(:@pending, true) }
+      @children.each(&:mark_pending!)
+      self
+    end
+
+    def pending?
+      !!@pending || (parent ? parent.pending? : false)
+    end
+
+    def mark_focused!
+      @focused = true
+      @examples.each { |ex| ex.focused = true }
+      @children.each(&:mark_focused!)
+      self
+    end
+
+    def focused?
+      !!@focused
+    end
+
     def include(mod)
       @included_modules << mod
     end
 
+    def render_views(*args)
+    end
+
+    def private(*args)
+    end
+
+    def public(*args)
+    end
+
+    def protected(*args)
+    end
+
+    def attr_reader(*names)
+      names.each do |name|
+        let(name) { instance_variable_get("@#{name}") }
+      end
+    end
+
+    def attr_writer(*names)
+      names.each do |name|
+        define_method("#{name}=") { |val| instance_variable_set("@#{name}", val) }
+      end
+    end
+
+    def attr_accessor(*names)
+      attr_reader(*names)
+      attr_writer(*names)
+    end
+
     def let(name, &block)
       @let_blocks[name.to_sym] = block
     end
@@ -67,79 +160,276 @@ module Crspec
       end
     end
 
-    def before(_scope = :each, &block)
-      @before_hooks << block
+    FORBIDDEN_HOOK_SCOPES = %i[all context suite].freeze
+
+    def before(*args, **kwargs, &block)
+      reject_serial_scope!(:before, args)
+      @before_hooks << { block: block, filters: args, kwfilters: kwargs }
     end
 
-    def after(_scope = :each, &block)
-      @after_hooks.unshift(block)
+    def after(*args, **kwargs, &block)
+      reject_serial_scope!(:after, args)
+      @after_hooks.unshift({ block: block, filters: args, kwfilters: kwargs })
     end
 
-    def ancestor_hooks(type)
-      hooks = []
-      hooks.concat(Crspec.configuration.before_hooks) if type == :before
+    def reject_serial_scope!(hook_name, args)
+      scope = args.first
+      return unless scope.is_a?(Symbol) && FORBIDDEN_HOOK_SCOPES.include?(scope)
 
-      curr = self
-      ancestors = []
-      while curr
-        ancestors.unshift(curr)
-        curr = curr.parent
-      end
+      raise MigrationError, <<~MSG
+        #{hook_name}(:#{scope}) is not supported by Crspec: shared state across
+        examples is inherently serial and breaks the P processes x N threads x
+        M fibers execution model.
 
-      ancestors.each do |grp|
-        list = type == :before ? grp.before_hooks : grp.after_hooks
-        hooks.concat(list)
+        Migrate to per-example setup instead:
+          - use before(:each) if the setup is cheap
+          - use let/let! for lazily-built (memoized per example) values
+
+        Run `crspec-transpile --analyze` on your suite to find and rewrite all
+        occurrences automatically.
+      MSG
+    end
+
+    def around(*args, **kwargs, &block)
+      @around_hooks << { block: block, filters: args, kwfilters: kwargs }
+    end
+
+    def finalize!
+      ancestor_metadata
+      ancestor_let_blocks
+      ancestor_eager_lets
+      ancestor_included_modules
+      described_class
+      %i[before after around].each { |type| raw_hooks_for(type) }
+
+      example_types = examples.map { |ex| effective_type_for(ex) }.uniq
+      example_types.each do |type|
+        %i[before after around].each { |hook_type| filtered_hooks(hook_type, type) }
+        modules_for_type(type)
+        example_class_for(type)
       end
 
-      hooks.concat(Crspec.configuration.after_hooks) if type == :after
+      children.each(&:finalize!)
+      self
+    end
 
-      hooks
+    def ancestor_hooks(type, example = nil)
+      filtered_hooks(type, example ? effective_type_for(example) : ancestor_metadata[:type])
     end
 
     def ancestor_let_blocks
-      blocks = {}
-      curr = self
-      ancestors = []
-      while curr
-        ancestors.unshift(curr)
-        curr = curr.parent
-      end
-      ancestors.each do |grp|
-        blocks.merge!(grp.instance_variable_get(:@let_blocks))
+      @ancestor_let_blocks ||= begin
+        blocks = {}
+        ancestor_chain.each do |grp|
+          blocks.merge!(grp.instance_variable_get(:@let_blocks))
+        end
+        unless blocks.key?(:subject)
+          desc_cls = described_class
+          if desc_cls.is_a?(Class)
+            blocks[:subject] = proc { desc_cls.new rescue nil }
+          elsif desc_cls
+            blocks[:subject] = proc { desc_cls }
+          end
+        end
+        blocks.freeze
       end
-      blocks
     end
 
     def ancestor_eager_lets
-      eager = []
-      curr = self
-      while curr
-        eager.concat(curr.instance_variable_get(:@eager_lets))
-        curr = curr.parent
-      end
-      eager
+      @ancestor_eager_lets ||= ancestor_chain.flat_map do |grp|
+        grp.instance_variable_get(:@eager_lets)
+      end.freeze
     end
 
     def ancestor_included_modules
-      mods = []
-      curr = self
-      ancestors = []
-      while curr
-        ancestors.unshift(curr)
-        curr = curr.parent
+      @ancestor_included_modules ||= ancestor_chain.flat_map do |grp|
+        grp.instance_variable_get(:@included_modules) || []
+      end.freeze
+    end
+
+    def ancestor_metadata
+      @ancestor_metadata ||= begin
+        meta = {}
+        ancestor_chain.each do |grp|
+          meta.merge!(grp.metadata || {})
+        end
+        meta.freeze
       end
-      ancestors.each do |grp|
-        mods.concat(grp.instance_variable_get(:@included_modules) || [])
+    end
+
+    def modules_for_example(example)
+      modules_for_type(effective_type_for(example))
+    end
+
+    def described_class
+      return @described_class if defined?(@described_class)
+
+      @described_class = begin
+        found = nil
+        curr = self
+        while curr
+          if curr.described_module
+            found = curr.described_module
+            break
+          end
+          curr = curr.parent
+        end
+        found
+      end
+    end
+
+    def effective_type_for(example)
+      meta = example.metadata || {}
+      meta.key?(:type) ? meta[:type] : ancestor_metadata[:type]
+    end
+
+    def run_eager_lets(instance)
+      ancestor_eager_lets.each do |name|
+        instance.send(name)
       end
-      mods
     end
 
     def create_instance(example)
-      modules_to_include = (Crspec.configuration.included_modules + ancestor_included_modules).uniq
+      klass = example_class_for(effective_type_for(example))
+      inst = klass.new(example)
+
+      klass.setup_callbacks.each do |cb|
+        if cb.is_a?(Symbol) || cb.is_a?(String)
+          inst.send(cb)
+        elsif cb.respond_to?(:call)
+          inst.instance_exec(&cb)
+        end
+      end
+
+      inst
+    end
+
+    private
+
+    def ancestor_chain
+      @ancestor_chain ||= begin
+        chain = []
+        curr = self
+        while curr
+          chain.unshift(curr)
+          curr = curr.parent
+        end
+        chain.freeze
+      end
+    end
+
+    def raw_hooks_for(type)
+      @raw_hooks_for ||= {}
+      @raw_hooks_for[type] ||= begin
+        raw_hooks = []
+        if type == :before
+          raw_hooks.concat(Crspec.configuration.before_hooks)
+        elsif type == :around
+          raw_hooks.concat(Crspec.configuration.around_hooks)
+        end
+
+        ancestor_chain.each do |grp|
+          list = case type
+                 when :before then grp.before_hooks
+                 when :after then grp.after_hooks
+                 when :around then grp.around_hooks
+                 end
+          raw_hooks.concat(list)
+        end
+
+        raw_hooks.concat(Crspec.configuration.after_hooks) if type == :after
+        raw_hooks.freeze
+      end
+    end
+
+    def filtered_hooks(hook_type, meta_type)
+      @filtered_hooks ||= {}
+      @filtered_hooks[[hook_type, meta_type]] ||= raw_hooks_for(hook_type).filter_map do |hook|
+        if hook.is_a?(Hash)
+          blk = hook[:block]
+          kw = hook[:kwfilters] || {}
+          filters = hook[:filters] || []
+
+          target_type = kw[:type] || (filters.first.is_a?(Hash) && filters.first[:type])
+          next if target_type && meta_type != target_type
+
+          blk
+        else
+          hook
+        end
+      end.freeze
+    end
+
+    def modules_for_type(meta_type)
+      @modules_for_type ||= {}
+      @modules_for_type[meta_type] ||= begin
+        all_entries = Crspec.configuration.included_modules + ancestor_included_modules
+
+        all_entries.filter_map do |entry|
+          if entry.is_a?(Hash)
+            mod = entry[:module]
+            kw = entry[:kwfilters] || {}
+            filters = entry[:filters] || []
+
+            target_type = kw[:type] || (filters.first.is_a?(Hash) && filters.first[:type])
+            next if target_type && meta_type != target_type
+
+            mod
+          else
+            entry
+          end
+        end.uniq.freeze
+      end
+    end
+
+    def example_class_for(meta_type)
+      @example_class_for ||= {}
+      @example_class_for[meta_type] ||= build_example_class(meta_type)
+    end
+
+    def build_example_class(meta_type)
+      modules_to_include = modules_for_type(meta_type)
+      desc_cls = described_class
 
       klass = Class.new do
+        define_singleton_method(:spec_type) { meta_type }
+
+        class << self
+          attr_writer :controller_class
+
+          def controller_class
+            @controller_class
+          end
+
+          def setup(*args, &block)
+            @setup_callbacks ||= []
+            @setup_callbacks << (block || args.first)
+          end
+
+          def teardown(*args, &block)
+            @teardown_callbacks ||= []
+            @teardown_callbacks << (block || args.first)
+          end
+
+          def setup_callbacks
+            @setup_callbacks || []
+          end
+
+          def teardown_callbacks
+            @teardown_callbacks || []
+          end
+        end
+
         include Expectations
         include Mock::DSL
+        include FileFixtures
+
+        if meta_type == :controller
+          include ActionController::TestCase::Behavior if defined?(ActionController::TestCase::Behavior)
+        elsif meta_type == :request
+          include ActionDispatch::Integration::Runner if defined?(ActionDispatch::Integration::Runner)
+          include ActionDispatch::IntegrationTest::Behavior if defined?(ActionDispatch::IntegrationTest::Behavior)
+        end
 
         modules_to_include.each do |mod|
           include mod
@@ -147,8 +437,25 @@ module Crspec
 
         attr_reader :__crspec_example__
 
-        def initialize(example)
+        define_method(:initialize) do |example|
           @__crspec_example__ = example
+          meta_type = self.class.spec_type
+          is_controller = meta_type == :controller || (desc_cls.is_a?(Class) && desc_cls.ancestors.map(&:to_s).include?("ActionController::Metal"))
+          if is_controller
+            ctrl_cls = desc_cls
+            begin
+              @controller = ctrl_cls.new if ctrl_cls.is_a?(Class)
+            rescue StandardError
+              # ignore
+            end
+            if defined?(ActionDispatch::TestRequest)
+              @request = ActionDispatch::TestRequest.create rescue nil
+              @response = ActionDispatch::TestResponse.new rescue nil
+            end
+            if defined?(::Rails) && ::Rails.application
+              @routes = ::Rails.application.routes
+            end
+          end
         end
 
         def execution_context
@@ -156,13 +463,14 @@ module Crspec
         end
         alias current_context execution_context
 
-        def described_class
-          nil
+        define_method(:described_class) do
+          desc_cls
         end
       end
 
-      lets = ancestor_let_blocks
-      lets.each do |let_name, let_proc|
+      klass.controller_class = desc_cls if desc_cls.is_a?(Class)
+
+      ancestor_let_blocks.each do |let_name, let_proc|
         current_proc = let_proc
         klass.define_method(let_name) do
           ExecutionContext.current.fetch_memoized(let_name) do
@@ -171,15 +479,7 @@ module Crspec
         end
       end
 
-      inst = klass.new(example)
-
-      # Evaluate eager lets
-      eager_lets = ancestor_eager_lets
-      eager_lets.each do |name|
-        inst.send(name)
-      end
-
-      inst
+      klass
     end
   end
 end

data/lib/crspec/execution_context.rb

@@ -14,13 +14,17 @@ module Crspec
     end
 
     def self.isolate(example_id, metadata = {})
-      parent_context = Fiber[STORAGE_KEY]
-      new_context = new(example_id, metadata, parent_context)
-
-      # Fiber storage inheritance preserves context while isolating mutations
-      Fiber.new(storage: { STORAGE_KEY => new_context }) do
+      new_context = new(example_id, metadata, Fiber[STORAGE_KEY])
+      old_context = Fiber[STORAGE_KEY]
+      old_space = Fiber[Mock::Space::STORAGE_KEY]
+      Fiber[STORAGE_KEY] = new_context
+      Fiber[Mock::Space::STORAGE_KEY] = nil
+      begin
         yield new_context
-      end.resume
+      ensure
+        Fiber[STORAGE_KEY] = old_context
+        Fiber[Mock::Space::STORAGE_KEY] = old_space
+      end
     end
 
     def initialize(example_id, metadata = {}, parent = nil)

data/lib/crspec/expectations.rb

@@ -5,6 +5,42 @@ require_relative "matchers"
 module Crspec
   class ExpectationNotMetError < StandardError; end
 
+  class MultipleExpectationsNotMetError < ExpectationNotMetError
+    attr_reader :failures
+
+    def initialize(failures)
+      @failures = failures
+      summary = failures.each_with_index.map { |msg, i| "  #{i + 1}) #{msg}" }.join("\n")
+      super("Got #{failures.size} failure(s):\n#{summary}")
+    end
+  end
+
+  # Fiber-local failure accumulator backing aggregate_failures.
+  module FailureAggregator
+    STORAGE_KEY = :crspec_failure_aggregator
+
+    def self.active?
+      !Fiber[STORAGE_KEY].nil?
+    end
+
+    def self.record(message)
+      Fiber[STORAGE_KEY] << message
+    end
+
+    def self.aggregate
+      previous = Fiber[STORAGE_KEY]
+      Fiber[STORAGE_KEY] = []
+      begin
+        yield
+        failures = Fiber[STORAGE_KEY]
+        raise MultipleExpectationsNotMetError, failures if failures.size > 1
+        raise ExpectationNotMetError, failures.first if failures.size == 1
+      ensure
+        Fiber[STORAGE_KEY] = previous
+      end
+    end
+  end
+
   class ExpectationTarget
     def initialize(actual)
       @actual = actual
@@ -14,7 +50,10 @@ module Crspec
       matcher ||= block
       return matcher.setup_expect(@actual) if matcher.respond_to?(:setup_expect)
 
-      raise ExpectationNotMetError, matcher.failure_message unless matcher.matches?(@actual)
+      unless matcher.matches?(@actual)
+        fail_with(matcher.failure_message)
+        return false
+      end
 
       true
     end
@@ -23,22 +62,43 @@ module Crspec
       matcher ||= block
       if matcher.matches?(@actual)
         msg = matcher.respond_to?(:failure_message_when_negated) ? matcher.failure_message_when_negated : "Expected matcher not to match"
-        raise ExpectationNotMetError, msg
+        fail_with(msg)
+        return false
       end
       true
     end
 
     alias to_not not_to
+
+    private
+
+    def fail_with(message)
+      if FailureAggregator.active?
+        FailureAggregator.record(message)
+      else
+        raise ExpectationNotMetError, message
+      end
+    end
   end
 
   module Expectations
     include Matchers
 
+    ExpectationNotMetError = Crspec::ExpectationNotMetError
+
     UNDEFINED = Object.new.freeze
 
     def expect(value = UNDEFINED, &block)
       actual = value.equal?(UNDEFINED) ? block : value
       ExpectationTarget.new(actual)
     end
+
+    def is_expected
+      expect(subject)
+    end
+
+    def aggregate_failures(_label = nil, &block)
+      FailureAggregator.aggregate(&block)
+    end
   end
 end

data/lib/crspec/file_fixtures.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Crspec
+  module FileFixtures
+    def file_fixture_path
+      Crspec.configuration.file_fixture_path
+    end
+
+    def file_fixture(fixture_name)
+      path = Pathname.new(File.join(file_fixture_path, fixture_name))
+      return path if path.file?
+
+      raise ArgumentError, "the directory '#{file_fixture_path}' does not contain a file named '#{fixture_name}'"
+    end
+  end
+end