minispec 0.0.1

data/lib/minispec/mocks/validations/return.rb

@@ -0,0 +1,74 @@
+class MiniSpec::Mocks::Validations
+
+  # extending expectation by expecting a specific returned value
+  #
+  # @example
+  #   expect(obj).to_receive(:a).and_return(1)
+  #   # for this to pass `obj.a` should return 1
+  #
+  # @example
+  #   expect(obj).to_receive(:a, :b).and_return(1, 2)
+  #   # for this to pass `obj.a` should return 1 and `obj.b` should return 2
+  #
+  # @example using a block to validate returned value
+  #   expect(obj).to_receive(:a).and_return {|v| v == 1}
+  #   # for this to pass `obj.a` should return 1
+  #
+  def and_return *expected, &block
+    return self if @failed
+    assert_given_arguments_match_received_messages(*expected, &block)
+    received = returned_values
+
+    if block
+      return @base.instance_exec(*received.values, &block) ||
+        returned_value_error!(@expected_messages, block, received)
+    end
+
+    expected = zipper(@expected_messages, expected)
+    received.each_pair do |msg,values|
+      # each message should return expected value at least once
+      values.any? {|v| validate_returned_value(expected[msg], v)} ||
+        returned_value_error!(msg, expected[msg], msg => values)
+    end
+    self
+  end
+  alias and_returned and_return
+
+  private
+  def returned_values
+    @expected_messages.inject({}) do |map,msg|
+      map.merge(msg => @messages[msg] ? @messages[msg].map {|m| m[:returned]} : [])
+    end
+  end
+
+  def validate_returned_value expected, returned
+    if expected.is_a?(Regexp)
+      return returned.is_a?(Regexp) ? expected == returned : returned.to_s =~ expected
+    end
+    expected == returned
+  end
+
+  def returned_value_error! message, expected, received
+    fail_with("%s received %s message(s) and returned unexpected value(s).\nExpected: %s\nActual:   %s" % [
+      pp(@object),
+      pp(message),
+      expected.is_a?(Proc) ?
+        'to pass validation at %s' % pp(source(expected)) :
+        pp(expected),
+      stringify_returned_values(received)
+    ])
+  end
+
+  def stringify_returned_values returned
+    returned.is_a?(Hash) || raise(ArgumentError, 'a Hash expected')
+    returned.map do |msg,values|
+      values.each_with_index.map do |value,i|
+        '%s call #%s returned %s' % [
+          pp(msg),
+          i + 1,
+          pp(value)
+        ]
+      end*"\n          "
+    end*"\n          "
+  end
+end

data/lib/minispec/mocks/validations/throw.rb

@@ -0,0 +1,91 @@
+class MiniSpec::Mocks::Validations
+  # checks whether received message throws expected symbol
+  #
+  # @note  you can match against thrown symbol but not against value.
+  #         this is a WONTFIX limitation. though it is doable
+  #         this would introduce a new layer of unproven complexity.
+  #
+  # @example
+  #   expect(obj).to_receive(:a).and_throw(:something)
+  #
+  # @example
+  #   expect(obj).to_receive(:a, :b).and_throw(:A, :B)
+  #   # for this to pass `obj.a` should throw :A and `obj.b` :B
+  #
+  def and_throw *expected, &block
+    return self if @failed
+    expected.all? {|x| x.is_a?(Symbol)} || raise(ArgumentError, '`and_throw` accepts only symbols')
+    # `and_throw` can be called without arguments
+    expected.empty? || assert_given_arguments_match_received_messages(*expected, &block)
+    received = thrown_symbols
+
+    if block
+      return @base.instance_exec(*received.values, &block) ||
+        throw_error!(@expected_messages, block, received)
+    end
+
+    expected = zipper(@expected_messages, expected)
+    received.each_pair do |msg,calls|
+      # each message should throw expected symbol at least once.
+      # if no specific symbol expected, check whether any symbol thrown.
+      calls.any? {|s| expected[msg] ? s == expected[msg] : s.is_a?(Symbol)} ||
+        throw_error!(msg, expected[msg], msg => calls)
+    end
+    self
+  end
+  alias and_thrown  and_throw
+  alias and_thrown? and_throw
+
+  # assure received message does not throw a symbol
+  #
+  # @example
+  #   expect(obj).to_receive(:a).without_throw
+  #
+  def without_throw
+    return self if @failed
+    thrown_symbols.each_pair do |msg,calls|
+      calls.any? {|x| x.is_a?(Symbol)} && unexpected_throw_error!(msg, calls)
+    end
+    self
+  end
+
+  private
+  def thrown_symbols
+    @expected_messages.inject({}) do |map,msg|
+      map.merge(msg => @messages[msg] ? @messages[msg].map {|m| extract_thrown_symbol(m[:raised])} : [])
+    end
+  end
+
+  def unexpected_throw_error! message, received
+    fail_with("%s received %s message(s) and thrown an unexpected symbol.\nExpected: %s\nActual:   %s" % [
+      pp(@object),
+      pp(message),
+      'nothing to be thrown',
+      stringify_thrown_symbols(message => received)
+    ])
+  end
+
+  def throw_error! message, expected, received
+    fail_with("%s received %s message(s) but did not throw accordingly.\nExpected: %s\nActual:   %s" % [
+      pp(@object),
+      pp(message),
+      expected.is_a?(Proc) ?
+        'results to be validated at %s' % pp(source(expected)) :
+        pp(expected),
+      stringify_thrown_symbols(received)
+    ])
+  end
+
+  def stringify_thrown_symbols received
+    received.is_a?(Hash) || raise(ArgumentError, 'a Hash expected')
+    received.map do |msg,calls|
+      calls.each_with_index.map do |call,i|
+        '%s call #%s thrown %s' % [
+          pp(msg),
+          i + 1,
+          call.is_a?(Symbol) ? pp(call) : 'nothing'
+        ]
+      end*"\n          "
+    end*"\n          "
+  end
+end

data/lib/minispec/mocks/validations/yield.rb

@@ -0,0 +1,141 @@
+class MiniSpec::Mocks::Validations
+  class AnyYield; end
+
+  # extending expectation by expecting received message to yield
+  #
+  # @example
+  #   class Apple
+  #
+  #     def color
+  #       yield
+  #     end
+  #
+  #     def taste
+  #     end
+  #   end
+  #
+  #   describe Apple do
+  #     testing :color do
+  #       apple = Apple.new
+  #
+  #       expect(apple).to_receive(:color).and_yield # => will pass
+  #       expect(apple).to_receive(:taste).and_yield # => will fail
+  #     end
+  #   end
+  #
+  # @example
+  #   class Apple
+  #
+  #     def color
+  #       yield 1, 2
+  #     end
+  #   end
+  #
+  #   describe Apple do
+  #     testing :color do
+  #       apple = Apple.new
+  #
+  #       expect(apple).to_receive(:color).and_yield(1, 2)       # => will pass
+  #       expect(apple).to_receive(:taste).and_yield(:something) # => will fail
+  #     end
+  #   end
+  #
+  def and_yield *expected, &block
+    return self if @failed
+    # `and_yield` can be called without arguments
+    expected.empty? || assert_given_arguments_match_received_messages(*expected, &block)
+    received = yielded_values
+
+    if block
+      return @base.instance_exec(*received.values, &block) ||
+        yield_error!(@expected_messages, block, received)
+    end
+
+    single_message_expected? ?
+      validate_yields(expected, received) :
+      validate_yields_list(expected, received)
+    self
+  end
+  alias and_yielded  and_yield
+  alias and_yielded? and_yield
+
+  # make sure received message wont yield
+  #
+  # @example
+  #   expect(:obj).to_receive(:a).without_yield
+  #
+  def without_yield
+    return self if @failed
+    yielded_values.each_pair do |msg,calls|
+      next if calls.all?(&:nil?)
+      unexpected_yield_error!(msg, calls)
+    end
+    self
+  end
+
+  private
+  def yielded_values
+    @expected_messages.inject({}) do |map,msg|
+      map.merge(msg => @messages[msg] ? @messages[msg].map {|m| m[:yielded]} : [])
+    end
+  end
+
+  def validate_yields expected, received
+    message = @expected_messages[0]
+    calls   = received[message]
+    return if validate_yields_calls(calls, expected)
+    yield_error!(message, expected, message => calls)
+  end
+
+  def validate_yields_list expected, received
+    expected = zipper(@expected_messages, expected)
+    received.each_pair do |msg,calls|
+      expect = Array(expected[msg]).flatten(1)
+      next if validate_yields_calls(calls, expect)
+      yield_error!(msg, expect, msg => calls)
+    end
+  end
+
+  def validate_yields_calls calls, expected
+    expected.nil? || expected.empty?  ?
+      calls.any? {|c| c.is_a?(Array)} :
+      calls.any? {|c| c == expected}
+  end
+
+  def unexpected_yield_error! message, received
+    fail_with("%s received %s message and unexpectedly yielded.\nExpected: %s\nActual:   %s" % [
+      pp(@object),
+      pp(message),
+      'nothing to be yielded',
+      stringify_received_yields(message => received)
+    ])
+  end
+
+  def yield_error! message, expected, received
+    fail_with("%s received %s message(s) but did not yield accordingly.\nExpected: %s\nActual:   %s" % [
+      pp(@object),
+      pp(message),
+      stringify_expected_yields(expected),
+      stringify_received_yields(received)
+    ])
+  end
+
+  def stringify_expected_yields expected
+    return 'yielded values to pass validation at %s' % pp(source(expected)) if expected.is_a?(Proc)
+    return 'something to be yielded' if expected.empty?
+    pp(expected)
+  end
+
+  def stringify_received_yields received
+    received.is_a?(Hash) || raise(ArgumentError, 'a Hash expected')
+    received.map do |msg,calls|
+      calls.each_with_index.map do |call,i|
+        '%s call #%s yielded %s' % [
+          pp(msg),
+          i + 1,
+          call ? pp(call) : 'nothing'
+        ]
+      end*"\n          "
+    end*"\n          "
+  end
+end

data/lib/minispec/proxy.rb

@@ -0,0 +1,201 @@
+module MiniSpec
+  class Proxy
+
+    @@negations = [
+      :not,
+      :to_not,
+      :has_not,
+      :have_not,
+      :does_not,
+      :did_not,
+      :is_not,
+      :is_not_a,
+      :wont,
+    ].freeze
+
+    # initializes a new proxy instance
+    # that will forward all received messages to tested object.
+    #
+    # @param base spec instance
+    # @param left_method  the method on spec instance that accepts tested object,
+    #   eg: is(...), does(...) etc.
+    # @param left_object  tested object itself
+    # @param negation  if set to a positive value assertion will be marked as failed if passed
+    # @param &proc  if block given, it will be yielded(at a later point)
+    #   and returned value will be used as tested object.
+    def initialize *args, &proc
+      @base, @left_method, @left_object, @negation, @failure_message = args
+      @left_proc = proc
+      @sugar = []
+    end
+
+    instance_methods.each do |m|
+      # overriding all instance methods so they point to tested object
+      # rather than to proxy instance.
+      # simply returns if no spec instance set.
+      #
+      # @example  checking whether `foo` if frozen.
+      #   is(:foo).frozen?
+      #   # `is` will initialize and return a MiniSpec::Proxy instance with :foo passed into it.
+      #   # MiniSpec::Proxy instance is receiving `frozen?` message and sending it to :foo.
+      #
+      define_method m do |*a, &p|
+        @base && __ms__assert(m, *a, &p)
+      end
+    end
+
+    # any missing method will be forwarded to #__ms__assert.
+    # simply returns if no spec instance set.
+    #
+    # @example checking whether `some_array` include `foo`
+    #   does(some_array).include? foo
+    #   # MiniSpec::Proxy instance does not respond to `include?`, so it is passed to `some_array`
+    def method_missing m, *a, &p
+      @base && __ms__assert(m, *a, &p)
+    end
+
+    %w[
+      a
+      is
+      is_a
+      are
+      will
+      was
+      does
+      did
+      have
+      has
+      to
+      be
+      been
+    ].each do |m|
+      # sugar methods that returns proxy instance.
+      #
+      # @example `a` serve as a bridge between tested object and `instance_of?` message
+      #   is(foo).a.instance_of?(Foo)
+      #
+      # @return [MiniSpec::Proxy] proxy instance
+      define_method(m) { @sugar.push(m); self }
+    end
+
+    # sugar methods that sets negation bit and returns proxy instance.
+    #
+    # @example `is_not_a` will set negation bit and return current proxy instance.
+    #   assure(this).is_not_a.instance_of? That
+    #
+    # @return [MiniSpec::Proxy] proxy instance
+    @@negations.each do |verb|
+      define_method(verb) { @negation = true; self }
+    end
+
+    # the core of MiniSpec assertion methodology.
+    # all tested objects arrives this point where they receive testing messages.
+    #
+    # @param right_method  message to be sent to tested object.
+    #   if there is a helper with such a name, the helper are run and result returned.
+    # @param *args  arguments to be passed to tested object when message sent.
+    # @param &right_proc  block to be passed to tested object when message sent.
+    # @return if some helper matched first argument returns helper's execution result.
+    #   returns `nil` if test passed.
+    #   returns a failure if test failed.
+    def __ms__assert right_method, *args, &right_proc
+      if helper = @base.class.helpers[right_method]
+        return __ms__run_helper(helper, *args, &right_proc)
+      end
+
+      result = __ms__send(right_method, *args, &right_proc)
+
+      if @negation           # sometimes
+        return unless result # verbosity
+      else                   # is
+        return if result     # a
+      end                    # virtue
+
+      __ms__fail(right_method, right_proc, *args)
+    end
+
+    # passing received message to tested object
+    def __ms__send right_method, *args, &right_proc
+      __ms__left_object.__send__(right_method, *args, &right_proc)
+    end
+
+    # executes a helper block earlier defined at class level
+    #
+    # @param  helper  helper name
+    # @param  *args   arguments to be passed into helper block
+    def __ms__run_helper helper, *args, &right_proc
+      helper_proc, helper_opts = helper
+      args.unshift(@left_proc || @left_object)
+      args.push(right_proc) if right_proc
+      args << {
+        left_method: @left_method,
+        left_object: @left_object,
+          left_proc: @left_proc,
+         right_proc: right_proc,
+           negation: @negation
+      }.freeze if helper_opts[:with_context]
+      @base.__ms__inside_helper = true
+      @base.instance_exec(*args, &helper_proc)
+    ensure
+      @base.__ms__inside_helper = false
+    end
+
+    # computes tested object based on arguments passed at initialize.
+    # if a block given it is yielded and returned value used as tested object.
+    # otherwise orig `@left_object` used.
+    # if given block raises an error it will be rescued and returned as tested object.
+    def __ms__left_object
+      return @left_object_value if @left_object_computed
+      @left_object_computed = true
+      @left_object_value = begin
+        @left_proc ? @base.instance_exec(&@left_proc) : @left_object
+      rescue Exception => e
+        e
+      end
+    end
+
+    # builds a MiniSpec failure and pass it to spec's #fail instance method.
+    # using splat cause it should be able to receive `nil` and `false` as second argument
+    # as well as work without second argument at all.
+    def __ms__fail right_method, right_proc, *args
+      right_object = right_proc ? \
+        __ms__proc_definition(right_method.to_s, right_proc) : \
+        (args.size > 0 ? args.first : :__ms__right_object)
+      failure = {
+         left_method: @left_method,
+         left_object: __ms__left_object,
+        right_method: (@sugar + [right_method])*' ',
+        right_object: right_object,
+            negation: @negation
+      }
+      failure[:message] = @failure_message if @failure_message
+      @base.send(:fail, failure)
+    end
+
+    # reads what follow after the given method at the line where given proc is defined
+    #
+    # @example
+    #   assure([]).has.any? {|x| x > 1}
+    #   # => {|x| x > 1}
+    #
+    # @return   a string if proc is defined in a real file.
+    #           `nil` otherwise (think of irb/pry)
+    def __ms__proc_definition meth, proc
+      return unless source = __ms__source_line(proc)
+      source = source.split(meth)[1..-1].map(&:strip).join(meth)
+      def source.inspect; self end
+      source
+    end
+
+    # reads the line at which given proc is defined.
+    #
+    # @return   a string if file exists.
+    #           `nil` if file does not exits(think of irb/pry)
+    def __ms__source_line proc
+      file, line = proc.source_location
+      return unless lines = MiniSpec.source_location_cache(file)
+      (line = lines[line - 1]) && line.strip
+    end
+
+  end
+end