minispec 0.0.1

data/lib/minispec/utils/pretty_print.rb

@@ -0,0 +1,51 @@
+# Borrowed and adapted from Pry - https://github.com/pry/pry
+
+# Copyright (c) 2013 John Mair (banisterfiend)
+#
+# 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 MiniSpec
+  module Utils
+    def pp obj
+      out = ''
+      q = MiniSpec::PrettyPrint.new(out)
+      q.guard_inspect_key { q.pp(obj) }
+      q.flush
+      out
+    end
+  end
+
+  class PrettyPrint < ::PP
+    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
+      "\e[32m%s\e[0m" % object_literal
+    end
+  end
+end

data/lib/minispec/utils/raise.rb

@@ -0,0 +1,123 @@
+module MiniSpec
+
+  # used when some block does not raise as expected
+  class ExceptionError < StandardError; end
+
+  module Utils
+
+    # checks whether given object is a exception of given class(if any),
+    # and/or match given String/Regexp(if any)
+    #
+    # 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.
+    #
+    # @param subject potentially a Exception instance
+    # @param [Hash]  context
+    # @param [Array] *args  actual expectations. can be a Class, String or Regexp
+    # @return [ExceptionError] if not raised as expected
+    #         [true]           if raised an exception that meets expectations
+    #
+    def exception_raised? subject, context, *args
+      if context[:right_proc]
+        args.any? && raise(ArgumentError, 'Both arguments and block given. Please use either one.')
+        return MiniSpec::ExceptionInspector.raised_as_expected_by_proc?(subject, context)
+      end
+
+      type, match = nil
+      args.each { |a| a.is_a?(Class) ? type = a : match = a }
+      regexp = match.is_a?(Regexp) ? match : /^#{Regexp.escape(match.to_s)}\z/
+
+      context = {negation: context[:negation]} # it is critical to not alter received context
+      if context[:is_a_exception]         = subject.is_a?(Exception)
+        context[:valid_exception_type]    = type  ? (subject.class == type)  : nil
+        context[:valid_exception_message] = match ? (subject.to_s =~ regexp) : nil
+      end
+
+      MiniSpec::ExceptionInspector.raised_as_expected?(subject, type, match, context)
+    end
+  end
+
+  module ExceptionInspector
+    extend MiniSpec::Utils
+    extend self
+
+    def raised_as_expected_by_proc? subject, context
+      x = context[:right_proc].call(*subject) # splat needed on multiple expectations
+      if context[:negation]
+        # return true if block returns false or nil
+        return true if !x
+        return ExceptionError.new('Not expected any error to be raised')
+      end
+      # return true if block returns a positive value
+      return true if x
+      ExceptionError.new('Expected some error to be raised')
+    end
+
+    def raised_as_expected? subject, type, match, context
+      if type && match
+        x = validate_type(subject, type, context)
+        return x if x.is_a?(ExceptionError)
+        validate_message(subject, match, context)
+      elsif type
+        validate_type(subject, type, context)
+      elsif match
+        validate_message(subject, match, context)
+      else
+        validate(context)
+      end
+    end
+
+    def validate context
+      x = context[:is_a_exception]
+      if context[:negation]
+        # return true if no exception raised
+        return true if !x
+        # return ExceptionError cause a exception raised but not expected
+        return ExceptionError.new('Not expected a error to be raised')
+      end
+      # return true if some exception raised
+      return true if x
+      # return ExceptionError cause no exception raised
+      ExceptionError.new('Expected some error to be raised')
+    end
+
+    def validate_type subject, type, context
+      x = context[:valid_exception_type]
+      if context[:negation]
+        # return true if raised exception is not of expected type OR no exception raised et all
+        return true if !x
+        # return ExceptionError cause exception should NOT be of given type
+        return ExceptionError.new("Not expected a %s error to be raised." % pp(type))
+      end
+      # return true if raised exception is of expected type
+      return true if x
+      # return ExceptionError cause raised exception is NOT of given type OR no exception raised et all
+      ExceptionError.new("Expected a %s error to be raised.\nInstead %s" % [
+        pp(type),
+        context[:is_a_exception] ?
+          'a %s error raised' % pp(subject.class) :
+          'nothing raised'
+      ])
+    end
+
+    def validate_message subject, match, context
+      x = context[:valid_exception_message]
+      if context[:negation]
+        # return true if exception message does not match expected value OR no exception raised et all
+        return true if !x
+        # return ExceptionError cause exception message should NOT match given value
+        return ExceptionError.new('Not expected raised error to match %s' % pp(match))
+      end
+      # return true if exception message matched expected value
+      return true if x
+      # return ExceptionError cause exception message does NOT match given value OR no exception raised et all
+      ExceptionError.new("Expected a error that match %s to be raised.\nInstead %s." % [
+        pp(match),
+        context[:is_a_exception] ?
+          'a error with following message raised: %s' % pp(subject) :
+          'nothing raised'
+      ])
+    end
+  end
+end

data/lib/minispec/utils/throw.rb

@@ -0,0 +1,140 @@
+module MiniSpec
+
+  class ThrowError < StandardError; end
+
+  module Utils
+
+    # checks whether given block throws a symbol
+    # and if yes compare it with expected one.
+    # if a optional value given it will be compared to thrown one.
+    #
+    # @param expected_symbol
+    # @param expected_value
+    # @param [Proc] &proc
+    # @return a failure [ThrowError] if expectation not met.
+    #         true if expectations met.
+    #
+    def symbol_thrown? expected_symbol, expected_value, context, &block
+      thrown_symbol, thrown_value = catch_symbol(expected_symbol, &block)
+
+      if context[:right_proc]
+        expected_symbol && raise(ArgumentError, 'Both arguments and block given. Please use either one.')
+        return MiniSpec::ThrowInspector.thrown_as_expected_by_proc?(thrown_symbol, context)
+      end
+
+      MiniSpec::ThrowInspector.thrown_as_expected?(expected_symbol, expected_value, thrown_symbol, thrown_value, context)
+    end
+
+    # calling given block and catching thrown symbol, if any.
+    #
+    # @param expected_symbol
+    # @param [Proc] &block
+    #
+    def catch_symbol expected_symbol, &block
+      thrown_symbol, thrown_value = nil
+      begin
+        if expected_symbol
+          thrown_value = catch :__ms__nothing_thrown do
+            catch expected_symbol do
+              block.call
+              throw :__ms__nothing_thrown, :__ms__nothing_thrown
+            end
+          end
+          thrown_symbol = expected_symbol unless thrown_value == :__ms__nothing_thrown
+        else
+          block.call
+        end
+      rescue => e
+        raise(e) unless thrown_symbol = extract_thrown_symbol(e)
+      end
+      [thrown_symbol, thrown_value]
+    end
+
+    # extract thrown symbol from given exception
+    #
+    # @param exception
+    #
+    def extract_thrown_symbol exception
+      return unless exception.is_a?(Exception)
+      return unless s = exception.message.scan(/uncaught throw\W+(\w+)/).flatten[0]
+      s.to_sym
+    end
+  end
+
+  module ThrowInspector
+    extend MiniSpec::Utils
+    extend self
+
+    def thrown_as_expected_by_proc? thrown_symbol, context
+      x = context[:right_proc].call(*thrown_symbol) # splat needed on multiple expectations
+      if context[:negation]
+        return true if !x
+        return ThrowError.new('Not expected any symbol to be thrown')
+      end
+      return true if x
+      ThrowError.new('Expected a symbol to be thrown')
+    end
+
+    def thrown_as_expected? expected_symbol, expected_value, thrown_symbol, thrown_value, context
+      if expected_symbol && expected_value
+        x = correct_symbol_thrown?(expected_symbol, thrown_symbol, context)
+        return x if x.is_a?(ThrowError)
+        correct_value_thrown?(expected_symbol, expected_value, thrown_value, context)
+      elsif expected_symbol
+        correct_symbol_thrown?(expected_symbol, thrown_symbol, context)
+      else
+        any_symbol_thrown?(thrown_symbol, context)
+      end
+    end
+
+    def any_symbol_thrown? thrown_symbol, context
+      if context[:negation]
+        return true if !thrown_symbol
+        return ThrowError.new('%s symbol thrown when not expected' % pp(thrown_symbol))
+      end
+      return true if thrown_symbol
+      ThrowError.new('Expected a symbol to be thrown')
+    end
+
+    def correct_symbol_thrown? expected_symbol, thrown_symbol, context
+      # needed here cause this method are invoked directly by mock validators.
+      # and it's not a double check cause Utils.symbol_thrown?
+      # wont arrive here if called with a block
+      if context[:right_proc]
+        return thrown_as_expected_by_proc?(thrown_symbol, context)
+      end
+
+      x = expected_symbol == thrown_symbol
+      if context[:negation]
+        return true if !x
+        return ThrowError.new('Not expected %s symbol to be thrown' % pp(thrown_symbol))
+      end
+      return true if x
+      ThrowError.new('Expected %s symbol to be thrown. Instead %s thrown.' % [
+        pp(expected_symbol),
+        thrown_symbol ?
+          pp(thrown_symbol) :
+          'nothing'
+      ])
+    end
+
+    def correct_value_thrown? thrown_symbol, expected_value, thrown_value, context
+      x = expected_value.is_a?(Regexp)   ?
+        (thrown_value.to_s =~ expected_value) :
+        (thrown_value      == expected_value)
+      if context[:negation]
+        return true if !x
+        return ThrowError.new('Not expected %s symbol\'s value to match %s' % [
+          thrown_symbol,
+          thrown_value,
+        ].map(&method(:pp)))
+      end
+      return true if x
+      ThrowError.new("Expected %s symbol's value to match %s\nActual value: %s" % [
+        thrown_symbol,
+        expected_value,
+        thrown_value
+      ].map(&method(:pp)))
+    end
+  end
+end

data/minispec.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+
+name, version = 'minispec 0.0.1'.split
+Gem::Specification.new do |spec|
+  spec.name          = name
+  spec.version       = version
+  spec.authors       = ['Slee Woo']
+  spec.email         = ['mail@sleewoo.com']
+  spec.description   = 'Simple, Intuitive, Full-featured Testing Framework'
+  spec.summary       = [name, version]*'-'
+  spec.homepage      = 'https://github.com/sleewoo/' + name
+  spec.license       = 'MIT'
+
+  spec.files = Dir['**/{*,.[a-z]*}'].reject {|e| e =~ /\.(gem|lock)\Z/}
+  spec.require_paths = ['lib']
+
+  spec.executables = Dir['bin/*'].map{|f| File.basename(f)}
+
+  spec.required_ruby_version = '>= 1.9.2'
+
+  spec.add_dependency 'diff-lcs', '~> 1.2'
+  spec.add_dependency 'coderay',  '~> 1.1'
+
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+end

data/test/mocks/expectations/amount.rb

@@ -0,0 +1,67 @@
+class MinispecTest::Expectations::Unit
+
+  should 'pass when received expected amount' do
+    expect(o).to_receive(:a).count(2)
+    o.a
+    o.a
+  end
+
+  should ':fail when received wrong amount of times' do
+    expect(o).to_receive(:a).count(2)
+    o.a
+  end
+
+  should 'pass when proc validates received amount' do
+    expect(o).to_receive(:a).count {|r| r == 2}
+    o.a
+    o.a
+  end
+
+  should ':fail when proc does not validate received amount' do
+    expect(o).to_receive(:a).count { false }
+    o.a
+  end
+
+  should 'pass when multiple messages uses one expectation' do
+    expect(o).to_receive(:a, :b).count(2)
+    o.a
+    o.b
+    o.b
+    o.a
+  end
+
+  should ':fail when received multiple messages amount are wrong' do
+    expect(o).to_receive(:a, :b).count(2)
+    o.a
+    o.b
+    o.b
+  end
+
+  should 'pass when each of multiple messages uses its own expectation' do
+    expect(o).to_receive(:a, :b).count(1, 2)
+    o.a
+    o.b
+    o.b
+  end
+
+  should ':fail when at least one message does not match its expectation' do
+    expect(o).to_receive(:a, :b).count(1, 1)
+    o.a
+    o.b
+    o.b
+  end
+
+  should 'pass when proc validates received multiple messages amount' do
+    expect(o).to_receive(:a, :b).count {|a, b| a == 2 && b == 2}
+    o.a
+    o.b
+    o.b
+    o.a
+  end
+
+  should ':fail when proc does not validate received multiple messages amount' do
+    expect(o).to_receive(:a, :b).count { false }
+    o.a
+    o.b
+  end
+end

data/test/mocks/expectations/arguments.rb

@@ -0,0 +1,126 @@
+class MinispecTest::Expectations::Unit
+
+  should 'pass when expected arguments matches given ones' do
+    expect(o).to_receive(:a).with(1, 2)
+    o.a(1, 2)
+    o.a(4, 5)
+  end
+
+  should ':fail when wrong arguments given' do
+    expect(o).to_receive(:a).with(4, 5)
+    o.a(1, 2)
+    o.a(:a, 'b', [:z])
+    o.a([:x], {y: :z})
+  end
+
+  should 'pass when proc validates arguments' do
+    expect(o).to_receive(:a).with {|x| x[0] == [1] && x[1] == [:b]}
+    o.a(1)
+    o.a(:b)
+    expect(o).to_receive(:b).with {|x| x[0] == [:x, [:y]] && x[1] == [9]}
+    o.b(:x, [:y])
+    o.b(9)
+    expect(o).to_receive(:c).with {|x| x[0] == [ [1], {2 => 3} ]}
+    o.c([1], {2 => 3})
+  end
+
+  should ':fail when proc does not validate arguments' do
+    expect(o).to_receive(:a).with {false}
+    o.a(1)
+    o.a(:x)
+    o.a({a: :b}, [:x, [:y]])
+  end
+
+  should 'pass when no arguments expected and no arguments given' do
+    expect(o).to_receive(:a).without_arguments
+    o.a
+  end
+
+  should 'pass when no arguments expected and message called at least once without arguments' do
+    expect(o).to_receive(:a).without_arguments
+    o.a(:x)
+    o.a(:y)
+    o.a
+  end
+
+  should ':fail when no arguments expected and message never called without arguments' do
+    expect(o).to_receive(:a).without_arguments
+    o.a(:x)
+    o.a(:y)
+  end
+
+  should 'pass when given multiple arguments matching expected ones' do
+    expect(o).to_receive(:a, :b, :c).with(1, 2, 3)
+    o.a 1
+    o.b 2
+    o.c 3
+  end
+
+  it 'plays well with Array arguments' do
+    expect(o).to_receive(:a, :b, :c).with([1], [4, 5, [6]], :c)
+    o.a [1]
+    o.a ['1']
+    o.b [4, 5, [6]]
+    o.b ['a', 'b', :c]
+    o.c :c
+  end
+
+  should 'pass when proc validates passed arguments' do
+    expect(o).to_receive(:a, :b, :c).with do |a, b, c|
+      a[0]   == [1] &&
+        a[1] == [:z] &&
+        b[0] == [[1], [2, 3]] &&
+        b[1] == [:x] &&
+        c[0] == [3, [:x], {y: :z}] &&
+        c[1] == [:o]
+    end
+    o.a 1
+    o.a :z
+    o.b [1], [2, 3]
+    o.b :x
+    o.c 3, [:x], {y: :z}
+    o.c :o
+  end
+
+  should ':fail when at least one argument does not meet expectations' do
+    expect(o).to_receive(:a, :b, :c).with(1, 2, [:x, "y", [:z]])
+    o.a 1
+    o.b [2]
+    o.c 3
+    o.c :x
+    o.c [:x, :y, {z: 'z'}]
+  end
+
+  should ':fail when proc does not validate passed arguments' do
+    expect(o).to_receive(:a, :b, :c).with { false }
+    o.a 1
+    o.a [1, 2]
+    o.b 2
+    o.b :x, [:y]
+    o.c ['3']
+  end
+
+  should 'pass when no arguments expected and all messages called without arguments' do
+    expect(o).to_receive(:a, :b, :c).without_arguments
+    o.a
+    o.b
+    o.c
+  end
+
+  should 'pass when no arguments expected and each message called at least once without arguments' do
+    expect(o).to_receive(:a, :b, :c).without_arguments
+    o.a
+    o.a(:x)
+    o.b
+    o.b(:y)
+    o.c
+    o.c(:z)
+  end
+
+  should ':fail when no arguments expected and at least one message never called without arguments' do
+    expect(o).to_receive(:a, :b, :c).without_arguments
+    o.a
+    o.b
+    o.c(:x)
+  end
+end