active-fedora 4.0.0.rc1 → 4.0.0.rc2

data/spec/integration/model_spec.rb

@@ -31,24 +31,27 @@ describe ActiveFedora::Model do
   end
   
   describe '#find' do
-    it "should return an array of instances of the calling Class" do
-      result = ModelIntegrationSpec::Basic.find(:all)
-      result.should be_instance_of(Array)
-      # this test is meaningless if the array length is zero
-      result.length.should > 0
-      result.each do |obj|
-        obj.class.should == ModelIntegrationSpec::Basic
+    describe "with :all" do
+      it "should return an array of instances of the calling Class" do
+        result = ModelIntegrationSpec::Basic.find(:all)
+        result.should be_instance_of(Array)
+        # this test is meaningless if the array length is zero
+        result.length.should > 0
+        result.each do |obj|
+          obj.class.should == ModelIntegrationSpec::Basic
+        end
       end
     end
+    describe "#find with a valid pid" do
+      subject { ActiveFedora::Base.find('hydrangea:fixture_mods_article1') }
+      it { should be_instance_of HydrangeaArticle}
+    end
   end
 
-  describe "#find_document with a valid pid" do
-    subject { ActiveFedora::Base.find_document('hydrangea:fixture_mods_article1') }
-    it { should be_instance_of HydrangeaArticle}
-  end
   
   describe '#load_instance' do
     it "should return an object of the given Model whose inner object is nil" do
+      ActiveSupport::Deprecation.expects(:warn).with("load_instance is deprecated.  Use find instead")
       result = ModelIntegrationSpec::Basic.load_instance(@test_instance.pid)
       result.class.should == ModelIntegrationSpec::Basic
       result.inner_object.new?.should be_false

data/spec/integration/mods_article_integration_spec.rb

@@ -21,7 +21,7 @@ describe ActiveFedora::Base do
   end
   
   before(:each) do
-    @test_article = HydrangeaArticle.load_instance("hydrangea:fixture_mods_article1")
+    @test_article = HydrangeaArticle.find("hydrangea:fixture_mods_article1")
   end
   
   describe ".update_indexed_attributes" do
@@ -37,7 +37,7 @@ describe ActiveFedora::Base do
       @test_article.update_indexed_attributes(test_args[:params], test_args[:opts])
       @test_article.get_values_from_datastream("descMetadata", [{:person=>0}, :first_name]).should == ["Replacement FirstName"]
       @test_article.save
-      retrieved_article = HydrangeaArticle.load_instance("hydrangea:fixture_mods_article1")
+      retrieved_article = HydrangeaArticle.find("hydrangea:fixture_mods_article1")
       retrieved_article.get_values_from_datastream("descMetadata", [{:person=>0}, :first_name]).should == ["Replacement FirstName"]
     end
   end

data/spec/integration/nokogiri_datastream_spec.rb

@@ -26,7 +26,7 @@ describe ActiveFedora::NokogiriDatastream do
     before do
       @pid = "hydrangea:fixture_mods_article1"
       @test_solr_object = HydrangeaArticle2.load_instance_from_solr(@pid)
-      @test_object = HydrangeaArticle2.load_instance(@pid)
+      @test_object = HydrangeaArticle2.find(@pid)
     end
 
     it "should return the same values whether getting from solr or Fedora" do

data/spec/integration/ntriples_datastream_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 describe ActiveFedora::NtriplesRDFDatastream do
   before do
     class MyDatastream < ActiveFedora::NtriplesRDFDatastream
+      register_vocabularies RDF::DC, RDF::FOAF, RDF::RDFS
       map_predicates do |map|
         map.title(:in => RDF::DC)
         map.part(:to => "hasPart", :in => RDF::DC)

data/spec/integration/rels_ext_datastream_spec.rb

@@ -73,8 +73,7 @@ describe ActiveFedora::RelsExtDatastream do
     @test_object.save
     # make sure that _something_ was actually added to the object's relationships hash
     @test_object.ids_for_outbound(:is_member_of).size.should == 1
-    o = ActiveFedora::Base.load_instance(@test_object.pid)
-    new_rels = ActiveFedora::Base.load_instance(@test_object.pid).relationships
+    new_rels = ActiveFedora::Base.find(@test_object.pid).relationships
     new_rels.should == @test_object.relationships
   end
 
@@ -115,16 +114,16 @@ describe ActiveFedora::RelsExtDatastream do
       model_rel = MockAFRelsSolr.to_class_uri
       #check inbound correct, testing goes to :has_part and testing2 goes to :has_member
       #get solr doc for @test_object2
-      solr_doc = MockAFRelsSolr.find_by_solr(@test_object2.pid).hits.first
+      solr_doc = MockAFRelsSolr.find_by_solr(@test_object2.pid).first
       test_from_solr_object2 = MockAFRelsSolr.new
       test_from_solr_object2.rels_ext.from_solr(solr_doc)
-      solr_doc = MockAFRelsSolr.find_by_solr(@test_object3.pid).hits.first
+      solr_doc = MockAFRelsSolr.find_by_solr(@test_object3.pid).first
       test_from_solr_object3 = MockAFRelsSolr.new
       test_from_solr_object3.rels_ext.from_solr(solr_doc)
-      solr_doc = MockAFRelsSolr.find_by_solr(@test_object4.pid).hits.first
+      solr_doc = MockAFRelsSolr.find_by_solr(@test_object4.pid).first
       test_from_solr_object4 = MockAFRelsSolr.new
       test_from_solr_object4.rels_ext.from_solr(solr_doc)
-      solr_doc = MockAFRelsSolr.find_by_solr(@test_object5.pid).hits.first
+      solr_doc = MockAFRelsSolr.find_by_solr(@test_object5.pid).first
       test_from_solr_object5 = MockAFRelsSolr.new
       test_from_solr_object5.rels_ext.from_solr(solr_doc)
       

data/spec/integration/semantic_node_spec.rb

@@ -152,7 +152,6 @@ describe ActiveFedora::SemanticNode do
       collection_members.first.pid.should == @test_object.pid
       collection_members.first.class.should == @test_object.class
     end
-    it "should create useable inbound finders if :inbound is set to true"
   end
   
   describe "inbound relationship finders" do

data/spec/integration/solr_service_spec.rb

@@ -43,12 +43,12 @@ describe ActiveFedora::SolrService do
       @foo_content = @foo_object.datastreams['descMetadata'].content
     end
     after(:all) do
-      @test_object.delete
-      @foo_object.delete
+      # @test_object.delete
+      # @foo_object.delete
     end
     it "should return an array of objects that are of the class stored in active_fedora_model_s" do
       query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@test_object.pid)} OR id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
-      solr_result = ActiveFedora::SolrService.instance.conn.query(query)
+      solr_result = ActiveFedora::SolrService.query(query)
       result = ActiveFedora::SolrService.reify_solr_results(solr_result)
       result.length.should == 2
       result.each do |r|
@@ -58,7 +58,7 @@ describe ActiveFedora::SolrService do
     
     it 'should load objects from solr data if a :load_from_solr option is passed in' do
       query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@test_object.pid)} OR id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
-      solr_result = ActiveFedora::SolrService.instance.conn.query(query)
+      solr_result = ActiveFedora::SolrService.query(query)
       result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
       result.length.should == 2
       result.each do |r|
@@ -75,7 +75,7 @@ describe ActiveFedora::SolrService do
     
     it 'should #reify a lightweight object as a new instance' do
       query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
-      solr_result = ActiveFedora::SolrService.instance.conn.query(query)
+      solr_result = ActiveFedora::SolrService.query(query)
       result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
       solr_foo = result.first
       real_foo = solr_foo.reify
@@ -87,7 +87,7 @@ describe ActiveFedora::SolrService do
     
     it 'should #reify! a lightweight object within the same instance' do
       query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
-      solr_result = ActiveFedora::SolrService.instance.conn.query(query)
+      solr_result = ActiveFedora::SolrService.query(query)
       result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
       solr_foo = result.first
       solr_foo.inner_object.should be_a(ActiveFedora::SolrDigitalObject)
@@ -98,7 +98,7 @@ describe ActiveFedora::SolrService do
     
     it 'should raise an exception when attempting to reify a first-class object' do
       query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
-      solr_result = ActiveFedora::SolrService.instance.conn.query(query)
+      solr_result = ActiveFedora::SolrService.query(query)
       result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
       solr_foo = result.first
       lambda {solr_foo.reify}.should_not raise_exception
@@ -109,7 +109,7 @@ describe ActiveFedora::SolrService do
   
     it 'should call load_instance_from_solr if :load_from_solr option passed in' do
       query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@test_object.pid)} OR id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
-      solr_result = ActiveFedora::SolrService.instance.conn.query(query)
+      solr_result = ActiveFedora::SolrService.query(query)
       ActiveFedora::Base.expects(:load_instance_from_solr).times(1)
       FooObject.expects(:load_instance_from_solr).times(1)
       result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})

data/spec/unit/base_extra_spec.rb

@@ -68,15 +68,26 @@ describe ActiveFedora::Base do
   end
 
   describe ".update_index" do
+    before do
+      mock_conn = mock("SolrConnection")
+      mock_conn.expects(:add)
+      mock_conn.expects(:commit)
+      mock_ss = mock("SolrService")
+      mock_ss.stubs(:conn).returns(mock_conn)
+      ActiveFedora::SolrService.stubs(:instance).returns(mock_ss)
+    end
+    
     it "should call .to_solr on all MetadataDatastreams AND RelsExtDatastreams and pass the resulting document to solr" do
-      ActiveFedora::SolrService.expects(:instance).returns(mock("SolrService", :conn => mock("SolrConnection", :update)))
       # Actually uses self.to_solr internally to gather solr info from all metadata datastreams
       mock1 = mock("ds1", :to_solr)
       mock2 = mock("ds2", :to_solr)
       mock3 = mock("RELS-EXT")
       
       mock_datastreams = {:ds1 => mock1, :ds2 => mock2, :rels_ext => mock3}
-      mock_datastreams.values.each {|ds| ds.stubs(:kind_of?).with(ActiveFedora::NokogiriDatastream).returns(false)}
+      mock_datastreams.values.each do |ds| 
+        ds.stubs(:kind_of?).with(ActiveFedora::RDFDatastream).returns(false)
+        ds.stubs(:kind_of?).with(ActiveFedora::NokogiriDatastream).returns(false)
+      end
       mock1.expects(:solrize_profile)
       mock2.expects(:solrize_profile)
       mock3.expects(:solrize_profile)
@@ -88,12 +99,36 @@ describe ActiveFedora::Base do
       @test_object.expects(:datastreams).returns(mock_datastreams)
       @test_object.expects(:solrize_profile)
       @test_object.expects(:solrize_relationships)
-      @test_object.send :update_index
+      @test_object.update_index
+    end
+
+    it "should call .to_solr on all RDFDatastreams and pass the resulting document to solr" do
+      # Actually uses self.to_solr internally to gather solr info from all metadata datastreams
+      mock1 = mock("ds1", :to_solr)
+      mock2 = mock("ds2", :to_solr)
+      mock3 = mock("RELS-EXT")
+      
+      mock_datastreams = {:ds1 => mock1, :ds2 => mock2, :rels_ext => mock3}
+      mock_datastreams.values.each do |ds| 
+        ds.stubs(:kind_of?).with(ActiveFedora::MetadataDatastream).returns(false)
+        ds.stubs(:kind_of?).with(ActiveFedora::NokogiriDatastream).returns(false)
+      end
+      mock1.expects(:solrize_profile)
+      mock2.expects(:solrize_profile)
+      mock3.expects(:solrize_profile)
+      mock1.expects(:kind_of?).with(ActiveFedora::RDFDatastream).returns(true)
+      mock2.expects(:kind_of?).with(ActiveFedora::RDFDatastream).returns(true)
+      mock3.expects(:kind_of?).with(ActiveFedora::RDFDatastream).returns(false)
+      #mock3.expects(:kind_of?).with(ActiveFedora::RelsExtDatastream).returns(true)
+
+      @test_object.expects(:datastreams).returns(mock_datastreams)
+      @test_object.expects(:solrize_profile)
+      @test_object.expects(:solrize_relationships)
+      @test_object.update_index
     end
 
-    it "should retrieve a solr Connection and call Connection.update" do
-      ActiveFedora::SolrService.expects(:instance).returns(mock("SolrService", :conn => mock("SolrConnection", :update)))
-      @test_object.send :update_index
+    it "should retrieve a solr Connection and call Connection.add" do
+      @test_object.update_index
     end
 
   end
@@ -104,8 +139,13 @@ describe ActiveFedora::Base do
     end
     
     it "should delete object from repository and index" do
-      ActiveFedora::SolrService.instance.conn.expects(:delete).with("__DO_NOT_USE__")      
       @test_object.inner_object.stubs(:delete)
+      mock_conn = mock("SolrConnection")
+      mock_conn.expects(:delete_by_id).with("__DO_NOT_USE__") 
+      mock_conn.expects(:commit)
+      mock_ss = mock("SolrService")
+      mock_ss.stubs(:conn).returns(mock_conn)
+      ActiveFedora::SolrService.stubs(:instance).returns(mock_ss)
       @test_object.expects(:inbound_relationships).returns({})
       @test_object.delete
     end

data/spec/unit/base_file_management_spec.rb

@@ -30,7 +30,7 @@ describe ActiveFedora::Base do
       mock_child = mock("object")
       mock_child.expects(:add_relationship).with(:is_part_of, @base)
       mock_child.expects(:save)
-      ActiveFedora::Base.expects(:load_instance).with("_PID_").returns(mock_child)
+      ActiveFedora::Base.expects(:find).with("_PID_").returns(mock_child)
       @base.file_objects_append("_PID_")
     end
   end

data/spec/unit/base_spec.rb

@@ -328,8 +328,6 @@ describe ActiveFedora::Base do
     end
 
     describe '.save' do
-      
-      
       it "should return true and set persisted if object and datastreams all save successfully" do
         stub_get(@this_pid)
         stub_add_ds(@this_pid, ['RELS-EXT'])
@@ -403,6 +401,19 @@ describe ActiveFedora::Base do
         
         @test_object.save
       end
+      it "should update solr index with all metadata if any RDFDatastreams have changed" do
+        stub_ingest(@this_pid)
+        stub_add_ds(@this_pid, ['ds1', 'RELS-EXT'])
+
+        dirty_ds = ActiveFedora::NtriplesRDFDatastream.new(@test_object.inner_object, 'ds1')
+        rels_ds = ActiveFedora::RelsExtDatastream.new(@test_object.inner_object, 'RELS-EXT')
+        rels_ds.model = @test_object
+        @test_object.add_datastream(rels_ds)
+        @test_object.add_datastream(dirty_ds)
+        @test_object.expects(:update_index)
+        
+        @test_object.save
+      end
       it "should NOT update solr index if no MetadataDatastreams have changed" do
         pending "Rels-ext is getting automatically added so we can't test this."
         ActiveFedora::DigitalObject.any_instance.stubs(:save)
@@ -497,11 +508,11 @@ describe ActiveFedora::Base do
       end
 
       it "should add pid, system_create_date and system_modified_date from object attributes" do
-        @test_object.expects(:create_date).returns("cDate")
-        @test_object.expects(:modified_date).returns("mDate")
+        @test_object.expects(:create_date).returns("2012-03-06T03:12:02Z")
+        @test_object.expects(:modified_date).returns("2012-03-07T03:12:02Z")
         solr_doc = @test_object.to_solr
-        solr_doc["system_create_dt"].should eql("cDate")
-        solr_doc["system_modified_dt"].should eql("mDate")
+        solr_doc["system_create_dt"].should eql("2012-03-06T03:12:02Z")
+        solr_doc["system_modified_dt"].should eql("2012-03-07T03:12:02Z")
         solr_doc[:id].should eql("#{@test_object.pid}")
       end
 
@@ -526,11 +537,11 @@ describe ActiveFedora::Base do
       end
 
       it "should add pid, system_create_date and system_modified_date from object attributes" do
-        @test_object.expects(:create_date).returns("cDate")
-        @test_object.expects(:modified_date).returns("mDate")
+        @test_object.expects(:create_date).returns("2012-03-04T03:12:02Z")
+        @test_object.expects(:modified_date).returns("2012-03-07T03:12:02Z")
         solr_doc = @test_object.to_solr
-        solr_doc["system_create_dt"].should eql("cDate")
-        solr_doc["system_modified_dt"].should eql("mDate")
+        solr_doc["system_create_dt"].should eql("2012-03-04T03:12:02Z")
+        solr_doc["system_modified_dt"].should eql("2012-03-07T03:12:02Z")
         solr_doc[:id].should eql("#{@test_object.pid}")
       end
 
@@ -552,8 +563,8 @@ describe ActiveFedora::Base do
       end
 
       it "should use mappings.yml to decide names of solr fields" do      
-        cdate = "2008-07-02T05:09:42.015Z"
-        mdate = "2009-07-07T23:37:18.991Z"
+        cdate = "2008-07-02T05:09:42Z"
+        mdate = "2009-07-07T23:37:18Z"
         @test_object.stubs(:create_date).returns(cdate)
         @test_object.stubs(:modified_date).returns(mdate)
         solr_doc = @test_object.to_solr
@@ -575,18 +586,36 @@ describe ActiveFedora::Base do
       
       it "should call .to_solr on all MetadataDatastreams and NokogiriDatastreams, passing the resulting document to solr" do
         mock1 = mock("ds1", :to_solr)
-        mock1.expects(:solrize_profile)
         mock2 = mock("ds2", :to_solr)
-        mock2.expects(:solrize_profile)
-        ngds = mock("ngds")
+        ngds = mock("ngds", :to_solr)
         ngds.expects(:solrize_profile)
+        mock1.expects(:solrize_profile)
+        mock2.expects(:solrize_profile)
+        mock1.expects(:kind_of?).with(ActiveFedora::RDFDatastream).returns(false)
+        mock1.expects(:kind_of?).with(ActiveFedora::NokogiriDatastream).returns(false)
         mock1.expects(:kind_of?).with(ActiveFedora::MetadataDatastream).returns(true)
+        mock2.expects(:kind_of?).with(ActiveFedora::RDFDatastream).returns(false)
+        mock2.expects(:kind_of?).with(ActiveFedora::NokogiriDatastream).returns(false)
         mock2.expects(:kind_of?).with(ActiveFedora::MetadataDatastream).returns(true)
+        ngds.expects(:kind_of?).with(ActiveFedora::RDFDatastream).returns(false)
+        ngds.expects(:kind_of?).with(ActiveFedora::NokogiriDatastream).returns(true)
         
         @test_object.expects(:datastreams).returns({:ds1 => mock1, :ds2 => mock2, :ngds => ngds})
+        @test_object.expects(:solrize_profile)
+        @test_object.expects(:solrize_relationships)
+        @test_object.to_solr
+      end
+      it "should call .to_solr on all RDFDatastreams, passing the resulting document to solr" do
+        mock = mock("ds1", :to_solr)
+        mock.expects(:solrize_profile)
+        mock.expects(:kind_of?).with(ActiveFedora::RDFDatastream).returns(true)
+        
+        @test_object.expects(:datastreams).returns({:ds1 => mock})
+        @test_object.expects(:solrize_profile)
         @test_object.expects(:solrize_relationships)
         @test_object.to_solr
       end
+
       it "should call .to_solr on the relationships rels-ext is dirty" do
         @test_object.add_relationship(:has_collection_member, "info:fedora/foo:member")
         rels_ext = @test_object.rels_ext

data/spec/unit/model_spec.rb

@@ -75,38 +75,29 @@ describe ActiveFedora::Model do
   describe '#find' do
     
     it "(:all) should query solr for all objects with :active_fedora_model_s of self.class" do
-      mock_solr = mock("SolrConnection")
-      mock_result = mock("MockResult")
-      mock_result.expects(:hits).returns([{"id" => "changeme:30"}, {"id" => "changeme:22"}])
-      mock_solr.expects(:query).with('has_model_s:info\\:fedora/afmodel\\:SpecModel_Basic', :rows=>1001).returns(mock_result)
-      ActiveFedora::SolrService.expects(:instance).returns(mock("SolrService", :conn => mock_solr))
-      SpecModel::Basic.expects(:load_instance).with("changeme:30").returns("Fake Object1")
-      SpecModel::Basic.expects(:load_instance).with("changeme:22").returns("Fake Object2")
+      ActiveFedora::SolrService.expects(:query).with('has_model_s:info\\:fedora/afmodel\\:SpecModel_Basic', :rows=>1001).returns([{"id" => "changeme:30"}, {"id" => "changeme:22"}])
+      SpecModel::Basic.expects(:find_one).with("changeme:30").returns("Fake Object1")
+      SpecModel::Basic.expects(:find_one).with("changeme:22").returns("Fake Object2")
       SpecModel::Basic.find(:all, :rows=>1001).should == ["Fake Object1", "Fake Object2"]
     end
-    
-    it "(String) should query solr for an object with the given id and return that object" do
-      SpecModel::Basic.expects(:load_instance).with("changeme:30").returns("Fake Object")
-      SpecModel::Basic.find("changeme:30").should == "Fake Object"
+    it "should use SpecModel::Basic.allocate.init_with to instantiate an object" do
+      ActiveFedora::ContentModel.expects(:known_models_for).returns([SpecModel::Basic])
+      SpecModel::Basic.any_instance.expects(:init_with).returns(mock("Model", :adapt_to=>SpecModel::Basic ))
+      SpecModel::Basic.expects(:connection_for_pid).with("_PID_")
+      SpecModel::Basic.find("_PID_")
     end
   end
 
   describe '#count' do
     
     it "should return a count" do
-      mock_solr = mock("SolrConnection")
-      mock_result = mock("MockResult")
-      mock_result.expects(:total_hits).returns(7)
-      mock_solr.expects(:query).with('has_model_s:info\\:fedora/afmodel\\:SpecModel_Basic', :rows=>0).returns(mock_result)
-      ActiveFedora::SolrService.expects(:instance).returns(mock("SolrService", :conn => mock_solr))
+      mock_result = {'response'=>{'numFound'=>7}}
+      ActiveFedora::SolrService.expects(:query).with('has_model_s:info\\:fedora/afmodel\\:SpecModel_Basic', :rows=>0, :raw=>true).returns(mock_result)
       SpecModel::Basic.count.should == 7
     end
     it "should allow conditions" do
-      mock_solr = mock("SolrConnection")
-      mock_result = mock("MockResult")
-      mock_result.expects(:total_hits).returns(7)
-      mock_solr.expects(:query).with('has_model_s:info\\:fedora/afmodel\\:SpecModel_Basic AND foo:bar', :rows=>0).returns(mock_result)
-      ActiveFedora::SolrService.expects(:instance).returns(mock("SolrService", :conn => mock_solr))
+      mock_result = {'response'=>{'numFound'=>7}}
+      ActiveFedora::SolrService.expects(:query).with('has_model_s:info\\:fedora/afmodel\\:SpecModel_Basic AND foo:bar', :rows=>0, :raw=>true).returns(mock_result)
       SpecModel::Basic.count(:conditions=>'foo:bar').should == 7
     end
   end
@@ -118,18 +109,14 @@ describe ActiveFedora::Model do
   
   describe '#find_by_solr' do
     it "(:all) should query solr for all objects with :active_fedora_model_s of self.class and return a Solr result" do
-      mock_solr = mock("SolrConnection")
       mock_response = mock("SolrResponse")
-      mock_solr.expects(:query).with('active_fedora_model_s:SpecModel\:\:Basic', {}).returns(mock_response)
-      ActiveFedora::SolrService.expects(:instance).returns(mock("SolrService", :conn => mock_solr))
+      ActiveFedora::SolrService.expects(:query).with('active_fedora_model_s:SpecModel\:\:Basic', {}).returns(mock_response)
     
       SpecModel::Basic.find_by_solr(:all).should equal(mock_response)
     end
     it "(String) should query solr for an object with the given id and return the Solr Result" do
-      mock_solr = mock("SolrConnection")
       mock_response = mock("SolrResponse")
-      mock_solr.expects(:query).with('id:changeme\:30', {}).returns(mock_response)
-      ActiveFedora::SolrService.expects(:instance).returns(mock("SolrService", :conn => mock_solr))
+      ActiveFedora::SolrService.expects(:query).with('id:changeme\:30', {}).returns(mock_response)
     
       SpecModel::Basic.find_by_solr("changeme:30").should equal(mock_response)
     end
@@ -137,8 +124,8 @@ describe ActiveFedora::Model do
   
   describe "load_instance" do
     it "should use SpecModel::Basic.allocate.init_with to instantiate an object" do
-      SpecModel::Basic.any_instance.expects(:init_with)
-      SpecModel::Basic.expects(:connection_for_pid).with("_PID_")
+      ActiveSupport::Deprecation.expects(:warn).with("load_instance is deprecated.  Use find instead")
+      SpecModel::Basic.expects(:find).with("_PID_")
       SpecModel::Basic.load_instance("_PID_")
     end
   end