active-fedora 6.8.0 → 7.0.0.pre1

data/spec/unit/serializers_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe ActiveFedora::Attributes::Serializers do
   subject { ActiveFedora::Base }
-  describe 'deserialize_dates_from_form' do
+  describe "deserialize_dates_from_form" do
     before do
       class Foo < ActiveFedora::Base
         attr_accessor :birthday
@@ -12,9 +12,9 @@ describe ActiveFedora::Attributes::Serializers do
       Object.send(:remove_const, :Foo)
     end
     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')
+    it "should deserialize dates" do
+      subject.attributes = {'birthday(1i)' =>'2012', 'birthday(2i)' =>'10', 'birthday(3i)' => '31'}
+      subject.birthday.should == '2012-10-31'
     end
   end
 

data/spec/unit/service_definitions_spec.rb

@@ -14,50 +14,50 @@ describe ActiveFedora::ServiceDefinitions do
 </fmm:MethodMap>
     MMAP
     @repository = ActiveFedora::Base.connection_for_pid(0)
-    allow(@repository).to receive(:datastream_dissemination).with({:pid => 'test:12', :dsid => 'METHODMAP'}).and_return mmap
-    Test.has_service_definition 'test:12'
+    @repository.stub(:datastream_dissemination).with({:pid=>'test:12',:dsid=>'METHODMAP'}).and_return mmap
+    Test.has_service_definition "test:12"
   end
 
-  subject {
+  subject { 
       obj = Test.new()
-      allow(obj).to receive(:pid).and_return('monkey:99')
+      obj.stub(:pid).and_return('monkey:99')
       obj
     }
-  describe 'method lookup' do
-    it 'should find method keys in the YAML config' do
-      expect(ActiveFedora::ServiceDefinitions.lookup_method('fedora-system:3', 'viewObjectProfile')).to eq(:object_profile)
+  describe "method lookup" do
+    it "should find method keys in the YAML config" do
+      ActiveFedora::ServiceDefinitions.lookup_method("fedora-system:3", "viewObjectProfile").should == :object_profile
     end
   end
-  describe 'method creation' do
-    it 'should create the system sdef methods' do
-      expect(subject).to respond_to(:object_profile)
+  describe "method creation" do
+    it "should create the system sdef methods" do
+      subject.should respond_to(:object_profile)
     end
-    it 'should create the declared sdef methods' do
-      expect(subject).to respond_to(:document_style_1)
+    it "should create the declared sdef methods" do
+      subject.should respond_to(:document_style_1)
     end
   end
-  describe 'generated method' do
-    it 'should call the appropriate rubydora rest api method' do
-      expect(@repository).to receive(:dissemination).with({:pid => 'monkey:99', :sdef => 'test:12', :method => 'getDocumentStyle1'})
+  describe "generated method" do
+    it "should call the appropriate rubydora rest api method" do
+      @repository.should_receive(:dissemination).with({:pid=>'monkey:99',:sdef=>'test:12', :method=>'getDocumentStyle1'})
       #@mock_client.stub(:[]).with('objects/monkey%3A99/methods/test%3A12/getDocumentStyle1')
 
       subject.document_style_1
     end
-    it 'should call the appropriate rubydora rest api method with parameters' do
-      expect(@repository).to receive(:dissemination).with({:pid => 'monkey:99', :sdef => 'test:12', :method => 'getDocumentStyle1', :format => 'xml'})
+    it "should call the appropriate rubydora rest api method with parameters" do
+      @repository.should_receive(:dissemination).with({:pid=>'monkey:99',:sdef=>'test:12', :method=>'getDocumentStyle1', :format=>'xml'})
       obj = Test.new()
-      allow(obj).to receive(:pid).and_return('monkey:99')
-      obj.document_style_1({:format => 'xml'})
+      obj.stub(:pid).and_return('monkey:99')
+      obj.document_style_1({:format=>'xml'})
     end
-    it 'should call the appropriate rubydora rest api method with a block' do
-      allow(@repository).to receive(:dissemination).with({:pid => 'monkey:99', :sdef => 'test:12', :method => 'getDocumentStyle1'}).and_yield 'ping!', 'pang!'
+    it "should call the appropriate rubydora rest api method with a block" do
+      @repository.stub(:dissemination).with({:pid=>'monkey:99',:sdef=>'test:12', :method=>'getDocumentStyle1'}).and_yield "ping!","pang!"
       obj = Test.new()
-      allow(obj).to receive(:pid).and_return('monkey:99')
-      block_response = ''
-      obj.document_style_1 {|res, req|
-        block_response += 'pong!' if res == 'ping!' and req == 'pang!'
+      obj.stub(:pid).and_return('monkey:99')
+      block_response = ""
+      obj.document_style_1 {|res,req|
+        block_response += 'pong!' if res == "ping!" and req == "pang!"
       }
-      expect(block_response).to eq('pong!')
+      block_response.should == "pong!"
     end
   end
 end

data/spec/unit/simple_datastream_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe ActiveFedora::SimpleDatastream do
 
   before do
-    @sample_xml =  '<fields><coverage>coverage1</coverage><coverage>coverage2</coverage><creation_date>2012-01-15</creation_date><mydate>fake-date</mydate><publisher>publisher1</publisher></fields>'
+    @sample_xml =  "<fields><coverage>coverage1</coverage><coverage>coverage2</coverage><creation_date>2012-01-15</creation_date><mydate>fake-date</mydate><publisher>publisher1</publisher></fields>"
     @test_ds = ActiveFedora::SimpleDatastream.from_xml(@sample_xml )
     @test_ds.field :coverage
     @test_ds.field :creation_date, :date
@@ -11,36 +11,36 @@ describe ActiveFedora::SimpleDatastream do
     @test_ds.field :publisher
 
   end
-  it 'from_xml should parse everything correctly' do
-    expect(@test_ds.ng_xml).to be_equivalent_to @sample_xml
+  it "from_xml should parse everything correctly" do
+    @test_ds.ng_xml.should be_equivalent_to @sample_xml
   end
 
-
+  
   describe '#new' do
-    describe 'model methods' do
+    describe "model methods" do 
 
       [:coverage, :mydate, :publisher].each do |el|
         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
+          @test_ds.send("#{el.to_s}=", value) 
+          @test_ds.send(el).first.should == value  #Looking at first because creator has 2 nodes
         end
       end
 
-      it 'should set date elements' do
+      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)
+        @test_ds.creation_date.first.should == d
       end
     end
   end
-
+  
   describe '.to_xml' do
     it 'should output the fields hash as Qualified Dublin Core XML' do
-      @test_ds.publisher = 'charlie'
-      @test_ds.coverage = ['80%', '20%']
+      @test_ds.publisher= "charlie"
+      @test_ds.coverage= ["80%", "20%"]
 
-      expect(@test_ds.to_xml).to be_equivalent_to('
+      @test_ds.to_xml.should be_equivalent_to('
         <fields>
           <coverage>80%</coverage>
           <coverage>20%</coverage>
@@ -51,11 +51,11 @@ describe ActiveFedora::SimpleDatastream do
     end
   end
 
-  describe '#to_solr' do
-    it 'should have title' 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')
+      solr[ActiveFedora::SolrService.solr_name('publisher', type: :string)].should == "publisher1"
+      solr[ActiveFedora::SolrService.solr_name('creation_date', type: :date)].should == "2012-01-15"
     end
   end
 

data/spec/unit/solr_config_options_spec.rb

@@ -4,64 +4,65 @@ require 'spec_helper'
 #include ActiveFedora
 
 describe ActiveFedora do
-
+  
   before(:all) do
     module SolrSpecModel
       class Basic < ActiveFedora::Base
-        def init_with_object(inner_obj)
+        def init_with(inner_obj)
         end
       end
     end
   end
-
+  
   before(:each) do
     @test_object = ActiveFedora::Base.new
   end
-
-
-  describe 'SOLR_DOCUMENT_ID' do
+  
+  
+  describe "SOLR_DOCUMENT_ID" do
     before(:all) do
-      SOLR_DOCUMENT_ID = 'MY_SAMPLE_ID'
+      SOLR_DOCUMENT_ID = "MY_SAMPLE_ID"
     end
     after(:all) do
-      SOLR_DOCUMENT_ID = 'id'
+      SOLR_DOCUMENT_ID = "id"
     end
-    it 'should be used by ActiveFedora::Base.to_solr' do
+    it "should be used by ActiveFedora::Base.to_solr" do
       @test_object.stub(pid: '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[:id]).to be_nil
+      SOLR_DOCUMENT_ID = "MY_SAMPLE_ID"
+      @test_object.to_solr[SOLR_DOCUMENT_ID.to_sym].should == 'changeme:123'
+      @test_object.to_solr[:id].should 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(SolrSpecModel::Basic.find_with_conditions(:id => 'changeme:30')).to equal(mock_response)
+    it "should be used by ActiveFedora::Base#find_with_conditions" do
+      mock_response = double("SolrResponse")
+      ActiveFedora::SolrService.should_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)
+  
+      SolrSpecModel::Basic.find_with_conditions(:id=>"changeme:30").should equal(mock_response)
     end
   end
-
-  describe 'ENABLE_SOLR_UPDATES' do
-
+  
+  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
+    
+    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
-      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.stub(:datastreams).and_return({:ds1 => dirty_ds})
+      @test_object.should_receive(:update_index).never
+      @test_object.should_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)
+    it "should prevent Base.delete from deleting the corresponding Solr document if false" do
+      ActiveFedora::SolrService.instance.conn.should_receive(:delete).with(@test_object.pid).never 
+      @test_object.inner_object.should_receive(:delete)
       @test_object.delete
     end
   end
 end
+

data/spec/unit/solr_digital_object_spec.rb

@@ -1,26 +1,25 @@
 require 'spec_helper'
 
 describe ActiveFedora::SolrDigitalObject do
-
-  describe 'repository' do
-    subject { ActiveFedora::SolrDigitalObject.new({}, {'datastreams' => {}}) }
-    describe 'when not finished' do
-      it 'should not respond_to? :repository' do
-        expect(subject).not_to respond_to :repository
+  describe "repository" do
+    subject { ActiveFedora::SolrDigitalObject.new({},{'datastreams'=>{}}) }
+    describe "when not finished" do
+      it "should not respond_to? :repository" do
+        subject.should_not respond_to :repository
       end
     end
-    describe 'when finished' do
+    describe "when finished" do
       before do
         subject.freeze
       end
-      it 'should respond_to? :repository' do
-        expect(subject).to respond_to :repository
+      it "should respond_to? :repository" do
+        subject.should respond_to :repository
       end
     end
   end
 
-  describe 'initializing' do
-    describe 'without a datastream in the ds spec and an xml mime type in the solr doc' do
+  describe "initializing" do
+    describe "without a datastream in the ds spec and an xml mime type in the solr doc" do
       before do
         class WithoutMetadataDs < ActiveFedora::Base
           ## No datastreams are defined in this class
@@ -29,22 +28,22 @@ describe ActiveFedora::SolrDigitalObject do
       after do
         Object.send(:remove_const, :WithoutMetadataDs)
       end
-      subject { ActiveFedora::SolrDigitalObject.new({}, {'datastreams' => {'properties' => {'dsMIME' => 'text/xml'}}}, WithoutMetadataDs) }
-      it 'should create an xml datastream' do
-        expect(subject.datastreams['properties']).to be_kind_of ActiveFedora::OmDatastream
+      subject { ActiveFedora::SolrDigitalObject.new({}, {'datastreams'=>{'properties'=>{'dsMIME'=>'text/xml'}}},WithoutMetadataDs) }
+      it "should create an xml datastream" do
+        subject.datastreams['properties'].should be_kind_of ActiveFedora::OmDatastream
       end
     end
-
+    
     describe "with a ds spec that's not part of the solrized object" do
       before do
         class MissingMetadataDs < ActiveFedora::Base
-          has_metadata :name => 'foo', :type => ActiveFedora::OmDatastream, :label => 'Foo Data'
+          has_metadata :name => "foo", :type => ActiveFedora::OmDatastream, :label => 'Foo Data'
         end
         after do
           Object.send(:remove_const, MissingMetadataDs)
         end
-        subject { ActiveFedora::SolrDigitalObject.new({}, {'datastreams' => {'properties' => {'dsMIME' => 'text/xml'}}}, MissingMetadataDs) }
-        it 'should have a foo datastream' do
+        subject { ActiveFedora::SolrDigitalObject.new({}, {'datastreams'=>{'properties'=>{'dsMIME'=>'text/xml'}}},MissingMetadataDs) }
+        it "should have a foo datastream" do
           subject.datastreams['foo'].label.should == 'Foo Data'
         end
       end
@@ -52,11 +51,4 @@ describe ActiveFedora::SolrDigitalObject do
   end
 
 
-  describe 'new_record?' do
-    subject { ActiveFedora::SolrDigitalObject.new({}, {'datastreams' => {}}) }
-    it 'should respond to :new_record? and return false' do
-      expect(subject.new_record?).to be_falsey
-    end
-  end
-
 end

data/spec/unit/solr_service_spec.rb

@@ -2,142 +2,155 @@ require 'spec_helper'
 
 describe ActiveFedora::SolrService do
   before do
-    Thread.current[:solr_service] = nil
+    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
-    expect(RSolr).to receive(:connect).with(:read_timeout => 120, :open_timeout => 120, :url => 'http://localhost:8080/solr')
+  
+  it "should take a narg constructor and configure for localhost" do
+    RSolr.should_receive(:connect).with(:read_timeout => 120, :open_timeout => 120, :url => 'http://localhost:8080/solr')
     ActiveFedora::SolrService.register
   end
-  it 'should accept host arg into constructor' do
-    expect(RSolr).to receive(:connect).with(:read_timeout => 120, :open_timeout => 120, :url => 'http://fubar')
+  it "should accept host arg into constructor" do
+    RSolr.should_receive(:connect).with(:read_timeout => 120, :open_timeout => 120, :url => 'http://fubar')
     ActiveFedora::SolrService.register('http://fubar')
   end
-  it 'should clobber options' do
-    expect(RSolr).to receive(:connect).with(:read_timeout => 120, :open_timeout => 120, :url => 'http://localhost:8080/solr', :autocommit => :off, :foo => :bar)
-    ActiveFedora::SolrService.register(nil, {:autocommit => :off, :foo => :bar})
+  it "should clobber options" do
+    RSolr.should_receive(:connect).with(:read_timeout => 120, :open_timeout => 120, :url => 'http://localhost:8080/solr', :autocommit=>:off, :foo=>:bar)
+    ActiveFedora::SolrService.register(nil, {:autocommit=>:off, :foo=>:bar})
   end
 
-  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)
+  it "should set the threadlocal solr service" do
+    RSolr.should_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})
+    Thread.current[:solr_service].should == ss
+    ActiveFedora::SolrService.instance.should == 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)
+  it "should try to initialize if the service not initialized, and fail if it does not succeed" do
+    Thread.current[:solr_service].should be_nil
+    ActiveFedora::SolrService.should_receive(:register)
+    proc{ActiveFedora::SolrService.instance}.should raise_error(ActiveFedora::SolrNotInitialized)
   end
 
-  describe 'reify solr results' do
+  describe "reify solr results" do
     before(:all) do
       class AudioRecord
         attr_accessor :pid
-        def init_with_object(inner_obj)
+        def init_with(inner_obj)
           self.pid = inner_obj.pid
           self
         end
         def self.connection_for_pid(pid)
         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:_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"]}]
+    end
+    describe ".reify_solr_result" do
+      it "should use .find to instantiate objects" do
+        AudioRecord.should_receive(:find).with("my:_PID1_", 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
+        AudioRecord.should_receive(:load_instance_from_solr).with("my:_PID1_", @sample_solr_hits.first)
+        ActiveFedora::SolrService.should_not 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)
+    describe ".reify_solr_results" do
+      it "should use AudioRecord.find to instantiate objects" do
+        AudioRecord.should_receive(:find).with("my:_PID1_", cast: true)
+        AudioRecord.should_receive(:find).with("my:_PID2_", cast: true)
+        AudioRecord.should_receive(:find).with("my:_PID3_", 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_')
-        expect(AudioRecord).to receive(:load_instance_from_solr).with('my:_PID2_')
-        expect(AudioRecord).to receive(:load_instance_from_solr).with('my:_PID3_')
+      it "should use AudioRecord.load_instance_from_solr when called with :load_from_solr option" do
+        AudioRecord.should_receive(:load_instance_from_solr).with("my:_PID1_", @sample_solr_hits[0])
+        AudioRecord.should_receive(:load_instance_from_solr).with("my:_PID2_", @sample_solr_hits[1])
+        AudioRecord.should_receive(:load_instance_from_solr).with("my:_PID3_", @sample_solr_hits[2])
+        ActiveFedora::SolrService.should_not 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)
+    describe ".lazy_reify_solr_results" do
+      it "should lazily reify solr results" do
+        AudioRecord.should_receive(:find).with("my:_PID1_", cast: true)
+        AudioRecord.should_receive(:find).with("my:_PID2_", cast: true)
+        AudioRecord.should_receive(:find).with("my:_PID3_", 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_')
-        expect(AudioRecord).to receive(:load_instance_from_solr).with('my:_PID2_')
-        expect(AudioRecord).to receive(:load_instance_from_solr).with('my:_PID3_')
+      it "should use AudioRecord.load_instance_from_solr when called with :load_from_solr option" do
+        AudioRecord.should_receive(:load_instance_from_solr).with("my:_PID1_", @sample_solr_hits[0])
+        AudioRecord.should_receive(:load_instance_from_solr).with("my:_PID2_", @sample_solr_hits[1])
+        AudioRecord.should_receive(:load_instance_from_solr).with("my:_PID3_", @sample_solr_hits[2])
+        ActiveFedora::SolrService.should_not receive(:query)
         ActiveFedora::SolrService.lazy_reify_solr_results(@sample_solr_hits, load_from_solr: true).each {|r| r}
       end
     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_"')
+    it "should generate a useable solr query from an array of Fedora pids" do
+      ActiveFedora::SolrService.construct_query_for_pids(["my:_PID1_", "my:_PID2_", "my:_PID3_"]).should == '_query_:"{!raw f=id}my:_PID1_" OR _query_:"{!raw f=id}my:_PID2_" OR _query_:"{!raw f=id}my:_PID3_"'
 
     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')
-
+    it "should return a valid solr query even if given an empty array as input" do
+      ActiveFedora::SolrService.construct_query_for_pids([""]).should == "id:NEVER_USE_THIS_ID"
+      
     end
   end
-
+  
   describe '#escape_uri_for_query' do
-    it 'should escape : with a backslash' do
-      expect(ActiveFedora::SolrService.escape_uri_for_query('my:pid')).to eq('my\:pid')
+    it "should escape : with a backslash" do
+      ActiveFedora::SolrService.escape_uri_for_query("my:pid").should == 'my\:pid'
     end
   end
 
-  describe '.query' do
-    it 'should call solr' 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)
-      ActiveFedora::SolrService.stub(:instance => double('instance', :conn => mock_conn))
-      expect(ActiveFedora::SolrService.query('querytext', :raw => true)).to eq(stub_result)
+  describe ".query" do
+    it "should call solr" do 
+      mock_conn = double("Connection")
+      stub_result = double("Result")
+      mock_conn.should_receive(:get).with('select', :params=>{:q=>'querytext', :qt=>'standard'}).and_return(stub_result)
+      ActiveFedora::SolrService.stub(:instance =>double("instance", :conn=>mock_conn))
+      ActiveFedora::SolrService.query('querytext', :raw=>true).should == stub_result
     end
   end
-  describe '.count' do
-    it 'should return a count of matching records' 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)
-      ActiveFedora::SolrService.stub(:instance => double('instance', :conn => mock_conn))
-      expect(ActiveFedora::SolrService.count('querytext')).to eq(7)
+  describe ".count" do
+    it "should return a count of matching records" do 
+      mock_conn = double("Connection")
+      stub_result = {'response' => {'numFound'=>'7'}}
+      mock_conn.should_receive(:get).with('select', :params=>{:rows=>0, :q=>'querytext', :qt=>'standard'}).and_return(stub_result)
+      ActiveFedora::SolrService.stub(:instance =>double("instance", :conn=>mock_conn))
+      ActiveFedora::SolrService.count('querytext').should == 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)
-      ActiveFedora::SolrService.stub(:instance => double('instance', :conn => mock_conn))
-      expect(ActiveFedora::SolrService.count('querytext', :fq => 'filter', :rows => 10)).to eq(7)
+    it "should accept query args" do
+      mock_conn = double("Connection")
+      stub_result = {'response' => {'numFound'=>'7'}}
+      mock_conn.should_receive(:get).with('select', :params=>{:rows=>0, :q=>'querytext', :qt=>'standard', :fq=>'filter'}).and_return(stub_result)
+      ActiveFedora::SolrService.stub(:instance =>double("instance", :conn=>mock_conn))
+      ActiveFedora::SolrService.count('querytext', :fq=>'filter', :rows=>10).should == 7 
     end
   end
-  describe '.add' do
-    it 'should call solr' do
-      mock_conn = double('Connection')
+  describe ".add" do
+    it "should call solr" do 
+      mock_conn = double("Connection")
       doc = {'id' => '1234'}
-      expect(mock_conn).to receive(:add).with(doc)
-      ActiveFedora::SolrService.stub(:instance => double('instance', :conn => mock_conn))
+      mock_conn.should_receive(:add).with(doc)
+      ActiveFedora::SolrService.stub(:instance =>double("instance", :conn=>mock_conn))
       ActiveFedora::SolrService.add(doc)
     end
   end
-  describe '.commit' do
-    it 'should call solr' do
-      mock_conn = double('Connection')
+  describe ".commit" do
+    it "should call solr" do 
+      mock_conn = double("Connection")
       doc = {'id' => '1234'}
-      expect(mock_conn).to receive(:commit)
-      ActiveFedora::SolrService.stub(:instance => double('instance', :conn => mock_conn))
+      mock_conn.should_receive(:commit)
+      ActiveFedora::SolrService.stub(:instance =>double("instance", :conn=>mock_conn))
       ActiveFedora::SolrService.commit()
     end
   end
-
+  
 end