pupu 0.0.1

data/vendor/rspec/spec/spec/expectations/extensions/kernel_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Object, "#should" do
+  before(:each) do
+    @target = "target"
+    @matcher = mock("matcher")
+    @matcher.stub!(:matches?).and_return(true)
+    @matcher.stub!(:failure_message_for_should)
+  end
+  
+  it "accepts and interacts with a matcher" do
+    @matcher.should_receive(:matches?).with(@target).and_return(true)    
+    @target.should @matcher
+  end
+  
+  it "asks for a failure_message_for_should when matches? returns false" do
+    @matcher.should_receive(:matches?).with(@target).and_return(false)
+    @matcher.should_receive(:failure_message_for_should).and_return("the failure message")
+    lambda {
+      @target.should @matcher
+    }.should fail_with("the failure message")
+  end
+end
+
+describe Object, "#should_not" do
+  before(:each) do
+    @target = "target"
+    @matcher = mock("matcher")
+  end
+  
+  it "accepts and interacts with a matcher" do
+    @matcher.should_receive(:matches?).with(@target).and_return(false)
+    @matcher.stub!(:failure_message_for_should_not)
+    
+    @target.should_not @matcher
+  end
+  
+  it "asks for a failure_message_for_should_not when matches? returns true" do
+    @matcher.should_receive(:matches?).with(@target).and_return(true)
+    @matcher.should_receive(:failure_message_for_should_not).and_return("the failure message for should not")
+    lambda {
+      @target.should_not @matcher
+    }.should fail_with("the failure message for should not")
+  end
+end

data/vendor/rspec/spec/spec/expectations/fail_with_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe Spec::Expectations, "#fail_with with no diff" do
+  before(:each) do
+    @old_differ = Spec::Expectations.differ
+    Spec::Expectations.differ = nil
+  end
+  
+  it "should handle just a message" do
+    lambda {
+      Spec::Expectations.fail_with "the message"
+    }.should fail_with("the message")
+  end
+  
+  after(:each) do
+    Spec::Expectations.differ = @old_differ
+  end
+end
+
+describe Spec::Expectations, "#fail_with with Array" do
+  before(:each) do
+    Spec.stub!(:warn)
+  end
+  
+  it "is deprecated" do
+    Spec.should_receive(:warn)
+    lambda {
+      Spec::Expectations.fail_with ["message", "expected", "actual"]
+    }.should raise_error
+  end
+end
+
+describe Spec::Expectations, "#fail_with with diff" do
+  before(:each) do
+    @old_differ = Spec::Expectations.differ
+    @differ = mock("differ")
+    Spec::Expectations.differ = @differ
+  end
+  
+  it "should not call differ if no expected/actual" do
+    lambda {
+      Spec::Expectations.fail_with "the message"
+    }.should fail_with("the message")
+  end
+  
+  it "should call differ if expected/actual are presented separately" do
+    @differ.should_receive(:diff_as_string).and_return("diff")
+    lambda {
+      Spec::Expectations.fail_with "the message", "expected", "actual"
+    }.should fail_with("the message\n\n Diff:diff")
+  end
+  
+  it "should call differ if expected/actual are not strings" do
+    @differ.should_receive(:diff_as_object).and_return("diff")
+    lambda {
+      Spec::Expectations.fail_with "the message", :expected, :actual
+    }.should fail_with("the message\n\n Diff:diff")
+  end
+  
+  it "should call differ if expected/actual are both hashes" do
+    @differ.should_receive(:diff_as_hash).and_return("diff")
+    lambda {
+      Spec::Expectations.fail_with "the message", {:a => :b}, {:a => 'b'}
+    }.should fail_with("the message\n\n Diff:diff")
+  end
+  
+  it "should not call differ if expected or actual are procs" do
+    @differ.should_not_receive(:diff_as_string)
+    @differ.should_not_receive(:diff_as_object)
+    @differ.should_not_receive(:diff_as_hash)
+    lambda {
+      Spec::Expectations.fail_with "the message", lambda {}, lambda {}
+    }.should fail_with("the message")
+  end
+
+  after(:each) do
+    Spec::Expectations.differ = @old_differ
+  end
+end
+
+describe Spec::Expectations, "#fail_with with a nil message" do
+  before(:each) do
+    @old_differ = Spec::Expectations.differ
+    Spec::Expectations.differ = nil
+  end
+
+  it "should handle just a message" do
+    lambda {
+      Spec::Expectations.fail_with nil
+    }.should raise_error(ArgumentError, /Failure message is nil\. Does your matcher define the appropriate failure_message_for_\* method to return a string\?/)
+  end
+
+  after(:each) do
+    Spec::Expectations.differ = @old_differ
+  end
+end

data/vendor/rspec/spec/spec/expectations/handler_spec.rb

@@ -0,0 +1,206 @@
+require 'spec_helper'
+
+module ExampleExpectations
+  
+  class ArbitraryMatcher
+    def initialize(*args, &block)
+      if args.last.is_a? Hash
+        @expected = args.last[:expected]
+      end
+      @expected = block.call if block
+      @block = block
+    end
+    
+    def matches?(target)
+      @target = target
+      return @expected == target
+    end
+    
+    def with(new_value)
+      @expected = new_value
+      self
+    end
+    
+    def failure_message
+      "expected #{@expected}, got #{@target}"
+    end
+    
+    def negative_failure_message
+      "expected not #{@expected}, got #{@target}"
+    end
+  end
+  
+  class PositiveOnlyMatcher < ArbitraryMatcher
+    undef negative_failure_message rescue nil
+  end
+  
+  def arbitrary_matcher(*args, &block)
+    ArbitraryMatcher.new(*args, &block)
+  end
+  
+  def positive_only_matcher(*args, &block)
+    PositiveOnlyMatcher.new(*args, &block)
+  end
+  
+end
+
+module Spec
+  module Expectations
+    describe PositiveExpectationHandler do
+      describe "#handle_matcher" do
+        it "asks the matcher if it matches" do
+          matcher = mock("matcher")
+          actual = Object.new
+          matcher.should_receive(:matches?).with(actual).and_return(true)
+          Spec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)
+        end
+      
+        it "returns the match value" do
+          matcher = mock("matcher")
+          actual = Object.new
+          matcher.should_receive(:matches?).with(actual).and_return(:this_value)
+          Spec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher).should == :this_value
+        end
+        
+        it "calls failure_message_for_should if the matcher implements it" do
+          matcher = mock("matcher", :failure_message_for_should => "message", :matches? => false)
+          actual = Object.new
+          
+          ::Spec::Expectations.should_receive(:fail_with).with("message")
+          
+          Spec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)
+        end
+        
+        it "calls fail if matcher.diffable?" do
+          matcher = mock("matcher",
+            :diffable? => true,
+            :failure_message_for_should => "message",
+            :matches? => false,
+            :expected => [1],
+            :actual   => 2
+          )
+          actual = Object.new
+          
+          ::Spec::Expectations.should_receive(:fail_with).with("message", 1, 2)
+          
+          Spec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)
+        end
+        
+        it "calls failure_message if the matcher does not implement failure_message_for_should" do
+          matcher = mock("matcher", :failure_message => "message", :matches? => false)
+          actual = Object.new
+          
+          ::Spec::Expectations.should_receive(:fail_with).with("message")
+          
+          Spec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)
+          
+        end
+        
+        it "appends the :or message in the options hash passed to should" do
+          matcher = mock("matcher", :failure_message_for_should => "message", :matches? => false)
+          actual = Object.new
+          
+          ::Spec::Expectations.should_receive(:fail_with).with("custom")
+          
+          Spec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher, "custom")
+        end
+      end
+    end
+
+    describe NegativeExpectationHandler do
+      describe "#handle_matcher" do
+        it "asks the matcher if it doesn't match when the matcher responds to #does_not_match?" do
+          matcher = mock("matcher", :does_not_match? => true, :negative_failure_message => nil)
+          actual = Object.new
+          matcher.should_receive(:does_not_match?).with(actual).and_return(true)
+          Spec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
+        end
+
+        it "asks the matcher if it matches when the matcher doesn't respond to #does_not_match?" do
+          matcher = mock("matcher")
+          actual = Object.new
+          matcher.stub!(:negative_failure_message)
+          matcher.should_receive(:matches?).with(actual).and_return(false)
+          Spec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
+        end
+      
+        it "returns the match value" do
+          matcher = mock("matcher")
+          actual = Object.new
+          matcher.should_receive(:matches?).with(actual).and_return(false)
+          matcher.stub!(:negative_failure_message).and_return("ignore")
+          Spec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher).should be_false
+        end
+
+        
+        it "calls failure_message_for_should_not if the matcher implements it" do
+          matcher = mock("matcher", :failure_message_for_should_not => "message", :matches? => true)
+          actual = Object.new
+          
+          ::Spec::Expectations.should_receive(:fail_with).with("message")
+          
+          Spec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
+          
+        end
+        
+        it "calls negative_failure_message if the matcher does not implement failure_message_for_should_not" do
+          matcher = mock("matcher", :negative_failure_message => "message", :matches? => true)
+          actual = Object.new
+          
+          ::Spec::Expectations.should_receive(:fail_with).with("message")
+          
+          Spec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
+          
+        end
+
+        
+        it "calls fail if matcher.diffable?" do
+          matcher = mock("matcher",
+            :diffable? => true,
+            :failure_message_for_should_not => "message",
+            :matches? => true,
+            :expected => [1],
+            :actual   => 2
+          )
+          actual = Object.new
+          
+          ::Spec::Expectations.should_receive(:fail_with).with("message", 1, 2)
+          
+          Spec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
+        end
+
+        it "appends the :or message in the options hash passed to should" do
+          matcher = mock("matcher", :failure_message_for_should_not => "message", :matches? => true)
+          actual = Object.new
+          
+          ::Spec::Expectations.should_receive(:fail_with).with("custom")
+          
+          Spec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher, "custom")
+        end
+
+      end
+    end
+    
+    describe PositiveExpectationHandler do
+      include ExampleExpectations
+      
+      it "should handle submitted args" do
+        5.should arbitrary_matcher(:expected => 5)
+        5.should arbitrary_matcher(:expected => "wrong").with(5)
+        lambda { 5.should arbitrary_matcher(:expected => 4) }.should fail_with("expected 4, got 5")
+        lambda { 5.should arbitrary_matcher(:expected => 5).with(4) }.should fail_with("expected 4, got 5")
+        5.should_not arbitrary_matcher(:expected => 4)
+        5.should_not arbitrary_matcher(:expected => 5).with(4)
+        lambda { 5.should_not arbitrary_matcher(:expected => 5) }.should fail_with("expected not 5, got 5")
+        lambda { 5.should_not arbitrary_matcher(:expected => 4).with(5) }.should fail_with("expected not 5, got 5")
+      end
+
+      it "should handle the submitted block" do
+        5.should arbitrary_matcher { 5 }
+        5.should arbitrary_matcher(:expected => 4) { 5 }
+        5.should arbitrary_matcher(:expected => 4).with(5) { 3 }
+      end
+  
+    end
+  end
+end

data/vendor/rspec/spec/spec/expectations/wrap_expectation_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module Spec
+  module Matchers
+    describe "wrap_expectation" do
+      
+      def stub_matcher
+        @_stub_matcher ||= simple_matcher do
+        end
+      end
+      
+      def failing_matcher
+        @_failing_matcher ||= simple_matcher do
+          1.should == 2
+        end
+      end
+      
+      it "should return true if there is no error" do
+        wrap_expectation stub_matcher do
+        end.should be_true
+      end
+      
+      it "should return false if there is an error" do
+        wrap_expectation failing_matcher do
+          raise "error"
+        end.should be_false
+      end
+    end
+  end
+end

data/vendor/rspec/spec/spec/interop/test/unit/resources/spec_that_fails.rb

@@ -0,0 +1,10 @@
+rspec_lib = File.dirname(__FILE__) + "/../../../../../../lib"
+$:.unshift rspec_lib unless $:.include?(rspec_lib)
+require 'spec/autorun'
+require 'spec/test/unit'
+
+describe "example group with failures" do
+  it "should fail" do
+    false.should be_true
+  end
+end

data/vendor/rspec/spec/spec/interop/test/unit/resources/spec_that_passes.rb

@@ -0,0 +1,10 @@
+rspec_lib = File.dirname(__FILE__) + "/../../../../../../lib"
+$:.unshift rspec_lib unless $:.include?(rspec_lib)
+require 'spec/autorun'
+require 'spec/test/unit'
+
+describe "example group with passing examples" do
+  it "should pass" do
+    true.should be_true
+  end
+end

data/vendor/rspec/spec/spec/interop/test/unit/resources/spec_with_errors.rb

@@ -0,0 +1,10 @@
+rspec_lib = File.dirname(__FILE__) + "/../../../../../../lib"
+$:.unshift rspec_lib unless $:.include?(rspec_lib)
+require 'spec/autorun'
+require 'spec/test/unit'
+
+describe "example group with errors" do
+  it "should raise errors" do
+    raise "error raised in example group with errors"
+  end
+end

data/vendor/rspec/spec/spec/interop/test/unit/resources/spec_with_options_hash.rb

@@ -0,0 +1,13 @@
+rspec_lib = File.dirname(__FILE__) + "/../../../../../../lib"
+$:.unshift rspec_lib unless $:.include?(rspec_lib)
+require 'spec/autorun'
+require 'spec/test/unit'
+
+describe "options hash" do
+  describe "#options" do
+    it "should expose the options hash" do
+      group = describe("group", :this => 'hash') {}
+      group.options[:this].should == 'hash'
+    end
+  end
+end

data/vendor/rspec/spec/spec/interop/test/unit/resources/test_case_that_fails.rb

@@ -0,0 +1,10 @@
+rspec_lib = File.dirname(__FILE__) + "/../../../../../../lib"
+$:.unshift rspec_lib unless $:.include?(rspec_lib)
+require 'spec/autorun'
+require 'spec/test/unit'
+
+class TestCaseThatFails < Test::Unit::TestCase
+  def test_that_fails
+    false.should be_true
+  end
+end

data/vendor/rspec/spec/spec/interop/test/unit/resources/test_case_that_passes.rb

@@ -0,0 +1,10 @@
+rspec_lib = File.dirname(__FILE__) + "/../../../../../../lib"
+$:.unshift rspec_lib unless $:.include?(rspec_lib)
+require 'spec/autorun'
+require 'spec/test/unit'
+
+class TestCaseThatPasses < Test::Unit::TestCase
+  def test_that_passes
+    true.should be_true
+  end
+end