tiramisu 0.0.0 → 0.0.1

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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,38 @@
+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/pretty_print.rb

@@ -0,0 +1,55 @@
+require 'pp'
+require 'coderay'
+
+# Stolen from [Pry](https://github.com/pry/pry)
+#
+# Copyright (c) 2013 John Mair (banisterfiend)
+# Copyright (c) 2015 Slee Woo (sleewoo)
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# 'Software'), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module Tiramisu
+  def pp obj
+    out = ''
+    q = Tiramisu::PrettyPrint.new(out)
+    q.guard_inspect_key { q.pp(obj) }
+    q.flush
+    out
+  end
+
+  class PrettyPrint < ::PP
+    OBJECT_LITERAL_FORMAT = "\e[32m%s\e[0m".freeze
+
+    def text str, width = str.length
+      if str.include?("\e[")
+        super "%s\e[0m" % str, width
+      elsif str.start_with?('#<') || str == '=' || str == '>'
+        super highlight_object_literal(str), width
+      else
+        super CodeRay.scan(str, :ruby).term, width
+      end
+    end
+
+    private
+    def highlight_object_literal object_literal
+      OBJECT_LITERAL_FORMAT % object_literal
+    end
+  end
+end

data/lib/tiramisu/run.rb

@@ -0,0 +1,77 @@
+module Tiramisu
+
+  def progress
+    @progress ||= TTY::ProgressBar.new ':current of :total [:bar]' do |cfg|
+      cfg.total = units.map {|u| u.tests.size}.reduce(:+) || 0
+      cfg.width = TTY::Screen.width
+      cfg.complete = '.'
+    end
+  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)
+        end
+        progress.advance
+      end
+    end
+    render_skips
+    progress.log ''
+  end
+
+  def render_failure unit, test_uuid, failure
+    indent = ''
+    [*unit.__ancestors__, unit].each do |u|
+      progress.log indent + u.__identity__
+      indent << INDENT
+    end
+    progress.log indent + test_uuid
+    indent << INDENT
+    case failure
+    when Exception
+      render_exception(indent, failure)
+    when GenericFailure, AssertionFailure
+      render_caller(indent, failure.caller)
+      __send__('render_%s' % failure.class.name.split('::').last, indent, failure)
+    else
+      progress.log(indent + failure.inspect)
+    end
+    progress.log ''
+  end
+
+  def render_exception indent, failure
+    progress.log indent + underline.bright_red(failure.message)
+    pretty_backtrace(failure).each {|l| progress.log(indent + l)}
+  end
+
+  def render_GenericFailure indent, failure
+    Array(failure.reason).each {|l| progress.log(indent + l.to_s)}
+  end
+
+  def render_AssertionFailure indent, failure
+    progress.log indent + cyan('a: ') + pp(failure.object)
+    progress.log indent + cyan('b: ') + failure.arguments.map {|a| pp(a)}.join(', ')
+  end
+
+  def render_caller indent, caller
+    return unless caller
+    progress.log indent + underline.bright_red(readline(caller))
+  end
+
+  def render_skips
+    return if skips.empty?
+    progress.log ''
+    progress.log bold.magenta('Skips:')
+    skips.each do |skip|
+      progress.log '  %s (%s)' % [blue(skip.reason || 'skip'), relative_location(skip.caller)]
+    end
+  end
+end

data/lib/tiramisu/unit.rb

@@ -0,0 +1,195 @@
+module Tiramisu
+  class Unit
+
+    # @example
+    #   assert(x) == y
+    #   assert(x).include?(y)
+    #   assert(x).nil?
+    #   refute(a).include?(b)
+    #   fail_if(a).include?(b)
+    [
+      :assert,
+      :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])
+      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
+    #   test :something do
+    #     skip "recheck this after fixing X"
+    #     assert(x) == y # this wont run
+    #   end
+    #
+    def skip reason = nil
+      throw(:__tiramisu_status__, Tiramisu::Skip.new(reason, caller[0]))
+    end
+
+    def __run__ test, before, around, after
+      __send__(before) if before
+      if around
+        __send__(around) {__send__(test)}
+      else
+        __send__(test)
+      end
+      __send__(after) if after
+      __mocks__.each(&:__tiramisu__validate_messages__)
+      :__tiramisu_passed__
+    rescue Exception => e
+      throw(:__tiramisu_status__, e)
+    end
+
+    private
+    def __mocks__
+      @__mocks__ ||= []
+    end
+  end
+
+  class << Unit
+
+    def spec
+      raise(NotImplementedError, 'Nested specs not supported. Please use a context instead')
+    end
+
+    # define a context inside current spec/context.
+    #
+    # @param label
+    # @param &block
+    #
+    def context label, &block
+      return unless block
+      Tiramisu.define_and_register_a_context(label, block, self)
+    end
+
+    # define a test
+    #
+    # @param label
+    # @param &block
+    #
+    def test label, &block
+      return unless block
+      tests[label] = Tiramisu.identity_string(:test, label, block)
+      define_method(tests[label], &block)
+    end
+    alias it test
+    alias should test
+
+    def tests
+      @__tiramisu_tests__ ||= {}
+    end
+
+    # run some code before/around/after any or specific tests
+    #
+    # @example call :define_users before any test (in current spec)
+    #   spec User do
+    #     before do
+    #       @users = ...
+    #     end
+    #
+    #     test :login do
+    #       # @users available here
+    #     end
+    #   end
+    #
+    # @example run only after :photos test
+    #   spec User do
+    #     after :photos do
+    #       ...
+    #     end
+    #
+    #     test :photos do
+    #       ...
+    #     end
+    #   end
+    #
+    # @example run around :authorize and :authenticate tests
+    #   spec User do
+    #     around :authorize, :authenticate do |&test|
+    #       SomeApi.with_auth do
+    #         test.call # run the test
+    #       end
+    #     end
+    #
+    #     test :authorize do
+    #       # will run inside `with_auth` block
+    #     end
+    #
+    #     test :authenticate do
+    #       # same
+    #     end
+    #   end
+    #
+    # @note if multiple hooks defined for same test only the last one will run
+    # @note named hooks will have precedence over wildcard ones
+    #
+    # @example  named hooks have precedence over wildcard ones
+    #   before :math do
+    #     # named hook, to run only before :math test
+    #   end
+    #
+    #   before do
+    #     # wildcard hook, to run before any test
+    #   end
+    #
+    #   test :math do
+    #     # only `bofore :math` hook will run here
+    #   end
+    #
+    [
+      :before,
+      :around,
+      :after
+    ].each do |hook|
+      define_method hook do |*tests,&block|
+        block || raise(ArgumentError, 'block missing')
+        meth = :"__tiramisu_hooks_#{hook}_#{block.source_location.join}__"
+        tests = [:__tiramisu_hooks_any__] if tests.empty?
+        tests.each {|t| (hooks[hook] ||= {})[t] = meth}
+        define_method(meth, &block)
+      end
+    end
+
+    def hooks
+      @__tiramisu_hooks__ ||= Tiramisu.void_hooks
+    end
+
+    # skipping a whole spec/context
+    #
+    # @example
+    #   spec Array do
+    #     skip
+    #
+    #     # code here wont be executed
+    #   end
+    #
+    def skip reason = nil
+      throw(:__tiramisu_skip__, Tiramisu::Skip.new(reason, caller[0]))
+    end
+
+    def run test
+      tests[test] || raise(StandardError, 'Undefined test %s at "%s"' % [test.inspect, __identity__])
+      catch :__tiramisu_status__ do
+        allocate.__run__ tests[test],
+          hooks[:before][test] || hooks[:before][:__tiramisu_hooks_any__],
+          hooks[:around][test] || hooks[:around][:__tiramisu_hooks_any__],
+          hooks[:after][test]  || hooks[:after][:__tiramisu_hooks_any__]
+      end
+    end
+  end
+end