active-fedora 8.7.0 → 9.0.0.beta1

data/spec/unit/readonly_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe ActiveFedora::Base do
+  it { is_expected.not_to be_readonly }
+
+  describe "#readonly!" do
+    it "should make the object readonly" do
+      expect { subject.readonly! }.to change { subject.readonly? }.from(false).to(true)
+    end
+  end
+
+  context "a readonly record" do
+    before { subject.readonly! }
+
+    it "should not be destroyable" do
+      expect { subject.destroy }.to raise_error ActiveFedora::ReadOnlyRecord
+    end
+
+    it "should not be mutable" do
+      expect { subject.save }.to raise_error ActiveFedora::ReadOnlyRecord
+    end
+  end
+end

data/spec/unit/rspec_matchers/belong_to_associated_active_fedora_object_matcher_spec.rb

@@ -3,27 +3,27 @@ require 'ostruct'
 require "active_fedora/rspec_matchers/belong_to_associated_active_fedora_object_matcher"
 
 describe RSpec::Matchers, "belong_to_associated_active_fedora_object_matcher" do
-  subject { OpenStruct.new(:pid => pid )}
-  let(:pid) { 123 }
+  subject { OpenStruct.new(:id => id )}
+  let(:id) { 123 }
   let(:object1) { Object.new }
   let(:object2) { Object.new }
   let(:association) { :association }
 
   it 'should match when association is properly stored in fedora' do
-    expect(subject.class).to receive(:find).with(pid).and_return(subject)
+    expect(subject.class).to receive(:find).with(id).and_return(subject)
     expect(subject).to receive(association).and_return(object1)
     expect(subject).to belong_to_associated_active_fedora_object(association).with_object(object1)
   end
 
   it 'should not match when association is different' do
-    expect(subject.class).to receive(:find).with(pid).and_return(subject)
+    expect(subject.class).to receive(:find).with(id).and_return(subject)
     expect(subject).to receive(association).and_return(object1)
     expect {
       expect(subject).to belong_to_associated_active_fedora_object(association).with_object(object2)
     }.to (
       raise_error(
         RSpec::Expectations::ExpectationNotMetError,
-        /expected #{subject.class} PID=#{pid} association: #{association.inspect}/
+        /expected #{subject.class} ID=#{id} association: #{association.inspect}/
       )
     )
   end
@@ -34,7 +34,7 @@ describe RSpec::Matchers, "belong_to_associated_active_fedora_object_matcher" do
     }.to(
       raise_error(
         ArgumentError,
-        "subject.should belong_to_associated_active_fedora_object(<association_name>).with_object(<object>)"
+        "expect(subject).to belong_to_associated_active_fedora_object(<association_name>).with_object(<object>)"
       )
     )
   end

data/spec/unit/rspec_matchers/have_many_associated_active_fedora_objects_matcher_spec.rb

@@ -3,28 +3,28 @@ require 'ostruct'
 require "active_fedora/rspec_matchers/have_many_associated_active_fedora_objects_matcher"
 
 describe RSpec::Matchers, "have_many_associated_active_fedora_objects_matcher" do
-  subject { OpenStruct.new(:pid => pid )}
-  let(:pid) { 123 }
+  subject { OpenStruct.new(:id => id )}
+  let(:id) { 123 }
   let(:object1) { Object.new }
   let(:object2) { Object.new }
   let(:object3) { Object.new }
   let(:association) { :association }
 
   it 'should match when association is properly stored in fedora' do
-    expect(subject.class).to receive(:find).with(pid).and_return(subject)
+    expect(subject.class).to receive(:find).with(id).and_return(subject)
     expect(subject).to receive(association).and_return([object1,object2])
     expect(subject).to have_many_associated_active_fedora_objects(association).with_objects([object1, object2])
   end
 
   it 'should not match when association is different' do
-    expect(subject.class).to receive(:find).with(pid).and_return(subject)
+    expect(subject.class).to receive(:find).with(id).and_return(subject)
     expect(subject).to receive(association).and_return([object1,object3])
     expect {
       expect(subject).to have_many_associated_active_fedora_objects(association).with_objects([object1, object2])
     }.to (
       raise_error(
         RSpec::Expectations::ExpectationNotMetError,
-        /expected #{subject.class} PID=#{pid} association: #{association.inspect}/
+        /expected #{subject.class} ID=#{id} association: #{association.inspect}/
       )
     )
   end
@@ -35,7 +35,7 @@ describe RSpec::Matchers, "have_many_associated_active_fedora_objects_matcher" d
     }.to(
       raise_error(
         ArgumentError,
-        "subject.should have_many_associated_active_fedora_objects(<association_name>).with_objects(<objects[]>)"
+          "expect(subject).to have_many_associated_active_fedora_objects(<association_name>).with_objects(<objects[]>)"
       )
     )
   end

data/spec/unit/rspec_matchers/have_predicate_matcher_spec.rb

@@ -3,28 +3,28 @@ require 'ostruct'
 require "active_fedora/rspec_matchers/have_predicate_matcher"
 
 describe RSpec::Matchers, "have_predicate_matcher" do
-  subject { OpenStruct.new(:pid => pid )}
-  let(:pid) { 123 }
+  subject { OpenStruct.new(:id => id )}
+  let(:id) { 123 }
   let(:object1) { Object.new }
   let(:object2) { Object.new }
   let(:object3) { Object.new }
   let(:predicate) { :predicate }
 
   it 'should match when relationship is "what we have in Fedora"' do
-    expect(subject.class).to receive(:find).with(pid).and_return(subject)
+    expect(subject.class).to receive(:find).with(id).and_return(subject)
     expect(subject).to receive(:relationships).with(predicate).and_return([object1,object2])
     expect(subject).to have_predicate(predicate).with_objects([object1, object2])
   end
 
   it 'should not match when relationship is different' do
-    expect(subject.class).to receive(:find).with(pid).and_return(subject)
+    expect(subject.class).to receive(:find).with(id).and_return(subject)
     expect(subject).to receive(:relationships).with(predicate).and_return([object1,object3])
     expect {
       expect(subject).to have_predicate(predicate).with_objects([object1, object2])
     }.to (
       raise_error(
         RSpec::Expectations::ExpectationNotMetError,
-        /expected #{subject.class} PID=#{pid} relationship: #{predicate.inspect}/
+        /expected #{subject.class} ID=#{id} relationship: #{predicate.inspect}/
       )
     )
   end
@@ -35,7 +35,7 @@ describe RSpec::Matchers, "have_predicate_matcher" do
     }.to(
       raise_error(
         ArgumentError,
-        "subject.should have_predicate(<predicate>).with_objects(<objects[]>)"
+          "expect(subject).to have_predicate(<predicate>).with_objects(<objects[]>)"
       )
     )
   end

data/spec/unit/serializers_spec.rb

@@ -14,7 +14,7 @@ describe ActiveFedora::Attributes::Serializers do
     subject { Foo.new }
     it "should deserialize dates" do
       subject.attributes = {'birthday(1i)' =>'2012', 'birthday(2i)' =>'10', 'birthday(3i)' => '31'}
-      expect(subject.birthday).to eq('2012-10-31')
+      expect(subject.birthday).to eq '2012-10-31'
     end
   end
 

data/spec/unit/simple_datastream_spec.rb

@@ -2,34 +2,24 @@ require 'spec_helper'
 
 describe ActiveFedora::SimpleDatastream do
 
+  let(:sample_xml) { "<fields><coverage>coverage1</coverage><coverage>coverage2</coverage><creation_date>2012-01-15</creation_date><mydate>fake-date</mydate><publisher>publisher1</publisher></fields>" }
+
   before do
-    @sample_xml =  "<fields><coverage>coverage1</coverage><coverage>coverage2</coverage><creation_date>2012-01-15</creation_date><mydate>fake-date</mydate><prefix>foobar</prefix><publisher>publisher1</publisher></fields>"
-    @test_ds = ActiveFedora::SimpleDatastream.from_xml(@sample_xml )
+    @test_ds = ActiveFedora::SimpleDatastream.new
+    allow(@test_ds).to receive(:retrieve_content).and_return('') # DS grabs the old content to compare against the new
+    @test_ds.content = sample_xml
     @test_ds.field :coverage
     @test_ds.field :creation_date, :date
     @test_ds.field :mydate
-    @test_ds.field :prefix
     @test_ds.field :publisher
-  end
 
-  it "from_xml should parse everything correctly" do
-    expect(@test_ds.ng_xml).to be_equivalent_to @sample_xml
   end
 
-  describe "#to_solr" do
-    it "should work as expected" do
-      expect(@test_ds.to_solr).to eq(
-        {
-          'coverage_tesim' => ['coverage1', 'coverage2'],
-          'creation_date_dtsim' => '2012-01-15',
-          'mydate_tesim' => 'fake-date',
-          'prefix_tesim' => 'foobar',
-          'publisher_tesim' => 'publisher1'
-        }
-      )
-    end
+  it "ng_xml should parse everything correctly" do
+    expect(@test_ds.ng_xml).to be_equivalent_to sample_xml
   end
 
+
   describe '#new' do
     describe "model methods" do
 
@@ -37,14 +27,14 @@ describe ActiveFedora::SimpleDatastream do
         it "should respond to getters and setters for the string typed #{el} element" do
           value = "Hey #{el}"
           @test_ds.send("#{el.to_s}=", value)
-          expect(@test_ds.send(el).first).to eq(value)  #Looking at first because creator has 2 nodes
+          expect(@test_ds.send(el).first).to eq value  #Looking at first because creator has 2 nodes
         end
       end
 
       it "should set date elements" do
         d = Date.parse('1939-05-23')
         @test_ds.creation_date = d
-        expect(@test_ds.creation_date.first).to eq(d)
+        expect(@test_ds.creation_date.first).to eq d
       end
     end
   end
@@ -60,7 +50,6 @@ describe ActiveFedora::SimpleDatastream do
           <coverage>20%</coverage>
           <creation_date>2012-01-15</creation_date>
           <mydate>fake-date</mydate>
-          <prefix>foobar</prefix>
           <publisher>charlie</publisher>
         </fields>')
     end
@@ -69,8 +58,8 @@ describe ActiveFedora::SimpleDatastream do
   describe "#to_solr" do
     it "should have title" do
       solr = @test_ds.to_solr
-      expect(solr[ActiveFedora::SolrService.solr_name('publisher', type: :string)]).to eq("publisher1")
-      expect(solr[ActiveFedora::SolrService.solr_name('creation_date', type: :date)]).to eq("2012-01-15")
+      expect(solr[ActiveFedora::SolrService.solr_name('publisher', type: :string)]).to eq "publisher1"
+      expect(solr[ActiveFedora::SolrService.solr_name('creation_date', type: :date)]).to eq "2012-01-15"
     end
   end
 

data/spec/unit/solr_config_options_spec.rb

@@ -1,21 +1,18 @@
 require 'spec_helper'
 
 describe ActiveFedora do
-  
+
   before(:all) do
     module SolrSpecModel
       class Basic < ActiveFedora::Base
-        def init_with_object(inner_obj)
-        end
       end
     end
   end
-  
+
   before(:each) do
     @test_object = ActiveFedora::Base.new
   end
-  
-  
+
   describe "SOLR_DOCUMENT_ID" do
     before(:all) do
       SOLR_DOCUMENT_ID = "MY_SAMPLE_ID"
@@ -24,40 +21,40 @@ describe ActiveFedora do
       SOLR_DOCUMENT_ID = "id"
     end
     it "should be used by ActiveFedora::Base.to_solr" do
-      allow(@test_object).to receive_messages(pid: 'changeme:123')
+      allow(@test_object).to receive(:id).and_return('changeme:123')
       SOLR_DOCUMENT_ID = "MY_SAMPLE_ID"
-      expect(@test_object.to_solr[SOLR_DOCUMENT_ID.to_sym]).to eq('changeme:123')
+      expect(@test_object.to_solr[SOLR_DOCUMENT_ID.to_sym]).to eq 'changeme:123'
       expect(@test_object.to_solr[:id]).to be_nil
     end
 
     it "should be used by ActiveFedora::Base#find_with_conditions" do
       mock_response = double("SolrResponse")
-      expect(ActiveFedora::SolrService).to receive(:query).with("_query_:\"{!raw f=#{ActiveFedora::SolrService.solr_name("has_model", :symbol)}}info:fedora/afmodel:SolrSpecModel_Basic\" AND " + SOLR_DOCUMENT_ID + ':changeme\\:30', {:sort => ["#{ActiveFedora::SolrService.solr_name("system_create", :stored_sortable, type: :date)} asc"]}).and_return(mock_response)
-  
+      expect(ActiveFedora::SolrService).to receive(:query).with("_query_:\"{!raw f=#{ActiveFedora::SolrService.solr_name("has_model", :symbol)}}SolrSpecModel::Basic\" AND " + SOLR_DOCUMENT_ID + ':changeme\\:30', {:sort => ["#{ActiveFedora::SolrService.solr_name("system_create", :stored_sortable, type: :date)} asc"]}).and_return(mock_response)
+
       expect(SolrSpecModel::Basic.find_with_conditions(:id=>"changeme:30")).to equal(mock_response)
     end
   end
-  
+
   describe "ENABLE_SOLR_UPDATES" do
-    
+
     before(:all) do
       ENABLE_SOLR_UPDATES = false
     end
     after(:all) do
       ENABLE_SOLR_UPDATES = true
     end
-    
+
     it "should prevent Base.save from calling update_index if false" do
-      dirty_ds = ActiveFedora::SimpleDatastream.new(@test_object.inner_object, 'ds1')
-      @test_object.datastreams['ds1'] = dirty_ds
+      dirty_ds = ActiveFedora::SimpleDatastream.new
+      @test_object.attached_files['ds1'] = dirty_ds
       allow(@test_object).to receive(:datastreams).and_return({:ds1 => dirty_ds})
       expect(@test_object).to receive(:update_index).never
       expect(@test_object).to receive(:refresh)
       @test_object.save
     end
     it "should prevent Base.delete from deleting the corresponding Solr document if false" do
-      expect(ActiveFedora::SolrService.instance.conn).to receive(:delete).with(@test_object.pid).never 
-      expect(@test_object.inner_object).to receive(:delete)
+      expect(ActiveFedora::SolrService.instance.conn).to receive(:delete).with(@test_object.id).never
+      expect(@test_object).to receive(:delete)
       @test_object.delete
     end
   end

data/spec/unit/solr_service_spec.rb

@@ -4,12 +4,12 @@ describe ActiveFedora::SolrService do
   before do
     Thread.current[:solr_service]=nil
   end
-
+  
   after(:all) do
     ActiveFedora::SolrService.register(ActiveFedora.solr_config[:url])
   end
-
-  it "should take a narg constructor and configure for localhost" do
+  
+  it "should take a n-arg constructor and configure for localhost" do
     expect(RSolr).to receive(:connect).with(:read_timeout => 120, :open_timeout => 120, :url => 'http://localhost:8080/solr')
     ActiveFedora::SolrService.register
   end
@@ -25,86 +25,70 @@ describe ActiveFedora::SolrService do
   it "should set the threadlocal solr service" do
     expect(RSolr).to receive(:connect).with(:read_timeout => 120, :open_timeout => 120, :url => 'http://localhost:8080/solr', :autocommit=>:off, :foo=>:bar)
     ss = ActiveFedora::SolrService.register(nil, {:autocommit=>:off, :foo=>:bar})
-    expect(Thread.current[:solr_service]).to eq(ss)
-    expect(ActiveFedora::SolrService.instance).to eq(ss)
+    expect(Thread.current[:solr_service]).to eq ss
+    expect(ActiveFedora::SolrService.instance).to eq ss
   end
   it "should try to initialize if the service not initialized, and fail if it does not succeed" do
     expect(Thread.current[:solr_service]).to be_nil
     expect(ActiveFedora::SolrService).to receive(:register)
-    expect{ActiveFedora::SolrService.instance}.to raise_error(ActiveFedora::SolrNotInitialized)
+    expect(proc{ActiveFedora::SolrService.instance}).to raise_error(ActiveFedora::SolrNotInitialized)
   end
 
   describe "reify solr results" do
     before(:all) do
       class AudioRecord
-        attr_accessor :pid
-        def init_with_object(inner_obj)
-          self.pid = inner_obj.pid
-          self
-        end
-        def self.connection_for_pid(pid)
+        attr_accessor :id
+        def self.connection_for_id(id)
         end
       end
-      @sample_solr_hits = [{"id"=>"my:_PID1_", ActiveFedora::SolrService.solr_name("has_model", :symbol)=>["info:fedora/afmodel:AudioRecord"]},
-                           {"id"=>"my:_PID2_", ActiveFedora::SolrService.solr_name("has_model", :symbol)=>["info:fedora/afmodel:AudioRecord"]},
-                           {"id"=>"my:_PID3_", ActiveFedora::SolrService.solr_name("has_model", :symbol)=>["info:fedora/afmodel:AudioRecord"]}]
+      @sample_solr_hits = [{"id"=>"my:_ID1_", ActiveFedora::SolrService.solr_name("has_model", :symbol)=>["AudioRecord"]},
+                           {"id"=>"my:_ID2_", ActiveFedora::SolrService.solr_name("has_model", :symbol)=>["AudioRecord"]},
+                           {"id"=>"my:_ID3_", ActiveFedora::SolrService.solr_name("has_model", :symbol)=>["AudioRecord"]}]
     end
     describe ".reify_solr_result" do
       it "should use .find to instantiate objects" do
-        expect(AudioRecord).to receive(:find).with("my:_PID1_", cast: true)
+        expect(AudioRecord).to receive(:find).with("my:_ID1_", cast: true)
         ActiveFedora::SolrService.reify_solr_result(@sample_solr_hits.first)
       end
-      it "should use .load_instance_from_solr when called with :load_from_solr option" do
-        expect(AudioRecord).to receive(:load_instance_from_solr).with("my:_PID1_", @sample_solr_hits.first)
-        expect(ActiveFedora::SolrService).not_to receive(:query)
-        ActiveFedora::SolrService.reify_solr_result(@sample_solr_hits.first, load_from_solr: true)
-      end
     end
     describe ".reify_solr_results" do
       it "should use AudioRecord.find to instantiate objects" do
-        expect(AudioRecord).to receive(:find).with("my:_PID1_", cast: true)
-        expect(AudioRecord).to receive(:find).with("my:_PID2_", cast: true)
-        expect(AudioRecord).to receive(:find).with("my:_PID3_", cast: true)
+        expect(AudioRecord).to receive(:find).with("my:_ID1_", cast: true)
+        expect(AudioRecord).to receive(:find).with("my:_ID2_", cast: true)
+        expect(AudioRecord).to receive(:find).with("my:_ID3_", cast: true)
         ActiveFedora::SolrService.reify_solr_results(@sample_solr_hits)
       end
-      it "should use AudioRecord.load_instance_from_solr when called with :load_from_solr option" do
-        expect(AudioRecord).to receive(:load_instance_from_solr).with("my:_PID1_", @sample_solr_hits[0])
-        expect(AudioRecord).to receive(:load_instance_from_solr).with("my:_PID2_", @sample_solr_hits[1])
-        expect(AudioRecord).to receive(:load_instance_from_solr).with("my:_PID3_", @sample_solr_hits[2])
-        expect(ActiveFedora::SolrService).not_to receive(:query)
-        ActiveFedora::SolrService.reify_solr_results(@sample_solr_hits, load_from_solr: true)
-      end
     end
     describe ".lazy_reify_solr_results" do
       it "should lazily reify solr results" do
-        expect(AudioRecord).to receive(:find).with("my:_PID1_", cast: true)
-        expect(AudioRecord).to receive(:find).with("my:_PID2_", cast: true)
-        expect(AudioRecord).to receive(:find).with("my:_PID3_", cast: true)
+        expect(AudioRecord).to receive(:find).with("my:_ID1_", cast: true)
+        expect(AudioRecord).to receive(:find).with("my:_ID2_", cast: true)
+        expect(AudioRecord).to receive(:find).with("my:_ID3_", cast: true)
         ActiveFedora::SolrService.lazy_reify_solr_results(@sample_solr_hits).each {|r| r}
       end
-      it "should use AudioRecord.load_instance_from_solr when called with :load_from_solr option" do
-        expect(AudioRecord).to receive(:load_instance_from_solr).with("my:_PID1_", @sample_solr_hits[0])
-        expect(AudioRecord).to receive(:load_instance_from_solr).with("my:_PID2_", @sample_solr_hits[1])
-        expect(AudioRecord).to receive(:load_instance_from_solr).with("my:_PID3_", @sample_solr_hits[2])
-        expect(ActiveFedora::SolrService).not_to receive(:query)
-        ActiveFedora::SolrService.lazy_reify_solr_results(@sample_solr_hits, load_from_solr: true).each {|r| r}
-      end
     end
   end
 
   describe "raw_query" do
     it "should generate a raw query clause" do
-      expect(ActiveFedora::SolrService.raw_query('id', "my:_PID1_")).to eq '_query_:"{!raw f=id}my:_PID1_"'
+      expect(ActiveFedora::SolrService.raw_query('id', "my:_ID1_")).to eq '_query_:"{!raw f=id}my:_ID1_"'
     end
   end
 
-  describe '#construct_query_for_pids' do
-    it "should generate a useable solr query from an array of Fedora pids" do
-      expect(ActiveFedora::SolrService.construct_query_for_pids(["my:_PID1_", "my:_PID2_", "my:_PID3_"])).to eq('_query_:"{!raw f=id}my:_PID1_" OR _query_:"{!raw f=id}my:_PID2_" OR _query_:"{!raw f=id}my:_PID3_"')
+  describe '#construct_query_for_ids' do
+    it "should generate a useable solr query from an array of Fedora ids" do
+      expect(ActiveFedora::SolrService.construct_query_for_ids(["my:_ID1_", "my:_ID2_", "my:_ID3_"])).to eq '_query_:"{!raw f=id}my:_ID1_" OR _query_:"{!raw f=id}my:_ID2_" OR _query_:"{!raw f=id}my:_ID3_"'
 
     end
     it "should return a valid solr query even if given an empty array as input" do
-      expect(ActiveFedora::SolrService.construct_query_for_pids([""])).to eq("id:NEVER_USE_THIS_ID")
+      expect(ActiveFedora::SolrService.construct_query_for_ids([""])).to eq "id:NEVER_USE_THIS_ID"
+    end
+  end
+
+  describe '#construct_query_for_pids' do
+    it "should generate a useable solr query from an array of Fedora ids" do
+      expect(Deprecation).to receive(:warn)
+      expect(ActiveFedora::SolrService.construct_query_for_pids(["my:_ID1_", "my:_ID2_", "my:_ID3_"])).to eq '_query_:"{!raw f=id}my:_ID1_" OR _query_:"{!raw f=id}my:_ID2_" OR _query_:"{!raw f=id}my:_ID3_"'
 
     end
   end
@@ -114,8 +98,8 @@ describe ActiveFedora::SolrService do
       mock_conn = double("Connection")
       stub_result = double("Result")
       expect(mock_conn).to receive(:get).with('select', :params=>{:q=>'querytext', :qt=>'standard'}).and_return(stub_result)
-      allow(ActiveFedora::SolrService).to receive_messages(:instance =>double("instance", :conn=>mock_conn))
-      expect(ActiveFedora::SolrService.query('querytext', :raw=>true)).to eq(stub_result)
+      allow(ActiveFedora::SolrService).to receive(:instance).and_return(double("instance", conn: mock_conn))
+      expect(ActiveFedora::SolrService.query('querytext', :raw=>true)).to eq stub_result
     end
   end
   describe ".count" do
@@ -123,15 +107,15 @@ describe ActiveFedora::SolrService do
       mock_conn = double("Connection")
       stub_result = {'response' => {'numFound'=>'7'}}
       expect(mock_conn).to receive(:get).with('select', :params=>{:rows=>0, :q=>'querytext', :qt=>'standard'}).and_return(stub_result)
-      allow(ActiveFedora::SolrService).to receive_messages(:instance =>double("instance", :conn=>mock_conn))
-      expect(ActiveFedora::SolrService.count('querytext')).to eq(7)
+      allow(ActiveFedora::SolrService).to receive(:instance).and_return(double("instance", conn: mock_conn))
+      expect(ActiveFedora::SolrService.count('querytext')).to eq 7
     end
     it "should accept query args" do
       mock_conn = double("Connection")
       stub_result = {'response' => {'numFound'=>'7'}}
       expect(mock_conn).to receive(:get).with('select', :params=>{:rows=>0, :q=>'querytext', :qt=>'standard', :fq=>'filter'}).and_return(stub_result)
-      allow(ActiveFedora::SolrService).to receive_messages(:instance =>double("instance", :conn=>mock_conn))
-      expect(ActiveFedora::SolrService.count('querytext', :fq=>'filter', :rows=>10)).to eq(7)
+      allow(ActiveFedora::SolrService).to receive(:instance).and_return(double("instance", conn: mock_conn))
+      expect(ActiveFedora::SolrService.count('querytext', :fq=>'filter', :rows=>10)).to eq 7
     end
   end
   describe ".add" do
@@ -139,7 +123,7 @@ describe ActiveFedora::SolrService do
       mock_conn = double("Connection")
       doc = {'id' => '1234'}
       expect(mock_conn).to receive(:add).with(doc, {:params=>{}})
-      allow(ActiveFedora::SolrService).to receive_messages(:instance =>double("instance", :conn=>mock_conn))
+      allow(ActiveFedora::SolrService).to receive(:instance).and_return(double("instance", conn: mock_conn))
       ActiveFedora::SolrService.add(doc)
     end
   end
@@ -148,31 +132,8 @@ describe ActiveFedora::SolrService do
       mock_conn = double("Connection")
       doc = {'id' => '1234'}
       expect(mock_conn).to receive(:commit)
-      allow(ActiveFedora::SolrService).to receive_messages(:instance =>double("instance", :conn=>mock_conn))
+      allow(ActiveFedora::SolrService).to receive(:instance).and_return(double("instance", conn: mock_conn))
       ActiveFedora::SolrService.commit()
     end
   end
-
-  describe '.class_from_solr_document' do
-    subject { described_class.class_from_solr_document(document) }
-
-    context 'when the document does not have has_model_ssim' do
-      let (:document) do
-        { "id" => "my:_PID1_" }
-      end
-
-      it 'raises a helpful error' do
-        expect { subject }.to raise_error "Solr document (id: my:_PID1_) is missing required has_model_ssim field."
-      end
-    end
-
-    context 'when the document has has_model_ssim' do
-      let (:document) do
-        { "id" => "my:_PID1_", ActiveFedora::SolrService.solr_name("has_model", :symbol) => ["info:fedora/afmodel:AudioRecord"] }
-      end
-
-      it { is_expected.to eq AudioRecord }
-
-    end
-  end
 end