active-fedora 5.1.0 → 5.2.0

data/spec/unit/file_configurator_spec.rb

@@ -13,7 +13,7 @@ describe ActiveFedora::FileConfigurator do
 
   describe "#initialize" do
     it "should trigger configuration reset (to empty defaults)" do
-      ActiveFedora::FileConfigurator.any_instance.expects(:reset!)
+      ActiveFedora::FileConfigurator.any_instance.should_receive(:reset!)
       ActiveFedora::FileConfigurator.new
     end 
   end
@@ -32,7 +32,7 @@ describe ActiveFedora::FileConfigurator do
       subject.reset!
     end
     it "should trigger configuration to load" do
-      subject.expects(:load_fedora_config).at_least_once
+      subject.should_receive(:load_fedora_config)
       subject.fedora_config
     end 
   end
@@ -41,7 +41,7 @@ describe ActiveFedora::FileConfigurator do
       subject.reset!
     end
     it "should trigger configuration to load" do
-      subject.expects(:load_solr_config).at_least_once
+      subject.should_receive(:load_solr_config)
       subject.solr_config
     end 
   end
@@ -63,55 +63,55 @@ describe ActiveFedora::FileConfigurator do
     
     describe "get_config_path(:fedora)" do
       it "should use the config_options[:config_path] if it exists" do
-        subject.expects(:config_options).at_least_once.returns({:fedora_config_path => "/path/to/fedora.yml"})
-        File.expects(:file?).with("/path/to/fedora.yml").returns(true)
+        subject.should_receive(:config_options).and_return({:fedora_config_path => "/path/to/fedora.yml"})
+        File.should_receive(:file?).with("/path/to/fedora.yml").and_return(true)
         subject.get_config_path(:fedora).should eql("/path/to/fedora.yml")
       end
 
       it "should look in Rails.root/config/fedora.yml if it exists and no fedora_config_path passed in" do
-        subject.expects(:config_options).at_least_once.returns({})
+        subject.should_receive(:config_options).and_return({})
         stub_rails(:root => "/rails/root")
-        File.expects(:file?).with("/rails/root/config/fedora.yml").returns(true)
+        File.should_receive(:file?).with("/rails/root/config/fedora.yml").and_return(true)
         subject.get_config_path(:fedora).should eql("/rails/root/config/fedora.yml")
         unstub_rails
       end
 
       it "should look in ./config/fedora.yml if neither rails.root nor :fedora_config_path are set" do
-        subject.expects(:config_options).at_least_once.returns({})
-        Dir.expects(:getwd).at_least_once.returns("/current/working/directory")
-        File.expects(:file?).with("/current/working/directory/config/fedora.yml").returns(true)
+        subject.should_receive(:config_options).and_return({})
+        Dir.stub(:getwd => "/current/working/directory")
+        File.should_receive(:file?).with("/current/working/directory/config/fedora.yml").and_return(true)
         subject.get_config_path(:fedora).should eql("/current/working/directory/config/fedora.yml")
       end
 
       it "should return default fedora.yml that ships with active-fedora if none of the above" do
-        subject.expects(:config_options).at_least_once.returns({})
-        Dir.expects(:getwd).at_least_once.returns("/current/working/directory")
-        File.expects(:file?).with("/current/working/directory/config/fedora.yml").returns(false)
-        File.expects(:file?).with(File.expand_path(File.join(File.dirname("__FILE__"),'config','fedora.yml'))).returns(true)
-        logger.expects(:warn).with("Using the default fedora.yml that comes with active-fedora.  If you want to override this, pass the path to fedora.yml to ActiveFedora - ie. ActiveFedora.init(:fedora_config_path => '/path/to/fedora.yml') - or set Rails.root and put fedora.yml into \#{Rails.root}/config.")
+        subject.should_receive(:config_options).and_return({})
+        Dir.should_receive(:getwd).and_return("/current/working/directory")
+        File.should_receive(:file?).with("/current/working/directory/config/fedora.yml").and_return(false)
+        File.should_receive(:file?).with(File.expand_path(File.join(File.dirname("__FILE__"),'config','fedora.yml'))).and_return(true)
+        logger.should_receive(:warn).with("Using the default fedora.yml that comes with active-fedora.  If you want to override this, pass the path to fedora.yml to ActiveFedora - ie. ActiveFedora.init(:fedora_config_path => '/path/to/fedora.yml') - or set Rails.root and put fedora.yml into \#{Rails.root}/config.")
         subject.get_config_path(:fedora).should eql(File.expand_path(File.join(File.dirname("__FILE__"),'config','fedora.yml')))
       end
     end
 
     describe "get_config_path(:solr)" do
       it "should return the solr_config_path if set in config_options hash" do
-        subject.expects(:config_options).at_least_once.returns({:solr_config_path => "/path/to/solr.yml"})
-        File.expects(:file?).with("/path/to/solr.yml").returns(true)
+        subject.stub(:config_options => {:solr_config_path => "/path/to/solr.yml"})
+        File.should_receive(:file?).with("/path/to/solr.yml").and_return(true)
         subject.get_config_path(:solr).should eql("/path/to/solr.yml")
       end
       
       it "should return the solr.yml file in the same directory as the fedora.yml if it exists" do
-        subject.expects(:path).returns("/path/to/fedora/config/fedora.yml")
-        File.expects(:file?).with("/path/to/fedora/config/solr.yml").returns(true)
+        subject.should_receive(:path).and_return("/path/to/fedora/config/fedora.yml")
+        File.should_receive(:file?).with("/path/to/fedora/config/solr.yml").and_return(true)
         subject.get_config_path(:solr).should eql("/path/to/fedora/config/solr.yml")
       end
       
       context "no solr.yml in same directory as fedora.yml and fedora.yml does not contain solr url" do
 
         before :each do
-          subject.expects(:config_options).at_least_once.returns({})
-          subject.expects(:path).returns("/path/to/fedora/config/fedora.yml")
-          File.expects(:file?).with("/path/to/fedora/config/solr.yml").returns(false)
+          subject.stub(:config_options => {})
+          subject.should_receive(:path).and_return("/path/to/fedora/config/fedora.yml")
+          File.should_receive(:file?).with("/path/to/fedora/config/solr.yml").and_return(false)
         end
         after :each do
           unstub_rails
@@ -119,21 +119,21 @@ describe ActiveFedora::FileConfigurator do
 
         it "should not raise an error if there is not a solr.yml in the same directory as the fedora.yml and the fedora.yml has a solr url defined and look in rails.root" do
           stub_rails(:root=>"/rails/root")
-          File.expects(:file?).with("/rails/root/config/solr.yml").returns(true)
+          File.should_receive(:file?).with("/rails/root/config/solr.yml").and_return(true)
           subject.get_config_path(:solr).should eql("/rails/root/config/solr.yml")
         end
 
         it "should look in ./config/solr.yml if no rails root" do
-          Dir.expects(:getwd).at_least_once.returns("/current/working/directory")
-          File.expects(:file?).with("/current/working/directory/config/solr.yml").returns(true)
+          Dir.stub(:getwd => "/current/working/directory")
+          File.should_receive(:file?).with("/current/working/directory/config/solr.yml").and_return(true)
           subject.get_config_path(:solr).should eql("/current/working/directory/config/solr.yml")
         end
 
         it "should return the default solr.yml file that ships with active-fedora if no other option is set" do
-          Dir.expects(:getwd).at_least_once.returns("/current/working/directory")
-          File.expects(:file?).with("/current/working/directory/config/solr.yml").returns(false)
-          File.expects(:file?).with(File.expand_path(File.join(File.dirname("__FILE__"),'config','solr.yml'))).returns(true)
-          logger.expects(:warn).with("Using the default solr.yml that comes with active-fedora.  If you want to override this, pass the path to solr.yml to ActiveFedora - ie. ActiveFedora.init(:solr_config_path => '/path/to/solr.yml') - or set Rails.root and put solr.yml into \#{Rails.root}/config.")
+          Dir.stub(:getwd => "/current/working/directory")
+          File.should_receive(:file?).with("/current/working/directory/config/solr.yml").and_return(false)
+          File.should_receive(:file?).with(File.expand_path(File.join(File.dirname("__FILE__"),'config','solr.yml'))).and_return(true)
+          logger.should_receive(:warn).with("Using the default solr.yml that comes with active-fedora.  If you want to override this, pass the path to solr.yml to ActiveFedora - ie. ActiveFedora.init(:solr_config_path => '/path/to/solr.yml') - or set Rails.root and put solr.yml into \#{Rails.root}/config.")
           subject.get_config_path(:solr).should eql(File.expand_path(File.join(File.dirname("__FILE__"),'config','solr.yml')))
         end
       end
@@ -145,25 +145,25 @@ describe ActiveFedora::FileConfigurator do
         subject.reset!
       end
       it "should load the file specified in fedora_config_path" do
-        subject.expects(:get_config_path).with(:fedora).returns("/path/to/fedora.yml")
-        subject.expects(:load_solr_config)
-        IO.expects(:read).with("/path/to/fedora.yml").returns("development:\n url: http://devfedora:8983\ntest:\n  url: http://myfedora:8080")
+        subject.should_receive(:get_config_path).with(:fedora).and_return("/path/to/fedora.yml")
+        subject.should_receive(:load_solr_config)
+        IO.should_receive(:read).with("/path/to/fedora.yml").and_return("development:\n url: http://devfedora:8983\ntest:\n  url: http://myfedora:8080")
         subject.load_fedora_config.should == {:url=>"http://myfedora:8080"}
         subject.fedora_config.should == {:url=>"http://myfedora:8080"}
       end
 
       it "should allow sharding" do
-        subject.expects(:get_config_path).with(:fedora).returns("/path/to/fedora.yml")
-        subject.expects(:load_solr_config)
-        IO.expects(:read).with("/path/to/fedora.yml").returns("development:\n  url: http://devfedora:8983\ntest:\n- url: http://myfedora:8080\n- url: http://myfedora:8081")
+        subject.should_receive(:get_config_path).with(:fedora).and_return("/path/to/fedora.yml")
+        subject.should_receive(:load_solr_config)
+        IO.should_receive(:read).with("/path/to/fedora.yml").and_return("development:\n  url: http://devfedora:8983\ntest:\n- url: http://myfedora:8080\n- url: http://myfedora:8081")
         subject.load_fedora_config.should == [{:url=>"http://myfedora:8080"}, {:url=>"http://myfedora:8081"}]
         subject.fedora_config.should == [{:url=>"http://myfedora:8080"}, {:url=>"http://myfedora:8081"}]
       end
 
       it "should parse the file using ERb" do
-        subject.expects(:get_config_path).with(:fedora).returns("/path/to/fedora.yml")
-        subject.expects(:load_solr_config)
-        IO.expects(:read).with("/path/to/fedora.yml").returns("development:\n  url: http://devfedora:<%= 8983 %>\ntest:\n  url: http://myfedora:<%= 8081 %>")
+        subject.should_receive(:get_config_path).with(:fedora).and_return("/path/to/fedora.yml")
+        subject.should_receive(:load_solr_config)
+        IO.should_receive(:read).with("/path/to/fedora.yml").and_return("development:\n  url: http://devfedora:<%= 8983 %>\ntest:\n  url: http://myfedora:<%= 8081 %>")
         subject.load_fedora_config.should == {:url=>"http://myfedora:8081"}
         subject.fedora_config.should == {:url=>"http://myfedora:8081"}
       end
@@ -174,17 +174,17 @@ describe ActiveFedora::FileConfigurator do
         subject.reset!
       end
       it "should load the file specified in solr_config_path" do
-        subject.expects(:get_config_path).with(:solr).returns("/path/to/solr.yml")
-        subject.expects(:load_fedora_config)
-        IO.expects(:read).with("/path/to/solr.yml").returns("development:\n  default:\n    url: http://devsolr:8983\ntest:\n  default:\n    url: http://mysolr:8080")
+        subject.should_receive(:get_config_path).with(:solr).and_return("/path/to/solr.yml")
+        subject.should_receive(:load_fedora_config)
+        IO.should_receive(:read).with("/path/to/solr.yml").and_return("development:\n  default:\n    url: http://devsolr:8983\ntest:\n  default:\n    url: http://mysolr:8080")
         subject.load_solr_config.should == {:url=>"http://mysolr:8080"}
         subject.solr_config.should == {:url=>"http://mysolr:8080"}
       end
 
       it "should parse the file using ERb" do
-        subject.expects(:get_config_path).with(:solr).returns("/path/to/solr.yml")
-        subject.expects(:load_fedora_config)
-        IO.expects(:read).with("/path/to/solr.yml").returns("development:\n  default:\n    url: http://devsolr:<%= 8983 %>\ntest:\n  default:\n    url: http://mysolr:<%= 8081 %>")
+        subject.should_receive(:get_config_path).with(:solr).and_return("/path/to/solr.yml")
+        subject.should_receive(:load_fedora_config)
+        IO.should_receive(:read).with("/path/to/solr.yml").and_return("development:\n  default:\n    url: http://devsolr:<%= 8983 %>\ntest:\n  default:\n    url: http://mysolr:<%= 8081 %>")
         subject.load_solr_config.should == {:url=>"http://mysolr:8081"}
         subject.solr_config.should == {:url=>"http://mysolr:8081"}
       end
@@ -206,7 +206,7 @@ describe ActiveFedora::FileConfigurator do
           subject.instance_variable_set :@config_loaded, true
         end
         it "should load the fedora and solr configs" do
-          subject.expects(:load_config).never
+          subject.should_receive(:load_config).never
           subject.config_loaded?.should be_true
           subject.load_configs
           subject.config_loaded?.should be_true
@@ -216,13 +216,13 @@ describe ActiveFedora::FileConfigurator do
 
     describe "check_fedora_path_for_solr" do
       it "should find the solr.yml file and return it if it exists" do
-        subject.expects(:path).returns("/path/to/fedora/fedora.yml")
-        File.expects(:file?).with("/path/to/fedora/solr.yml").returns(true)
+        subject.should_receive(:path).and_return("/path/to/fedora/fedora.yml")
+        File.should_receive(:file?).with("/path/to/fedora/solr.yml").and_return(true)
         subject.check_fedora_path_for_solr.should == "/path/to/fedora/solr.yml"
       end
       it "should return nil if the solr.yml file is not there" do
-        subject.expects(:path).returns("/path/to/fedora/fedora.yml")
-        File.expects(:file?).with("/path/to/fedora/solr.yml").returns(false)
+        subject.should_receive(:path).and_return("/path/to/fedora/fedora.yml")
+        File.should_receive(:file?).with("/path/to/fedora/solr.yml").and_return(false)
         subject.check_fedora_path_for_solr.should be_nil
       end
     end
@@ -246,14 +246,14 @@ describe ActiveFedora::FileConfigurator do
       subject.should respond_to(:solr_config_path)
     end
     it "loads a config from the current working directory as a second choice" do
-      Dir.stubs(:getwd).returns(@fake_rails_root)
+      Dir.stub(:getwd).and_return(@fake_rails_root)
       subject.init
       subject.get_config_path(:fedora).should eql("#{@fake_rails_root}/config/fedora.yml")
       subject.solr_config_path.should eql("#{@fake_rails_root}/config/solr.yml")
     end
     it "loads the config that ships with this gem as a last choice" do
-      Dir.stubs(:getwd).returns("/fake/path")
-      logger.expects(:warn).with("Using the default fedora.yml that comes with active-fedora.  If you want to override this, pass the path to fedora.yml to ActiveFedora - ie. ActiveFedora.init(:fedora_config_path => '/path/to/fedora.yml') - or set Rails.root and put fedora.yml into \#{Rails.root}/config.").times(3)
+      Dir.stub(:getwd).and_return("/fake/path")
+      logger.should_receive(:warn).with("Using the default fedora.yml that comes with active-fedora.  If you want to override this, pass the path to fedora.yml to ActiveFedora - ie. ActiveFedora.init(:fedora_config_path => '/path/to/fedora.yml') - or set Rails.root and put fedora.yml into \#{Rails.root}/config.").exactly(3).times
       subject.init
       expected_config = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "config"))
       subject.get_config_path(:fedora).should eql(expected_config+'/fedora.yml')
@@ -298,14 +298,14 @@ describe ActiveFedora::FileConfigurator do
     end
 
     it "should return the path to the default config/predicate_mappings.yml if specified config file not found" do
-      File.expects(:exist?).with("/path/to/predicate_mappings.yml").returns(false)
-      File.expects(:exist?).with(default_predicate_mapping_file).returns(true)
+      File.should_receive(:exist?).with("/path/to/predicate_mappings.yml").and_return(false)
+      File.should_receive(:exist?).with(default_predicate_mapping_file).and_return(true)
       subject.send(:build_predicate_config_path,"/path/to").should == default_predicate_mapping_file
     end
 
     it "should return the path to the specified config_path if it exists" do
-      File.expects(:exist?).with("/path/to/predicate_mappings.yml").returns(true)
-      subject.expects(:valid_predicate_mapping?).returns(true)
+      File.should_receive(:exist?).with("/path/to/predicate_mappings.yml").and_return(true)
+      subject.should_receive(:valid_predicate_mapping?).and_return(true)
       subject.send(:build_predicate_config_path,"/path/to").should == "/path/to/predicate_mappings.yml"
     end    
   end

data/spec/unit/has_many_collection_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe ActiveFedora::Associations::HasManyAssociation do
   it "should be able to replace the collection" do
     @owner = stub(:new_record? => false, :to_ary => nil, :internal_uri => 'info:fedora/changeme:99')
-    @reflection = stub(:klass => Mocha::Mock, :options=>{:property=>'predicate'})
+    @reflection = stub(:klass => mock.class, :options=>{:property=>'predicate'})
     #ac = ActiveFedora::Associations::AssociationCollection.new(@owner, @reflection)
     ac = ActiveFedora::Associations::HasManyAssociation.new(@owner, @reflection)
     @target = [stub(:to_ary => nil, :new_record? => false, :remove_relationship=>true), stub(:to_ary => nil, :new_record? => false, :remove_relationship=>true), stub(:to_ary => nil, :new_record? => false, :remove_relationship=>true)]

data/spec/unit/model_spec.rb

@@ -36,57 +36,54 @@ describe ActiveFedora::Model do
       describe ":all" do
         describe "called on a concrete class" do
           it "should query solr for all objects with :has_model_s of self.class" do
-            SpecModel::Basic.expects(:find_one).with("changeme:30", nil).returns("Fake Object1")
-            SpecModel::Basic.expects(:find_one).with("changeme:22", nil).returns("Fake Object2")
-            mock_docs = mock('docs')
-            mock_docs.expects(:each).multiple_yields([{"id" => "changeme:30"}],[{"id" => "changeme:22"}])
-            mock_docs.expects(:has_next?).returns(false)
-            ActiveFedora::SolrService.instance.conn.expects(:paginate).with(1, 1000, 'select', :params=>{:q=>@model_query, :qt => 'standard', :sort => ['system_create_dt asc'], :fl=> 'id', }).returns('response'=>{'docs'=>mock_docs})
+            SpecModel::Basic.should_receive(:find_one).with("changeme:30", nil).and_return("Fake Object1")
+            SpecModel::Basic.should_receive(:find_one).with("changeme:22", nil).and_return("Fake Object2")
+            mock_docs = [{"id" => "changeme:30"}, {"id" => "changeme:22"}]
+            mock_docs.should_receive(:has_next?).and_return(false)
+            ActiveFedora::SolrService.instance.conn.should_receive(:paginate).with(1, 1000, 'select', :params=>{:q=>@model_query, :qt => 'standard', :sort => ['system_create_dt asc'], :fl=> 'id', }).and_return('response'=>{'docs'=>mock_docs})
             SpecModel::Basic.find(:all).should == ["Fake Object1", "Fake Object2"]
           end
         end
         describe "called without a specific class" do
           it "should specify a q parameter" do
-            ActiveFedora::Base.expects(:find_one).with("changeme:30", nil).returns("Fake Object1")
-            ActiveFedora::Base.expects(:find_one).with("changeme:22", nil).returns("Fake Object2")
-            mock_docs = mock('docs')
-            mock_docs.expects(:each).multiple_yields([{"id" => "changeme:30"}],[{"id" => "changeme:22"}])
-            mock_docs.expects(:has_next?).returns(false)
-            ActiveFedora::SolrService.instance.conn.expects(:paginate).with(1, 1000, 'select', :params=>{:q=>'*:*', :qt => 'standard', :sort => ['system_create_dt asc'], :fl=> 'id', }).returns('response'=>{'docs'=>mock_docs})
+            ActiveFedora::Base.should_receive(:find_one).with("changeme:30", nil).and_return("Fake Object1")
+            ActiveFedora::Base.should_receive(:find_one).with("changeme:22", nil).and_return("Fake Object2")
+            mock_docs = [{"id" => "changeme:30"},{"id" => "changeme:22"}]
+            mock_docs.should_receive(:has_next?).and_return(false)
+            ActiveFedora::SolrService.instance.conn.should_receive(:paginate).with(1, 1000, 'select', :params=>{:q=>'*:*', :qt => 'standard', :sort => ['system_create_dt asc'], :fl=> 'id', }).and_return('response'=>{'docs'=>mock_docs})
             ActiveFedora::Base.find(:all).should == ["Fake Object1", "Fake Object2"]
           end
         end
       end
       describe "and a pid is specified" do
         it "should use SpecModel::Basic.allocate.init_with to instantiate an object" do
-          SpecModel::Basic.any_instance.expects(:init_with).returns(SpecModel::Basic.new)
-          ActiveFedora::DigitalObject.expects(:find).returns(stub("inner obj", :'new?'=>false))
+          SpecModel::Basic.any_instance.should_receive(:init_with).and_return(SpecModel::Basic.new)
+          ActiveFedora::DigitalObject.should_receive(:find).and_return(stub("inner obj", :'new?'=>false))
           SpecModel::Basic.find("_PID_").should be_a SpecModel::Basic
         end
         it "should raise an exception if it is not found" do
-          Rubydora::Repository.any_instance.expects(:object).raises(RestClient::ResourceNotFound)
-          SpecModel::Basic.expects(:connection_for_pid).with("_PID_")
+          Rubydora::Repository.any_instance.should_receive(:object).and_raise(RestClient::ResourceNotFound)
+          SpecModel::Basic.should_receive(:connection_for_pid).with("_PID_")
           lambda {SpecModel::Basic.find("_PID_")}.should raise_error ActiveFedora::ObjectNotFoundError
         end
       end
     end
     describe "with :cast" do
       it "should use SpecModel::Basic.allocate.init_with to instantiate an object" do
-        SpecModel::Basic.any_instance.expects(:init_with).returns(mock("Model", :adapt_to_cmodel=>SpecModel::Basic.new ))
-        ActiveFedora::DigitalObject.expects(:find).returns(stub("inner obj", :'new?'=>false))
+        SpecModel::Basic.any_instance.should_receive(:init_with).and_return(mock("Model", :adapt_to_cmodel=>SpecModel::Basic.new ))
+        ActiveFedora::DigitalObject.should_receive(:find).and_return(stub("inner obj", :'new?'=>false))
         SpecModel::Basic.find("_PID_", :cast=>true)
       end
     end
 
     describe "with conditions" do
       it "should filter by the provided fields" do
-        SpecModel::Basic.expects(:find_one).with("changeme:30", nil).returns("Fake Object1")
-        SpecModel::Basic.expects(:find_one).with("changeme:22", nil).returns("Fake Object2")
+        SpecModel::Basic.should_receive(:find_one).with("changeme:30", nil).and_return("Fake Object1")
+        SpecModel::Basic.should_receive(:find_one).with("changeme:22", nil).and_return("Fake Object2")
 
-        mock_docs = mock('docs')
-        mock_docs.expects(:each).multiple_yields([{"id" => "changeme:30"}],[{"id" => "changeme:22"}])
-        mock_docs.expects(:has_next?).returns(false)
-        ActiveFedora::SolrService.instance.conn.expects(:paginate).with() { |page, rows, method, hash|
+        mock_docs = [{"id" => "changeme:30"},{"id" => "changeme:22"}]
+        mock_docs.should_receive(:has_next?).and_return(false)
+        ActiveFedora::SolrService.instance.conn.should_receive(:paginate).with() { |page, rows, method, hash|
             page == 1 &&
             rows == 1000 &&
             method == 'select' &&
@@ -97,7 +94,7 @@ describe ActiveFedora::Model do
             hash[:params][:q].split(" AND ").include?("foo:\"bar\"") &&
             hash[:params][:q].split(" AND ").include?("baz:\"quix\"") &&
             hash[:params][:q].split(" AND ").include?("baz:\"quack\"")
-        }.returns('response'=>{'docs'=>mock_docs})
+        }.and_return('response'=>{'docs'=>mock_docs})
         SpecModel::Basic.find({:foo=>'bar', :baz=>['quix','quack']}).should == ["Fake Object1", "Fake Object2"]
       end
     end
@@ -105,33 +102,31 @@ describe ActiveFedora::Model do
 
   describe '#all' do
     it "should pass everything through to .find" do
-      SpecModel::Basic.expects(:find).with(:all, {})
+      SpecModel::Basic.should_receive(:find).with(:all, {})
       SpecModel::Basic.all
     end
   end
 
   describe '#find_each' do
     it "should query solr for all objects with :active_fedora_model_s of self.class" do
-      mock_docs = mock('docs')
-      mock_docs.expects(:each).multiple_yields([{"id" => "changeme:30"}],[{"id" => "changeme:22"}])
-      mock_docs.expects(:has_next?).returns(false)
-      ActiveFedora::SolrService.instance.conn.expects(:paginate).with(1, 1000, 'select', :params=>{:q=>@model_query, :qt => 'standard', :sort => ['system_create_dt asc'], :fl=> 'id', }).returns('response'=>{'docs'=>mock_docs})
+      mock_docs = [{"id" => "changeme:30"},{"id" => "changeme:22"}]
+      mock_docs.should_receive(:has_next?).and_return(false)
+      ActiveFedora::SolrService.instance.conn.should_receive(:paginate).with(1, 1000, 'select', :params=>{:q=>@model_query, :qt => 'standard', :sort => ['system_create_dt asc'], :fl=> 'id', }).and_return('response'=>{'docs'=>mock_docs})
       
-      SpecModel::Basic.expects(:find_one).with("changeme:30", nil).returns(SpecModel::Basic.new(:pid=>'changeme:30'))
-      SpecModel::Basic.expects(:find_one).with("changeme:22", nil).returns(SpecModel::Basic.new(:pid=>'changeme:22'))
+      SpecModel::Basic.should_receive(:find_one).with("changeme:30", nil).and_return(SpecModel::Basic.new(:pid=>'changeme:30'))
+      SpecModel::Basic.should_receive(:find_one).with("changeme:22", nil).and_return(SpecModel::Basic.new(:pid=>'changeme:22'))
       yielded = mock("yielded method")
-      yielded.expects(:run).with { |obj| obj.class == SpecModel::Basic}.twice
+      yielded.should_receive(:run).with { |obj| obj.class == SpecModel::Basic}.twice
       SpecModel::Basic.find_each(){|obj| yielded.run(obj) }
     end
     describe "with conditions" do
       it "should filter by the provided fields" do
-        SpecModel::Basic.expects(:find_one).with("changeme:30", nil).returns(SpecModel::Basic.new(:pid=>'changeme:30'))
-        SpecModel::Basic.expects(:find_one).with("changeme:22", nil).returns(SpecModel::Basic.new(:pid=>'changeme:22'))
+        SpecModel::Basic.should_receive(:find_one).with("changeme:30", nil).and_return(SpecModel::Basic.new(:pid=>'changeme:30'))
+        SpecModel::Basic.should_receive(:find_one).with("changeme:22", nil).and_return(SpecModel::Basic.new(:pid=>'changeme:22'))
 
-        mock_docs = mock('docs')
-        mock_docs.expects(:each).multiple_yields([{"id" => "changeme:30"}],[{"id" => "changeme:22"}])
-        mock_docs.expects(:has_next?).returns(false)
-        ActiveFedora::SolrService.instance.conn.expects(:paginate).with() { |page, rows, method, hash|
+        mock_docs = [{"id" => "changeme:30"},{"id" => "changeme:22"}]
+        mock_docs.should_receive(:has_next?).and_return(false)
+        ActiveFedora::SolrService.instance.conn.should_receive(:paginate).with() { |page, rows, method, hash|
             page == 1 &&
             rows == 1000 &&
             method == 'select' &&
@@ -142,9 +137,9 @@ describe ActiveFedora::Model do
             hash[:params][:q].split(" AND ").include?("foo:\"bar\"") &&
             hash[:params][:q].split(" AND ").include?("baz:\"quix\"") &&
             hash[:params][:q].split(" AND ").include?("baz:\"quack\"")
-        }.returns('response'=>{'docs'=>mock_docs})
+        }.and_return('response'=>{'docs'=>mock_docs})
         yielded = mock("yielded method")
-        yielded.expects(:run).with { |obj| obj.class == SpecModel::Basic}.twice
+        yielded.should_receive(:run).with { |obj| obj.class == SpecModel::Basic}.twice
         SpecModel::Basic.find_each({:foo=>'bar', :baz=>['quix','quack']}){|obj| yielded.run(obj) }
       end
     end
@@ -154,8 +149,8 @@ describe ActiveFedora::Model do
     describe "with conditions hash" do
       it "should filter by the provided fields" do
         mock_docs = mock('docs')
-        mock_docs.expects(:has_next?).returns(false)
-        ActiveFedora::SolrService.instance.conn.expects(:paginate).with() { |page, rows, method, hash|
+        mock_docs.should_receive(:has_next?).and_return(false)
+        ActiveFedora::SolrService.instance.conn.should_receive(:paginate).with() { |page, rows, method, hash|
             page == 1 &&
             rows == 1002 &&
             method == 'select' &&
@@ -166,9 +161,9 @@ describe ActiveFedora::Model do
             hash[:params][:q].split(" AND ").include?("foo:\"bar\"") &&
             hash[:params][:q].split(" AND ").include?("baz:\"quix\"") &&
             hash[:params][:q].split(" AND ").include?("baz:\"quack\"")
-        }.returns('response'=>{'docs'=>mock_docs})
+        }.and_return('response'=>{'docs'=>mock_docs})
         yielded = mock("yielded method")
-        yielded.expects(:run).with(mock_docs)
+        yielded.should_receive(:run).with(mock_docs)
         SpecModel::Basic.find_in_batches({:foo=>'bar', :baz=>['quix','quack']}, {:batch_size=>1002, :fl=>'id'}){|group| yielded.run group }.should
       end
     end
@@ -178,18 +173,18 @@ describe ActiveFedora::Model do
     
     it "should return a count" do
       mock_result = {'response'=>{'numFound'=>7}}
-      ActiveFedora::SolrService.expects(:query).with(@model_query, :rows=>0, :raw=>true).returns(mock_result)
+      ActiveFedora::SolrService.should_receive(:query).with(@model_query, :rows=>0, :raw=>true).and_return(mock_result)
       SpecModel::Basic.count.should == 7
     end
     it "should allow conditions" do
       mock_result = {'response'=>{'numFound'=>7}}
-      ActiveFedora::SolrService.expects(:query).with("#{@model_query} AND foo:bar", :rows=>0, :raw=>true).returns(mock_result)
+      ActiveFedora::SolrService.should_receive(:query).with("#{@model_query} AND foo:bar", :rows=>0, :raw=>true).and_return(mock_result)
       SpecModel::Basic.count(:conditions=>'foo:bar').should == 7
     end
 
     it "should count without a class specified" do
       mock_result = {'response'=>{'numFound'=>7}}
-      ActiveFedora::SolrService.expects(:query).with("foo:bar", :rows=>0, :raw=>true).returns(mock_result)
+      ActiveFedora::SolrService.should_receive(:query).with("foo:bar", :rows=>0, :raw=>true).and_return(mock_result)
       ActiveFedora::Base.count(:conditions=>'foo:bar').should == 7
     end
   end
@@ -197,20 +192,20 @@ describe ActiveFedora::Model do
   describe '#find_with_conditions' do
     it "should make a query to solr and return the results" do
       mock_result = stub('Result')
-           ActiveFedora::SolrService.expects(:query).with() { |args|
+           ActiveFedora::SolrService.should_receive(:query).with() { |args|
             q = args.first if args.is_a? Array
             q ||= args
             q.split(" AND ").include?(@model_query) &&
             q.split(" AND ").include?("foo:\"bar\"") &&
             q.split(" AND ").include?("baz:\"quix\"") &&
             q.split(" AND ").include?("baz:\"quack\"")
-        }.returns(mock_result)
+        }.and_return(mock_result)
       SpecModel::Basic.find_with_conditions(:foo=>'bar', :baz=>['quix','quack']).should == mock_result
     end
 
     it "should escape quotes" do
       mock_result = stub('Result')
-           ActiveFedora::SolrService.expects(:query).with() { |args|
+           ActiveFedora::SolrService.should_receive(:query).with() { |args|
             q = args.first if args.is_a? Array
             q ||= args
             q.split(" AND ").include?(@model_query) &&
@@ -218,18 +213,18 @@ describe ActiveFedora::Model do
             q.split(" AND ").include?('foo:"9\\" Nails"') &&
             q.split(" AND ").include?('baz:"7\\" version"') &&
             q.split(" AND ").include?('baz:"quack"')
-        }.returns(mock_result)
+        }.and_return(mock_result)
       SpecModel::Basic.find_with_conditions(:foo=>'9" Nails', :baz=>['7" version','quack']).should == mock_result
     end
 
     it "shouldn't use the class if it's called on AF:Base " do
       mock_result = stub('Result')
-      ActiveFedora::SolrService.expects(:query).with('baz:"quack"', {:sort => ['system_create_dt asc']}).returns(mock_result)
+      ActiveFedora::SolrService.should_receive(:query).with('baz:"quack"', {:sort => ['system_create_dt asc']}).and_return(mock_result)
       ActiveFedora::Base.find_with_conditions(:baz=>'quack').should == mock_result
     end
     it "should use the query string if it's provided" do
       mock_result = stub('Result')
-      ActiveFedora::SolrService.expects(:query).with('chunky:monkey', {:sort => ['system_create_dt asc']}).returns(mock_result)
+      ActiveFedora::SolrService.should_receive(:query).with('chunky:monkey', {:sort => ['system_create_dt asc']}).and_return(mock_result)
       ActiveFedora::Base.find_with_conditions('chunky:monkey').should == mock_result
     end
   end
@@ -253,13 +248,13 @@ describe ActiveFedora::Model do
   
     context "with the namespace declared in the model" do
       before do
-        subject.stubs(:pid_namespace).returns("test-cModel")
+        subject.stub(:pid_namespace).and_return("test-cModel")
       end
       its(:to_class_uri) {should == 'info:fedora/test-cModel:SpecModel_CamelCased' }
     end
     context "with the suffix declared in the model" do
       before do
-        subject.stubs(:pid_suffix).returns("-TEST-SUFFIX")
+        subject.stub(:pid_suffix).and_return("-TEST-SUFFIX")
       end
       its(:to_class_uri) {should == 'info:fedora/afmodel:SpecModel_CamelCased-TEST-SUFFIX' }
     end