rspec 0.6.3 → 0.6.4

data/examples/airport_spec.rb

@@ -1,33 +0,0 @@
-require File.dirname(__FILE__) + '/../lib/spec'
-
-class Airport
-  def working?
-    true
-  end
-  
-  def need?(thing)
-    false unless [:cables, :electricity].include? thing
-  end
-end
-
-context "Airport at home" do
-  setup do
-    @airport = Airport.new
-  end
-  
-  specify "should always work" do
-    @airport.should_be_working
-  end
-
-  specify "not need cables" do
-    @airport.should_not_need :cables
-  end
-
-  specify "not need electricity" do
-    @airport.should_not_need :electricity
-  end
-  
-  teardown do
-    @airport = nil
-  end
-end

data/examples/custom_method_spec.rb

@@ -1,24 +0,0 @@
-require File.dirname(__FILE__)  + '/../lib/spec'
-
-context "Rspec allow you to define custom methods" do
-  specify "Rspec should allow you to define methods" do
-    a_method
-    @a_method_called.should_be true
-  end
-
-  def a_method
-    @a_method_called = true
-  end
-end
-require File.dirname(__FILE__)  + '/../lib/spec'
-
-context "Rspec allow you to define custom methods" do
-  specify "Rspec should allow you to define methods" do
-    a_method
-    @a_method_called.should_be true
-  end
-
-  def a_method
-    @a_method_called = true
-  end
-end

data/examples/sugar_spec.rb

@@ -1,14 +0,0 @@
-require File.dirname(__FILE__) + '/../lib/spec'
-
-context "Underscore sugar" do
-  specify "should be available for regular objects" do
-    1.should_equal 1
-    lambda { 1.should_not_equal 1 }.should_raise
-  end
-
-  specify "should be available for mocks" do
-    sweetened = mock "sweetened"
-    sweetened.should_receive :salt
-    sweetened.salt
-  end
-end

data/lib/spec/api.rb

@@ -1,8 +0,0 @@
-require 'spec/api/exceptions'
-require 'spec/api/mocks/argument_expectation'
-require 'spec/api/mocks/order_group'
-require 'spec/api/mocks/message_expectation'
-require 'spec/api/mocks/mock'
-require 'spec/api/expectations'
-require 'spec/api/helper'
-require 'spec/api/sugar'

data/lib/spec/api/expectations.rb

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

@@ -1,4 +0,0 @@
-require 'spec/api/helper/should_base'
-require 'spec/api/helper/have_helper'
-require 'spec/api/helper/should_helper'
-require 'spec/api/helper/should_negator'

data/lib/spec/api/helper/diff.rb

@@ -1,54 +0,0 @@
-begin
-  require 'rubygems'
-  require 'diff/lcs' #necessary to do loading bug on some machines - not sure why - DaC
-  require 'diff/lcs/hunk'
-rescue LoadError
-  raise "You must gem install diff-lcs to use this feature"
-end
-
-module Spec
-  class ShouldBase
-    unless defined?(RSPEC_TESTING)
-      alias old_default_message default_message
-      def default_message(expectation, expected=:no_expectation_specified)
-        result = old_default_message(expectation, expected)
-        if expected.is_a?(String)
-          result << "\nDiff:" << diff_as_string(@target.to_s, expected)
-        end
-        result
-      end
-    end
-
-    # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
-    def diff_as_string(data_old, data_new, format=:unified, context_lines=3)
-      data_old = data_old.split(/\n/).map! { |e| e.chomp }
-      data_new = data_new.split(/\n/).map! { |e| e.chomp }
-      output = ""
-      diffs = Diff::LCS.diff(data_old, data_new)
-      return output if diffs.empty?
-      oldhunk = hunk = nil  
-      file_length_difference = 0
-      diffs.each do |piece|
-        begin
-          hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, context_lines,
-                                     file_length_difference)
-          file_length_difference = hunk.file_length_difference      
-          next unless oldhunk      
-          # Hunks may overlap, which is why we need to be careful when our
-          # diff includes lines of context. Otherwise, we might print
-          # redundant lines.
-          if (context_lines > 0) and hunk.overlaps?(oldhunk)
-            hunk.unshift(oldhunk)
-          else
-            output << oldhunk.diff(format)
-          end
-        ensure
-          oldhunk = hunk
-          output << "\n"
-        end
-      end  
-      #Handle the last remaining hunk
-      output << oldhunk.diff(format) << "\n"
-    end  
-  end
-end

data/lib/spec/api/helper/have_helper.rb

@@ -1,40 +0,0 @@
-module Spec
-
-  class HaveHelper < ShouldBase
-
-    def initialize(target, relativity=:exactly, expected=nil)
-      @target = target
-      @expected = expected == :no ? 0 : expected
-      @at_least = (relativity == :at_least)
-      @at_most = (relativity == :at_most)
-    end
-    
-    def method_missing(sym, *args)
-      fail_with_message(build_message(sym)) unless as_specified?(sym)
-    end
-    
-    def collection(sym)
-      @target.send(sym)
-    end
-    
-    def actual_size(collection)
-      return collection.length if collection.respond_to? :length
-      return collection.size if collection.respond_to? :size
-    end
-    
-    def build_message(sym)
-      message = "<#{@target.class.to_s}> should have"
-      message += " at least" if @at_least
-      message += " at most" if @at_most
-      message += " #{@expected} #{sym} (has #{actual_size(collection(sym))})"
-    end
-    
-    def as_specified?(sym)
-      return actual_size(collection(sym)) >= @expected if @at_least
-      return actual_size(collection(sym)) <= @expected if @at_most
-      return actual_size(collection(sym)) == @expected
-    end
-
-  end
-
-end

data/lib/spec/api/helper/should_base.rb

@@ -1,31 +0,0 @@
-class TrueClass; def inspect_for_expectation_not_met_error; "<true>" end end
-class FalseClass; def inspect_for_expectation_not_met_error; "<false>" end end
-class NilClass; def inspect_for_expectation_not_met_error; "nil" end end
-class Class; def inspect_for_expectation_not_met_error; "<#{name}>" end end
-class Proc; def inspect_for_expectation_not_met_error; "<Proc>" end end
-class Array; def inspect_for_expectation_not_met_error; inspect end end
-class String; def inspect_for_expectation_not_met_error; inspect end end
-class Object
-  def inspect_for_expectation_not_met_error
-    return "#{self.class} #{inspect}" if inspect.include? "<"
-    return "#{self.class} <#{inspect}>" unless inspect.include? "<"
-  end
-end
-
-module Spec
-  class ShouldBase
-
-    def default_message(expectation, expected=:no_expectation_specified)
-      message = "#{@target.inspect_for_expectation_not_met_error} #{expectation}"
-      if (expected != :no_expectation_specified)
-        message << " " << expected.inspect_for_expectation_not_met_error
-      end
-      message
-     end
-
-    def fail_with_message(message)
-      Kernel::raise(Spec::Api::ExpectationNotMetError.new(message))
-    end
-    
-  end
-end

data/lib/spec/api/helper/should_helper.rb

@@ -1,93 +0,0 @@
-module Spec
-
-  class ShouldHelper < ShouldBase
-
-    def initialize(target)
-      @target = target
-      @be_seen = false
-    end
-    
-    def not
-      ShouldNegator.new(@target)
-    end
-    
-    def have(expected_number=nil)
-      HaveHelper.new(@target, :exactly, expected_number)
-    end
-  
-    def have_exactly(expected_number=nil)
-      HaveHelper.new(@target, :exactly, expected_number)
-    end
-  
-    def have_at_least(expected_number=nil)
-      HaveHelper.new(@target, :at_least, expected_number)
-    end
-  
-    def have_at_most(expected_number=nil)
-      HaveHelper.new(@target, :at_most, expected_number)
-    end
-  
-    def satisfy(&block)
-      return if block.call(@target)
-      fail_with_message "Supplied expectation was not satisfied"
-    end
-        
-    def equal(expected)
-      fail_with_message(default_message("should equal", expected)) unless (@target == expected)
-    end
-
-    def be(expected = :___no_arg)
-      @be_seen = true
-      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
-
-    def an_instance_of expected_class
-      fail_with_message(default_message("should be an instance of", expected_class)) unless @target.instance_of? expected_class
-    end
-    
-    def a_kind_of expected_class
-      fail_with_message(default_message("should be a kind of", expected_class)) unless @target.kind_of? expected_class
-    end
-    
-    def respond_to message
-      fail_with_message(default_message("should respond to", message)) unless @target.respond_to? message
-    end
-    
-    def method_missing(sym, *args)
-      return if @target.send("#{sym}?", *args)
-      fail_with_message(default_message("should be #{sym}" + (args.empty? ? '' : (' ' + args.join(', '))))) if @be_seen
-      fail_with_message(default_message("should #{sym}" + (args.empty? ? '' : (' ' + args.join(', '))))) unless @be_seen
-    end
-
-    def match(expected)
-       fail_with_message(default_message("should match", expected)) unless (@target =~ expected)
-    end
-
-    def raise(exception=Exception, message=nil)
-      begin
-        @target.call
-      rescue exception => e
-        e.message.should_equal message unless message.nil?
-        return
-      rescue => e
-        fail_with_message("#{default_message("should raise", exception)} but raised #{e.inspect}")
-      end
-      fail_with_message("#{default_message("should raise", exception)} but raised nothing")
-    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
-end

data/lib/spec/api/helper/should_negator.rb

@@ -1,72 +0,0 @@
-module Spec
-  
-  class ShouldNegator < ShouldBase
-    
-    def initialize(target)
-      @target = target
-      @be_seen = false
-    end
-  
-    def satisfy
-      fail_with_message "Supplied expectation was satisfied, but should not have been" if (yield @target)
-    end
-        
-    def equal(expected)
-      fail_with_message(default_message("should not equal", expected)) if (@target == expected)
-    end
-    
-    def be(expected = :no_arg)
-      @be_seen = true
-      return self if (expected == :no_arg)
-      fail_with_message(default_message("should not be", expected)) if (@target.equal?(expected))
-    end
-
-    def an_instance_of expected_class
-      fail_with_message(default_message("should not be an instance of", expected_class)) if @target.instance_of? expected_class
-    end
-    
-    def a_kind_of expected_class
-      fail_with_message(default_message("should not be a kind of", expected_class)) if @target.kind_of? expected_class
-    end
-
-    def respond_to message
-      fail_with_message(default_message("should not respond to", message)) if @target.respond_to? message
-    end
-    
-    def match(expected)
-        fail_with_message(default_message("should not match", expected)) if (@target =~ expected)
-    end
-    
-    def raise(exception=Exception, message=nil)
-      begin
-        @target.call
-      rescue exception => e
-        return unless message.nil? || e.message == message
-        fail_with_message("#{default_message("should not raise", exception)}") if e.instance_of? exception
-        fail_with_message("#{default_message("should not raise", exception)} but raised #{e.inspect}") unless e.instance_of? exception
-      rescue
-        true
-      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
-        true
-      end
-    end
-
-    def method_missing(sym, *args)
-      return unless @target.send("#{sym}?", *args)
-      fail_with_message(default_message("should not #{sym}" + (args.empty? ? '' : (' ' + args.join(', '))))) unless @be_seen
-      fail_with_message(default_message("should not be #{sym}" + (args.empty? ? '' : (' ' + args.join(', '))))) if @be_seen
-    end
-
-  end
-
-end

data/test/spec/api/helper/arbitrary_predicate_test.rb

@@ -1,112 +0,0 @@
-require File.dirname(__FILE__) + '/../../../test_helper'
-
-module Spec
-  module Api
-    module Helper
-
-      class ArbitraryPredicateTest < Test::Unit::TestCase
-
-        # should_be_funny
-
-        def test_should_be_funny_should_raise_when_target_doesnt_understand_funny
-          assert_raise(NoMethodError) do
-            5.should_be_funny
-          end
-        end
-
-        def test_should_be_funny_should_raise_when_sending_funny_to_target_returns_false
-          mock = HandCodedMock.new(false)
-          assert_raise(ExpectationNotMetError) do
-            mock.should_be_funny
-          end
-          mock.__verify
-        end
-
-        def test_should_be_funny_should_raise_when_sending_funny_to_target_returns_nil
-          mock = HandCodedMock.new(nil)
-          assert_raise(ExpectationNotMetError) do
-            mock.should_be_funny
-          end
-          mock.__verify
-        end
-
-        def test_should_be_funny_should_not_raise_when_sending_funny_to_target_returns_true
-          mock = HandCodedMock.new(true)
-          assert_nothing_raised do
-            mock.should_be_funny
-          end
-          mock.__verify
-        end
-
-        def test_should_be_funny_should_not_raise_when_sending_funny_to_target_returns_something_other_than_true_false_or_nil
-          mock = HandCodedMock.new(5)
-          assert_nothing_raised do
-            mock.should_be_funny
-          end
-          mock.__verify
-        end
-
-        # should_be_funny(args)
-  
-        def test_should_be_funny_with_args_passes_args_properly
-          mock = HandCodedMock.new(true)
-          assert_nothing_raised do
-            mock.should_be_hungry(1, 2, 3)
-          end
-          mock.__verify
-        end
-
-        # should_not_be_funny
-
-        def test_should_not_be_funny_should_raise_when_target_doesnt_understand_funny
-          assert_raise(NoMethodError) do
-            5.should_not_be_funny
-          end
-        end
-
-        def test_should_not_be_funny_should_raise_when_sending_funny_to_target_returns_true
-          mock = HandCodedMock.new(true)
-          assert_raise(ExpectationNotMetError) do
-            mock.should_not_be_funny
-          end
-          mock.__verify
-        end
-
-        def test_should_not_be_funny_shouldnt_raise_when_sending_funny_to_target_returns_nil
-          mock = HandCodedMock.new(nil)
-          assert_nothing_raised do
-            mock.should_not_be_funny
-          end
-          mock.__verify
-        end
-
-        def test_should_not_be_funny_shouldnt_raise_when_sending_funny_to_target_returns_false
-          mock = HandCodedMock.new(false)
-          assert_nothing_raised do
-            mock.should_not_be_funny
-          end
-          mock.__verify
-        end
-
-        def test_should_not_be_funny_should_raise_when_sending_funny_to_target_returns_something_other_than_true_false_or_nil
-          mock = HandCodedMock.new(5)
-          assert_raise(ExpectationNotMetError) do
-            mock.should_not_be_funny
-          end
-          mock.__verify
-        end
-  
-        # should_be_funny(args)
-  
-        def test_should_not_be_funny_with_args_passes_args_properly
-          mock = HandCodedMock.new(false)
-          assert_nothing_raised do
-            mock.should_not_be_hungry(1, 2, 3)
-          end
-          mock.__verify
-        end
-
-      end
-    end
-  end
-end