newbamboo-rspec 1.1.12

data/lib/spec/matchers/throw_symbol.rb

@@ -0,0 +1,106 @@
+module Spec
+  module Matchers
+    
+    class ThrowSymbol #:nodoc:
+      def initialize(expected_symbol = nil, expected_arg=nil)
+        @expected_symbol = expected_symbol
+        @expected_arg = expected_arg
+        @caught_symbol = nil
+      end
+      
+      def matches?(given_proc)
+        begin
+          if @expected_symbol.nil?
+            given_proc.call
+          else
+            @caught_arg = catch :proc_did_not_throw_anything do
+              catch @expected_symbol do
+                given_proc.call
+                throw :proc_did_not_throw_anything, :nothing_thrown
+              end
+            end
+            @caught_symbol = @expected_symbol unless @caught_arg == :nothing_thrown
+          end
+
+        # Ruby 1.8 uses NameError with `symbol'
+        # Ruby 1.9 uses ArgumentError with :symbol
+        rescue NameError, ArgumentError => e
+          raise e unless e.message =~ /uncaught throw (`|\:)([a-zA-Z0-9_]*)(')?/
+          @caught_symbol = $2.to_sym
+
+        ensure
+          if @expected_symbol.nil?
+            return !@caught_symbol.nil?
+          else
+            if @expected_arg.nil?
+              return @caught_symbol == @expected_symbol
+            else
+              # puts [@caught_symbol, @expected_symbol].inspect
+              # puts [@caught_arg, @expected_arg].inspect
+              return @caught_symbol == @expected_symbol && @caught_arg == @expected_arg
+            end
+          end
+        end
+      end
+
+      def failure_message
+        if @caught_symbol
+          "expected #{expected}, got #{@caught_symbol.inspect}"
+        else
+          "expected #{expected} but nothing was thrown"
+        end
+      end
+      
+      def negative_failure_message
+        if @expected_symbol
+          "expected #{expected} not to be thrown"
+        else
+          "expected no Symbol, got :#{@caught_symbol}"
+        end
+      end
+      
+      def description
+        "throw #{expected}"
+      end
+      
+      private
+      
+        def expected
+          @expected_symbol.nil? ? "a Symbol" : "#{@expected_symbol.inspect}#{args}"
+        end
+        
+        def args
+          @expected_arg.nil? ? "" : " with #{@expected_arg.inspect}"
+        end
+      
+    end
+ 
+    # :call-seq:
+    #   should throw_symbol()
+    #   should throw_symbol(:sym)
+    #   should throw_symbol(:sym, arg)
+    #   should_not throw_symbol()
+    #   should_not throw_symbol(:sym)
+    #   should_not throw_symbol(:sym, arg)
+    #
+    # Given no argument, matches if a proc throws any Symbol.
+    #
+    # Given a Symbol, matches if the given proc throws the specified Symbol.
+    #
+    # Given a Symbol and an arg, matches if the given proc throws the
+    # specified Symbol with the specified arg.
+    #
+    # == Examples
+    #
+    #   lambda { do_something_risky }.should throw_symbol
+    #   lambda { do_something_risky }.should throw_symbol(:that_was_risky)
+    #   lambda { do_something_risky }.should throw_symbol(:that_was_risky, culprit)
+    #
+    #   lambda { do_something_risky }.should_not throw_symbol
+    #   lambda { do_something_risky }.should_not throw_symbol(:that_was_risky)
+    #   lambda { do_something_risky }.should_not throw_symbol(:that_was_risky, culprit)
+    def throw_symbol(sym=nil)
+      Matchers::ThrowSymbol.new(sym)
+    end
+  end
+end

data/lib/spec/matchers/wrap_expectation.rb

@@ -0,0 +1,55 @@
+module Spec
+  module Matchers
+    # wraps an expectation in a block that will return true if the
+    # expectation passes and false if it fails (without bubbling up
+    # the failure).
+    #     
+    # This is intended to be used in the context of a simple matcher,
+    # and is especially useful for wrapping multiple expectations or
+    # one or more assertions from test/unit extensions when running
+    # with test/unit.
+    #
+    # == Examples
+    #
+    #   def eat_cheese(cheese)
+    #     simple_matcher do |mouse, matcher|
+    #       matcher.failure_message = "expected #{mouse} to eat cheese"
+    #       wrap_expectation do |matcher|
+    #         assert_eats_cheese(mouse)
+    #       end
+    #     end
+    #   end
+    #
+    #   describe Mouse do
+    #     it "eats cheese" do
+    #       Mouse.new.should eat_cheese
+    #     end
+    #   end
+    #
+    # You might be wondering "why would I do this if I could just say"
+    # assert_eats_cheese?", a fair question, indeed. You might prefer
+    # to replace the word assert with something more aligned with the
+    # rest of your code examples. You are using rspec, after all.
+    #
+    # The other benefit you get is that you can use the negative version
+    # of the matcher:
+    #
+    #   describe Cat do
+    #     it "does not eat cheese" do
+    #       Cat.new.should_not eat_cheese
+    #     end
+    #   end
+    #
+    # So in the event there is no assert_does_not_eat_cheese available,
+    # you're all set!
+    def wrap_expectation(matcher, &block)
+      begin
+        block.call(matcher)
+        return true
+      rescue Exception => e
+        matcher.failure_message = e.message
+        return false
+      end
+    end
+  end
+end

data/lib/spec/matchers.rb

@@ -0,0 +1,141 @@
+require 'spec/matchers/operator_matcher'
+require 'spec/matchers/generated_descriptions'
+require 'spec/matchers/errors'
+require 'spec/matchers/method_missing'
+require 'spec/matchers/simple_matcher'
+require 'spec/matchers/be'
+require 'spec/matchers/be_close'
+require 'spec/matchers/change'
+require 'spec/matchers/match_array'
+require 'spec/matchers/eql'
+require 'spec/matchers/equal'
+require 'spec/matchers/exist'
+require 'spec/matchers/has'
+require 'spec/matchers/have'
+require 'spec/matchers/include'
+require 'spec/matchers/match'
+require 'spec/matchers/raise_error'
+require 'spec/matchers/respond_to'
+require 'spec/matchers/satisfy'
+require 'spec/matchers/throw_symbol'
+require 'spec/matchers/wrap_expectation'
+
+module Spec
+
+  # RSpec ships with a number of useful Expression Matchers. An Expression Matcher
+  # is any object that responds to the following methods:
+  #
+  #   matches?(actual)
+  #   failure_message
+  #   negative_failure_message #optional
+  #   description #optional
+  #
+  # See Spec::Expectations to learn how to use these as Expectation Matchers.
+  # See Spec::Mocks to learn how to use them as Mock Argument Matchers.
+  #
+  # == Predicates
+  #
+  # In addition to those Expression Matchers that are defined explicitly, RSpec will
+  # create custom Matchers on the fly for any arbitrary predicate, giving your specs
+  # a much more natural language feel. 
+  #
+  # A Ruby predicate is a method that ends with a "?" and returns true or false.
+  # Common examples are +empty?+, +nil?+, and +instance_of?+.
+  #
+  # All you need to do is write +should be_+ followed by the predicate without
+  # the question mark, and RSpec will figure it out from there. For example:
+  #
+  #   [].should be_empty => [].empty? #passes
+  #   [].should_not be_empty => [].empty? #fails
+  #
+  # In addtion to prefixing the predicate matchers with "be_", you can also use "be_a_"
+  # and "be_an_", making your specs read much more naturally:
+  #
+  #   "a string".should be_an_instance_of(String) =>"a string".instance_of?(String) #passes
+  #
+  #   3.should be_a_kind_of(Fixnum) => 3.kind_of?(Numeric) #passes
+  #   3.should be_a_kind_of(Numeric) => 3.kind_of?(Numeric) #passes
+  #   3.should be_an_instance_of(Fixnum) => 3.instance_of?(Fixnum) #passes
+  #   3.should_not be_instance_of(Numeric) => 3.instance_of?(Numeric) #fails
+  #
+  # RSpec will also create custom matchers for predicates like +has_key?+. To
+  # use this feature, just state that the object should have_key(:key) and RSpec will
+  # call has_key?(:key) on the target. For example:
+  #
+  #   {:a => "A"}.should have_key(:a) => {:a => "A"}.has_key?(:a) #passes
+  #   {:a => "A"}.should have_key(:b) => {:a => "A"}.has_key?(:b) #fails
+  #
+  # You can use this feature to invoke any predicate that begins with "has_", whether it is
+  # part of the Ruby libraries (like +Hash#has_key?+) or a method you wrote on your own class.
+  #
+  # == Custom Expectation Matchers
+  #
+  # When you find that none of the stock Expectation Matchers provide a natural
+  # feeling expectation, you can very easily write your own.
+  #
+  # For example, imagine that you are writing a game in which players can
+  # be in various zones on a virtual board. To specify that bob should
+  # be in zone 4, you could say:
+  #
+  #   bob.current_zone.should eql(Zone.new("4"))
+  #
+  # But you might find it more expressive to say:
+  #
+  #   bob.should be_in_zone("4")
+  #
+  # and/or
+  #
+  #   bob.should_not be_in_zone("3")
+  #
+  # To do this, you would need to write a class like this:
+  #
+  #   class BeInZone
+  #     def initialize(expected)
+  #       @expected = expected
+  #     end
+  #     def matches?(target)
+  #       @target = target
+  #       @target.current_zone.eql?(Zone.new(@expected))
+  #     end
+  #     def failure_message
+  #       "expected #{@target.inspect} to be in Zone #{@expected}"
+  #     end
+  #     def negative_failure_message
+  #       "expected #{@target.inspect} not to be in Zone #{@expected}"
+  #     end
+  #   end
+  #
+  # ... and a method like this:
+  #
+  #   def be_in_zone(expected)
+  #     BeInZone.new(expected)
+  #   end
+  #
+  # And then expose the method to your specs. This is normally done
+  # by including the method and the class in a module, which is then
+  # included in your spec:
+  #
+  #   module CustomGameMatchers
+  #     class BeInZone
+  #       ...
+  #     end
+  #
+  #     def be_in_zone(expected)
+  #       ...
+  #     end
+  #   end
+  #
+  #   describe "Player behaviour" do
+  #     include CustomGameMatchers
+  #     ...
+  #   end
+  #
+  # or you can include in globally in a spec_helper.rb file <tt>require</tt>d
+  # from your spec file(s):
+  #
+  #   Spec::Runner.configure do |config|
+  #     config.include(CustomGameMatchers)
+  #   end
+  #
+  module Matchers; end
+end

data/lib/spec/mocks/argument_expectation.rb

@@ -0,0 +1,49 @@
+module Spec
+  module Mocks
+    
+    class ArgumentExpectation
+      attr_reader :args
+      
+      def initialize(args, &block)
+        @args = args
+        @matchers_block = block
+        
+        if ArgumentMatchers::AnyArgsMatcher === args.first
+          @match_any_args = true
+        elsif ArgumentMatchers::NoArgsMatcher === args.first
+          @matchers = []
+        else
+          @matchers = args.collect {|arg| matcher_for(arg)}
+        end
+      end
+      
+      def matcher_for(arg)
+        return ArgumentMatchers::MatcherMatcher.new(arg)   if is_matcher?(arg)
+        return ArgumentMatchers::RegexpMatcher.new(arg) if arg.is_a?(Regexp)
+        return ArgumentMatchers::EqualityProxy.new(arg)
+      end
+      
+      def is_matcher?(obj)
+        return obj.respond_to?(:matches?) && obj.respond_to?(:description)
+      end
+      
+      def args_match?(given_args)
+        match_any_args? || matchers_block_matches?(given_args) || matchers_match?(given_args)
+      end
+      
+      def matchers_block_matches?(given_args)
+        @matchers_block ? @matchers_block.call(*given_args) : nil
+      end
+      
+      def matchers_match?(given_args)
+        @matchers == given_args
+      end
+      
+      def match_any_args?
+        @match_any_args
+      end
+      
+    end
+    
+  end
+end

data/lib/spec/mocks/argument_matchers.rb

@@ -0,0 +1,237 @@
+module Spec
+  module Mocks
+
+    # ArgumentMatchers are messages that you can include in message
+    # expectations to match arguments against a broader check than simple
+    # equality.
+    #
+    # With the exception of any_args() and no_args(), the matchers
+    # are all positional - they match against the arg in the given position.
+    module ArgumentMatchers
+
+      class AnyArgsMatcher
+        def description
+          "any args"
+        end
+      end
+
+      class AnyArgMatcher
+        def initialize(ignore)
+        end
+
+        def ==(other)
+          true
+        end
+      end
+
+      class NoArgsMatcher
+        def description
+          "no args"
+        end
+
+        def ==(args)
+          args == []
+        end
+      end
+
+      class RegexpMatcher
+        def initialize(regexp)
+          @regexp = regexp
+        end
+
+        def ==(value)
+          return value =~ @regexp unless value.is_a?(Regexp)
+          value == @regexp
+        end
+      end
+
+      class BooleanMatcher
+        def initialize(ignore)
+        end
+
+        def ==(value)
+          TrueClass === value || FalseClass === value
+        end
+      end
+
+      class HashIncludingMatcher
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def ==(actual)
+          @expected.each do | key, value |
+            return false unless actual.has_key?(key) && value == actual[key]
+          end
+          true
+        rescue NoMethodError => ex
+          return false
+        end
+
+        def description
+          "hash_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})"
+        end
+      end
+      
+      class HashNotIncludingMatcher
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def ==(actual)
+          @expected.each do | key, value |
+            return false if actual.has_key?(key) && value == actual[key]
+          end
+          true
+        rescue NoMethodError => ex
+          return false
+        end
+
+        def description
+          "hash_not_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})"
+        end
+      end
+      
+      class DuckTypeMatcher
+        def initialize(*methods_to_respond_to)
+          @methods_to_respond_to = methods_to_respond_to
+        end
+
+        def ==(value)
+          @methods_to_respond_to.all? { |sym| value.respond_to?(sym) }
+        end
+      end
+
+      class MatcherMatcher
+        def initialize(matcher)
+          @matcher = matcher
+        end
+
+        def ==(value)
+          @matcher.matches?(value)
+        end
+      end
+
+      class EqualityProxy
+        def initialize(given)
+          @given = given
+        end
+
+        def ==(expected)
+          @given == expected
+        end
+      end
+      
+      class InstanceOf
+        def initialize(klass)
+          @klass = klass
+        end
+        
+        def ==(actual)
+          actual.instance_of?(@klass)
+        end
+      end
+      
+      class KindOf
+        def initialize(klass)
+          @klass = klass
+        end
+        
+        def ==(actual)
+          actual.kind_of?(@klass)
+        end
+      end
+
+      # :call-seq:
+      #   object.should_receive(:message).with(any_args())
+      #
+      # Passes if object receives :message with any args at all. This is
+      # really a more explicit variation of object.should_receive(:message)
+      def any_args
+        AnyArgsMatcher.new
+      end
+      
+      # :call-seq:
+      #   object.should_receive(:message).with(anything())
+      #
+      # Passes as long as there is an argument.
+      def anything
+        AnyArgMatcher.new(nil)
+      end
+      
+      # :call-seq:
+      #   object.should_receive(:message).with(no_args)
+      #
+      # Passes if no arguments are passed along with the message
+      def no_args
+        NoArgsMatcher.new
+      end
+      
+      # :call-seq:
+      #   object.should_receive(:message).with(duck_type(:hello))
+      #   object.should_receive(:message).with(duck_type(:hello, :goodbye))
+      #
+      # Passes if the argument responds to the specified messages.
+      #
+      # == Examples
+      #
+      #   array = []
+      #   display = mock('display')
+      #   display.should_receive(:present_names).with(duck_type(:length, :each))
+      #   => passes
+      def duck_type(*args)
+        DuckTypeMatcher.new(*args)
+      end
+
+      # :call-seq:
+      #   object.should_receive(:message).with(boolean())
+      #
+      # Passes if the argument is boolean.
+      def boolean
+        BooleanMatcher.new(nil)
+      end
+      
+      # :call-seq:
+      #   object.should_receive(:message).with(hash_including(:key => val))
+      #   object.should_receive(:message).with(hash_including(:key))
+      #   object.should_receive(:message).with(hash_including(:key, :key2 => val2))
+      # Passes if the argument is a hash that includes the specified key(s) or key/value
+      # pairs. If the hash includes other keys, it will still pass.
+      def hash_including(*args)
+        HashIncludingMatcher.new(anythingize_lonely_keys(*args))
+      end
+      
+      # :call-seq:
+      #   object.should_receive(:message).with(hash_not_including(:key => val))
+      #   object.should_receive(:message).with(hash_not_including(:key))
+      #   object.should_receive(:message).with(hash_not_including(:key, :key2 => :val2))
+      #
+      # Passes if the argument is a hash that doesn't include the specified key(s) or key/value
+      def hash_not_including(*args)
+        HashNotIncludingMatcher.new(anythingize_lonely_keys(*args))
+      end
+      
+      # Passes if arg.instance_of?(klass)
+      def instance_of(klass)
+        InstanceOf.new(klass)
+      end
+      
+      alias_method :an_instance_of, :instance_of
+      
+      # Passes if arg.kind_of?(klass)
+      def kind_of(klass)
+        KindOf.new(klass)
+      end
+      
+      alias_method :a_kind_of, :kind_of
+      
+      private
+      
+      def anythingize_lonely_keys(*args)
+        hash = args.last.class == Hash ? args.delete_at(-1) : {}
+        args.each { | arg | hash[arg] = anything }
+        hash
+      end
+    end
+  end
+end

data/lib/spec/mocks/error_generator.rb

@@ -0,0 +1,82 @@
+module Spec
+  module Mocks
+    class ErrorGenerator
+      attr_writer :opts
+      
+      def initialize(target, name)
+        @target = target
+        @name = name
+      end
+      
+      def opts
+        @opts ||= {}
+      end
+
+      def raise_unexpected_message_error(sym, *args)
+        __raise "#{intro} received unexpected message :#{sym}#{arg_message(*args)}"
+      end
+      
+      def raise_unexpected_message_args_error(expectation, *args)
+        expected_args = format_args(*expectation.expected_args)
+        actual_args = args.empty? ? "(no args)" : format_args(*args)
+        __raise "#{intro} expected #{expectation.sym.inspect} with #{expected_args} but received it with #{actual_args}"
+      end
+      
+      def raise_expectation_error(sym, expected_received_count, actual_received_count, *args)
+        __raise "#{intro} expected :#{sym}#{arg_message(*args)} #{count_message(expected_received_count)}, but received it #{count_message(actual_received_count)}"
+      end
+      
+      def raise_out_of_order_error(sym)
+        __raise "#{intro} received :#{sym} out of order"
+      end
+      
+      def raise_block_failed_error(sym, detail)
+        __raise "#{intro} received :#{sym} but passed block failed with: #{detail}"
+      end
+      
+      def raise_missing_block_error(args_to_yield)
+        __raise "#{intro} asked to yield |#{arg_list(*args_to_yield)}| but no block was passed"
+      end
+      
+      def raise_wrong_arity_error(args_to_yield, arity)
+        __raise "#{intro} yielded |#{arg_list(*args_to_yield)}| to block with arity of #{arity}"
+      end
+      
+      private
+      def intro
+        @name ? "Mock '#{@name}'" : @target.class == Class ? "<#{@target.inspect} (class)>" : (@target.nil? ? "nil" : @target.to_s)
+      end
+      
+      def __raise(message)
+        message = opts[:message] unless opts[:message].nil?
+        Kernel::raise(Spec::Mocks::MockExpectationError, message)
+      end
+      
+      def arg_message(*args)
+        " with " + format_args(*args)
+      end
+      
+      def format_args(*args)
+        args.empty? ? "(no args)" : "(" + arg_list(*args) + ")"
+      end
+
+      def arg_list(*args)
+        args.collect do |arg|
+          arg.respond_to?(:description) ? arg.description : arg.inspect
+        end.join(", ")
+      end
+      
+      def count_message(count)
+        return "at least #{pretty_print(count.abs)}" if count < 0
+        return pretty_print(count)
+      end
+
+      def pretty_print(count)
+        return "once" if count == 1
+        return "twice" if count == 2
+        return "#{count} times"
+      end
+
+    end
+  end
+end

data/lib/spec/mocks/errors.rb

@@ -0,0 +1,10 @@
+module Spec
+  module Mocks
+    class MockExpectationError < StandardError
+    end
+    
+    class AmbiguousReturnError < StandardError
+    end
+  end
+end
+

data/lib/spec/mocks/extensions/object.rb

@@ -0,0 +1,3 @@
+class Object
+  include Spec::Mocks::Methods
+end

data/lib/spec/mocks/extensions.rb

@@ -0,0 +1 @@
+require 'spec/mocks/extensions/object'

data/lib/spec/mocks/framework.rb

@@ -0,0 +1,15 @@
+# Require everything except the global extensions of class and object. This
+# supports wrapping rspec's mocking functionality without invading every
+# object in the system.
+
+require 'spec/mocks/methods'
+require 'spec/mocks/argument_matchers'
+require 'spec/mocks/spec_methods'
+require 'spec/mocks/proxy'
+require 'spec/mocks/mock'
+require 'spec/mocks/argument_expectation'
+require 'spec/mocks/message_expectation'
+require 'spec/mocks/order_group'
+require 'spec/mocks/errors'
+require 'spec/mocks/error_generator'
+require 'spec/mocks/space'