has_finder 0.1.3 → 0.1.4

data/spec/rails/vendor/plugins/rspec/spec/spec/dsl/predicate_matcher_spec.rb

@@ -1,21 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
-  module DSL
-    class Fish
-      def can_swim?(distance_in_yards)
-        distance_in_yards < 1000
-      end
-    end
-    
-    describe "predicate_matcher[method_on_object] = matcher_method" do
-      predicate_matchers[:swim] = :can_swim?
-      it "should match matcher_method if method_on_object returns true" do
-        swim(100).matches?(Fish.new).should be_true
-      end
-      it "should not match matcher_method if method_on_object returns false" do
-        swim(10000).matches?(Fish.new).should be_false
-      end
-    end
-  end
-end

data/spec/rails/vendor/plugins/rspec/spec/spec/dsl/shared_behaviour_spec.rb

@@ -1,228 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
-  module DSL
-    describe Behaviour, ", with :shared => true" do
-      
-      before(:each) do
-        @formatter = Spec::Mocks::Mock.new("formatter", :null_object => true)
-        @behaviour = behaviour_class.new("behaviour") {}
-      end
-
-      after(:each) do
-        @formatter.rspec_verify
-        @behaviour_class = nil
-        $shared_behaviours.clear unless $shared_behaviours.nil?
-      end
-
-      def behaviour_class
-        unless @behaviour_class
-          @behaviour_class = Behaviour.dup
-          # dup copies the class instance vars
-          @behaviour_class.instance_variable_set(:@shared_behaviours, nil)
-        end
-        @behaviour_class
-      end
-
-      def make_shared_behaviour(name, opts=nil, &block)
-        behaviour = behaviour_class.new(name, :shared => true, &block)
-        behaviour_class.add_shared_behaviour(behaviour)
-        behaviour
-      end
-      
-      def non_shared_behaviour()
-        @non_shared_behaviour ||= behaviour_class.new("behaviour") {}
-      end
-
-      it "should accept an optional options hash" do
-        lambda { behaviour_class.new("context") {} }.should_not raise_error(Exception)
-        lambda { behaviour_class.new("context", :shared => true) {} }.should_not raise_error(Exception)
-      end
-
-      it "should return all shared behaviours" do
-        b1 = make_shared_behaviour("b1", :shared => true) {}
-        b2 = make_shared_behaviour("b2", :shared => true) {}
-        
-        b1.should_not be(nil)
-        b2.should_not be(nil)
-        
-        behaviour_class.find_shared_behaviour("b1").should equal(b1)
-        behaviour_class.find_shared_behaviour("b2").should equal(b2)
-      end
-
-      it "should be shared when configured as shared" do
-        behaviour = make_shared_behaviour("behaviour") {}
-        behaviour.should be_shared
-      end
-
-      it "should not be shared when not configured as shared" do
-        non_shared_behaviour.should_not be_shared
-      end
-
-      it "should raise if run when shared" do
-        behaviour = make_shared_behaviour("context") {}
-        $example_ran = false
-        behaviour.it("test") {$example_ran = true}
-        lambda { behaviour.run(@formatter) }.should raise_error
-        $example_ran.should be_false
-      end
-
-      it "should contain examples when shared" do
-        shared_behaviour = make_shared_behaviour("shared behaviour") {}
-        shared_behaviour.it("shared example") {}
-        shared_behaviour.number_of_examples.should == 1
-      end
-
-      it "should complain when adding a second shared behaviour with the same description" do
-        describe "shared behaviour", :shared => true do
-        end
-        lambda do
-          describe "shared behaviour", :shared => true do
-          end
-        end.should raise_error(ArgumentError)
-      end
-
-      it "should NOT complain when adding the same shared behaviour instance again" do
-        shared_behaviour = behaviour_class.new("shared behaviour", :shared => true) {}
-        behaviour_class.add_shared_behaviour(shared_behaviour)
-        behaviour_class.add_shared_behaviour(shared_behaviour)
-      end
-
-      it "should NOT complain when adding the same shared behaviour again (i.e. file gets reloaded)" do
-        lambda do 
-          2.times do 
-            describe "shared behaviour which gets loaded twice", :shared => true do
-            end 
-          end
-        end.should_not raise_error(ArgumentError)
-      end
-        
-      it "should add examples to current behaviour when calling it_should_behave_like" do
-        shared_behaviour = make_shared_behaviour("shared behaviour") {}
-        shared_behaviour.it("shared example") {}
-        shared_behaviour.it("shared example 2") {}
-
-        @behaviour.it("example") {}
-        @behaviour.number_of_examples.should == 1
-        @behaviour.it_should_behave_like("shared behaviour")
-        @behaviour.number_of_examples.should == 3
-      end
-
-      it "should run shared examples" do
-        shared_example_ran = false
-        shared_behaviour = make_shared_behaviour("shared behaviour") {}
-        shared_behaviour.it("shared example") { shared_example_ran = true }
-
-        example_ran = false
-
-        @behaviour.it_should_behave_like("shared behaviour")
-        @behaviour.it("example") {example_ran = true}
-        @behaviour.run(@formatter)
-        example_ran.should be_true
-        shared_example_ran.should be_true
-      end
-
-      it "should run setup and teardown from shared behaviour" do
-        shared_setup_ran = false
-        shared_teardown_ran = false
-        shared_behaviour = make_shared_behaviour("shared behaviour") {}
-        shared_behaviour.before { shared_setup_ran = true }
-        shared_behaviour.after { shared_teardown_ran = true }
-        shared_behaviour.it("shared example") { shared_example_ran = true }
-
-        example_ran = false
-
-        @behaviour.it_should_behave_like("shared behaviour")
-        @behaviour.it("example") {example_ran = true}
-        @behaviour.run(@formatter)
-        example_ran.should be_true
-        shared_setup_ran.should be_true
-        shared_teardown_ran.should be_true
-      end
-
-      it "should run before(:all) and after(:all) only once from shared behaviour" do
-        shared_before_all_run_count = 0
-        shared_after_all_run_count = 0
-        shared_behaviour = make_shared_behaviour("shared behaviour") {}
-        shared_behaviour.before(:all) { shared_before_all_run_count += 1}
-        shared_behaviour.after(:all) { shared_after_all_run_count += 1}
-        shared_behaviour.it("shared example") { shared_example_ran = true }
-
-        example_ran = false
-
-        @behaviour.it_should_behave_like("shared behaviour")
-        @behaviour.it("example") {example_ran = true}
-        @behaviour.run(@formatter)
-        example_ran.should be_true
-        shared_before_all_run_count.should == 1
-        shared_after_all_run_count.should == 1
-      end
-
-      it "should include modules, included into shared behaviour, into current behaviour" do
-        @formatter.should_receive(:add_behaviour).with(any_args)
-        @formatter.should_receive(:example_finished).twice.with(any_args)
-
-        shared_behaviour = make_shared_behaviour("shared behaviour") {}
-        shared_behaviour.it("shared example") { shared_example_ran = true }
-
-        mod1_method_called = false
-        mod1 = Module.new do
-          define_method :mod1_method do
-            mod1_method_called = true
-          end
-        end
-
-        mod2_method_called = false
-        mod2 = Module.new do
-          define_method :mod2_method do
-            mod2_method_called = true
-          end
-        end
-
-        shared_behaviour.include mod2
-
-        @behaviour.it_should_behave_like("shared behaviour")
-        @behaviour.include mod1
-
-        @behaviour.it("test") do
-          mod1_method
-          mod2_method
-        end
-        @behaviour.run(@formatter)
-        mod1_method_called.should be_true
-        mod2_method_called.should be_true
-      end
-      
-      it "should make methods defined in the shared behaviour available in consuming behaviour" do
-        shared_behaviour = make_shared_behaviour("shared behaviour xyz") do
-          def a_shared_helper_method
-            "this got defined in a shared behaviour"
-          end
-        end
-        @behaviour.it_should_behave_like("shared behaviour xyz")
-        success = false
-        @behaviour.it("should access a_shared_helper_method") do
-          a_shared_helper_method
-          success = true
-        end
-        @behaviour.run(@formatter)
-        success.should be_true
-      end
-
-      it "should error if told to inherit from a class" do
-        shared_behaviour = make_shared_behaviour("shared behaviour") {}
-        shared_behaviour.it("shared example") { shared_example_ran = true }
-        lambda { shared_behaviour.inherit Object }.should raise_error(ArgumentError)
-      end
-      
-      it "should raise when named shared behaviour can not be found" do
-        begin
-          @behaviour.it_should_behave_like("non-existent shared behaviour")
-          violated
-        rescue => e
-          e.message.should == "Shared Behaviour 'non-existent shared behaviour' can not be found"
-        end
-      end
-    end
-  end
-end

data/spec/rails/vendor/plugins/rspec/spec/spec/expectations/differs/default_spec.rb

@@ -1,107 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper.rb'
-require File.dirname(__FILE__) + '/../../../../lib/spec/expectations/differs/default'
-
-module Spec
-  module Fixtures
-    class Animal
-      def initialize(name,species)
-        @name,@species = name,species
-      end
-
-      def inspect
-        <<-EOA
-<Animal
-  name=#{@name},
-  species=#{@species}
->
-        EOA
-      end
-    end
-  end
-end
-
-describe "Diff" do
-  before(:each) do
-    @differ = Spec::Expectations::Differs::Default.new
-  end
-
-  it "should output unified diff of two strings" do
-    expected="foo\nbar\nzap\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nline\n"
-    actual="foo\nzap\nbar\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nanother\nline\n"
-    expected_diff="\n\n@@ -1,6 +1,6 @@\n foo\n-bar\n zap\n+bar\n this\n is\n soo\n@@ -9,5 +9,6 @@\n equal\n insert\n a\n+another\n line\n"
-    diff = @differ.diff_as_string(expected, actual)
-    diff.should eql(expected_diff)
-  end
-
-  it "should output unified diff message of two arrays" do
-    expected = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'charlie', :width, 'quite wide' ]
-    actual   = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'tango'  , :width, 'very wide'  ]
-
-    expected_diff = <<'EOD'
-
-
-@@ -5,7 +5,7 @@
-  :metasyntactic,
-  "variable",
-  :delta,
-- "charlie",
-+ "tango",
-  :width,
-- "quite wide"]
-+ "very wide"]
-EOD
-
-
-    diff = @differ.diff_as_object(expected,actual)
-    diff.should == expected_diff
-  end
-
-  it "should output unified diff message of two objects" do
-    expected = Spec::Fixtures::Animal.new "bob", "giraffe"
-    actual   = Spec::Fixtures::Animal.new "bob", "tortoise"
-
-    expected_diff = <<'EOD'
-
-@@ -1,5 +1,5 @@
- <Animal
-   name=bob,
--  species=giraffe
-+  species=tortoise
- >
-EOD
-
-    diff = @differ.diff_as_object(expected,actual)
-    diff.should == expected_diff
-  end
-
-end
-
-
-describe "Diff in context format" do
-  before(:each) do
-    @differ = Spec::Expectations::Differs::Default.new(:context)
-  end
-
-  it "should output unified diff message of two objects" do
-    expected = Spec::Fixtures::Animal.new "bob", "giraffe"
-    actual   = Spec::Fixtures::Animal.new "bob", "tortoise"
-
-    expected_diff = <<'EOD'
-
-***************
-*** 1,5 ****
-  <Animal
-    name=bob,
-!   species=giraffe
-  >
---- 1,5 ----
-  <Animal
-    name=bob,
-!   species=tortoise
-  >
-EOD
-
-    diff = @differ.diff_as_object(expected,actual)
-    diff.should == expected_diff
-  end
-end

data/spec/rails/vendor/plugins/rspec/spec/spec/expectations/extensions/object_spec.rb

@@ -1,46 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper.rb'
-
-describe "Object#should" do
-  before(:each) do
-    @target = "target"
-    @matcher = mock("matcher")
-    @matcher.stub!(:matches?).and_return(true)
-    @matcher.stub!(:failure_message)
-  end
-  
-  it "should accept and interact with a matcher" do
-    @matcher.should_receive(:matches?).with(@target).and_return(true)
-    
-    @target.should @matcher
-  end
-  
-  it "should ask for a failure_message when matches? returns false" do
-    @matcher.should_receive(:matches?).with(@target).and_return(false)
-    @matcher.should_receive(:failure_message).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 "should accept and interact with a matcher" do
-    @matcher.should_receive(:matches?).with(@target).and_return(false)
-    @matcher.stub!(:negative_failure_message)
-    
-    @target.should_not @matcher
-  end
-  
-  it "should ask for a negative_failure_message when matches? returns true" do
-    @matcher.should_receive(:matches?).with(@target).and_return(true)
-    @matcher.should_receive(:negative_failure_message).and_return("the negative failure message")
-    lambda {
-      @target.should_not @matcher
-    }.should fail_with("the negative failure message")
-  end
-end

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

@@ -1,71 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-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
-  
-  it "should handle an Array" do
-    lambda {
-      Spec::Expectations.fail_with ["the message","expected","actual"]
-    }.should fail_with("the message")
-  end
-
-  after(:each) do
-    Spec::Expectations.differ = @old_differ
-  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\nDiff: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\nDiff: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)
-    lambda {
-      Spec::Expectations.fail_with "the message", lambda {}, lambda {}
-    }.should fail_with("the message")
-  end
-  
-  it "should call differ if expected/actual are presented in an Array with message" do
-    @differ.should_receive(:diff_as_string).with("actual","expected").and_return("diff")
-    lambda {
-      Spec::Expectations.fail_with(["the message", "expected", "actual"])
-    }.should fail_with(/the message\nDiff:diff/)
-  end
-  
-  after(:each) do
-    Spec::Expectations.differ = @old_differ
-  end
-end