tiramisu 0.0.0 → 0.0.1

data/Rakefile

@@ -1,2 +1,11 @@
-require "bundler/gem_tasks"
+require 'rake'
+require 'rake/testtask'
+require 'bundler/gem_tasks'
 
+root = File.expand_path('..', __FILE__)
+Rake::TestTask.new do |t|
+  t.ruby_opts << '-r "%s/test/setup" -I "%s/lib"' % [root, root]
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+task default: :test

data/bin/tiramisu

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'tiramisu'
+Tiramisu.run(*$*)

data/lib/tiramisu.rb

@@ -1,5 +1,120 @@
-require "tiramisu/version"
+require 'tty-progressbar'
+require 'tty-screen'
+require 'pastel'
 
 module Tiramisu
-  # Your code goes here...
+  extend self
+
+  DEFAULT_PATTERN = '{spec,test}/**/{*_spec.rb,*_test.rb}'.freeze
+  GLOBAL_SETUPS = []
+
+  GenericFailure = Struct.new(:reason, :caller)
+  AssertionFailure = Struct.new(:object, :arguments, :caller)
+
+  Skip = Struct.new(:reason, :caller)
+
+  INDENT = '  '.freeze
+  PASTEL = Pastel.new
+  %w[
+    red
+    bright_red
+    green
+    blue
+    cyan
+    magenta
+    bold
+    underline
+  ].each {|m| define_method(m) {|*a| PASTEL.__send__(m, *a)}}
+
+  def units
+    @units ||= []
+  end
+
+  def assertions
+    @assertions ||= {}
+  end
+
+  def skips
+    @skips ||= []
+  end
+
+  def define_spec label, block
+    define_unit_class(:spec, label, block, [].freeze)
+  end
+
+  def define_and_register_a_spec label, block
+    units << define_spec(label, block)
+  end
+
+  def define_context label, block, parent
+    define_unit_class(:context, label, block, [*parent.__ancestors__, parent].freeze)
+  end
+
+  def define_and_register_a_context label, block, parent
+    units << define_context(label, block, parent)
+  end
+
+  # define a class that will hold contexts and tests
+  #
+  # @param  [String, Symbol] type
+  # @param  [String, Symbol] label
+  # @param  [Proc] block
+  # @param  [Array] ancestors
+  # @return [Unit]
+  #
+  def define_unit_class type, label, block, ancestors
+    identity = identity_string(type, label, block).freeze
+    Class.new ancestors.last || Unit do
+      define_singleton_method(:__ancestors__) {ancestors}
+      define_singleton_method(:__identity__) {identity}
+      Tiramisu::GLOBAL_SETUPS.each {|b| class_exec(&b)}
+      # execute given block only after global setups executed and all utility methods defined
+      result = catch(:__tiramisu_skip__) {class_exec(&block)}
+      Tiramisu.skips << result if result.is_a?(Skip)
+    end
+  end
+
+  # define a module that when included will execute the given block on base
+  #
+  # @param  [Proc] block
+  # @return [Module]
+  #
+  def define_unit_module block
+    block || raise(ArgumentError, 'missing block')
+    Module.new do
+      # any spec/context that will include this module will "inherit" it's logic
+      #
+      # @example
+      #   EnumeratorSpec = spec 'Enumerator tests' do
+      #     # some tests here
+      #   end
+      #
+      #   spec Array do
+      #     include EnumeratorSpec
+      #   end
+      #
+      #   spec Hash do
+      #     include EnumeratorSpec
+      #   end
+      #
+      define_singleton_method(:included) {|b| b.class_exec(&block)}
+    end
+  end
+
+  # stop any code and report a failure
+  def fail reason, caller
+    throw(:__tiramisu_status__, GenericFailure.new(Array(reason), caller))
+  end
+
+  def void_hooks
+    {before: {}, around: {}, after: {}}
+  end
 end
+
+require 'tiramisu/core_ext'
+require 'tiramisu/pretty_print'
+require 'tiramisu/mock'
+require 'tiramisu/util'
+require 'tiramisu/unit'
+require 'tiramisu/assert'
+require 'tiramisu/run'

data/lib/tiramisu/assert.rb

@@ -0,0 +1,142 @@
+module Tiramisu
+  class Assert
+
+    def initialize object, action = :assert, caller = nil
+      @object = object
+      @caller = caller
+      @assert = action == :assert
+      @refute = action == :refute
+      @assert || @refute || Kernel.raise(ArgumentError, 'action should be either :assert or :refute')
+    end
+
+    instance_methods.each do |m|
+      # overriding all instance methods so received messages to be passed to tested object.
+      #
+      # @example
+      #   assert(x).frozen?
+      #   # `assert` returns a object that receives `frozen?` message and pass it to x
+      #
+      define_method m do |*a, &b|
+        __assert__(m, a, b)
+      end
+    end
+
+    # forward any missing method to tested object.
+    #
+    # @example
+    #   assert(some_array).include? x
+    #   # object returned by `assert` does not respond to `include?`
+    #   # so `include?` is passed to `some_array`
+    #
+    def method_missing m, *a, &b
+      __assert__(m, a, b)
+    end
+
+    # ensure the given block raises as expected
+    #
+    # @note if block given it will have precedence over arguments
+    #
+    # @example assertion pass if block raises whatever
+    #   assert {some code}.raise
+    #
+    # @example assertion pass if block raises NameError
+    #   assert {some code}.raise NameError
+    #
+    # @example assertion pass if block raises NameError and error message matches /blah/
+    #   assert {some code}.raise NameError, /blah/
+    #
+    # @example assertion pass if block raises whatever error that matches /blah/
+    #   assert {some code}.raise nil, /blah/
+    #
+    # @example assertion pass if validation block returns a positive value
+    #   assert {some code}.raise {|e| e.is_a?(NameError) && e.message =~ /blah/}
+    #
+    #
+    # @example assertion pass if nothing raised
+    #   refute {some code}.raise
+    #   # same
+    #   fail_if {some code}.raise
+    #
+    # @example assertion fails only if block raises a NameError.
+    #   it may raise whatever but NameError. if nothing raised assertion will fail.
+    #
+    #   fail_if {some code}.raise NameError
+    #
+    # @example assertion pass if raised error does not match /blah/
+    #   if nothing raised assertion will fail.
+    #
+    #   fail_if {some code}.raise nil, /blah/
+    #
+    # @example assertion will pass if raised error is not a NameError
+    #   and error message does not match /blah/
+    #   if nothing raised assertion will fail as well.
+    #
+    #   fail_if {some code}.raise NameError, /blah/
+    #
+    def raise type = nil, message = nil, &block
+      failure = Tiramisu.__send__(
+        @assert ? :assert_raised_as_expected : :refute_raised_as_expected,
+        @object, type, message, block
+      )
+      Tiramisu.fail(failure, caller[0]) if failure
+    end
+    alias to_raise raise
+
+    # ensure given block thrown as expected
+    #
+    # @note if block given it will have precedence over arguments
+    #
+    # @example assertion pass if any symbol thrown
+    #   assert {some code}.throw
+    #
+    # @example assertion pass only if :x symbol thrown
+    #   assert {some code}.throw(:x)
+    #
+    # @example assertion pass only if given block validates thrown symbol
+    #   assert {some code}.throw {|sym| sym == :x}
+    #
+    def throw expected_symbol = nil, &block
+      failure = Tiramisu.__send__(
+        @assert ? :assert_thrown_as_expected : :refute_thrown_as_expected,
+        @object, expected_symbol ? expected_symbol.to_sym : nil, block
+      )
+      Tiramisu.fail(failure, caller[0]) if failure
+    end
+    alias to_throw throw
+
+    # ensure given mock will receive expected message by the end of test
+    #
+    # @example
+    #   test :auth do
+    #     user = mock(User.new)
+    #     expect(user).to_receive(:password)
+    #     user.authenticate
+    #     # by the end of test user should receive :password message,
+    #     # otherwise the test will fail
+    #   end
+    #
+    # @param Symbol expected message
+    # @return [Mock::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
+    end
+    alias to_receive receive
+
+    private
+    def __assert__ message, arguments, block
+      Kernel.throw(:__tiramisu_status__, @object[:raised]) if @object[:raised]
+      result = __send_message__(@object[:returned], message, arguments, block)
+      return true if (@assert && result) || (@refute && !result)
+      Kernel.throw(:__tiramisu_status__, AssertionFailure.new(@object[:returned], arguments, @caller))
+    end
+
+    def __send_message__ object, message, arguments, block
+      if assertion = Tiramisu.assertions[message.to_sym]
+        return assertion.call(object, *arguments, &block)
+      end
+      object.__send__(message, *arguments, &block)
+    end
+  end
+end

data/lib/tiramisu/core_ext.rb

@@ -0,0 +1,102 @@
+module Kernel
+
+  # when called with a no-nil no-false argument it defines, register and returns a spec.
+  # when called with a nil or false argument it defines and returns a spec but does not register it.
+  # when called without arguments it defines a global setup that will run on each new created spec/context.
+  #
+  # @note a Unit Module is a regular Ruby Module that when included will execute the Unit's block on base
+  #
+  # @example define regular specs
+  #   spec :some_spec do
+  #     # ...
+  #   end
+  #
+  # @example define a spec that will run on its own and can also be included into another specs/contexts
+  #   shared = spec :some_shared_spec do
+  #     # ...
+  #   end
+  #   # `shared` is now a spec good for inclusion in another specs/contexts.
+  #
+  # @example define a spec that wont run on itself but can be included into another specs/contexts
+  #   Shared = spec nil do
+  #     # ...
+  #   end
+  #   # `Shared` is now a module good for inclusion in another specs/contexts
+  #   # but because `nil` used as first argument it wont run as a spec itself
+  #
+  # @example define a global setup, i.e. a block that will run inside any new defined spec/context
+  #   spec do
+  #     include Rack::Test # now Rack::Test will be included in any spec/context
+  #   end
+  #
+  def spec label = (noargs=true; nil), &block
+    block || raise(ArgumentError, 'missing block')
+
+    if noargs
+      # no arguments given, defining a global setup and returning
+      return Tiramisu::GLOBAL_SETUPS << block
+    end
+
+    if label
+      # a no-nil no-false argument given, defining a regular spec
+      Tiramisu.define_and_register_a_spec(label, block)
+    end
+
+    # defining a shared spec that wont run itself
+    # but can be included in another specs/contexts
+    Tiramisu.define_unit_module(block)
+  end
+
+  # when used out of tests it defines a assertion helper.
+  # the block should return a no-false no-nil value for assertion to pass.
+  # the block will receive tested object as first argument
+  # and any arguments passed to assertion as consequent ones.
+  # it will also receive the passed block.
+  #
+  # @example checks whether two arrays has same keys, orderlessly
+  #   assert :has_same_keys_as do |a, b|
+  #     a.keys.sort == b.keys.sort
+  #   end
+  #
+  #   spec :some_spec do
+  #     test :some_test do
+  #       a = [1, 2]
+  #       b = [2, 1]
+  #       assert(a).has_same_keys_as(b) # => true
+  #     end
+  #   end
+  #
+  # @example same assertion by multiple names
+  #   assert :includes, :to_include do |a, b|
+  #     a.keys.sort == b.keys.sort
+  #   end
+  #
+  #   spec :some_spec do
+  #     test :some_test do
+  #       a = [1, 2]
+  #       assert(a).includes(1) # => true
+  #       # same
+  #       expect(a).to_include(1) # => true
+  #     end
+  #   end
+  #
+  # @param [Array] *labels
+  #
+  def assert *labels, &block
+    labels.any? || raise(ArgumentError, 'Wrong number of arguments, 0 for 1+')
+    block || raise(ArgumentError, 'missing block')
+    labels.each {|label| Tiramisu.assertions[label.to_sym] = block}
+  end
+
+  # stop executing any code and report a failure
+  #
+  # @example
+  #   x > y || fail('x should be greater than y')
+  #
+  # @param reason
+  #
+  def fail *reason
+    reason.empty? && raise(ArgumentError, 'Wrong number or arguments, 0 for 1+')
+    Tiramisu.fail(reason.flatten, caller[0])
+  end
+end

data/lib/tiramisu/mock.rb

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

data/lib/tiramisu/mock/expectation.rb

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