tiramisu 0.0.1 → 0.0.2

data/lib/tiramisu/mock/expectation/raise.rb

@@ -1,34 +0,0 @@
-module Tiramisu
-  class Mock
-    class Expectation
-
-      # ensure received message raises as expected
-      #
-      # @note if block given it will have precedence over arguments
-      #
-      # @example
-      #   x = mock(X.new)
-      #   expect(x).to_receive(:y).and_raise(NoMethodError)
-      #   # call `x.y` for test to pass
-      #
-      def and_raise type = nil, message = nil, &block
-        @raise = block || [type, message]
-      end
-
-      def assert_message_raised_as_expected
-        return unless @raise
-        if @raise.is_a?(Proc)
-          received_messages.find {|log| @raise.call(log[:raised])} || Tiramisu.fail([
-            'Looks like :%s message never raised as expected' % expected_message,
-            'See validation block'
-          ], @caller)
-        else
-          received_messages.each do |log|
-            next unless f = Tiramisu.assert_raised_as_expected(log, *@raise)
-            Tiramisu.fail(f, log[:caller])
-          end
-        end
-      end
-    end
-  end
-end

data/lib/tiramisu/mock/expectation/return.rb

@@ -1,34 +0,0 @@
-module Tiramisu
-  class Mock
-    class Expectation
-
-      # ensure received message returns expected value
-      #
-      # @note if block given it will have precedence over arguments
-      #
-      # @example
-      #   n = mock(1)
-      #   expect(n).to_receive(:+).with(1).and_return(2)
-      #
-      def and_return value = nil, &block
-        @return = block || value
-      end
-
-      private
-      def assert_message_returned_correct_value
-        return unless @return
-        if @return.is_a?(Proc)
-          received_messages.find {|log| @return.call(log[:returned])} || Tiramisu.fail([
-            'Looks like :%s message never returned expected value' % expected_message,
-            'See validation block'
-          ], @caller)
-        else
-          received_messages.find {|log| log[:returned] == @return} || Tiramisu.fail([
-            'Looks like :%s message never returned expected value:' % expected_message,
-            Array(@return).map {|x| Tiramisu.pp(x)}.join(', ')
-          ], @caller)
-        end
-      end
-    end
-  end
-end

data/lib/tiramisu/mock/expectation/throw.rb

@@ -1,26 +0,0 @@
-module Tiramisu
-  class Mock
-    class Expectation
-
-      # ensure received message throws as expected
-      #
-      # @note if block given it will have precedence over arguments
-      #
-      # @example
-      #   x = mock(X.new)
-      #   expect(x).to_receive(:y).and_throw(:z)
-      #
-      def and_throw symbol = nil, &block
-        @throw = [symbol, block]
-      end
-
-      def assert_message_thrown_as_expected
-        return unless @throw
-        received_messages.each do |log|
-          next unless f = Tiramisu.assert_thrown_as_expected(log, *@throw)
-          Tiramisu.fail(f, log[:caller])
-        end
-      end
-    end
-  end
-end

data/lib/tiramisu/mock/expectation/with.rb

@@ -1,38 +0,0 @@
-module Tiramisu
-  class Mock
-    class Expectation
-
-      # ensure expected message received with correct arguments
-      #
-      # @note if block given it will have precedence over arguments
-      #
-      # @example
-      #   test :some_test do
-      #     some_object = mock(SomeObject.new)
-      #     expect(some_object).to_receive(:some_method).with(:some, :args)
-      #     # call `some_object.some_method(:some, :args)` for test to pass
-      #   end
-      #
-      def with *args, &block
-        @with = block || args
-        self
-      end
-
-      private
-      def assert_message_received_with_correct_arguments
-        return unless @with
-        if @with.is_a?(Proc)
-          received_messages.find {|log| @with.call(log[:arguments])} || Tiramisu.fail([
-            'Looks like :%s message never was called with expected arguments' % expected_message,
-            'See validation block'
-          ], @caller)
-        else
-          received_messages.find {|log| log[:arguments] == @with} || Tiramisu.fail([
-            'Looks like :%s message never was called with expected arguments:' % expected_message,
-            Array(@with).map {|x| Tiramisu.pp(x)}.join(', ')
-          ], @caller)
-        end
-      end
-    end
-  end
-end

data/lib/tiramisu/mock/expectation.rb

@@ -1,44 +0,0 @@
-module Tiramisu
-  class Mock
-    class Expectation
-
-      attr_reader :expected_message, :received_messages
-
-      def initialize expected_message, assert, caller
-        @expected_message = expected_message.to_sym
-        @assert = assert
-        @caller = caller
-      end
-
-      def validate received_messages
-        @received_messages = received_messages[expected_message] || []
-        return refute_message_received unless @assert
-        assert_message_received
-        assert_message_received_with_correct_arguments
-        assert_message_returned_correct_value
-        assert_message_raised_as_expected
-        assert_message_thrown_as_expected
-      end
-
-      private
-      def assert_message_received
-        Tiramisu.fail('Expected %s to receive %s message' % [
-          Tiramisu.pp(@object),
-          Tiramisu.pp(expected_message)
-        ], @caller) if received_messages.empty?
-      end
-
-      def refute_message_received
-        Tiramisu.fail('Not Expected %s to receive %s message' % [
-          Tiramisu.pp(@object),
-          Tiramisu.pp(expected_message)
-        ], @caller) if received_messages.any?
-      end
-    end
-  end
-end
-
-require 'tiramisu/mock/expectation/with'
-require 'tiramisu/mock/expectation/return'
-require 'tiramisu/mock/expectation/raise'
-require 'tiramisu/mock/expectation/throw'

data/lib/tiramisu/mock.rb

@@ -1,48 +0,0 @@
-module Tiramisu
-  class Mock
-
-    def initialize object
-      @object = object
-    end
-
-    instance_methods.each do |m|
-      define_method m do |*a, &b|
-        __tiramisu__register_and_send__(m, a, b)
-      end
-    end
-
-    def method_missing m, *a, &b
-      __tiramisu__register_and_send__(m, a, b)
-    end
-
-    def __tiramisu__expectations__
-      @__tiramisu__expectations__ ||= []
-    end
-
-    def __tiramisu__messages__
-      @__tiramisu__messages__ ||= {}
-    end
-
-    def __tiramisu__validate_messages__
-      __tiramisu__messages__.freeze
-      __tiramisu__expectations__.each do |expectation|
-        expectation.validate(__tiramisu__messages__)
-      end
-    end
-
-    private
-    def __tiramisu__register_and_send__ m, a, b
-      log = {arguments: a, block: b, caller: Tiramisu.relative_location(caller[1])}
-      (__tiramisu__messages__[m] ||= []).push(log)
-      begin
-        log[:returned] = @object.__send__(m, *a, &b)
-      rescue UncaughtThrowError => e
-        log[:thrown] = Tiramisu.extract_thrown_symbol(e)
-      rescue Exception => e
-        log[:raised] = e
-      end
-    end
-  end
-end
-
-require 'tiramisu/mock/expectation'