rspec 1.3.2 → 2.0.0.a2

data/spec/spec/matchers/include_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-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 pass if target is a Hash and has the expected as a key' do
-    {:key => 'value'}.should include(:key)
-  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\"")
-    lambda {
-      {:key => 'value'}.should include(:other)
-    }.should fail_with(%Q|expected {:key=>"value"} to include :other|)
-  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 pass if target is a Hash including all items as keys' do
-    {:key => 'value', :other => 'value'}.should include(:key, :other)
-  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
-  
-  it 'should pass if target is a Hash missing any item as a key' do
-    lambda {
-      {:key => 'value'}.should include(:key, :other)
-    }.should fail_with(%Q|expected {:key=>"value"} to include :key and :other|)
-  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 pass if target is a Hash and does not have the expected as a key' do
-    {:other => 'value'}.should_not include(:key)
-  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\"")
-    lambda {
-      {:key => 'value'}.should_not include(:key)
-    }.should fail_with(%Q|expected {:key=>"value"} not to include :key|)
-  end
-end
-
-describe "should include(:key => value)" do
-  it "should pass if target is a Hash and includes the key/value pair" do
-    {:key => 'value'}.should include(:key => 'value')
-  end
-  it "should pass if target is a Hash and includes the key/value pair among others" do
-    {:key => 'value', :other => 'different'}.should include(:key => 'value')
-  end
-  it "should fail if target is a Hash and has a different value for key" do
-    lambda {
-      {:key => 'different'}.should include(:key => 'value')
-    }.should fail_with(%Q|expected {:key=>"different"} to include {:key=>"value"}|)
-  end
-  it "should fail if target is a Hash and has a different key" do
-    lambda {
-      {:other => 'value'}.should include(:key => 'value')
-    }.should fail_with(%Q|expected {:other=>"value"} to include {:key=>"value"}|)
-  end
-end

data/spec/spec/matchers/match_array_spec.rb

@@ -1,115 +0,0 @@
-require 'spec_helper'
-
-class UnsortableObject
-  def initialize(id)
-    @id = id
-  end
-
-  def inspect
-    @id.to_s
-  end
-
-  def ==(other)
-    false
-  end
-end
-
-describe "array.should =~ other_array" do
-  it "should pass if target contains all items" do
-    [1,2,3].should =~ [1,2,3]
-  end
-
-  it "should pass if target contains all items out of order" do
-    [1,3,2].should =~ [1,2,3]
-  end
-
-  it "should fail if target includes extra items" do
-    lambda {
-      [1,2,3,4].should =~ [1,2,3]
-    }.should fail_with(<<-MESSAGE)
-expected collection contained:  [1, 2, 3]
-actual collection contained:    [1, 2, 3, 4]
-the extra elements were:        [4]
-MESSAGE
-  end
-
-  it "should fail if target is missing items" do
-    lambda {
-      [1,2].should =~ [1,2,3]
-    }.should fail_with(<<-MESSAGE)
-expected collection contained:  [1, 2, 3]
-actual collection contained:    [1, 2]
-the missing elements were:      [3]
-MESSAGE
-  end
-
-  it "should fail if target is missing items and has extra items" do
-
-    lambda {
-      [1,2,4].should =~ [1,2,3]
-    }.should fail_with(<<-MESSAGE)
-expected collection contained:  [1, 2, 3]
-actual collection contained:    [1, 2, 4]
-the missing elements were:      [3]
-the extra elements were:        [4]
-MESSAGE
-  end
-
-  it "should sort items in the error message if they all respond to <=>" do
-    lambda {
-      [6,2,1,5].should =~ [4,1,2,3]
-    }.should fail_with(<<-MESSAGE)
-expected collection contained:  [1, 2, 3, 4]
-actual collection contained:    [1, 2, 5, 6]
-the missing elements were:      [3, 4]
-the extra elements were:        [5, 6]
-MESSAGE
-  end
-
-  it "should not sort items in the error message if they don't all respond to <=>" do
-    with_ruby 1.8 do
-      lambda {
-        [UnsortableObject.new(2), UnsortableObject.new(1)].should =~ [UnsortableObject.new(4), UnsortableObject.new(3)]
-      }.should fail_with(<<-MESSAGE)
-expected collection contained:  [4, 3]
-actual collection contained:    [2, 1]
-the missing elements were:      [4, 3]
-the extra elements were:        [2, 1]
-MESSAGE
-    end
-  end
-
-  it "should accurately report extra elements when there are duplicates" do
-    lambda {
-      [1,1,1,5].should =~ [1,5]
-    }.should fail_with(<<-MESSAGE)
-expected collection contained:  [1, 5]
-actual collection contained:    [1, 1, 1, 5]
-the extra elements were:        [1, 1]
-MESSAGE
-  end
-
-  it "should accurately report missing elements when there are duplicates" do
-    lambda {
-      [1,5].should =~ [1,1,5]
-    }.should fail_with(<<-MESSAGE)
-expected collection contained:  [1, 1, 5]
-actual collection contained:    [1, 5]
-the missing elements were:      [1]
-MESSAGE
-  end
-
-  it "should work with subclasses of Array" do
-    class SuperArray < Array; end
-    SuperArray.new([1,2,3]).should =~ SuperArray.new([3,2,1])
-  end
-
-end
-
-describe "should_not =~ [:with, :multiple, :args]" do
-  it "should not be supported" do
-    lambda {
-      [1,2,3].should_not =~ [1,2,3]
-    }.should fail_with(/Matcher does not support should_not/)
-  end
-end

data/spec/spec/matchers/match_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-
-describe "should match(expected)" do
-  it "should pass when target (String) matches expected (Regexp)" do
-    "string".should match(/tri/)
-  end
-
-  it "should pass when target (String) matches expected (String)" 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 fail when target (String) does not match expected (String)" 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_for_should.should == "expected \"string\" to match /rings/"
-  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 pass when target (String) matches does not match (String)" 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 fail when target (String) matches expected (String)" 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.failure_message_for_should_not.should == "expected \"string\" not to match /tri/"
-  end
-end

data/spec/spec/matchers/matcher_spec.rb

@@ -1,289 +0,0 @@
-require 'spec_helper'
-
-class UnexpectedError < StandardError; end
-
-module Spec
-  module Matchers
-    describe Matcher do
-      context "without overrides" do
-        before(:each) do
-          @matcher = Spec::Matchers::Matcher.new(:be_a_multiple_of, 3) do |multiple|
-            match do |actual|
-              actual % multiple == 0
-            end
-          end
-        end
-
-        it "provides a default description" do
-          @matcher.description.should == "be a multiple of 3"
-        end
-
-        it "provides a default failure message for #should" do
-          @matcher.matches?(8)
-          @matcher.failure_message_for_should.should == "expected 8 to be a multiple of 3"
-        end
-
-        it "provides a default failure message for #should_not" do
-          @matcher.matches?(9)
-          @matcher.failure_message_for_should_not.should == "expected 9 not to be a multiple of 3"
-        end
-      end
-
-      it "is not diffable by default" do
-        matcher = Spec::Matchers::Matcher.new(:name) {}
-        matcher.should_not be_diffable
-      end
-
-      it "is diffable when told to be" do
-        matcher = Spec::Matchers::Matcher.new(:name) { diffable }
-        matcher.should be_diffable
-      end
-
-      it "provides expected" do
-        matcher = Spec::Matchers::Matcher.new(:name, 'expected string') {}
-        matcher.expected.should == ['expected string']
-      end
-
-      it "provides actual" do
-        matcher = Spec::Matchers::Matcher.new(:name, 'expected string') do
-          match {|actual|}
-        end
-
-        matcher.matches?('actual string')
-
-        matcher.actual.should == 'actual string'
-      end
-
-      context "wrapping another expectation (should == ...)" do
-        it "returns true if the wrapped expectation passes" do
-          matcher = Spec::Matchers::Matcher.new(:name, 'value') do |expected|
-            match do |actual|
-              actual.should == expected
-            end
-          end
-          matcher.matches?('value').should be_true
-        end
-
-        it "returns false if the wrapped expectation fails" do
-          matcher = Spec::Matchers::Matcher.new(:name, 'value') do |expected|
-            match do |actual|
-              actual.should == expected
-            end
-          end
-          matcher.matches?('other value').should be_false
-        end
-      end
-
-      context "with overrides" do
-        before(:each) do
-          @matcher = Spec::Matchers::Matcher.new(:be_boolean, true) do |boolean|
-            match do |actual|
-              actual
-            end
-            description do
-              "be the boolean #{boolean}"
-            end
-            failure_message_for_should do |actual|
-              "expected #{actual} to be the boolean #{boolean}"
-            end
-            failure_message_for_should_not do |actual|
-              "expected #{actual} not to be the boolean #{boolean}"
-            end
-          end
-        end
-
-        it "does not hide result of match block when true" do
-          @matcher.matches?(true).should be_true
-        end
-
-        it "does not hide result of match block when false" do
-          @matcher.matches?(false).should be_false
-        end
-
-        it "overrides the description" do
-          @matcher.description.should == "be the boolean true"
-        end
-
-        it "overrides the failure message for #should" do
-          @matcher.matches?(false)
-          @matcher.failure_message_for_should.should == "expected false to be the boolean true"
-        end
-
-        it "overrides the failure message for #should_not" do
-          @matcher.matches?(true)
-          @matcher.failure_message_for_should_not.should == "expected true not to be the boolean true"
-        end
-      end
-
-      context "#new" do
-        it "passes matches? arg to match block" do
-          matcher = Spec::Matchers::Matcher.new(:ignore) do
-            match do |actual|
-              actual == 5
-            end
-          end
-          matcher.matches?(5).should be_true
-        end
-
-        it "exposes arg submitted through #new to matcher block" do
-          matcher = Spec::Matchers::Matcher.new(:ignore, 4) do |expected|
-            match do |actual|
-              actual > expected
-            end
-          end
-          matcher.matches?(5).should be_true
-        end
-      end
-
-      context "with no args" do
-        before(:each) do
-          @matcher = Spec::Matchers::Matcher.new(:matcher_name) do
-            match do |actual|
-              actual == 5
-            end
-          end
-        end
-
-        it "matches" do
-          @matcher.matches?(5).should be_true
-        end
-
-        it "describes" do
-          @matcher.description.should == "matcher name"
-        end
-      end
-
-      context "with 1 arg" do
-        before(:each) do
-          @matcher = Spec::Matchers::Matcher.new(:matcher_name, 1) do |expected|
-            match do |actual|
-              actual == 5 && expected == 1
-            end
-          end
-        end
-
-        it "matches" do
-          @matcher.matches?(5).should be_true
-        end
-
-        it "describes" do
-          @matcher.description.should == "matcher name 1"
-        end
-      end
-
-      context "with multiple args" do
-        before(:each) do
-          @matcher = Spec::Matchers::Matcher.new(:matcher_name, 1, 2, 3, 4) do |a,b,c,d|
-            match do |sum|
-              a + b + c + d == sum
-            end
-          end
-        end
-
-        it "matches" do
-          @matcher.matches?(10).should be_true
-        end
-
-        it "describes" do
-          @matcher.description.should == "matcher name 1, 2, 3, and 4"
-        end
-      end
-
-      it "supports helper methods" do
-        matcher = Spec::Matchers::Matcher.new(:be_similar_to, [1,2,3]) do |sample|
-          match do |actual|
-            similar?(sample, actual)
-          end
-
-          def similar?(a, b)
-            a.sort == b.sort
-          end
-        end
-
-        matcher.matches?([2,3,1]).should be_true
-      end
-
-      it "supports fluent interface" do
-        matcher = Spec::Matchers::Matcher.new(:first_word) do
-          def second_word
-            self
-          end
-        end
-
-        matcher.second_word.should == matcher
-      end
-
-      it "treats method missing normally for undeclared methods" do
-        matcher = Spec::Matchers::Matcher.new(:ignore) { }
-        expect { matcher.non_existent_method }.to raise_error(NoMethodError)
-      end
-
-      it "has access to other matchers" do
-        matcher = Spec::Matchers::Matcher.new(:ignore, 3) do |expected|
-          match do |actual|
-            extend Spec::Matchers
-            actual.should eql(5 + expected)
-          end
-        end
-
-        matcher.matches?(8).should be_true
-      end
-
-      describe "#match_unless_raises" do
-        context "with a passing assertion" do
-          let(:mod) do
-            Module.new do
-              def assert_equal(a,b)
-                a == b ? nil : (raise UnexpectedError.new("#{a} does not equal #{b}"))
-              end
-            end
-          end
-          let(:matcher) do
-            m = mod
-            Spec::Matchers::Matcher.new :equal, 4 do |expected|
-              extend m
-              match_unless_raises UnexpectedError do
-                assert_equal expected, actual
-              end
-            end
-          end
-          it "passes as you would expect" do
-            matcher.matches?(4).should be_true
-          end
-          it "fails as you would expect" do
-            matcher.matches?(5).should be_false
-          end
-        end
-
-        context "with an unexpected error" do
-          let(:matcher) do
-            Spec::Matchers::Matcher.new :foo, :bar do |expected|
-              match_unless_raises SyntaxError do |actual|
-                raise "unexpected exception"
-              end
-            end
-          end
-
-          it "raises the error" do
-            expect do
-              matcher.matches?(:bar)
-            end.to raise_error("unexpected exception")
-          end
-        end
-
-      end
-
-      it "can define chainable methods" do
-        matcher = Spec::Matchers::Matcher.new(:name) do
-          chain(:expecting) do |expected_value|
-            @expected_value = expected_value
-          end
-          match { |actual| actual == @expected_value }
-        end
-
-        matcher.expecting('value').matches?('value').should be_true
-        matcher.expecting('value').matches?('other value').should be_false
-      end
-    end
-  end
-end