rspec 0.4.0 → 0.5.0

data/lib/spec.rb

@@ -1,18 +1,5 @@
-require 'spec/context'
-require 'spec/should_base'
-require 'spec/have_helper'
-require 'spec/should_helper'
-require 'spec/kind_helper'
-require 'spec/instance_helper'
-require 'spec/respond_helper'
-require 'spec/should_negator'
-require 'spec/kind_negator'
-require 'spec/instance_negator'
-require 'spec/respond_negator'
-require 'spec/expectations'
-require 'spec/exceptions'
-require 'spec/text_runner'
-require 'spec/gui_runner'
-require 'spec/mock'
-require 'spec/collector'
-require 'spec/dsl'
+$LOAD_PATH.push File.dirname(__FILE__) + '/../lib'
+
+require 'spec/api'
+require 'spec/runner'
+require 'spec/runner/kernel_ext'

data/lib/spec/api.rb

@@ -0,0 +1,4 @@
+require 'spec/api/exceptions'
+require 'spec/api/mock'
+require 'spec/api/expectations'
+require 'spec/api/helper'

data/lib/spec/{exceptions.rb → api/exceptions.rb}

@@ -1,5 +1,5 @@
 module Spec
-  module Exceptions
+  module Api
     class ExpectationNotMetError < StandardError
     end
     

data/lib/spec/{expectations.rb → api/expectations.rb}

@@ -1,16 +1,17 @@
 module Spec
-
   module ObjectExpectations
-
 		def should
 			ShouldHelper.new self
 		end
 	end
-
 end
 
-
 class Object
   include Spec::ObjectExpectations
 end
 
+class Numeric
+  def close?(other, precision)
+    (self - other).abs < precision
+  end
+end

data/lib/spec/api/helper.rb

@@ -0,0 +1,10 @@
+require 'spec/api/helper/should_base'
+require 'spec/api/helper/have_helper'
+require 'spec/api/helper/instance_helper'
+require 'spec/api/helper/instance_negator'
+require 'spec/api/helper/kind_helper'
+require 'spec/api/helper/kind_negator'
+require 'spec/api/helper/respond_helper'
+require 'spec/api/helper/respond_negator'
+require 'spec/api/helper/should_helper'
+require 'spec/api/helper/should_negator'

data/lib/spec/{have_helper.rb → api/helper/have_helper.rb}

@@ -4,7 +4,7 @@ module Spec
 
     def initialize(target, expected=nil)
       @target = target
-      @expected = expected
+      @expected = expected == :no ? 0 : expected
       @min = false
       @max = false
     end

data/lib/spec/{should_base.rb → api/helper/should_base.rb}

@@ -21,14 +21,16 @@ module Spec
 		  elsif obj.kind_of? Proc
 		    "<Proc>"
 	    elsif (obj.kind_of? Array) || (obj.kind_of? String)
-	      "<#{obj.inspect}>"
-	    else
-        "<#{obj.inspect}:#{obj.class}>"
+	      "#{obj.inspect}"
+	    elsif obj.inspect.include? "<"
+        "#{obj.class} #{obj.inspect}"
+      else
+        "#{obj.class} <#{obj.inspect}>"
       end
  	  end
 
 		def fail_with_message(message)
-			Kernel::raise(Spec::Exceptions::ExpectationNotMetError.new(message))
+			Kernel::raise(Spec::Api::ExpectationNotMetError.new(message))
 		end
 
   end

data/lib/spec/{should_helper.rb → api/helper/should_helper.rb}

@@ -25,6 +25,7 @@ module Spec
     def be(expected = :no_arg)
       return self if (expected == :no_arg)
       return if (expected == false and @target.nil?)
+			return if (expected == true and (!@target.nil?) and (@target != false))
     	fail_with_message(default_message("should be", expected)) unless (@target.equal?(expected))
     end
 
@@ -68,6 +69,17 @@ module Spec
         fail_with_message(default_message("should raise", exception.inspect))
       end
     end
+    
+    def throw(symbol)
+      begin
+        catch symbol do
+          @target.call
+          fail_with_message(default_message("should throw", symbol.inspect))
+        end
+      rescue NameError
+        fail_with_message(default_message("should throw", symbol.inspect))
+      end
+    end
 
   end
 

data/lib/spec/{should_negator.rb → api/helper/should_negator.rb}

@@ -54,6 +54,17 @@ module Spec
       end
     end
     
+    def throw(symbol=:___this_is_a_symbol_that_will_never_occur___)
+      begin
+        catch symbol do
+          @target.call
+          return true
+        end
+        fail_with_message(default_message("should not throw", symbol.inspect))
+      rescue NameError
+      end
+    end
+    
     def method_missing(sym, *args)
       return unless @target.send("#{sym}?", *args)
       fail_with_message(default_message("should not be #{sym}" + (args.empty? ? '' : (' ' + args.join(', ')))))

data/lib/spec/api/mock.rb

@@ -0,0 +1,184 @@
+module Spec
+  module Api
+    class Mock
+
+      DEFAULT_OPTIONS = {
+        :null_object => false
+      }
+      # Creates a new mock with a +name+ (that will be used in error messages only)
+      # Options:
+      # * <tt>:null_object</tt> - if true, the mock object acts as a forgiving null object allowing any message to be sent to it.
+      def initialize(name, options={})
+        @name = name
+        @options = DEFAULT_OPTIONS.dup.merge(options)
+        @expectations = []
+      end
+
+      def should_receive(sym, &block)
+        expected_from = caller(1)[0]
+        expectation = MessageExpectation.new(@name, expected_from, sym, block_given? ? block : nil)
+        @expectations << expectation
+        expectation
+      end
+
+      def __verify
+        @expectations.each do |expectation|
+          expectation.verify_messages_received
+        end
+      end
+
+      def method_missing(sym, *args, &block)
+        # TODO: use find_expectation(sym, args) which will lookup based on sym, args and strict mode.
+        if expectation = find_matching_expectation(sym, *args)
+          expectation.verify_message(args, block)
+        else
+          begin
+            # act as null object if method is missing and we ignore them. return value too!
+            @options[:null_object] ? self : super(sym, *args, &block)
+          rescue NoMethodError
+            raise Spec::Api::MockExpectationError, "Mock '#{@name}' received unexpected message '#{sym.to_s}' with " + (args.collect{|arg| "<#{arg}:#{arg.class.name}>"}.join(", "))
+          end
+        end
+      end
+
+    private
+
+      def find_matching_expectation(sym, *args)
+        expectation = @expectations.find {|expectation| expectation.matches(sym, args)}
+      end
+
+    end
+
+    # Represents the expection of the reception of a message
+    class MessageExpectation
+
+      def initialize(mock_name, expected_from, sym, block)
+        @mock_name = mock_name
+        @expected_from = expected_from
+        @sym = sym
+        @method_block = block
+        @block = proc {}
+        @received_count = 0
+        @expected_received_count = 1
+        @expected_params = nil
+        @consecutive = false
+      end
+  
+      def matches(sym, args)
+        @sym == sym and (@expected_params.nil? or @expected_params == args)
+      end
+
+      # This method is called at the end of a spec, after teardown.
+      def verify_messages_received
+        # TODO: this doesn't provide good enough error messages to fix the error.
+        # Error msg should tell exactly what went wrong. (AH).
+    
+        return if @expected_received_count == -2
+        return if (@expected_received_count == -1) && (@received_count > 0)
+        return if @expected_received_count == @received_count
+    
+        expected_signature = nil
+        if @expected_params.nil?
+          expected_signature = @sym
+        else
+          params = @expected_params.collect{|param| "<#{param}:#{param.class.name}>"}.join(", ")
+          expected_signature = "#{@sym}(#{params})"
+        end
+    
+        count_message = "{@expected_received_count} times"
+        count_message = "at least once" if (@expected_received_count == -1)
+        count_message = "never" if (@expected_received_count == 0)
+        count_message = "once" if (@expected_received_count == 1)
+        count_message = "twice" if (@expected_received_count == 2)
+
+        message = "Mock '#{@mock_name}' expected #{expected_signature} #{count_message}, but received it #{@received_count} times"
+        begin
+          raise Spec::Api::MockExpectationError, message
+        rescue => error
+          error.backtrace.insert(0, @expected_from)
+          raise error
+        end
+      end
+
+      # This method is called when a method is invoked on a mock
+      def verify_message(args, block)
+        unless @method_block.nil?
+          begin
+            result = @method_block.call(*args)
+          rescue Spec::Api::ExpectationNotMetError => detail
+            raise Spec::Api::MockExpectationError, "Call expectation violated with: " + $!
+          end
+          @received_count += 1
+          return result
+        end
+    
+        unless @expected_params.nil? or @expected_params == args
+          raise Spec::Api::MockExpectationError,
+            "#{@sym}: Parameter mismatch: Expected <#{@expected_params}>, got <#{args}>" 
+        end
+        args << block unless block.nil?
+        @received_count += 1
+        value = @block.call(*args)
+    
+        return value unless @consecutive
+    
+        value[[@received_count, value.size].min - 1]
+      end
+
+      def with(*args)
+        @expected_params = args
+        self
+      end
+
+      def with_no_args
+        @expected_params = []
+        self
+      end
+  
+      def with_any_args
+        @expected_params = nil
+        self
+      end
+  
+      def at_least_once
+        @expected_received_count = -1
+        self
+      end
+
+       def any_number_of_times
+         @expected_received_count = -2
+         self
+       end
+  
+      def never
+        @expected_received_count = 0
+        self
+      end
+  
+      def once
+        @expected_received_count = 1
+        self
+      end
+  
+      def twice
+        @expected_received_count = 2
+        self
+      end
+  
+      def returns(value=nil,&block)
+        @block = block_given? ? block : proc { value }
+      end
+
+      def returns_consecutively(value=[nil],&block)
+        @consecutive = true
+        @block = block_given? ? block : proc { value }
+      end
+  
+      # this reads better in English IMHO: (AH)
+      # uri_specs.should_receive(:[]).with(:overview).and_return("http://some.host/look_here/\#{path}")
+      alias :and_return :returns
+      alias :and_return_consecutively :returns_consecutively
+  
+    end
+  end
+end

data/lib/spec/rake/spectask.rb

@@ -0,0 +1,153 @@
+#!/usr/bin/env ruby
+
+# Define a task library for running RSpec contexts.
+
+require 'rake'
+require 'rake/tasklib'
+require File.dirname(__FILE__) + '/../../spec'
+
+module Spec
+module Rake
+
+  # Create a task that runs a set of RSpec contexts.
+  #
+  # Example:
+  #  
+  #   Rake::SpecTask.new do |t|
+  #     t.libs << "spec"
+  #     t.spec_files = FileList['spec/**/*_spec.rb']
+  #     t.verbose = true
+  #   end
+  #
+  # If rake is invoked with a "SPEC=filename" command line option,
+  # then the list of spec files will be overridden to include only the
+  # filename specified on the command line.  This provides an easy way
+  # to run just one spec.
+  #
+  # If rake is invoked with a "SPECOPTS=options" command line option,
+  # then the given options are passed to the spec process after a
+  # '--'.  This allows Test::Unit options to be passed to the spec
+  # suite.
+  #
+  # Examples:
+  #
+  #   rake spec                           # run specs normally
+  #   rake spec SPEC=just_one_file.rb     # run just one spec file.
+  #   rake spec SPECOPTS="-v"             # run in verbose mode
+  #   rake spec SPECOPTS="--runner=fox"   # use the fox spec runner
+  #
+  class SpecTask < ::Rake::TaskLib
+
+    # Name of spec task. (default is :spec)
+    attr_accessor :name
+
+    # List of directories to added to $LOAD_PATH before running the
+    # specs. (default is 'lib')
+    attr_accessor :libs
+
+    # True if verbose spec output desired. (default is false)
+    attr_accessor :verbose
+
+    # Test options passed to the spec suite.  An explicit
+    # SPECOPTS=opts on the command line will override this. (default
+    # is NONE)
+    attr_accessor :options
+
+    # Request that the specs be run with the warning flag set.
+    # E.g. warning=true implies "ruby -w" used to run the specs.
+    attr_accessor :warning
+
+    # Glob pattern to match spec files. (default is 'spec/spec*.rb')
+    attr_accessor :pattern
+
+    # Style of spec loader to use.  Options are:
+    #
+    # * :rake -- Rake provided spec loading script (default).
+    # * :specrb -- Ruby provided spec loading script.
+    # * :direct -- Load specs using command line loader.
+    # 
+    attr_accessor :loader
+
+    # Array of commandline options to pass to ruby when running spec loader.
+    attr_accessor :ruby_opts
+
+    # Explicitly define the list of spec files to be included in a
+    # spec.  +list+ is expected to be an array of file names (a
+    # FileList is acceptable).  If both +pattern+ and +spec_files+ are
+    # used, then the list of spec files is the union of the two.
+    def spec_files=(list)
+      @spec_files = list
+    end
+
+    # Create a specing task.
+    def initialize(name=:spec)
+      @name = name
+      @libs = ["lib"]
+      @pattern = nil
+      @options = nil
+      @spec_files = nil
+      @verbose = false
+      @warning = false
+      @loader = :rake
+      @ruby_opts = []
+      yield self if block_given?
+      @pattern = 'spec/**/*_spec.rb' if @pattern.nil? && @spec_files.nil?
+      define
+    end
+
+    # Create the tasks defined by this task lib.
+    def define
+      lib_path = @libs.join(File::PATH_SEPARATOR)
+      desc "Run specs" + (@name==:spec ? "" : " for #{@name}")
+      task @name do
+        run_code =
+          case @loader
+          when :direct
+            "-e 'ARGV.each{|f| load f}'"
+          when :rake
+            rake_loader
+          end
+
+        RakeFileUtils.verbose(@verbose) do
+          @ruby_opts.unshift( "-I#{lib_path}" )
+          @ruby_opts.unshift( "-w" ) if @warning
+          ruby @ruby_opts.join(" ") +
+            " \"#{run_code}\" " +
+            file_list.collect { |fn| "\"#{fn}\"" }.join(' ') +
+            " #{option_list}"
+        end
+      end
+      self
+    end
+
+    def option_list # :nodoc:
+      ENV['SPECOPTS'] || @options || ""
+    end
+
+    def file_list # :nodoc:
+      if ENV['SPEC']
+        FileList[ ENV['SPEC'] ]
+      else
+        result = []
+        result += @spec_files.to_a if @spec_files
+        result += FileList[ @pattern ].to_a if @pattern
+        FileList[result]
+      end
+    end
+
+    def rake_loader # :nodoc:
+      find_file('rake/rake_test_loader') or
+      fail "unable to find rake test loader"
+    end
+
+    def find_file(fn) # :nodoc:
+      $LOAD_PATH.each do |path|
+      file_path = File.join(path, "#{fn}.rb")
+        return file_path if File.exist? file_path
+      end
+      nil
+    end
+  end
+end
+end
+