minispec 0.0.1

data/lib/minispec/mocks/validations.rb

@@ -0,0 +1,80 @@
+module MiniSpec
+  module Mocks
+    class Validations
+      include MiniSpec::Utils
+
+      def initialize base, object, context, *expected_messages
+        expected_messages.empty? && raise(ArgumentError, 'Wrong number of arguments (3 for 4+)')
+        expected_messages.all? {|m| m.is_a?(Symbol)} || raise(ArgumentError, 'Only symbols accepted')
+        @base, @object, @context, @failed = base, object, context, false
+        @expected_messages = expected_messages.freeze
+        @messages = expected_and_received.freeze
+        validate_received_messages!
+      end
+
+      private
+      # selecting only expected messages in the order they was received.
+      # @param expected_messages [Array]
+      # @return [Hash]
+      def expected_and_received
+        @base.__ms__mocks__instance_messages(@context[:left_object]).inject({}) do |map,msg|
+          @expected_messages.include?(msg[:method]) && (map[msg[:method]] ||= []).push(msg)
+          map
+        end
+      end
+
+      def validate_received_messages!
+        @expected_messages.each do |m|
+          @context[:negation] ?
+            @messages.keys.include?(m) && message_validation_error!(m, true) :
+            @messages.keys.include?(m) || message_validation_error!(m)
+        end
+      end
+
+      def message_validation_error! message, negation = false
+        fail_with('%sExpected %s to receive %s message' % [
+          negation ? 'NOT ' : '',
+          pp(@object),
+          pp(message),
+        ])
+      end
+
+      def single_message_expected?
+        @expected_messages.size == 1
+      end
+
+      # checks whether correct number of arguments given.
+      # in any situation, at least one argument required.
+      # if multiple messages expected, number of arguments should be equal to one
+      # or to the number of expected messages.
+      def assert_given_arguments_match_received_messages *args, &block
+        if block
+          args.empty? || raise(ArgumentError, 'Both arguments and block given. Please use either one.')
+          return true # if block given, no arguments accepted, so nothing to validate
+        end
+
+        # single argument acceptable for any number of expected messages
+        return if args.size == 1
+
+        # when a single message expected, any number of arguments accepted
+        return if @expected_messages.size == 1
+
+        # on multiple messages, number of arguments should match number of expected messages
+        return if args.size == @expected_messages.size
+
+        raise(ArgumentError, 'wrong number of arguments (%i for 1..%i)' % [
+          args.size,
+          @expected_messages.size
+        ], caller[1..-1])
+      end
+
+      def fail_with message
+        return unless @failed = message
+        @base.fail(message)
+        self
+      end
+    end
+  end
+end
+
+Dir[File.expand_path('../validations/**/*.rb', __FILE__)].each {|f| require(f)}

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

@@ -0,0 +1,63 @@
+class MiniSpec::Mocks::Validations
+
+  # assure expected message(s) was received a specific amount of times
+  #
+  # @example  expect `a` to be received exactly 2 times
+  #   expect(obj).to_receive(:a).count(2)
+  #
+  # @example  expect `a` to be received 2 or more times
+  #   expect(obj).to_receive(:a).count {|a| a >= 2}
+  #
+  # @example  expect `a` and `b` to be received 2 times each
+  #   expect(obj).to_receive(:a, :b).count(2)
+  #
+  # @example  expect `a` to be received 2 times and `b` 3 times
+  #   expect(obj).to_receive(:a, :b).count(2, 3)
+  #
+  # @example  expect both `a` and `b` to be received more than 2 times
+  #   expect(obj).to_receive(:a, :b).count {|a,b| a > 2 && b > 2}
+  #
+  def count *expected, &block
+    return self if @failed
+    assert_given_arguments_match_received_messages(*expected, &block)
+    received = received_amounts
+
+    if block
+      return @base.instance_exec(*received.values, &block) ||
+        amount_error!(@expected_messages, block, received)
+    end
+
+    expected = zipper(@expected_messages, expected)
+    received.each_pair do |message,amount|
+      # each message should be received expected amount of times
+      amount == expected[message] ||
+        amount_error!(message, expected[message], amount)
+    end
+    self
+  end
+  alias times count
+
+  def once;  count(1); end
+  def twice; count(2); end
+
+  private
+  # returns a Hash of messages each with amount of times it was called.
+  # basically it does the same as `@messages.values.map(&:size)`
+  # except it returns the messages in the order they are expected.
+  def received_amounts
+    @expected_messages.inject({}) do |map,msg|
+      map.merge(msg => (@messages[msg] || []).size)
+    end
+  end
+
+  def amount_error! messages, expected, received
+    fail_with("%s received %s message(s) wrong amount of times.\nExpected: %s\nActual:   %s" % [
+      pp(@object),
+      pp(messages),
+      expected.is_a?(Proc) ?
+        ('to be validated at %s' % pp(source(expected))) :
+        Array(expected).map {|x| pp(x)}*', ',
+      pp(received)
+    ])
+  end
+end

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

@@ -0,0 +1,161 @@
+class MiniSpec::Mocks::Validations
+
+  # validates received arguments against expected ones
+  #
+  # @example
+  #   expect(obj).to_receive(:a).with(1)
+  #   obj.a(1)
+  #
+  # @example
+  #   expect(obj).to_receive(:a).with(1, 2)
+  #   obj.a(1, 2)
+  #
+  # @example
+  #   expect(obj).to_receive(:a).with(1, [:a, :b, :c])
+  #   obj.a(1, [:a, :b, :c])
+  #
+  # @example
+  #   expect(obj).to_receive(:a).with {|x| x[0] == [1, 2, 3] && x[1] == [:x, [:y], 'z']}
+  #   obj.a(1, 2, 3)
+  #   obj.a(:x, [:y], 'z')
+  #
+  # @example
+  #   expect(obj).to_receive(:a, :b, :c).with(1)
+  #   obj.a(1)
+  #   obj.b(1)
+  #   obj.c(1)
+  #
+  # @example
+  #   expect(obj).to_receive(:a, :b, :c).with(1, 2, 3)
+  #   obj.a(1)
+  #   obj.b(2)
+  #   obj.c(3)
+  #
+  # @example
+  #   expect(obj).to_receive(:a, :b, :c).with([1, 2, 3])
+  #   obj.a(1, 2, 3)
+  #   obj.b(1, 2, 3)
+  #   obj.c(1, 2, 3)
+  #
+  # @example
+  #   expect(obj).to_receive(:a, :b, :c).with([1, 2], [:x, :y], :z)
+  #   obj.a(1, 2)
+  #   obj.b(:x, :y)
+  #   obj.c(:z)
+  #
+  # @example
+  #   expect(obj).to_receive(:a, :b, :c).with([[1, 2]], [[:x, :y]], [:z])
+  #   obj.a([1, 2])
+  #   obj.b([:x, :y])
+  #   obj.c([:z])
+  #
+  # @example
+  #   expect(obj).to_receive(:a, :b, :c).with do |a,b,c|
+  #     a == [[1, 2]] &&
+  #       b == [[:x, :y]] &&
+  #       c == [:z]
+  #   end
+  #   obj.a(1, 2)
+  #   obj.b(:x, :y)
+  #   obj.c(:z)
+  #
+  # @example
+  #   expect(obj).to_receive(:a, :b, :c).with do |a,b,c|
+  #     a == [[1, 2], [3, 4]] &&
+  #       b == [[:x, :y], [2]] &&
+  #       c == [[:z], [[:a, :b], :c]]
+  #   end
+  #   obj.a(1, 2)
+  #   obj.a(3, 4)
+  #   obj.b(:x, :y)
+  #   obj.b(2)
+  #   obj.c(:z)
+  #   obj.c([:a, :b], :c)
+  #
+  def with *expected, &block
+    return self if @failed
+    assert_given_arguments_match_received_messages(*expected, &block)
+    received = received_arguments
+
+    if block
+      return @base.instance_exec(*received.values, &block) ||
+        arguments_error!(@expected_messages, block, received)
+    end
+
+    single_message_expected? ?
+      validate_arguments(expected, received) :
+      validate_arguments_list(expected, received)
+    self
+  end
+
+  def without_arguments
+    return self if @failed
+    received_arguments.each_pair do |msg,args|
+      # each message should be called without arguments at least once
+      args.any?(&:empty?) || arguments_error!(msg, [], msg => args)
+    end
+    self
+  end
+  alias without_any_arguments without_arguments
+
+  private
+  # returns a Hash of received messages,
+  # each with a list of arguments it was called with.
+  #
+  # @example
+  #   obj.a(:x)
+  #   obj.a([:x])
+  #   obj.a(:y, [:z])
+  #   => { a: [ [:x], [[:x]], [:y, [:z]] ] }
+  #
+  def received_arguments
+    @expected_messages.inject({}) do |map,msg|
+      map.merge(msg => @messages[msg] ? @messages[msg].map {|m| m[:arguments]} : [])
+    end
+  end
+
+  def validate_arguments expected, received
+    message   = @expected_messages[0]
+    arguments = received[message]
+    return if arguments.any? {|x| x == expected}
+    arguments_error!(message, expected, message => arguments)
+  end
+
+  def validate_arguments_list expected, received
+    expected = zipper(@expected_messages, expected)
+    received.each_pair do |msg,args|
+      next if args.any? {|x| x == [expected[msg]]}
+      arguments_error!(msg, expected[msg], msg => args)
+    end
+  end
+
+  def stringify_expected_arguments expected
+    return 'to be validated at %s' % pp(source(expected)) if expected.is_a?(Proc)
+    expected = Array(expected)
+    return 'to be called without arguments' if expected.empty?
+    expected.map {|a| pp(a)}*', '
+  end
+
+  def stringify_received_arguments received
+    received.is_a?(Hash) || raise(ArgumentError, 'expected a Hash')
+    received.map do |msg,args|
+      '%s called %s' % [
+        pp(msg),
+        args.map do |arr|
+          arr.empty? ?
+            'without arguments' :
+            'with %s' % arr.map {|a| pp(a)}.join(', ')
+        end*' then '
+      ]
+    end*"\n          "
+  end
+
+  def arguments_error! message, expected, received
+    fail_with("%s received %s message(s) with unexpected arguments.\nExpected: %s\nActual:   %s" % [
+      pp(@object),
+      pp(message),
+      stringify_expected_arguments(expected),
+      stringify_received_arguments(received)
+    ])
+  end
+end

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

@@ -0,0 +1,43 @@
+class MiniSpec::Mocks::Validations
+
+  def with_caller *expected, &block
+    return self if @failed
+    assert_given_arguments_match_received_messages(*expected, &block)
+    received = received_callers
+
+    if block
+      return @base.instance_exec(*received.values, &block) ||
+        caller_error!(@expected_messages, block)
+    end
+
+    expected = zipper(@expected_messages, expected)
+    received.each_pair do |msg,callers|
+      # each message should be called from expected caller at least once
+      callers.any? {|line| caller_match?(line, expected[msg])} ||
+        caller_error!(msg, expected[msg])
+    end
+    self
+  end
+
+  private
+  def received_callers
+    @expected_messages.inject({}) do |map,msg|
+      map.merge(msg => @messages[msg] ? @messages[msg].map {|m| m[:caller]} : [])
+    end
+  end
+
+  def caller_match? line, pattern
+    regexp = pattern.is_a?(Regexp) ? pattern : Regexp.new(Regexp.escape(pattern))
+    line.any? {|l| l =~ regexp}
+  end
+
+  def caller_error! message, expected
+    fail_with("%s received %s message(s) from wrong location.\nCaller does not %s" % [
+      pp(@object),
+      pp(message),
+      expected.is_a?(Proc) ?
+        ('pass validation at %s' % pp(source(expected))) :
+        ('match %s' % pp(expected))
+    ])
+  end
+end

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

@@ -0,0 +1,47 @@
+class MiniSpec::Mocks::Validations
+
+  # checks whether expected messages was received in a specific order
+  #
+  # @note  this method will work only when multiple messages expected.
+  #   that's it, unlike RSpec, it wont work like this:
+  #   `expect(obj).to_receive(:a).ordered`
+  #   `expect(obj).to_receive(:b).ordered`
+  #
+  #   instead it will work like this:
+  #   `expect(obj).to_receive(:a, :b).ordered`
+  #
+  # @example
+  #   expect(obj).to_receive(:a, :b, :c).ordered
+  #
+  # @example  expect for same sequence N times
+  #   expect(obj).to_receive(:a, :b).ordered(2)
+  #   # for this to pass `obj.a` and `obj.b` should be both called twice in same order
+  #
+  def ordered n = 1, &block
+    block                    && raise(ArgumentError, '#ordered does not accept a block')
+    n.is_a?(Integer)         || raise(ArgumentError, '#ordered expects a single Integer argument')
+    single_message_expected? && raise(ArgumentError, '#ordered works only with multiple messages')
+    received_in_expected_order?(n)
+  end
+
+  private
+  def received_in_expected_order? n
+    x = 0
+    messages_in_received_order.each_cons(@expected_messages.size) {|c| x += 1 if c == @expected_messages}
+    x == n || ordered_error!(n, x)
+  end
+
+  # returns an Array of all messages in the order they was received
+  def messages_in_received_order
+    @base.__ms__mocks__instance_messages(@context[:left_object]).map {|m| m[:method]}
+  end
+
+  def ordered_error! expected, received
+    fail_with("Expected %s to receive %s sequence %s times.\nInstead it was received %s times." % [
+      pp(@object),
+      pp(@expected_messages),
+      expected,
+      received
+    ])
+  end
+end

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

@@ -0,0 +1,111 @@
+class MiniSpec::Mocks::Validations
+
+  # expect received message(s) to raise a exception.
+  #
+  # if no args given any raised exception accepted.
+  # if a class given it checks whether raised exception is of given type.
+  # if a string or regexp given it checks whether raised message matches it.
+  #
+  # @example  expect `a` to raise something
+  #   expect(obj).to_receive(:a).and_raise
+  #
+  # @example  expect `a` to raise ArgumentError
+  #   expect(obj).to_receive(:a).and_raise(ArgumentError)
+  #
+  # @example  raised exception should be of ArgumentError type and match /something/
+  #   expect(obj).to_receive(:a).and_raise([ArgumentError, /something/])
+  #
+  # @example  expect `a` to raise ArgumentError and `b` to raise RuntimeError
+  #   expect(obj).to_receive(:a, :b).and_raise(ArgumentError, RuntimeError)
+  #
+  # @example  expect `a` to raise ArgumentError matching /something/ and `b` to raise RuntimeError
+  #   expect(obj).to_receive(:a, :b).and_raise([ArgumentError, /something/], RuntimeError)
+  #
+  def and_raise *expected, &block
+    return self if @failed
+    # `and_raise` can be called without arguments
+    expected.empty? || assert_given_arguments_match_received_messages(*expected, &block)
+    received = raised_exceptions
+
+    if block
+      return @base.instance_exec(*received.values, &block) ||
+        exception_error!(@expected_messages, block, received)
+    end
+
+    expected = single_message_expected?   ?
+      {@expected_messages[0] => expected} :
+      zipper(@expected_messages, expected)
+    context  = @context.merge(negation: nil, right_proc: nil) # do NOT alter @context
+    received.each_pair do |msg,calls|
+      # each message should raise as expected at least once
+      calls.any? {|c| exception_raised?(c, context, *expected[msg]) == true} ||
+        exception_error!(msg, expected[msg], msg => calls)
+    end
+    self
+  end
+  alias and_raised  and_raise
+  alias and_raised? and_raise
+
+  # make sure received message(s) does not raise any exception
+  #
+  # @example
+  #   expect(obj).to_receive(:a).without_raise
+  #
+  def without_raise
+    return self if @failed
+    raised_exceptions.each_pair do |msg,calls|
+      calls.any? {|r| r.is_a?(Exception)} && unexpected_exception_error!(msg, calls)
+    end
+    self
+  end
+
+  private
+  def raised_exceptions
+    @expected_messages.inject({}) do |map,msg|
+      map.merge(msg => @messages[msg] ? @messages[msg].map {|m| m[:raised]} : [])
+    end
+  end
+
+  def unexpected_exception_error! message, received
+    fail_with("%s received %s message and raised an unexpected error.\nExpected: %s\nActual:   %s" % [
+      pp(@object),
+      pp(message),
+      'nothing to be raised',
+      stringify_received_exception(message => received)
+    ])
+  end
+
+  def exception_error! message, expected, received
+    fail_with("%s received %s message(s) but did not raise accordingly.\nExpected: %s\nActual:   %s" % [
+      pp(@object),
+      pp(message),
+      stringify_expected_exception(expected),
+      stringify_received_exception(received)
+    ])
+  end
+
+  def stringify_expected_exception expected
+    return 'any exception to be raised' unless expected
+    return 'raised exception to be validated at %s' % pp(source(expected)) if expected.is_a?(Proc)
+    Array(expected).map(&method(:pp))*':'
+  end
+
+  def stringify_received_exception 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 raised %s' % [
+          pp(msg),
+          i + 1,
+          call.is_a?(Exception) ?
+            stringify_exception(call) :
+            'nothing'
+        ]
+      end*"\n          "
+    end*"\n          "
+  end
+
+  def stringify_exception exception
+    [exception.class, exception.message].map(&method(:pp))*':'
+  end
+end