active-fedora 6.7.8 → 6.8.0

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)
-    @repository.stub(:datastream_dissemination).with({:pid=>'test:12',:dsid=>'METHODMAP'}).and_return mmap
-    Test.has_service_definition "test:12"
+    allow(@repository).to receive(:datastream_dissemination).with({:pid => 'test:12', :dsid => 'METHODMAP'}).and_return mmap
+    Test.has_service_definition 'test:12'
   end
 
-  subject { 
+  subject {
       obj = Test.new()
-      obj.stub(:pid).and_return('monkey:99')
+      allow(obj).to receive(:pid).and_return('monkey:99')
       obj
     }
-  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
+  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)
     end
   end
-  describe "method creation" do
-    it "should create the system sdef methods" do
-      subject.should respond_to(:object_profile)
+  describe 'method creation' do
+    it 'should create the system sdef methods' do
+      expect(subject).to respond_to(:object_profile)
     end
-    it "should create the declared sdef methods" do
-      subject.should respond_to(:document_style_1)
+    it 'should create the declared sdef methods' do
+      expect(subject).to respond_to(:document_style_1)
     end
   end
-  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'})
+  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'})
       #@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
-      @repository.should_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
+      expect(@repository).to receive(:dissemination).with({:pid => 'monkey:99', :sdef => 'test:12', :method => 'getDocumentStyle1', :format => 'xml'})
       obj = Test.new()
-      obj.stub(:pid).and_return('monkey:99')
-      obj.document_style_1({:format=>'xml'})
+      allow(obj).to receive(: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
-      @repository.stub(: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
+      allow(@repository).to receive(:dissemination).with({:pid => 'monkey:99', :sdef => 'test:12', :method => 'getDocumentStyle1'}).and_yield 'ping!', 'pang!'
       obj = Test.new()
-      obj.stub(:pid).and_return('monkey:99')
-      block_response = ""
-      obj.document_style_1 {|res,req|
-        block_response += 'pong!' if res == "ping!" and req == "pang!"
+      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!'
       }
-      block_response.should == "pong!"
+      expect(block_response).to eq('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
-    @test_ds.ng_xml.should be_equivalent_to @sample_xml
+  it 'from_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 
+    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) 
-          @test_ds.send(el).first.should == value  #Looking at first because creator has 2 nodes
+          @test_ds.send("#{el.to_s}=", value)
+          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
+      it 'should set date elements' do
         d = Date.parse('1939-05-23')
         @test_ds.creation_date = d
-        @test_ds.creation_date.first.should == d
+        expect(@test_ds.creation_date.first).to eq(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%']
 
-      @test_ds.to_xml.should be_equivalent_to('
+      expect(@test_ds.to_xml).to 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
-      solr[ActiveFedora::SolrService.solr_name('publisher', type: :string)].should == "publisher1"
-      solr[ActiveFedora::SolrService.solr_name('creation_date', type: :date)].should == "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

@@ -4,7 +4,7 @@ require 'spec_helper'
 #include ActiveFedora
 
 describe ActiveFedora do
-  
+
   before(:all) do
     module SolrSpecModel
       class Basic < ActiveFedora::Base
@@ -13,56 +13,55 @@ describe ActiveFedora do
       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"
-      @test_object.to_solr[SOLR_DOCUMENT_ID.to_sym].should == 'changeme:123'
-      @test_object.to_solr[:id].should be_nil
+      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
     end
 
-    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)
+    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)
     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
-      @test_object.stub(:datastreams).and_return({:ds1 => dirty_ds})
-      @test_object.should_receive(:update_index).never
-      @test_object.should_receive(:refresh)
+      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
-      ActiveFedora::SolrService.instance.conn.should_receive(:delete).with(@test_object.pid).never 
-      @test_object.inner_object.should_receive(:delete)
+    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)
       @test_object.delete
     end
   end
 end
-

data/spec/unit/solr_digital_object_spec.rb

@@ -2,25 +2,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
-        subject.should_not respond_to :repository
+  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
       end
     end
-    describe "when finished" do
+    describe 'when finished' do
       before do
         subject.freeze
       end
-      it "should respond_to? :repository" do
-        subject.should respond_to :repository
+      it 'should respond_to? :repository' do
+        expect(subject).to 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 +29,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
-        subject.datastreams['properties'].should be_kind_of ActiveFedora::OmDatastream
+      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
       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,10 +52,10 @@ describe ActiveFedora::SolrDigitalObject do
   end
 
 
-  describe "new_record?" do
-    subject { ActiveFedora::SolrDigitalObject.new({},{'datastreams'=>{}}) }
-    it "should respond to :new_record? and return false" do
-      subject.new_record?.should be_false
+  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
 

data/spec/unit/solr_service_spec.rb

@@ -2,39 +2,39 @@ 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
-    RSolr.should_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
+    expect(RSolr).to 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
-    RSolr.should_receive(:connect).with(:read_timeout => 120, :open_timeout => 120, :url => 'http://fubar')
+  it 'should accept host arg into constructor' do
+    expect(RSolr).to receive(:connect).with(:read_timeout => 120, :open_timeout => 120, :url => 'http://fubar')
     ActiveFedora::SolrService.register('http://fubar')
   end
-  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})
+  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})
   end
 
-  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
+  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)
   end
-  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)
+  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)
   end
 
-  describe "reify solr results" do
+  describe 'reify solr results' do
     before(:all) do
       class AudioRecord
         attr_accessor :pid
@@ -45,99 +45,99 @@ describe ActiveFedora::SolrService do
         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_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)
+    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)
         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
-        AudioRecord.should_receive(:load_instance_from_solr).with("my:_PID1_")
-        AudioRecord.should_receive(:load_instance_from_solr).with("my:_PID2_")
-        AudioRecord.should_receive(:load_instance_from_solr).with("my:_PID3_")
+      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_')
         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
-        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)
+    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)
         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
-        AudioRecord.should_receive(:load_instance_from_solr).with("my:_PID1_")
-        AudioRecord.should_receive(:load_instance_from_solr).with("my:_PID2_")
-        AudioRecord.should_receive(:load_instance_from_solr).with("my:_PID3_")
+      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_')
         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
-      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_"'
+    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_"')
 
     end
-    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"
-      
+    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')
+
     end
   end
-  
+
   describe '#escape_uri_for_query' do
-    it "should escape : with a backslash" do
-      ActiveFedora::SolrService.escape_uri_for_query("my:pid").should == 'my\:pid'
+    it 'should escape : with a backslash' do
+      expect(ActiveFedora::SolrService.escape_uri_for_query('my:pid')).to eq('my\:pid')
     end
   end
 
-  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
+  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)
     end
   end
-  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 
+  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)
     end
-    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 
+    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)
     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'}
-      mock_conn.should_receive(:add).with(doc)
-      ActiveFedora::SolrService.stub(:instance =>double("instance", :conn=>mock_conn))
+      expect(mock_conn).to 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'}
-      mock_conn.should_receive(:commit)
-      ActiveFedora::SolrService.stub(:instance =>double("instance", :conn=>mock_conn))
+      expect(mock_conn).to receive(:commit)
+      ActiveFedora::SolrService.stub(:instance => double('instance', :conn => mock_conn))
       ActiveFedora::SolrService.commit()
     end
   end
-  
+
 end