minispec 0.0.1

data/lib/minispec/api/class/before.rb

@@ -0,0 +1,101 @@
+module MiniSpec
+  module ClassAPI
+
+    # run some code before any or matching tests.
+    # if called without arguments the hook will run before any test.
+    # if any arguments passed it will run only before matched tests.
+    # strings, symbols and regexps accepted as arguments.
+    # also :except option accepted.
+    #
+    # @example callback to run before any test
+    #   describe SomeTest do
+    #
+    #     before do
+    #       # ...
+    #     end
+    #   end
+    #
+    # @example callback to run only before :cart test
+    #   describe Specs do
+    #
+    #     before :cart do
+    #       # ...
+    #     end
+    #
+    #     testing :cart do
+    #       # ...
+    #     end
+    #   end
+    #
+    # @example callback to run before any test that match /cart/
+    #   describe Specs do
+    #
+    #     before /cart/ do
+    #       # ...
+    #     end
+    #
+    #     testing :cart do
+    #       # ...
+    #     end
+    #   end
+    #
+    # @example callback to run before any test that match /cart/ except :load_cart
+    #   describe Specs do
+    #
+    #     before /cart/, except: :load_cart do
+    #       # ...
+    #     end
+    #
+    #   end
+    #
+    # @example callback to run before any test that match /shoes/
+    #           but ones that match /red/
+    #   describe Specs do
+    #
+    #     before /shoes/, except: /red/ do
+    #       # ...
+    #     end
+    #
+    #   end
+    #
+    def before *matchers, &proc
+      proc || raise(ArgumentError, 'block is missing')
+      matchers.flatten!
+      matchers = [:*] if matchers.empty?
+      return if before?.find {|x| x[0] == matchers && x[1].source_location == proc.source_location}
+      before?.push([matchers, proc])
+    end
+
+    def before? filter = nil
+      hooks_filter(@before ||= [], filter)
+    end
+
+    def reset_before
+      @before = []
+    end
+
+    # import `:before` and `:before_all` hooks from base
+    def import_before base
+      import_instance_variable(:before_all, base)
+      base.before?.each {|(m,p)| self.before(m, &p)}
+    end
+    alias import_before_from import_before
+
+    # code to run once at spec initialization, just before start running tests.
+    # this callback will run only once - at spec initialization.
+    # for callbacks that runs before any test @see #before
+    def before_all &proc
+      proc || raise(ArgumentError, 'block is missing')
+      @before_all = proc
+    end
+    alias before! before_all
+
+    def before_all?
+      @before_all
+    end
+
+    def reset_before_all
+      remove_instance_variable(:@before_all)
+    end
+  end
+end

data/lib/minispec/api/class/helpers.rb

@@ -0,0 +1,116 @@
+module MiniSpec
+  module ClassAPI
+
+    # define custom assertion helpers.
+    #
+    # @note  helpers can be overridden by name,
+    # that's it, if some spec inherits `:a_duck?` helper
+    # you can use `helper(:a_duck?) { ... }` to override it.
+    #
+    # @note  tested object are passed to helper via first argument.
+    #   any arguments passed to helper are sent after tested object.
+    #
+    # @note  if a block used on left side,
+    #   it will be passed as last argument and the helper is responsible to call it.
+    #   please note that block will be passed as usual argument rather than a block.
+    #
+    # @note  if you need the current context to be passed into helper
+    #   use `:with_context` option. when doing so,
+    #   the context will come as last argument.
+    #
+    # @example
+    #
+    #   describe SomeTest do
+    #
+    #     helper :a_pizza? do |food|
+    #       does(food) =~  /cheese/
+    #       does(food) =~ /olives/
+    #     end
+    #
+    #     testing :foods do
+    #       food = Cook.some_food(with: 'cheese', and: 'olives')
+    #       is(food).a_pizza? #=> passed
+    #
+    #       food = Cook.some_food(with: 'potatoes')
+    #       is(food).a_pizza? #=> failed
+    #     end
+    #   end
+    #
+    # @example any other arguments are sent after tested object
+    #
+    #   describe SomeTest do
+    #
+    #     helper :a_pizza? do |food, ingredients|
+    #       does(food) =~ /dough/
+    #       does(ingredients).include? 'cheese'
+    #       does(ingredients).include? 'olives'
+    #     end
+    #
+    #     testing :foods do
+    #       ingredients = ['cheese', 'olives']
+    #       food = Cook.some_food(ingredients)
+    #       is(food).a_pizza? ingredients
+    #     end
+    #   end
+    #
+    # @example  given block passed as last argument
+    #
+    #    # block comes as a usual argument rather than a block
+    #    helper :is_invalid do |attr, block|
+    #      e = assert(&block).raise(FormulaValidationError)
+    #      assert(e.attr) == attr
+    #    end
+    #
+    #    test 'validates name' do
+    #      assert(:name).is_invalid do
+    #        formula "name with spaces" do
+    #          url "foo"
+    #          version "1.0"
+    #        end
+    #      end
+    #    end
+    #
+    # @example  using `with_context` option to get context as last argument
+    #
+    #   describe SomeTest do
+    #
+    #     helper :a_pizza?, with_context: true do |subject, ingredients, context|
+    #       # context is a Hash containing :left_method, left_object, :left_proc and :negation keys
+    #     end
+    #
+    #     testing :foods do
+    #       is(:smth).a_pizza? ['some', 'ingredients']
+    #       # helper's context will look like:
+    #       # {left_method: :is, left_object: :smth, left_proc: nil, negation: nil}
+    #
+    #       is { smth }.a_pizza? ['some', 'ingredients']
+    #       # helper's context will look like:
+    #       # {left_method: :is, left_object: nil, left_proc: 'the -> { smth } proc', negation: nil}
+    #     end
+    #   end
+    #
+    def helper helper, opts = {}, &proc
+      proc || raise(ArgumentError, 'block is missing')
+      helpers[helper] = [proc, opts]
+    end
+
+    def helpers
+      @helpers ||= {}
+    end
+
+    def alias_helper target, source
+      proc, opts = helpers[source]
+      proc || raise(ArgumentError, '%s helper does not exists' % source.inspect)
+      helper(target, opts, &proc)
+    end
+
+    def import_helpers base
+      base.helpers.each_pair {|h,(p,o)| self.helper(h, o, &p)}
+    end
+    alias import_helpers_from import_helpers
+
+    def reset_helpers
+      @helpers = {}
+    end
+  end
+end

data/lib/minispec/api/class/let.rb

@@ -0,0 +1,44 @@
+module MiniSpec
+  module ClassAPI
+
+    # @example
+    #   describe Math do
+    #     let(:x) { 0.1 }
+    #     let(:y) { 1.0 }
+    #
+    #     test 'x vs y' do
+    #       assert(x) < y
+    #     end
+    #   end
+    #
+    def let meth, &proc
+      proc || raise(ArgumentError, 'block is missing')
+      vars[meth] = proc
+      define_method(meth) { @__ms__vars[meth] ||= self.instance_exec(&proc) }
+    end
+
+    # same as #let except it will compute the value on every run
+    def let! meth, &proc
+      proc || raise(ArgumentError, 'block is missing')
+      vars[meth] = proc
+      define_method(meth, &proc)
+    end
+
+    def subject &proc
+      let(:subject, &proc)
+    end
+
+    def vars
+      @vars ||= {}
+    end
+
+    def import_vars base
+      base.vars.each_pair {|v,p| self.let(v, &p)}
+    end
+    alias import_vars_from import_vars
+
+    def reset_vars
+      @vars = {}
+    end
+  end
+end

data/lib/minispec/api/class/tests.rb

@@ -0,0 +1,33 @@
+module MiniSpec
+  module ClassAPI
+
+    MiniSpec::TEST_WRAPPERS.each do |verb|
+      # defines test wrappers, class methods that receives test label as first argument
+      # and test body as block.
+      # given block will be executed inside spec instance.
+      #
+      # @param label
+      # @param &proc
+      define_method verb do |label, &proc|
+        # do NOT stringify label!
+        # otherwise many before/after/around hooks will broke
+        tests[label] = [verb.to_s, proc]
+      end
+    end
+
+    def tests
+      @tests ||= {}
+    end
+
+    def import_tests base
+      return if base == Minispec
+      base.tests.each_pair {|l,(v,p)| self.send(v, l, &p)}
+    end
+    alias import_tests_from import_tests
+
+    def reset_tests
+      @tests = {}
+    end
+
+  end
+end

data/lib/minispec/api/instance.rb

@@ -0,0 +1,158 @@
+module MiniSpec
+  module InstanceAPI
+
+    # @return [Array]
+    attr_reader :__ms__failures
+
+    attr_accessor :__ms__inside_helper
+
+    (MiniSpec::AFFIRMATIONS + MiniSpec::NEGATIONS).each do |left_method|
+      # defining methods that will proxy tested object.
+      # methods accepts either a single argument or no arguments at all.
+      # if no arguments nor block given, it will use `subject` as test object(@see #subject).
+      # if block given it will have priority over both arguments and subject.
+      #
+      # @example test object passed into `is` proxy via first argument
+      #   is(1) < 2
+      #
+      # @example test object passed into `does` proxy via block
+      #   does { some_array }.include? some_value
+      #
+      # @param *args
+      # @return [MiniSpec::Proxy] a proxy instance
+      #   that will send all received messages to tested object and track the result
+      #
+      define_method left_method do |*args, &proc|
+        Minispec.assertions += 1
+        MiniSpec::Utils.valid_proxy_arguments?(left_method, *args, &proc)
+        __ms__inside_helper ? @__ms__callers.push(caller[0]) : @__ms__callers = [caller[0]]
+        # using args#size rather than args#any? cause first argument can be nil or false
+        left_object = args.size > 0  ? args.first : self.subject
+        negate  = MiniSpec::NEGATIONS.include?(left_method)
+        failure_message = args[1].is_a?(Hash) ?
+          args[1][:message] || args[1][:failure] || args[1][:error] :
+          nil
+        MiniSpec::Proxy.new(self, left_method, left_object, negate, failure_message, &proc)
+      end
+    end
+
+    # this will be overridden when the spec are defined using Minispec's DSL
+    #
+    # @example
+    #   describe Hash do
+    #     # subject will be set to Hash
+    #     it 'responds to :[]' do
+    #       assert.respond_to?(:[]) # same as assert(Hash).respond_to?(:[])
+    #     end
+    #   end
+    #
+    def subject; end
+
+    # stop evaluation of the current test right away
+    #
+    # @example
+    #   test :some_test do
+    #     is(1) < 2
+    #     skip
+    #     is(1) > 2 # this wont be evaluated so the test will pass
+    #   end
+    #
+    def skip
+      @__ms__skipped = caller.first
+      throw :__ms__stop_evaluation
+    end
+    alias skip! skip
+
+    def __ms__skipped?; @__ms__skipped end
+
+    # adds a new failure to the stack.
+    # a failure is a Hash containing keys like
+    #   :message
+    #   :left_method
+    #   :left_object
+    #   :right_method
+    #   :right_object
+    #   :negation
+    #   :callers
+    # used by MiniSpec::Run#failures_summary and MiniSpecRun#failure_message
+    # to output useful info about failed tests.
+    #
+    # @param failure  if failure is `nil` or `false` it simply returns.
+    #                 unless failure is a Hash it is building a Hash like
+    #                 {message: failure} and adding it to the stack.
+    # @return [Array] failures stack
+    def fail failure = {}
+      return unless failure
+      unless failure.is_a?(Hash)
+        failure || raise(ArgumentError, 'Please provide a failure message')
+        failure = {message: failure}
+      end
+      @__ms__failures << failure.merge(callers: @__ms__callers)
+      throw :__ms__stop_evaluation unless self.class.continue_on_failures?
+    end
+    alias fail! fail
+
+    # @api private
+    # setting/resetting all necessary instance variables
+    # for a test to run in clean state
+    def __ms__prepare_test
+      @__ms__vars     = {}
+      @__ms__failures = []
+      @__ms__skipped  = nil
+      __ms__mocks__reset_variables
+    end
+
+    def __ms__mocks__reset_variables
+      @__ms__messages          = []
+      @__ms__proxies           = {}
+      @__ms__stubs             = {}
+      @__ms__stubs__originals  = {}
+      @__ms__expectations      = []
+    end
+
+    def __ms__run_test label
+      Minispec.tests += 1
+      __ms__prepare_test
+      runner = proc do
+        # running :before hooks, if any
+        self.class.before?(label).each {|(l,m,b)| instance_exec(l,m,&b)}
+
+        # running test
+        catch :__ms__stop_evaluation do
+          instance_exec(&self.class.tests[label].last)
+        end
+
+        # running :after hooks, if any
+        self.class.after?(label).each {|(l,m,b)| instance_exec(l,m,&b)}
+      end
+
+      if around = self.class.around?(label).last
+        self.instance_exec(runner, &around.last)
+      else
+        runner.call
+      end
+
+      __ms__mocks__validate_expectations
+      __ms__mocks__restore_originals
+      @__ms__failures
+    rescue Exception => e
+      [e]
+    ensure
+      __ms__mocks__reset_variables
+    end
+
+    # runs before any tests
+    def __ms__boot
+      __ms__prepare_test
+      (hook = self.class.before_all?) && self.instance_exec(&hook)
+    end
+
+    # runs after all tests finished.
+    # runs unconditionally even when there are failed tests.
+    def __ms__halt
+      (hook = self.class.after_all?) && self.instance_exec(&hook)
+    end
+  end
+end
+
+Dir[File.expand_path('../instance/**/*.rb', __FILE__)].each {|f| require(f)}