expectation 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ba45fedcad85c3bc355804668620c834db45f2a1
-  data.tar.gz: 19766d7a77e76bd18e51e246ab1fee0ed0be3209
+  metadata.gz: 0e82b68f20c078cadb99ae70a9fe2d3f73288680
+  data.tar.gz: 071efc275974c5a339a4f4178cdaf6dd042f398d
 SHA512:
-  metadata.gz: 321eeaddc541552fd4261b5b6b9ca5f2095280abdc974ef3cb104077f5fee924d4d53cdf3218d839decf553099073276e0fa3d22dae07af26ca1ca77030e1654
-  data.tar.gz: 6b40a3e8403b34dea1eac1d877b62c62a1a0d5d7de9798cda203e1492305e32fbe00ba5fc252803c746c6b9b4e47772a1c66d1787866f440e3a6f3aa88063551
+  metadata.gz: 7cb4aa141fe72c1ca03c748add680c855b8c20e2b946386c3380a342515054fc8de7b32e8f5c32cc3e46f7a18ee1c9a0c16f4e816bed7503a146ad65f455d59b
+  data.tar.gz: 6b9ebdad0ceadeb168cd26587a5ca0407b7e8c5151fa6daebced22366d0d1cd10ddee17033862ae2c612bf03c71ae4f82f6d33ea9d1c9f8474aafc8580fa1a01

data/README.md

@@ -29,3 +29,4 @@ with a String entry at key `:foo`, and either an Array or nil at key `:bar`.
 ## License
 
 The expectations gem is distributed under the terms of the Modified BSD License, see LICENSE.BSD for details.
+

data/lib/contracts.rb

@@ -1,7 +1,8 @@
 #--
 # Author::    radiospiel  (mailto:eno@radiospiel.org)
 # Copyright:: Copyright (c) 2011, 2012 radiospiel
-# License::   Distributes under the terms of the Modified BSD License, see LICENSE.BSD for details.
+# License::   Distributes under the terms of the Modified BSD License,
+#             see LICENSE.BSD for details.
 #++
 
 # The Contract module provides annotation support. That basically
@@ -24,15 +25,23 @@
 #     end
 #   end
 #
+require "logger"
+
 module Contracts
   class Error < ArgumentError; end
 
+  (class << self; self; end).class_eval do
+    attr :logger, true
+  end
+  self.logger = Logger.new(STDOUT)
+
   def self.current_contracts
     Thread.current[:current_contracts] ||= []
   end
 
   def self.consume_current_contracts
-    r, Thread.current[:current_contracts] = Thread.current[:current_contracts], nil
+    r = Thread.current[:current_contracts]
+    Thread.current[:current_contracts] = nil
     r
   end
 
@@ -54,22 +63,45 @@ module Contracts
     end
 
     def invoke(receiver, *args, &blk)
+      #
+      # Some contracts might need a per-invocation scope. If that is the take
+      # their before_call method will return their specific scope, and we'll
+      # carry that over to the after_call and on_exception calls.
+      #
+      # Since this is potentially costly we do rather not create a combined
+      # scope object unless we really need it; also there is an optimized
+      # code path for after_call's in effect. (Not for on_exception though;
+      # since they should only occur in exceptional situations they can carry
+      # a bit of performance penalty just fine.)
+      #
+      # TODO: This could be improved by having a each annotation take care of
+      # each individual call; a first experiment to do that, however, failed.
+      annotation_scopes = nil
+
       @before_annotations.each do |annotation|
-        annotation.before_call(receiver, *args, &blk)
+        next unless annotation_scope = annotation.before_call(receiver, *args, &blk)
+        annotation_scopes ||= {}
+        annotation_scopes[annotation.object_id] = annotation_scope
       end
 
       # instance methods are UnboundMethod, class methods are Method.
       rv = @method.is_a?(Method) ? @method.call(*args, &blk)
                                  : @method.bind(receiver).call(*args, &blk)
 
-      @after_annotations.each do |annotation|
-        annotation.after_call(rv, receiver, *args, &blk)
+      if annotation_scopes
+        @after_annotations.each do |annotation|
+          annotation.after_call(annotation_scopes[annotation.object_id], rv, receiver, *args, &blk)
+        end
+      else
+        @after_annotations.each do |annotation|
+          annotation.after_call(nil, rv, receiver, *args, &blk)
+        end
       end
 
       return rv
     rescue StandardError => exc
       @exception_annotations.each do |annotation|
-        annotation.on_exception(exc, receiver, *args, &blk)
+        annotation.on_exception(annotation_scopes && annotation_scopes[annotation.object_id], exc, receiver, *args, &blk)
       end
       raise exc
     end
@@ -122,7 +154,7 @@ module Contracts
     #
     # Returns a description of the method; i.e. Class#name or Class.name
     def method_name
-      if method.is_a?(Method)                               # A singleton method?
+      if method.is_a?(Method) # A singleton method?
         # The method owner is the singleton class of the class. Sadly, the
         # the singleton class has no name; hence we try to construct the name
         # from its to_s description.
@@ -132,66 +164,16 @@ module Contracts
         "#{method.owner}##{method.name}"
       end
     end
-  end
-end
-
-require "expectation"
-
-class Contracts::Expects < Contracts::Base
-  attr :expectations
-
-  def initialize(expectations)
-    @expectations = expectations
-  end
-
-  def before_call(receiver, *args, &blk)
-    @parameter_names ||= method.parameters.map(&:last)
 
-    @parameter_names.each_with_index do |parameter_name, idx|
-      next unless expectation = expectations[parameter_name]
+    private
 
-      Expectation.match! args[idx], expectation
+    def error!(message)
+      fail Contracts::Error, message, caller[6..-1]
     end
-  rescue Expectation::Error
-    raise Contracts::Error, "#{$!} in call to `#{method_name}`", caller[5..-1]
   end
 end
 
-module Contracts::ClassMethods
-  def Expects(expectation)
-    expect! expectation => Hash
-    Contracts::Expects.new(expectation)
-  end
-end
-
-class Contracts::Returns < Contracts::Base
-  attr :expectation
-
-  def initialize(expectation)
-    @expectation = expectation
-  end
-
-  def after_call(rv, receiver, *args, &blk)
-    Expectation.match! rv, expectation
-  rescue Expectation::Error
-    raise Contracts::Error, "#{$!} in return of `#{method_name}`", caller[5..-1]
-  end
-end
-
-module Contracts::ClassMethods
-  def Returns(expectation)
-    Contracts::Returns.new(expectation)
-  end
-end
-
-class Contracts::Nothrows < Contracts::Base
-  def on_exception(rv, method, receiver, *args, &blk)
-    raise Contracts::Error, "Nothrow method `#{method_name}` raised exception: #{$!}", caller[5..-1]
-  end
-end
-
-module Contracts::ClassMethods
-  def Nothrow
-    Contracts::Nothrows.new
-  end
-end
+require_relative "contracts/expects.rb"
+require_relative "contracts/nothrows.rb"
+require_relative "contracts/returns.rb"
+require_relative "contracts/runtime.rb"

data/lib/contracts/expects.rb

@@ -0,0 +1,46 @@
+#--
+# Author::    radiospiel  (mailto:eno@radiospiel.org)
+# Copyright:: Copyright (c) 2011, 2012 radiospiel
+# License::   Distributes under the terms of the Modified BSD License,
+#             see LICENSE.BSD for details.
+#++
+
+# The Contract module provides support for Expects annotations.
+
+require "expectation"
+
+class Contracts::Expects < Contracts::Base
+  attr_reader :expectations
+
+  def initialize(expectations)
+    @expectations = expectations
+  end
+
+  def before_call(_receiver, *args, &_blk)
+    args.each_with_index do |value, idx|
+      next unless expectation = expectations_ary[idx]
+      Expectation::Matcher.match! value, expectation
+    end
+
+    nil
+  rescue Expectation::Error
+    error! "#{$ERROR_INFO} in call to `#{method_name}`"
+  end
+
+  private
+
+  def expectations_ary
+    @expectations_ary ||= begin
+      method.parameters.map do |_flag, parameter_name|
+        expectations[parameter_name]
+      end
+    end
+  end
+end
+
+module Contracts::ClassMethods
+  def Expects(expectation)
+    expect! expectation => Hash
+    Contracts::Expects.new(expectation)
+  end
+end

data/lib/contracts/nothrows.rb

@@ -0,0 +1,18 @@
+#--
+# Author::    radiospiel  (mailto:eno@radiospiel.org)
+# Copyright:: Copyright (c) 2011, 2012 radiospiel
+# License::   Distributes under the terms of the Modified BSD License,
+#             see LICENSE.BSD for details.
+#++
+
+class Contracts::Nothrows < Contracts::Base
+  def on_exception(_, _rv, _method, _receiver, *_args, &_blk)
+    error! "Nothrow method `#{method_name}` raised exception: #{$ERROR_INFO}"
+  end
+end
+
+module Contracts::ClassMethods
+  def Nothrow
+    Contracts::Nothrows.new
+  end
+end

data/lib/contracts/returns.rb

@@ -0,0 +1,26 @@
+#--
+# Author::    radiospiel  (mailto:eno@radiospiel.org)
+# Copyright:: Copyright (c) 2011, 2012 radiospiel
+# License::   Distributes under the terms of the Modified BSD License,
+#             see LICENSE.BSD for details.
+#++
+
+class Contracts::Returns < Contracts::Base
+  attr_reader :expectation
+
+  def initialize(expectation)
+    @expectation = expectation
+  end
+
+  def after_call(_, rv, _receiver, *_args, &_blk)
+    Expectation::Matcher.match! rv, expectation
+  rescue Expectation::Error
+    error! "#{$ERROR_INFO} in return of `#{method_name}`"
+  end
+end
+
+module Contracts::ClassMethods
+  def Returns(expectation)
+    Contracts::Returns.new(expectation)
+  end
+end

data/lib/contracts/runtime.rb

@@ -0,0 +1,47 @@
+#--
+# Author::    radiospiel  (mailto:eno@radiospiel.org)
+# Copyright:: Copyright (c) 2011, 2012 radiospiel
+# License::   Distributes under the terms of the Modified BSD License,
+#             see LICENSE.BSD for details.
+#++
+
+class Contracts::Runtime < Contracts::Base
+  attr_reader :expected_runtime, :max
+
+  def initialize(expected_runtime, options)
+    @expected_runtime = expected_runtime
+    @max = options[:max]
+
+    expect! max.nil? || expected_runtime <= max
+  end
+
+  def before_call(_receiver, *_args, &_blk)
+    Time.now
+  end
+
+  def after_call(starts_at, _rv, _receiver, *_args, &_blk)
+    runtime = Time.now - starts_at
+
+    if max && runtime >= max
+      error! "#{method_name} took longer than allowed: %.02f secs > %.02f secs." % [runtime, expected_runtime]
+    end
+
+    if runtime >= expected_runtime
+      Contracts.logger.warn "#{method_name} took longer than expected: %.02f secs > %.02f secs." % [runtime, expected_runtime]
+    end
+  end
+
+  def logger
+    self.class.logger
+  end
+end
+
+module Contracts::ClassMethods
+  include Contracts
+
+  +Expects(expected_runtime: Numeric)
+  +Expects(options: { max: [Numeric, nil] })
+  def Runtime(expected_runtime, options = {})
+    Contracts::Runtime.new expected_runtime, options
+  end
+end

data/lib/core/exception.rb

@@ -1,15 +1,15 @@
 #--
 # Author::    radiospiel  (mailto:eno@radiospiel.org)
 # Copyright:: Copyright (c) 2011, 2012 radiospiel
-# License::   Distributes under the terms of the Modified BSD License, see LICENSE.BSD for details.
+# License::   Distributes under the terms of the Modified BSD License,
+#             see LICENSE.BSD for details.
 #++
 
 class Exception
-  # Create an ArgumentError with an adjusted backtrace. We don't want to 
+  # Create an ArgumentError with an adjusted backtrace. We don't want to
   # see the user all the annotation internals.
   def reraise_with_current_backtrace!
     set_backtrace caller[2..-1]
-    raise self
+    fail self
   end
 end
-

data/lib/expectation.rb

@@ -1,12 +1,15 @@
 #--
 # Author::    radiospiel  (mailto:eno@radiospiel.org)
 # Copyright:: Copyright (c) 2011, 2012 radiospiel
-# License::   Distributes under the terms of the Modified BSD License, see LICENSE.BSD for details.
+# License::   Distributes under the terms of the Modified BSD License,
+#             see LICENSE.BSD for details.
 #++
 
 module Expectation; end
 
 require_relative "core/exception"
+require_relative "expectation/matcher"
+require_relative "expectation/multi_matcher"
 require_relative "expectation/assertions"
 
 # The Expectation module implements methods to verify one or more values
@@ -16,13 +19,13 @@ require_relative "expectation/assertions"
 #
 # == Example
 #
-# This function expects a String argument starting with <tt>"http:"</tt>, 
-# an Integer or Float argument, and a Hash with a String entry at key 
+# This function expects a String argument starting with <tt>"http:"</tt>,
+# an Integer or Float argument, and a Hash with a String entry at key
 # <tt>:foo</tt>, and either an Array or +nil+ at key <tt>:bar</tt>.
-# 
+#
 #   def function(a, b, options = {})
-#     expect! a => /^http:/, 
-#             b => [Integer, Float], 
+#     expect! a => /^http:/,
+#             b => [Integer, Float],
 #             options => {
 #               :foo => String,
 #               :bar => [ Array, nil ]
@@ -30,77 +33,31 @@ require_relative "expectation/assertions"
 #   end
 
 module Expectation
-  class Error < ArgumentError
-    attr :value, :expectation, :info
-
-    def initialize(value, expectation, info = nil)
-      @value, @expectation, @info = 
-        value, expectation, info
-    end
-    
-    def to_s
-      message = "#{value.inspect} does not match #{expectation.inspect}"
-      message += ", #{info}" if info
-      message
-    end
-  end
+  Error = Expectation::Matcher::Mismatch
 
   #
-  # Verifies a number of expectations. If one or more expectations are 
-  # not met it raises an ArgumentError (on the first failing expectation).
-  def expect!(*expectations, &block)
+  # Verifies a number of expectations. If one or more expectations are
+  # not met it raises an Error (on the first failing expectation).
+  #
+  # In contrast to the global expect! function this method does not
+  # adjust an Error's backtrace.
+  def self.expect!(*expectations, &block)
     expectations.each do |expectation|
       if expectation.is_a?(Hash)
         expectation.all? do |actual, exp|
-          match! actual, exp
+          Matcher.match! actual, exp
         end
       else
-        match! expectation, :truish
+        Matcher.match! expectation, :truish
       end
     end
 
-    match! block, :__block if block
-  rescue Error
-    $!.reraise_with_current_backtrace!
-  end  
-
-  #
-  # Does a value match an expectation?
-  def match?(value, expectation)
-    match! value, expectation
-    true
-  rescue Error
-    false
-  end
-
-  # Matches a value against an expectation. Raises an Expectation::Error
-  # if the expectation could not be matched.
-  def match!(value, expectation, key=nil)
-    match = case expectation
-      when :truish  then !!value
-      when :fail    then false
-      when Array    then expectation.any? { |e| _match?(value, e) }
-      when Proc     then expectation.arity == 0 ? expectation.call : expectation.call(value)
-      when Regexp   then value.is_a?(String) && expectation =~ value
-      when :__block then value.call
-      when Hash     then Hash === value && 
-                         expectation.each { |key, exp| match! value[key], exp, key }
-      else               expectation === value
-    end
-
-    return if match
-
-    raise Error.new(value, expectation, key && "at key #{key.inspect}")
-  end
-
-  private
-
-  def _match?(value, expectation)
-    match! value, expectation
-    true
-  rescue Error
-    false
+    Matcher.match! block, :__block if block
   end
 end
 
-Object.send :include, Expectation
+def expect!(*args, &block)
+  Expectation.expect! *args, &block
+rescue Expectation::Error
+  $ERROR_INFO.reraise_with_current_backtrace!
+end

data/lib/expectation/assertions.rb

@@ -1,15 +1,15 @@
 #--
 # Author::    radiospiel  (mailto:eno@radiospiel.org)
 # Copyright:: Copyright (c) 2011, 2012 radiospiel
-# License::   Distributes under the terms of the Modified BSD License, see LICENSE.BSD for details.
+# License::   Distributes under the terms of the Modified BSD License,
+#             see LICENSE.BSD for details.
 #++
 
-
 # The Expectation::Assertions module provides expect! and inexpect!
 # assertions to use from within test cases.
 #
 # == Example
-# 
+#
 #   class ExpectationTest < Test::Unit::TestCase
 #     include Expectation::Assertions
 #
@@ -25,12 +25,12 @@ module Expectation::Assertions
     begin
       Expectation.expect!(*expectation, &block)
     rescue Expectation::Error
-      exc = $!
+      exc = $ERROR_INFO
     end
 
     assert_block(exc && exc.message) { !exc }
   end
-  
+
   # verifies the failure of the passed in expectations
   def inexpect!(*expectation, &block)
     exc = nil
@@ -38,7 +38,7 @@ module Expectation::Assertions
     begin
       Expectation.expect!(*expectation, &block)
     rescue Expectation::Error
-      exc = $!
+      exc = $ERROR_INFO
     end
 
     assert_block("Expectation(s) should fail, but didn't") { exc }

data/lib/expectation/matcher.rb

@@ -0,0 +1,82 @@
+#--
+# Author::    radiospiel  (mailto:eno@radiospiel.org)
+# Copyright:: Copyright (c) 2011, 2012 radiospiel
+# License::   Distributes under the terms of the Modified BSD License,
+#             see LICENSE.BSD for details.
+#++
+
+# The Expectation::Matcher module implements the logic to match a value
+# against a pattern.
+
+module Expectation::Matcher
+  class Mismatch < ArgumentError
+    attr_reader :value, :expectation, :info
+
+    def initialize(value, expectation, info = nil)
+      @value = value
+      @expectation = expectation
+      @info = info
+    end
+
+    def to_s
+      message = "#{value.inspect} does not match #{expectation.inspect}"
+      case info
+      when nil    then  message
+      when Fixnum then  "#{message}, at index #{info}"
+      else              "#{message}, at key #{info.inspect}"
+      end
+    end
+  end
+
+  extend self
+
+  #
+  # Does a value match an expectation?
+  def match?(value, expectation)
+    match! value, expectation
+    true
+  rescue Mismatch
+    false
+  end
+
+  #
+  # Matches a value against an expectation. Raises an Expectation::Mismatch
+  # if the expectation could not be matched.
+  #
+  # The info parameter is used to add some position information to
+  # any Mismatch raised.
+  def match!(value, expectation, info = nil)
+    match = case expectation
+            when :truish  then !!value
+            when :fail    then false
+            when Array    then
+              if expectation.length == 1
+                # Array as "array of elements matching an expectation"; for example
+                # [1,2,3] => [Fixnum]
+                e = expectation.first
+                value.each_with_index { |v, idx| match!(v, e, idx) }
+              else
+                # Array as "object matching one of given expectations
+                expectation.any? { |e| _match?(value, e) }
+              end
+            when Proc     then expectation.arity == 0 ? expectation.call : expectation.call(value)
+            when Regexp   then value.is_a?(String) && expectation =~ value
+            when :__block then value.call
+            when Hash     then Hash === value &&
+                               expectation.each { |key, exp| match! value[key], exp, key }
+            else               expectation === value
+    end
+
+    return if match
+    fail Mismatch.new(value, expectation, info)
+  end
+
+  private
+
+  def _match?(value, expectation)
+    match! value, expectation
+    true
+  rescue Mismatch
+    false
+  end
+end

data/lib/expectation/multi_matcher.rb

@@ -0,0 +1,25 @@
+#--
+# Author::    radiospiel  (mailto:eno@radiospiel.org)
+# Copyright:: Copyright (c) 2011, 2012 radiospiel
+# License::   Distributes under the terms of the Modified BSD License,
+#             see LICENSE.BSD for details.
+#++
+
+# The Expectation::MultiMatcher class provides support for T1 | T2 matches.
+
+class Expectation::MultiMatcher < Array
+  def initialize(lhs, rhs)
+    push lhs
+    push rhs
+  end
+
+  def |(other)
+    push other
+  end
+end
+
+class Module
+  def |(other)
+    Expectation::MultiMatcher.new(self, other)
+  end
+end

data/lib/expectation/version.rb

@@ -1,8 +1,9 @@
 #--
 # Author::    radiospiel  (mailto:eno@radiospiel.org)
 # Copyright:: Copyright (c) 2011, 2012 radiospiel
-# License::   Distributes under the terms of the Modified BSD License, see LICENSE.BSD for details.
+# License::   Distributes under the terms of the Modified BSD License,
+#             see LICENSE.BSD for details.
 module Expectation
   # The expectation gem's version.
-  VERSION="1.0.0"
+  VERSION = '1.1.0'
 end

data/test/contracts_test.rb

@@ -4,30 +4,14 @@
 require_relative 'test_helper'
 
 require "contracts"
+Contracts.logger.level = Logger::ERROR
 
 class ContractsTest < Test::Unit::TestCase
-  class Foo
-    include Contracts
-
-    +Expects(a: 1)
-    def sum(a, b, c)
-      a + b + c
-    end
-
-    +Returns(2)
-    def returns_arg(r)
-      r
-    end
-
-    +Expects(v: Fixnum)
-    def throw_on_one(v)
-      raise if v == 1
-    end
+  class Base
+  end
 
-    +Nothrow()
-    def unexpected_throw_on_one(v)
-      raise if v == 1
-    end
+  class Foo < Base
+    include Contracts
   end
 
   attr :foo
@@ -36,6 +20,15 @@ class ContractsTest < Test::Unit::TestCase
     @foo = Foo.new
   end
 
+  # -- Expects contracts ------------------------------------------------------
+
+  class Foo
+    +Expects(a: 1)
+    def sum(a, b, c)
+      a + b + c
+    end
+  end
+
   def test_contracts_check_number_of_arguments
     e = assert_raise(ArgumentError) {
       foo.sum(1)        # scripts/test:67:in `f': wrong number of arguments (1 for 3) (ArgumentError)
@@ -54,6 +47,30 @@ class ContractsTest < Test::Unit::TestCase
     assert e.backtrace.first.include?("test/contracts_test.rb:")
   end
 
+  class Foo
+    attr :a, :b
+    +Expects(b: String)
+    def with_default_arg(a, b="check")
+      @a, @b = a, b
+    end
+  end
+
+  def test_default_args
+    foo.with_default_arg :one
+
+    assert_equal(foo.a, :one)
+    assert_equal(foo.b, "check")
+  end
+
+  # -- Returns contracts ------------------------------------------------------
+
+  class Foo
+    +Returns(2)
+    def returns_arg(r)
+      r
+    end
+  end
+
   def test_returns_contract
     assert_nothing_raised() {
       foo.returns_arg(2)
@@ -65,6 +82,37 @@ class ContractsTest < Test::Unit::TestCase
     assert e.backtrace.first.include?("test/contracts_test.rb:")
   end
 
+  # -- test for call to super -------------------------------------------------
+
+  class Base
+    attr :checked
+
+    def check
+      @checked = true
+    end
+  end
+
+  class Foo
+    +Returns(true)
+    def check
+      super
+    end
+  end
+
+  def test_calls_super
+    foo.check
+    assert foo.checked
+  end
+
+  # -- Nothrow contracts ------------------------------------------------------
+
+  class Foo
+    +Nothrow()
+    def unexpected_throw_on_one(v)
+      raise if v == 1
+    end
+  end
+
   def test_nothrow_contract
     assert_nothing_raised() {
       foo.unexpected_throw_on_one(2)
@@ -76,6 +124,13 @@ class ContractsTest < Test::Unit::TestCase
     assert e.backtrace.first.include?("test/contracts_test.rb:")
   end
 
+  class Foo
+    +Expects(v: Fixnum)
+    def throw_on_one(v)
+      raise if v == 1
+    end
+  end
+
   def test_still_throws_fine
     assert_nothing_raised() {
       foo.throw_on_one(2)
@@ -85,4 +140,25 @@ class ContractsTest < Test::Unit::TestCase
       foo.throw_on_one(1)
     }
   end
+
+  # -- Runtime contracts ------------------------------------------------------
+
+  require "timecop"
+  class Foo
+    +Runtime(0.01, max: 0.05)
+    def wait_for(time)
+      Timecop.travel(Time.now + time)
+    end
+  end
+
+  def test_runtime
+    foo.wait_for 0.001
+    foo.wait_for 0.02
+
+    e = assert_raise(Contracts::Error) {
+      foo.wait_for 10
+    }
+
+    Timecop.return
+  end
 end

data/test/expection_test.rb

@@ -9,7 +9,7 @@ class ExpectationTest < Test::Unit::TestCase
   end
 
   #
-  # This test covers the usual use case: expectations are 
+  # This test covers the usual use case: expectations are
   # passed in a single Hash.
   def test_hash_expectation
     assert_expectation! "1" => /1/
@@ -36,6 +36,28 @@ class ExpectationTest < Test::Unit::TestCase
     assert_failed_expectation! do nil end
   end
 
+  def test_array_expectations
+    assert_expectation! 1 => [Fixnum, String]
+    assert_expectation! 1 => [String, Fixnum]
+    assert_failed_expectation! 1 => [NilClass, String]
+  end
+
+  def test_multi_expectations
+    assert_expectation! 1 => Fixnum | String
+    assert_expectation! 1 => String | 1
+    assert_failed_expectation! 1 => NilClass | String
+    assert_expectation! 1 => NilClass | String | 1
+  end
+
+  module I; end
+  class X; include I; end
+  class Y; end
+
+  def test_interface_expectations
+    assert_expectation! X.new => I
+    assert_failed_expectation! Y.new => I
+  end
+
   def test_exception_message
     e = assert_failed_expectation!({ 1 => 2 })
     assert e.message.include?("1 does not match 2")

data/test/matching_test.rb

@@ -5,21 +5,23 @@ require_relative 'test_helper'
 
 class MatchingTest < Test::Unit::TestCase
   def assert_match(value, expectation)
-    assert_equal true, Expectation.match?(value, expectation)
+    assert_equal true, Expectation::Matcher.match?(value, expectation)
   end
 
   def assert_mismatch(value, expectation)
-    assert_equal false, Expectation.match?(value, expectation)
+    assert_equal false, Expectation::Matcher.match?(value, expectation)
   end
 
   def test_mismatches_raise_exceptions
-    assert_nothing_raised do
-      Expectation.match! 1, 1
-    end
+    assert_match 1, 1
+    assert_mismatch 1, 2
+  end
 
-    assert_raise(Expectation::Error) {
-      Expectation.match! 1, 2
-    }
+  def test_array_matches
+    assert_match    [1],              [Integer]
+    assert_mismatch [1],              [String]
+    assert_match    [1, "2"],         [[Integer, String]]
+    assert_mismatch [1, "2", /abc/],  [[Integer, String]]
   end
 
   def test_int_expectations

data/test/test_helper.rb

@@ -1,18 +1,23 @@
 require 'rubygems'
 require 'bundler/setup'
 
-require 'simplecov'
-require 'simplecov-console'
+if ENV["COVERAGE"]
+  require 'simplecov'
+  require 'simplecov-console'
+end
+
 require 'test/unit'
 
-SimpleCov.start do
-  add_filter "test/*.rb"
-end
+if ENV["COVERAGE"]
+  SimpleCov.start do
+    add_filter "test/*.rb"
+  end
 
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-  SimpleCov::Formatter::HTMLFormatter,
-  SimpleCov::Formatter::Console,
-]
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    SimpleCov::Formatter::Console,
+  ]
+end
 
 require "expectation"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: expectation
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - radiospiel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-09 00:00:00.000000000 Z
+date: 2015-11-20 00:00:00.000000000 Z
 dependencies: []
 description: Defensive programming with expectations
 email: eno@radiospiel.org
@@ -18,9 +18,15 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/contracts.rb
+- lib/contracts/expects.rb
+- lib/contracts/nothrows.rb
+- lib/contracts/returns.rb
+- lib/contracts/runtime.rb
 - lib/core/exception.rb
 - lib/expectation.rb
 - lib/expectation/assertions.rb
+- lib/expectation/matcher.rb
+- lib/expectation/multi_matcher.rb
 - lib/expectation/version.rb
 - test/assertions_test.rb
 - test/contracts_module_test.rb