rspec 0.0.10 → 0.1.0

data/spec/spec/matchers/have_spec.rb

@@ -1,293 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module HaveSpecHelper
-  def create_collection_owner_with(n)
-    owner = Spec::Expectations::Helper::CollectionOwner.new
-    (1..n).each do |n|
-      owner.add_to_collection_with_length_method(n)
-      owner.add_to_collection_with_size_method(n)
-    end
-    owner
-  end
-end
-
-describe "should have(n).items" do
-  include HaveSpecHelper
-
-  it "should pass if target has a collection of items with n members" do
-    owner = create_collection_owner_with(3)
-    owner.should have(3).items_in_collection_with_length_method
-    owner.should have(3).items_in_collection_with_size_method
-  end
-
-  it "should convert :no to 0" do
-    owner = create_collection_owner_with(0)
-    owner.should have(:no).items_in_collection_with_length_method
-    owner.should have(:no).items_in_collection_with_size_method
-  end
-
-  it "should fail if target has a collection of items with < n members" do
-    owner = create_collection_owner_with(3)
-    lambda {
-      owner.should have(4).items_in_collection_with_length_method
-    }.should fail_with("expected 4 items_in_collection_with_length_method, got 3")
-    lambda {
-      owner.should have(4).items_in_collection_with_size_method
-    }.should fail_with("expected 4 items_in_collection_with_size_method, got 3")
-  end
-  
-  it "should fail if target has a collection of items with > n members" do
-    owner = create_collection_owner_with(3)
-    lambda {
-      owner.should have(2).items_in_collection_with_length_method
-    }.should fail_with("expected 2 items_in_collection_with_length_method, got 3")
-    lambda {
-      owner.should have(2).items_in_collection_with_size_method
-    }.should fail_with("expected 2 items_in_collection_with_size_method, got 3")
-  end
-end
-
-describe 'should have(1).item when ActiveSupport::Inflector is defined' do
-  include HaveSpecHelper
-  
-  before do
-    unless defined?(ActiveSupport::Inflector)
-      module ActiveSupport
-        class Inflector
-          def self.pluralize(string)
-            string.to_s + 's'
-          end
-        end
-      end
-    end
-  end
-  
-  it 'should pluralize the collection name' do
-    owner = create_collection_owner_with(1)
-    owner.should have(1).item
-  end
-end
-
-describe "should have(n).items where result responds to items but returns something other than a collection" do
-  it "should provide a meaningful error" do
-    owner = Class.new do
-      def items
-        Object.new
-      end
-    end.new
-    lambda do
-      owner.should have(3).items
-    end.should raise_error("expected items to be a collection but it does not respond to #length or #size")
-  end
-end
-
-describe "should_not have(n).items" do
-  include HaveSpecHelper
-
-  it "should pass if target has a collection of items with < n members" do
-    owner = create_collection_owner_with(3)
-    owner.should_not have(4).items_in_collection_with_length_method
-    owner.should_not have(4).items_in_collection_with_size_method
-  end
-  
-  it "should pass if target has a collection of items with > n members" do
-    owner = create_collection_owner_with(3)
-    owner.should_not have(2).items_in_collection_with_length_method
-    owner.should_not have(2).items_in_collection_with_size_method
-  end
-
-  it "should fail if target has a collection of items with n members" do
-    owner = create_collection_owner_with(3)
-    lambda {
-      owner.should_not have(3).items_in_collection_with_length_method
-    }.should fail_with("expected target not to have 3 items_in_collection_with_length_method, got 3")
-    lambda {
-      owner.should_not have(3).items_in_collection_with_size_method
-      }.should fail_with("expected target not to have 3 items_in_collection_with_size_method, got 3")
-  end
-end
-
-describe "should have_exactly(n).items" do
-  include HaveSpecHelper
-
-  it "should pass if target has a collection of items with n members" do
-    owner = create_collection_owner_with(3)
-    owner.should have_exactly(3).items_in_collection_with_length_method
-    owner.should have_exactly(3).items_in_collection_with_size_method
-  end
-
-  it "should convert :no to 0" do
-    owner = create_collection_owner_with(0)
-    owner.should have_exactly(:no).items_in_collection_with_length_method
-    owner.should have_exactly(:no).items_in_collection_with_size_method
-  end
-
-  it "should fail if target has a collection of items with < n members" do
-    owner = create_collection_owner_with(3)
-    lambda {
-      owner.should have_exactly(4).items_in_collection_with_length_method
-    }.should fail_with("expected 4 items_in_collection_with_length_method, got 3")
-    lambda {
-      owner.should have_exactly(4).items_in_collection_with_size_method
-    }.should fail_with("expected 4 items_in_collection_with_size_method, got 3")
-  end
-  
-  it "should fail if target has a collection of items with > n members" do
-    owner = create_collection_owner_with(3)
-    lambda {
-      owner.should have_exactly(2).items_in_collection_with_length_method
-    }.should fail_with("expected 2 items_in_collection_with_length_method, got 3")
-    lambda {
-      owner.should have_exactly(2).items_in_collection_with_size_method
-    }.should fail_with("expected 2 items_in_collection_with_size_method, got 3")
-  end
-end
-
-describe "should have_at_least(n).items" do
-  include HaveSpecHelper
-
-  it "should pass if target has a collection of items with n members" do
-    owner = create_collection_owner_with(3)
-    owner.should have_at_least(3).items_in_collection_with_length_method
-    owner.should have_at_least(3).items_in_collection_with_size_method
-  end
-  
-  it "should pass if target has a collection of items with > n members" do
-    owner = create_collection_owner_with(3)
-    owner.should have_at_least(2).items_in_collection_with_length_method
-    owner.should have_at_least(2).items_in_collection_with_size_method
-  end
-
-  it "should fail if target has a collection of items with < n members" do
-    owner = create_collection_owner_with(3)
-    lambda {
-      owner.should have_at_least(4).items_in_collection_with_length_method
-    }.should fail_with("expected at least 4 items_in_collection_with_length_method, got 3")
-    lambda {
-      owner.should have_at_least(4).items_in_collection_with_size_method
-    }.should fail_with("expected at least 4 items_in_collection_with_size_method, got 3")
-  end
-  
-  it "should provide educational negative failure messages" do
-    #given
-    owner = create_collection_owner_with(3)
-    length_matcher = have_at_least(3).items_in_collection_with_length_method
-    size_matcher = have_at_least(3).items_in_collection_with_size_method
-    
-    #when
-    length_matcher.matches?(owner)
-    size_matcher.matches?(owner)
-    
-    #then
-    length_matcher.negative_failure_message.should == <<-EOF
-Isn't life confusing enough?
-Instead of having to figure out the meaning of this:
-  should_not have_at_least(3).items_in_collection_with_length_method
-We recommend that you use this instead:
-  should have_at_most(2).items_in_collection_with_length_method
-EOF
-
-    size_matcher.negative_failure_message.should == <<-EOF
-Isn't life confusing enough?
-Instead of having to figure out the meaning of this:
-  should_not have_at_least(3).items_in_collection_with_size_method
-We recommend that you use this instead:
-  should have_at_most(2).items_in_collection_with_size_method
-EOF
-  end
-end
-
-describe "should have_at_most(n).items" do
-  include HaveSpecHelper
-
-  it "should pass if target has a collection of items with n members" do
-    owner = create_collection_owner_with(3)
-    owner.should have_at_most(3).items_in_collection_with_length_method
-    owner.should have_at_most(3).items_in_collection_with_size_method
-  end
-
-  it "should fail if target has a collection of items with > n members" do
-    owner = create_collection_owner_with(3)
-    lambda {
-      owner.should have_at_most(2).items_in_collection_with_length_method
-    }.should fail_with("expected at most 2 items_in_collection_with_length_method, got 3")
-    lambda {
-      owner.should have_at_most(2).items_in_collection_with_size_method
-    }.should fail_with("expected at most 2 items_in_collection_with_size_method, got 3")
-  end
-  
-  it "should pass if target has a collection of items with < n members" do
-    owner = create_collection_owner_with(3)
-    owner.should have_at_most(4).items_in_collection_with_length_method
-    owner.should have_at_most(4).items_in_collection_with_size_method
-  end
-
-  it "should provide educational negative failure messages" do
-    #given
-    owner = create_collection_owner_with(3)
-    length_matcher = have_at_most(3).items_in_collection_with_length_method
-    size_matcher = have_at_most(3).items_in_collection_with_size_method
-    
-    #when
-    length_matcher.matches?(owner)
-    size_matcher.matches?(owner)
-    
-    #then
-    length_matcher.negative_failure_message.should == <<-EOF
-Isn't life confusing enough?
-Instead of having to figure out the meaning of this:
-  should_not have_at_most(3).items_in_collection_with_length_method
-We recommend that you use this instead:
-  should have_at_least(4).items_in_collection_with_length_method
-EOF
-    
-    size_matcher.negative_failure_message.should == <<-EOF
-Isn't life confusing enough?
-Instead of having to figure out the meaning of this:
-  should_not have_at_most(3).items_in_collection_with_size_method
-We recommend that you use this instead:
-  should have_at_least(4).items_in_collection_with_size_method
-EOF
-  end
-end
-
-describe "have(n).items(args, block)" do
-  it "should pass args to target" do
-    target = mock("target")
-    target.should_receive(:items).with("arg1","arg2").and_return([1,2,3])
-    target.should have(3).items("arg1","arg2")
-  end
-
-  it "should pass block to target" do
-    target = mock("target")
-    block = lambda { 5 }
-    target.should_receive(:items).with("arg1","arg2", block).and_return([1,2,3])
-    target.should have(3).items("arg1","arg2", block)
-  end
-end
-
-describe "have(n).items where target IS a collection" do
-  it "should reference the number of items IN the collection" do
-    [1,2,3].should have(3).items
-  end
-
-  it "should fail when the number of items IN the collection is not as expected" do
-    lambda { [1,2,3].should have(7).items }.should fail_with("expected 7 items, got 3")
-  end
-end
-
-describe "have(n).characters where target IS a String" do
-  it "should pass if the length is correct" do
-    "this string".should have(11).characters
-  end
-
-  it "should fail if the length is incorrect" do
-    lambda { "this string".should have(12).characters }.should fail_with("expected 12 characters, got 11")
-  end
-end
-
-describe "have(n).things on an object which is not a collection nor contains one" do
-  it "should fail" do
-    lambda { Object.new.should have(2).things }.should raise_error(NoMethodError, /undefined method `things' for #<Object:/)
-  end
-end

data/spec/spec/matchers/include_spec.rb

@@ -1,45 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-describe "should include(expected)" do
-  it "should pass if target includes expected" do
-    [1,2,3].should include(3)
-    "abc".should include("a")
-  end
-
-  it "should fail if target does not include expected" do
-    lambda {
-      [1,2,3].should include(4)
-    }.should fail_with("expected [1, 2, 3] to include 4")
-    lambda {
-      "abc".should include("d")
-    }.should fail_with("expected \"abc\" to include \"d\"")
-  end
-end
-
-describe "should include(with, multiple, args)" do
-  it "should pass if target includes all items" do
-    [1,2,3].should include(1,2,3)
-  end
-
-  it "should fail if target does not include any one of the items" do
-    lambda {
-      [1,2,3].should include(1,2,4)
-    }.should fail_with("expected [1, 2, 3] to include 1, 2 and 4")
-  end
-end
-
-describe "should_not include(expected)" do
-  it "should pass if target does not include expected" do
-    [1,2,3].should_not include(4)
-    "abc".should_not include("d")
-  end
-
-  it "should fail if target includes expected" do
-    lambda {
-      [1,2,3].should_not include(3)
-    }.should fail_with("expected [1, 2, 3] not to include 3")
-    lambda {
-      "abc".should_not include("c")
-    }.should fail_with("expected \"abc\" not to include \"c\"")
-  end
-end

data/spec/spec/matchers/match_spec.rb

@@ -1,37 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-describe "should match(expected)" do
-  it "should pass when target (String) matches expected (Regexp)" do
-    "string".should match(/tri/)
-  end
-
-  it "should fail when target (String) does not match expected (Regexp)" do
-    lambda {
-      "string".should match(/rings/)
-    }.should fail
-  end
-  
-  it "should provide message, expected and actual on failure" do
-    matcher = match(/rings/)
-    matcher.matches?("string")
-    matcher.failure_message.should == ["expected \"string\" to match /rings/", /rings/, "string"]
-  end
-end
-
-describe "should_not match(expected)" do
-  it "should pass when target (String) matches does not match (Regexp)" do
-    "string".should_not match(/rings/)
-  end
-
-  it "should fail when target (String) matches expected (Regexp)" do
-    lambda {
-      "string".should_not match(/tri/)
-    }.should fail
-  end
-
-  it "should provide message, expected and actual on failure" do
-    matcher = match(/tri/)
-    matcher.matches?("string")
-    matcher.negative_failure_message.should == ["expected \"string\" not to match /tri/", /tri/, "string"]
-  end
-end

data/spec/spec/matchers/matcher_methods_spec.rb

@@ -1,78 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module Matchers
-    context %Q{The Spec::Matchers module gets included in the execution context of every spec.
-This module should provide the following methods, each of which returns a Matcher object.} do
-      it "be_true" do
-        be_true.should be_an_instance_of(Be)
-      end
-      it "be_false" do
-        be_false.should be_an_instance_of(Be)
-      end
-      it "be_nil" do
-        be_nil.should be_an_instance_of(Be)
-      end
-      it "be_arbitrary_predicate" do
-        be_arbitrary_predicate.should be_an_instance_of(Be)
-      end
-      it "be_close" do
-        be_close(1,2).should be_an_instance_of(BeClose)
-      end
-      it "change" do
-        change("target", :message).should be_an_instance_of(Change)
-      end
-      it "eql" do
-        eql(:expected).should be_an_instance_of(Eql)
-      end
-      it "equal" do
-        equal(:expected).should be_an_instance_of(Equal)
-      end
-      it "have" do
-        have(0).should be_an_instance_of(Have)
-      end
-      it "have_exactly" do
-        have_exactly(0).should be_an_instance_of(Have)
-      end
-      it "have_at_least" do
-        have_at_least(0).should be_an_instance_of(Have)
-      end
-      it "have_at_most" do
-        have_at_most(0).should be_an_instance_of(Have)
-      end
-      it "include" do
-        include(:value).should be_an_instance_of(Include)
-      end
-      it "match" do
-        match(:value).should be_an_instance_of(Match)
-      end
-      it "raise_error" do
-        raise_error.should be_an_instance_of(RaiseError)
-        raise_error(NoMethodError).should be_an_instance_of(RaiseError)
-        raise_error(NoMethodError, "message").should be_an_instance_of(RaiseError)
-      end
-      it "satisfy" do
-        satisfy{}.should be_an_instance_of(Satisfy)
-      end
-      it "throw_symbol" do
-        throw_symbol.should be_an_instance_of(ThrowSymbol)
-        throw_symbol(:sym).should be_an_instance_of(ThrowSymbol)
-      end
-      it "respond_to" do
-        respond_to(:sym).should be_an_instance_of(RespondTo)
-      end
-    end
-    
-    describe "Spec::Matchers#method_missing" do
-      it "should convert be_xyz to Be(:be_xyz)" do
-        Be.should_receive(:new).with(:be_whatever)
-        be_whatever
-      end
-
-      it "should convert have_xyz to Has(:have_xyz)" do
-        Has.should_receive(:new).with(:have_whatever)
-        have_whatever
-      end
-    end
-  end
-end