tiramisu 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 15c77ab81176ab960b8d55ff6b30c05de6498700
-  data.tar.gz: 918b1cce8aa2d7787e57475a4ebd2ba62f82d6b7
+  metadata.gz: 6b275bd81b3a2fd180b1d094268b9bf5c6280309
+  data.tar.gz: ba695c8ac455c1ff10e7a17e503c005f59006c73
 SHA512:
-  metadata.gz: 55f1152918df1a60339810cd2dfcb9f2816f8fab17c2c5baf3f760b00f63dad0f0e0ff0f968afefc28397da175cad8c6d2d8f9ccb9ed3d4342741cc5e600cf3f
-  data.tar.gz: 18d17a4227e9280bfbb4506fde2f69be7953f8ceba7e1851001414a57222c49ab8717b40ac10b70f1947a7180e811916925f1a87d928a505916575f6d5d06f41
+  metadata.gz: 906c88938fff1ad3556893cc19550c9806ad758f962dcb20889adaf7c17542bb70c7ad33851c3158afc63e2361e3282d94e93b99238f4bc149c4f69bc84c7984
+  data.tar.gz: 39dcd11c0f4cec696030f47f08b79e27e0bc7998d2da856ace138ce77c19dd2c852be606cf3d794d7381cf91ab539edba21d910e4f99e98d2c908a46b594ba58

data/README.md

@@ -1,3 +1,5 @@
+[![Build Status](https://travis-ci.org/sleewoo/tiramisu.svg)](https://travis-ci.org/sleewoo/tiramisu)
+
 ## Tiramisu - a super-simple testing library for Ruby
 
 Its base API consist of just 10(yes, ten!) memorable methods:

data/lib/tiramisu/assert.rb

@@ -116,14 +116,19 @@ module Tiramisu
     #   end
     #
     # @param Symbol expected message
-    # @return [Mock::Expectation]
+    # @return [Expectation]
     #
     def receive expected_message
-      @object[:returned].__tiramisu__expectations__ rescue Kernel.raise(ArgumentError, '`receive` works only with predefined mocks')
-      @object[:returned].__tiramisu__expectations__.push(Mock::Expectation.new(expected_message.to_sym, @assert, caller[0])).last
+      Kernel.throw(:__tiramisu_status__, @object[:raised]) if @object[:raised]
+      @__expectation__ = Expectation.new(@object[:returned], expected_message.to_sym, @assert, caller[0])
     end
     alias to_receive receive
 
+    def __validate_expectations__
+      return unless @__expectation__
+      @__expectation__.validate
+    end
+
     private
     def __assert__ message, arguments, block
       Kernel.throw(:__tiramisu_status__, @object[:raised]) if @object[:raised]

data/lib/tiramisu/core_ext.rb

@@ -34,7 +34,8 @@ module Kernel
 
     if noargs
       # no arguments given, defining a global setup and returning
-      return Tiramisu::GLOBAL_SETUPS << block
+      Tiramisu::GLOBAL_SETUPS.include?(block) || Tiramisu::GLOBAL_SETUPS.push(block)
+      return
     end
 
     if label

data/lib/tiramisu/expectations/raise.rb

@@ -0,0 +1,32 @@
+module Tiramisu
+  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

data/lib/tiramisu/expectations/return.rb

@@ -0,0 +1,32 @@
+module Tiramisu
+  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

data/lib/tiramisu/expectations/throw.rb

@@ -0,0 +1,24 @@
+module Tiramisu
+  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

data/lib/tiramisu/expectations/with.rb

@@ -0,0 +1,36 @@
+module Tiramisu
+  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

data/lib/tiramisu/expectations.rb

@@ -0,0 +1,82 @@
+module Tiramisu
+  class Expectation
+
+    def self.restore_object_status obj
+      return unless obj.instance_variable_get(:@__tiramisu__original_methods__)
+
+      obj.instance_variable_get(:@__tiramisu__original_methods__).each_pair do |n,m|
+        obj.define_singleton_method(n, &m)
+      end
+
+      obj.instance_variable_set(:@__tiramisu__original_methods__, {})
+      obj.instance_variable_set(:@__tiramisu__received_messages__, {})
+    end
+
+    attr_reader :expected_message, :received_messages
+
+    def initialize object, expected_message, assert, caller
+      proxify(@object = object)
+      @expected_message = expected_message.to_sym
+      @assert = assert
+      @caller = caller
+    end
+
+    def validate
+      @received_messages = @object.__tiramisu__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 proxify object
+      return if object.respond_to?(:__tiramisu__original_methods__)
+      def object.__tiramisu__original_methods__; @__tiramisu__original_methods__ ||= {} end
+      def object.__tiramisu__received_messages__; @__tiramisu__received_messages__ ||= {} end
+      object.methods.each do |m|
+        next if m == :__tiramisu__original_methods__ || m == :__tiramisu__received_messages__
+        object.__tiramisu__original_methods__[m] = object.method(m)
+        object.define_singleton_method m do |*a,&b|
+          log = {arguments: a, block: b, caller: Tiramisu.relative_location(caller[0])}
+          (__tiramisu__received_messages__[m] ||= []).push(log)
+          begin
+            log[:returned] = __tiramisu__original_methods__[m].call(*a, &b)
+          rescue UncaughtThrowError => e
+            log[:thrown] = Tiramisu.extract_thrown_symbol(e)
+          rescue Exception => e
+            log[:raised] = e
+          end
+        end
+      end
+      object.define_singleton_method :method_missing do |m,*a,&b|
+        log = {arguments: a, block: b, caller: Tiramisu.relative_location(caller[0])}
+        (__tiramisu__received_messages__[:method_missing] ||= []).push(log.merge(arguments: [m] + a))
+        (__tiramisu__received_messages__[m] ||= []).push(log.merge({
+          raised: NoMethodError.new("undefined method `%s' for %s:%s" % [m, object.inspect, object.class])
+        }))
+      end
+    end
+
+    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
+
+require 'tiramisu/expectations/with'
+require 'tiramisu/expectations/return'
+require 'tiramisu/expectations/raise'
+require 'tiramisu/expectations/throw'

data/lib/tiramisu/run.rb

@@ -9,22 +9,38 @@ module Tiramisu
   end
 
   def run pattern_or_files = DEFAULT_PATTERN
-    load_files(pattern_or_files)
-    units.shuffle.each do |unit|
-      # exceptions raised inside unit#__run__ will be treated as failures and pretty printed.
-      # any other exceptions will be treated as implementation errors and ugly printed.
-      unit.tests.keys.shuffle.each do |test|
-        status = unit.run(test)
-        if status.is_a?(Skip)
-          skips << status
-        else
-          status == :__tiramisu_passed__ || render_failure(unit, unit.tests[test], status)
+    find_files(pattern_or_files).shuffle.each do |file|
+      r, w = IO.pipe
+      pid = Kernel.fork do
+        r.close
+        load_file(file)
+        progress.log ''
+        progress.log blue(relative_location(file))
+        units.shuffle.each do |unit|
+          # exceptions raised inside unit#__run__ will be treated as failures and pretty printed.
+          # any other exceptions will be treated as implementation errors and ugly printed.
+          unit.tests.keys.shuffle.each do |test|
+            status = unit.run(test)
+            if status.is_a?(Skip)
+              w.puts({reason: status.reason, caller: status.caller}.to_json)
+            else
+              unless status == :__tiramisu_passed__
+                render_failure(unit, unit.tests[test], status)
+                Kernel.exit(1)
+              end
+            end
+            progress.advance
+          end
         end
-        progress.advance
+      end
+      _, status = Process.waitpid2(pid)
+      Kernel.exit(1) unless status.success?
+      w.close
+      while skip = r.gets
+        skips << JSON.parse(skip)
       end
     end
     render_skips
-    progress.log ''
   end
 
   def render_failure unit, test_uuid, failure
@@ -68,10 +84,11 @@ module Tiramisu
 
   def render_skips
     return if skips.empty?
-    progress.log ''
-    progress.log bold.magenta('Skips:')
+    puts
+    puts bold.magenta('Skips:')
     skips.each do |skip|
-      progress.log '  %s (%s)' % [blue(skip.reason || 'skip'), relative_location(skip.caller)]
+      puts '  %s (%s)' % [blue(skip['reason'] || 'skip'), relative_location(skip['caller'])]
     end
+    puts
   end
 end

data/lib/tiramisu/unit.rb

@@ -12,23 +12,13 @@ module Tiramisu
       :refute
     ].each do |meth|
       define_method meth do |obj = nil, &block|
-        obj = block ? Tiramisu.call_block(block) : {returned: obj}.freeze
-        Tiramisu::Assert.new(obj, meth, caller[0])
+        __objects__[obj = block ? Tiramisu.call_block(block) : {returned: obj}.freeze] = true
+        __assertions__.push(Tiramisu::Assert.new(obj, meth, caller[0])).last
       end
     end
     alias expect assert
     alias fail_if refute
 
-    # wrap given object into a proxy that will register and pass all messages
-    #
-    # @example
-    #   user = mock(User.new)
-    #   expect(user).to_receive(:some_method)
-    #
-    def mock obj
-      __mocks__.push(Mock.new(obj)).last
-    end
-
     # stop executing current test and mark it as skipped
     #
     # @example
@@ -49,15 +39,20 @@ module Tiramisu
         __send__(test)
       end
       __send__(after) if after
-      __mocks__.each(&:__tiramisu__validate_messages__)
+      __assertions__.each(&:__validate_expectations__)
+      __objects__.each_key {|o| Tiramisu::Expectation.restore_object_status(o[:returned])}
       :__tiramisu_passed__
     rescue Exception => e
       throw(:__tiramisu_status__, e)
     end
 
     private
-    def __mocks__
-      @__mocks__ ||= []
+    def __objects__
+      @__objects__ ||= {}
+    end
+
+    def __assertions__
+      @__assertions__ ||= []
     end
   end
 

data/lib/tiramisu/util.rb

@@ -55,9 +55,9 @@ module Tiramisu
     [relative_location(file), line]
   end
 
-  def load_files pattern_or_files
-    files = pattern_or_files.is_a?(Array) ? pattern_or_files : Dir[pwd(pattern_or_files)]
-    files.each {|f| load_file(f)}
+  def find_files pattern_or_files
+    return pattern_or_files if pattern_or_files.is_a?(Array)
+    Dir[pwd(pattern_or_files)]
   end
 
   def load_file file

data/lib/tiramisu.rb

@@ -1,6 +1,7 @@
 require 'tty-progressbar'
 require 'tty-screen'
 require 'pastel'
+require 'json'
 
 module Tiramisu
   extend self
@@ -113,7 +114,7 @@ end
 
 require 'tiramisu/core_ext'
 require 'tiramisu/pretty_print'
-require 'tiramisu/mock'
+require 'tiramisu/expectations'
 require 'tiramisu/util'
 require 'tiramisu/unit'
 require 'tiramisu/assert'

data/test/receive_and_raise_test.rb

@@ -4,8 +4,7 @@ describe :receive_and_raise do
     this = self
     spec rand do
       test :test do
-        x = mock(:x)
-        expect(x).to_receive(:y).and_raise(NoMethodError)
+        expect(x = 'x').to_receive(:y).and_raise(NoMethodError)
         x.y
       end
       this.assert_equal :__tiramisu_passed__, run(:test)
@@ -16,8 +15,7 @@ describe :receive_and_raise do
     this = self
     spec rand do
       test :test do
-        x = mock(:x)
-        expect(x).to_receive(:y).and_raise
+        expect(x = 'x').to_receive(:y).and_raise
         x.y
       end
       this.assert_equal :__tiramisu_passed__, run(:test)
@@ -28,8 +26,7 @@ describe :receive_and_raise do
     this = self
     spec rand do
       test :test do
-        x = mock(:x)
-        expect(x).to_receive(:to_s).and_raise
+        expect(x = 'x').to_receive(:to_s).and_raise
         x.to_s
       end
       this.assert_match /Expected a exception to be raised/, run(:test).reason*' '
@@ -40,8 +37,7 @@ describe :receive_and_raise do
     this = self
     spec rand do
       test :test do
-        x = mock(:x)
-        expect(x).to_receive(:y).and_raise(NameError)
+        expect(x = 'x').to_receive(:y).and_raise(NameError)
         x.y
       end
       this.assert_match /Expected a NameError to be raised/, run(:test).reason*' '
@@ -52,8 +48,7 @@ describe :receive_and_raise do
     this = self
     spec rand do
       test :test do
-        x = mock(:x)
-        expect(x).to_receive(:y).and_raise(NoMethodError, /blah/)
+        expect(x = 'x').to_receive(:y).and_raise(NoMethodError, /blah/)
         x.y
       end
       this.assert_match /to match "blah"/, run(:test).reason*' '
@@ -64,8 +59,7 @@ describe :receive_and_raise do
     this = self
     spec rand do
       test :test do
-        x = mock(:x)
-        expect(x).to_receive(:y).and_raise(NoMethodError, /undefined method `y' for :x:Symbol/)
+        expect(x = 'x').to_receive(:y).and_raise(NoMethodError, /undefined method `y' for "x":String/)
         x.y
       end
       this.assert_equal :__tiramisu_passed__, run(:test)
@@ -76,16 +70,14 @@ describe :receive_and_raise do
     this, t, m = self, nil, nil
     spec rand do
       test :test do
-        x = mock(:x)
-        expect(x).to_receive(:y).and_raise {|e|
+        expect(x = 'x').to_receive(:y).and_raise {|e|
           t, m = e.class, e.message
-          this.assert_match /undefined method .y. for :x:Symbol/, e.message
         }
         x.y
       end
       run(:test)
       this.assert_equal NoMethodError, t
-      this.assert_match /undefined method .y. for :x:Symbol/, m
+      this.assert_match /undefined method .y. for "x":String/, m
     end
   end
 end

data/test/receive_and_return_test.rb

@@ -4,9 +4,8 @@ describe :receive_and_return do
     this = self
     spec rand do
       test :test do
-        x = mock(1)
-        expect(x).to_receive(:+).with(1).and_return(2)
-        x + 1
+        expect(x = 'x').to_receive(:+).with('y').and_return('xy')
+        x + 'y'
       end
       this.assert_equal :__tiramisu_passed__, run(:test)
     end
@@ -16,8 +15,7 @@ describe :receive_and_return do
     this = self
     spec rand do
       test :test do
-        x = mock(:x)
-        expect(x).to_receive(:to_s).and_return(:y)
+        expect(x = 'x').to_receive(:to_s).and_return(:y)
         x.to_s
       end
       this.assert_match /Looks like :to_s message never returned expected value/, run(:test).reason*' '
@@ -28,9 +26,8 @@ describe :receive_and_return do
     this = self
     spec rand do
       test :test do
-        x = mock(1)
-        expect(x).to_receive(:+).with(1).and_return {|v| v == 2}
-        x + 1
+        expect(x = 'x').to_receive(:+).with('y').and_return {|v| v == 'xy'}
+        x + 'y'
       end
       this.assert_equal :__tiramisu_passed__, run(:test)
     end
@@ -40,33 +37,8 @@ describe :receive_and_return do
     this = self
     spec rand do
       test :test do
-        x = mock(1)
-        expect(x).to_receive(:+).with(1).and_return {false}
-        x + 1
-      end
-      this.assert_match /Looks like :\+ message never returned expected value/, run(:test).reason*' '
-    end
-  end
-
-  it 'should pass when block validates all returned value' do
-    this = self
-    spec rand do
-      test :test do
-        x = mock(1)
-        expect(x).to_receive(:+).with(1).and_return {|v| v == 2}
-        x + 1
-      end
-      this.assert_equal :__tiramisu_passed__, run(:test)
-    end
-  end
-
-  it 'should fail when block does not validate returned value' do
-    this = self
-    spec rand do
-      test :test do
-        x = mock(1)
-        expect(x).to_receive(:+).with(1).and_return {false}
-        x + 1
+        expect(x = 'x').to_receive(:+).with('y').and_return {false}
+        x + 'y'
       end
       this.assert_match /Looks like :\+ message never returned expected value/, run(:test).reason*' '
     end

data/test/receive_and_throw_test.rb

@@ -4,7 +4,7 @@ describe :receive_and_throw do
     this = self
     spec rand do
       test :test do
-        x = mock(Class.new {define_singleton_method(:y) {throw :z}})
+        x = Class.new {define_singleton_method(:y) {throw :z}}
         expect(x).to_receive(:y).and_throw
         x.y
       end
@@ -16,7 +16,7 @@ describe :receive_and_throw do
     this = self
     spec rand do
       test :test do
-        x = mock(Class.new {define_singleton_method(:y) {throw :z}})
+        x = Class.new {define_singleton_method(:y) {throw :z}}
         expect(x).to_receive(:y).and_throw(:z)
         x.y
       end
@@ -28,7 +28,7 @@ describe :receive_and_throw do
     this = self
     spec rand do
       test :test do
-        x = mock(Class.new {define_singleton_method(:y) {}})
+        x = Class.new {define_singleton_method(:y) {}}
         expect(x).to_receive(:y).and_throw
         x.y
       end
@@ -40,7 +40,7 @@ describe :receive_and_throw do
     this = self
     spec rand do
       test :test do
-        x = mock(Class.new {define_singleton_method(:y) {throw :z}})
+        x = Class.new {define_singleton_method(:y) {throw :z}}
         expect(x).to_receive(:y).and_throw(:a)
         x.y
       end
@@ -52,7 +52,7 @@ describe :receive_and_throw do
     this = self
     spec rand do
       test :test do
-        x = mock(Class.new {define_singleton_method(:y) {throw :z}})
+        x = Class.new {define_singleton_method(:y) {throw :z}}
         expect(x).to_receive(:y).and_throw {|s| s == :z}
         x.y
       end
@@ -64,7 +64,7 @@ describe :receive_and_throw do
     this = self
     spec rand do
       test :test do
-        x = mock(Class.new {define_singleton_method(:y) {throw :z}})
+        x = Class.new {define_singleton_method(:y) {throw :z}}
         expect(x).to_receive(:y).and_throw {false}
         x.y
       end

data/test/receive_test.rb

@@ -4,8 +4,7 @@ describe :receive do
     this = self
     spec rand do
       test :test do
-        x = mock(:x)
-        expect(x).to_receive(:class)
+        expect(x = 'x').to_receive(:class)
         x.class
       end
       this.assert_equal :__tiramisu_passed__, run(:test)
@@ -16,8 +15,7 @@ describe :receive do
     this = self
     spec rand do
       test :test do
-        x = mock(:x)
-        expect(x).to_receive(:class)
+        expect(x = 'x').to_receive(:class)
       end
       this.assert_equal Tiramisu::GenericFailure, run(:test).class
     end
@@ -27,8 +25,7 @@ describe :receive do
     this = self
     spec rand do
       test :test do
-        x = mock(:x)
-        fail_if(x).receive(:class)
+        fail_if(x = 'x').receive(:class)
       end
       this.assert_equal :__tiramisu_passed__, run(:test)
     end
@@ -38,8 +35,7 @@ describe :receive do
     this = self
     spec rand do
       test :test do
-        x = mock(:x)
-        fail_if(x).receive(:class)
+        fail_if(x = 'x').receive(:class)
         x.class
       end
       this.assert_equal Tiramisu::GenericFailure, run(:test).class