harvestdor 0.0.13 → 0.0.14

data/spec/oai_harvest_spec.rb

@@ -12,9 +12,9 @@ describe 'Harvestdor::Client oai harvesting' do
   describe "druids_via_oai" do
     before(:each) do
       oai_response = double('oai_response')
-      oai_response.stub(:entries).and_return(['foo', 'bar'])
-      oai_response.stub(:resumption_token).and_return('')
-      @harvestdor_client.oai_client.stub(:list_identifiers).with(an_instance_of(Hash)) { 
+      allow(oai_response).to receive(:entries).and_return(['foo', 'bar'])
+      allow(oai_response).to receive(:resumption_token).and_return('')
+      allow(@harvestdor_client.oai_client).to receive(:list_identifiers).with(an_instance_of(Hash)) { 
           oai_response
       }
     end
@@ -24,14 +24,14 @@ describe 'Harvestdor::Client oai harvesting' do
       header2 = OAI::Header.new(nil)
       header2.identifier = 'oai:searchworks.stanford.edu/druid:bar'
       oai_response = double('oai_response')
-      oai_response.stub(:entries).and_return([header1, header2])
-      @harvestdor_client.druids_via_oai.should == ['foo', 'bar']
+      allow(oai_response).to receive(:entries).and_return([header1, header2])
+      expect(@harvestdor_client.druids_via_oai).to eql(['foo', 'bar'])
     end
     it "should have results viewable as an array" do
-      @harvestdor_client.druids_via_oai.should be_an_instance_of(Array)
+      expect(@harvestdor_client.druids_via_oai).to be_an_instance_of(Array)
     end
     it "should have enumerable results" do
-      @harvestdor_client.druids_via_oai.should respond_to(:each, :count)
+      expect(@harvestdor_client.druids_via_oai).to respond_to(:each, :count)
     end
     it "should yield to a passed block" do
       expect { |b| @harvestdor_client.druids_via_oai(&b) }.to yield_successive_args('foo', 'bar')
@@ -41,9 +41,9 @@ describe 'Harvestdor::Client oai harvesting' do
   describe "oai_records" do
     before(:each) do
       @oai_response = double('oai_response')
-      @oai_response.stub(:entries).and_return([1, 2])
-      @oai_response.stub(:resumption_token).and_return('')
-      @harvestdor_client.oai_client.stub(:list_records).with(an_instance_of(Hash)) { 
+      allow(@oai_response).to receive(:entries).and_return([1, 2])
+      allow(@oai_response).to receive(:resumption_token).and_return('')
+      allow(@harvestdor_client.oai_client).to receive(:list_records).with(an_instance_of(Hash)) { 
           @oai_response
       }
     end
@@ -56,14 +56,14 @@ describe 'Harvestdor::Client oai harvesting' do
       header2.identifier = 'oai:searchworks.stanford.edu/druid:bar'
       oai_rec2 = OAI::Record.new(nil)
       oai_rec2.header = header2
-      @oai_response.stub(:entries).and_return([oai_rec1, oai_rec2])
-      @harvestdor_client.oai_records.should == [oai_rec1, oai_rec2]
+      allow(@oai_response).to receive(:entries).and_return([oai_rec1, oai_rec2])
+      expect(@harvestdor_client.oai_records).to eql([oai_rec1, oai_rec2])
     end
     it "should have results viewable as an array" do
-      @harvestdor_client.oai_records.should be_an_instance_of(Array)
+      expect(@harvestdor_client.oai_records).to be_an_instance_of(Array)
     end
     it "should have enumerable results" do
-      @harvestdor_client.oai_records.should respond_to(:each, :count)
+      expect(@harvestdor_client.oai_records).to respond_to(:each, :count)
     end
     it "should yield to a passed block" do
       expect { |b| @harvestdor_client.oai_records(&b) }.to yield_successive_args(1, 2)
@@ -73,9 +73,9 @@ describe 'Harvestdor::Client oai harvesting' do
   describe "oai_headers" do
     before(:each) do
       @oai_response = double('oai_response')
-      @oai_response.stub(:entries).and_return([1, 2])
-      @oai_response.stub(:resumption_token).and_return('')
-      @harvestdor_client.oai_client.stub(:list_identifiers).with(an_instance_of(Hash)) { 
+      allow(@oai_response).to receive(:entries).and_return([1, 2])
+      allow(@oai_response).to receive(:resumption_token).and_return('')
+      allow(@harvestdor_client.oai_client).to receive(:list_identifiers).with(an_instance_of(Hash)) { 
           @oai_response
       }
     end
@@ -84,14 +84,14 @@ describe 'Harvestdor::Client oai harvesting' do
       header1.identifier = 'oai:searchworks.stanford.edu/druid:foo'
       header2 = OAI::Header.new(nil)
       header2.identifier = 'oai:searchworks.stanford.edu/druid:bar'
-      @oai_response.stub(:entries).and_return([header1, header2])
-      @harvestdor_client.oai_headers.should == [header1, header2]
+      allow(@oai_response).to receive(:entries).and_return([header1, header2])
+      expect(@harvestdor_client.oai_headers).to eql([header1, header2])
     end
     it "should have results viewable as an array" do
-      @harvestdor_client.oai_headers.should be_an_instance_of(Array)
+      expect(@harvestdor_client.oai_headers).to be_an_instance_of(Array)
     end
     it "should have enumerable results" do
-      @harvestdor_client.oai_headers.should respond_to(:each, :count)
+      expect(@harvestdor_client.oai_headers).to respond_to(:each, :count)
     end
     it "should yield to a passed block" do
       expect { |b| @harvestdor_client.oai_headers(&b) }.to yield_successive_args(1, 2)
@@ -102,12 +102,12 @@ describe 'Harvestdor::Client oai harvesting' do
     it "should return OAI::Record object" do
       oai_rec = OAI::Record.new(nil)
       oai_resp = double('oai_response')
-      oai_resp.stub(:record).and_return(oai_rec)
-      @harvestdor_client.oai_client.stub(:get_record) { 
+      allow(oai_resp).to receive(:record).and_return(oai_rec)
+      allow(@harvestdor_client.oai_client).to receive(:get_record){
           oai_resp
       }
-      @harvestdor_client.oai_record('druid').should == oai_rec
-      @harvestdor_client.oai_record('druid', 'mods').should == oai_rec
+      expect(@harvestdor_client.oai_record('druid')).to eql(oai_rec)
+      expect(@harvestdor_client.oai_record('druid', 'mods')).to eql(oai_rec)
     end
   end  
 
@@ -120,57 +120,57 @@ describe 'Harvestdor::Client oai harvesting' do
       
     end
     it "should use client's default values for OAI arguments if they are not present in the method param hash" do
-      @harvestdor_client.send(:scrub_oai_args).should == @expected_oai_args
+      expect(@harvestdor_client.send(:scrub_oai_args)).to eql(@expected_oai_args)
     end
     it "should use OAI arguments from the method param hash if they are present" do
       passed_options = {:metadata_prefix => 'mods', :from => '2012-11-30'}
-      @harvestdor_client.send(:scrub_oai_args, passed_options).should == @expected_oai_args.merge(passed_options)
+      expect(@harvestdor_client.send(:scrub_oai_args, passed_options)).to eql(@expected_oai_args.merge(passed_options))
     end
     it "should use nil value for option when it is passed in options hash" do
       client = Harvestdor::Client.new({:default_from_date => '2012-01-01'})
-      client.config.default_from_date.should == '2012-01-01'
+      expect(client.config.default_from_date).to eql('2012-01-01')
       passed_options = {:from => nil}
-      client.send(:scrub_oai_args, passed_options)[:from].should == nil
+      expect(client.send(:scrub_oai_args, passed_options)[:from]).to eql(nil)
     end
   end
 
   describe "harvest" do
     it "should perform a list_records OAI request when first arg is true" do
       oai_response = double('oai_response')
-      oai_response.stub(:entries).and_return([])
-      @harvestdor_client.oai_client.stub(:list_records).with(an_instance_of(Hash)) { 
+      allow(oai_response).to receive(:entries).and_return([])
+      allow(@harvestdor_client.oai_client).to receive(:list_records).with(an_instance_of(Hash)) { 
           oai_response
       }
-      @harvestdor_client.oai_client.should_receive(:list_records)
+      expect(@harvestdor_client.oai_client).to receive(:list_records)
       @harvestdor_client.send(:harvest, :list_records, {})
     end
     
     it "should perform a list_identifiers OAI request when first arg is false" do
       oai_response = double('oai_response')
-      oai_response.stub(:entries).and_return([])
-      @harvestdor_client.oai_client.stub(:list_identifiers).with(an_instance_of(Hash)) { 
+      allow(oai_response).to receive(:entries).and_return([])
+      allow(@harvestdor_client.oai_client).to receive(:list_identifiers).with(an_instance_of(Hash)) { 
           oai_response
       }
-      @harvestdor_client.oai_client.should_receive(:list_identifiers)
+      expect(@harvestdor_client.oai_client).to receive(:list_identifiers)
       @harvestdor_client.send(:harvest, :list_identifiers, {})
     end
 
     it "should use passed OAI arguments" do
       oai_response = double('oai_response')
-      oai_response.stub(:entries).and_return([])
-      @harvestdor_client.oai_client.stub(:list_identifiers).with(an_instance_of(Hash)) { 
+      allow(oai_response).to receive(:entries).and_return([])
+      allow(@harvestdor_client.oai_client).to receive(:list_identifiers).with(an_instance_of(Hash)) { 
           oai_response
       }
       oai_options_hash = {:metadata_prefix => 'mods', :from => '2012-11-30'}
-      @harvestdor_client.oai_client.should_receive(:list_identifiers).with(oai_options_hash)
+      expect(@harvestdor_client.oai_client).to receive(:list_identifiers).with(oai_options_hash)
       @harvestdor_client.send(:harvest, :list_identifiers, oai_options_hash)
     end
     
     it "should yield to a passed block" do
       oai_response = double('oai_response')
-      oai_response.stub(:entries).and_return([1, 2])
-      oai_response.stub(:resumption_token).and_return('')
-      @harvestdor_client.oai_client.stub(:list_records).with(an_instance_of(Hash)) { 
+      allow(oai_response).to receive(:entries).and_return([1, 2])
+      allow(oai_response).to receive(:resumption_token).and_return('')
+      allow(@harvestdor_client.oai_client).to receive(:list_records).with(an_instance_of(Hash)) { 
           oai_response
       }
       expect { |b| @harvestdor_client.send(:harvest, :list_records, {}, &b) }.to yield_successive_args(1, 2)
@@ -179,34 +179,34 @@ describe 'Harvestdor::Client oai harvesting' do
     context "resumption tokens" do
       it "should stop processing when no records/headers are received" do
         oai_response = double('oai_response')
-        oai_response.stub(:entries).and_return([])
-        @harvestdor_client.oai_client.stub(:list_records).with(an_instance_of(Hash)) { 
+        allow(oai_response).to receive(:entries).and_return([])
+        allow(@harvestdor_client.oai_client).to receive(:list_records).with(an_instance_of(Hash)) { 
             oai_response
         }
 
         i = 0
         @harvestdor_client.send(:harvest, :list_records, {}) { |record| i += 1 }
-        i.should == 0
+        expect(i).to eql(0)
       end
 
       it "should stop processing when the resumption token is empty" do
         oai_response_with_token = double('oai_response')
-        oai_response_with_token.stub(:entries).and_return([1,2,3,4,5])
-        oai_response_with_token.stub(:resumption_token).and_return('')
-        @harvestdor_client.oai_client.stub(:list_records).with(an_instance_of(Hash)) { 
+        allow(oai_response_with_token).to receive(:entries).and_return([1,2,3,4,5])
+        allow(oai_response_with_token).to receive(:resumption_token).and_return('')
+        allow(@harvestdor_client.oai_client).to receive(:list_records).with(an_instance_of(Hash)) { 
           oai_response_with_token
         }
 
         i = 0
         @harvestdor_client.send(:harvest, :list_records, {}) { |record| i += 1 }
-        i.should == 5
+        expect(i).to eql(5)
       end
 
       it "should stop processing when there was no resumption token" do
         oai_response_with_token = double('oai_response')
-        oai_response_with_token.stub(:entries).and_return([1,2,3,4,5])
-        oai_response_with_token.stub(:resumption_token).and_return(nil)
-        @harvestdor_client.oai_client.stub(:list_records).with(an_instance_of(Hash)) { 
+        allow(oai_response_with_token).to receive(:entries).and_return([1,2,3,4,5])
+        allow(oai_response_with_token).to receive(:resumption_token).and_return(nil)
+        allow(@harvestdor_client.oai_client).to receive(:list_records).with(an_instance_of(Hash)) { 
           oai_response_with_token
         }
 

data/spec/oai_integration_spec.rb

@@ -16,18 +16,22 @@ describe 'Harvestdor::Client OAI Harvesting Integration Tests', :integration =>
         @oai_args = {:metadata_prefix => 'mods', :from => nil, :until => nil, :set => 'is_governed_by_hy787xj5878'}
       end
       it "should be able to harvest headers" do
-        headers = @test_hclient.oai_headers(@oai_args)
-        headers.should be_an_instance_of(Array)
-        headers.size.should > 0
-        headers.size.should < 50  # no resumption token
-        headers.first.should be_an_instance_of(OAI::Header)
+        VCR.use_cassette('headers') do
+          headers = @test_hclient.oai_headers(@oai_args)
+          expect(headers).to be_an_instance_of(Array)
+          expect(headers.size).to be > 0
+          expect(headers.size).to be < 50  # no resumption token
+          expect(headers.first).to be_an_instance_of(OAI::Header)
+        end
       end
       it "should be able to harvest records" do
-        records = @test_hclient.oai_records(@oai_args)
-        records.should be_an_instance_of(Array)
-        records.size.should > 0
-        records.size.should < 50  # no resumption token
-        records.first.should be_an_instance_of(OAI::Record)
+        VCR.use_cassette('records') do
+          records = @test_hclient.oai_records(@oai_args)
+          expect(records).to be_an_instance_of(Array)
+          expect(records.size).to be > 0
+          expect(records.size).to be < 50  # no resumption token
+          expect(records.first).to be_an_instance_of(OAI::Record)
+        end
       end
     end
     context "with resumption tokens" do
@@ -37,29 +41,31 @@ describe 'Harvestdor::Client OAI Harvesting Integration Tests', :integration =>
       it "should be able to harvest headers" do
         skip "need to find small set > 50 on test"
         headers = @test_hclient.oai_headers(@oai_args)
-        headers.should be_an_instance_of(Array)
-        headers.size.should > 50
-        headers.first.should be_an_instance_of(OAI::Header)
+        expect(headers).to be_an_instance_of(Array)
+        expect(headers.size).to be > 50
+        expect(headers.first).to be_an_instance_of(OAI::Header)
       end
       it "should be able to harvest records" do
-        pending "need to find small set > 50 on test"
+        skip "need to find small set > 50 on test"
         records = @test_hclient.harvest_records(@oai_args)
-        records.should be_an_instance_of(Array)
-        records.size.should > 50
-        records.first.should be_an_instance_of(OAI::Record)
+        expect(records).to be_an_instance_of(Array)
+        expect(records.size).to be > 50
+        expect(records.first).to be_an_instance_of(OAI::Record)
       end
     end
     context "oai_record (single record request)" do
       before(:all) do
-        @rec = @test_hclient.oai_record('jt959wc5586')
+        VCR.use_cassette('jt959wc5586_test') do
+          @rec = @test_hclient.oai_record('jt959wc5586')
+        end
       end
       it "should get a single OAI::Record object" do
-        @rec.should be_an_instance_of(OAI::Record)
+        expect(@rec).to be_an_instance_of(OAI::Record)
       end
       it "should keep utf-8 encoded characters intact" do
         xml = Nokogiri::XML(@rec.metadata.to_s)
         xml.remove_namespaces!
-        xml.root.xpath('/metadata/mods/titleInfo/subTitle').text.should =~ /^recueil complet des débats législatifs & politiques des chambres françaises/
+        expect(xml.root.xpath('/metadata/mods/titleInfo/subTitle').text).to match /^recueil complet des débats législatifs & politiques des chambres françaises/
       end
     end
   end
@@ -74,18 +80,22 @@ describe 'Harvestdor::Client OAI Harvesting Integration Tests', :integration =>
         @oai_args = {:metadata_prefix => 'mods', :from => nil, :until => nil, :set => 'is_governed_by_sd064kn5856'}
       end
       it "should be able to harvest headers" do
-        headers = @prod_hclient.oai_headers(@oai_args)
-        headers.should be_an_instance_of(Array)
-        headers.size.should > 0
-        headers.size.should < 50  # no resumption token
-        headers.first.should be_an_instance_of(OAI::Header)
+        VCR.use_cassette('prod_headers') do
+          headers = @prod_hclient.oai_headers(@oai_args)
+          expect(headers).to be_an_instance_of(Array)
+          expect(headers.size).to be > 0
+          expect(headers.size).to be < 50  # no resumption token
+          expect(headers.first).to be_an_instance_of(OAI::Header)
+        end
       end
       it "should be able to harvest records" do
-        records = @prod_hclient.oai_records(@oai_args)
-        records.should be_an_instance_of(Array)
-        records.size.should > 0
-        records.size.should < 50  # no resumption token
-        records.first.should be_an_instance_of(OAI::Record)
+        VCR.use_cassette('prod_records') do
+          records = @prod_hclient.oai_records(@oai_args)
+          expect(records).to be_an_instance_of(Array)
+          expect(records.size).to be > 0
+          expect(records.size).to be < 50  # no resumption token
+          expect(records.first).to be_an_instance_of(OAI::Record)
+        end
       end
     end
     context "with resumption tokens" do
@@ -94,30 +104,34 @@ describe 'Harvestdor::Client OAI Harvesting Integration Tests', :integration =>
         @oai_args = {:metadata_prefix => 'mods', :from => nil, :until => nil, :set => 'is_member_of_collection_jh957jy1101'}
       end
       it "should be able to harvest headers" do
-        headers = @prod_hclient.oai_headers(@oai_args)
-        headers.should be_an_instance_of(Array)
-        headers.size.should > 50
-        headers.first.should be_an_instance_of(OAI::Header)
+        VCR.use_cassette('headers_with_resumption') do
+          headers = @prod_hclient.oai_headers(@oai_args)
+          expect(headers).to be_an_instance_of(Array)
+          expect(headers.size).to be > 50
+          expect(headers.first).to be_an_instance_of(OAI::Header)
+        end
       end
       it "should be able to harvest records" do
-        pending "the request always seems to time out"
+        skip "the request always seems to time out"
         records = @prod_hclient.oai_records(@oai_args)
-        records.should be_an_instance_of(Array)
-        records.size.should > 50
-        records.first.should be_an_instance_of(OAI::Record)
+        expect(records).to be_an_instance_of(Array)
+        expect(records.size).to be > 50
+        expect(records.first).to be_an_instance_of(OAI::Record)
       end
     end
     context "oai_record (single record request)" do
       before(:all) do
-        @rec = @prod_hclient.oai_record('jt959wc5586')
+        VCR.use_cassette('jt959wc5586_prod') do
+          @rec = @prod_hclient.oai_record('jt959wc5586')
+        end
       end
       it "should get a single OAI::Record object" do
-        @rec.should be_an_instance_of(OAI::Record)
+        expect(@rec).to be_an_instance_of(OAI::Record)
       end
       it "should keep utf-8 encoded characters intact" do
         xml = Nokogiri::XML(@rec.metadata.to_s)
         xml.remove_namespaces!
-        xml.root.xpath('/metadata/mods/titleInfo/subTitle').text.should =~ /^recueil complet des débats législatifs & politiques des chambres françaises/
+        expect(xml.root.xpath('/metadata/mods/titleInfo/subTitle').text).to  match /^recueil complet des débats législatifs & politiques des chambres françaises/
       end
     end
   end

data/spec/purl_xml_spec.rb

@@ -17,35 +17,41 @@ describe Harvestdor::Client do
   end
   
   it "#mods returns a Nokogiri::XML::Document from the purl mods" do
-    x = Harvestdor.mods(@druid, @purl)
-    x.should be_kind_of(Nokogiri::XML::Document)
-    x.root.name.should == 'mods'
-    x.root.namespace.href.should == Harvestdor::MODS_NAMESPACE
+    VCR.use_cassette('purl_mods') do
+      x = Harvestdor.mods(@druid, @purl)
+      expect(x).to be_kind_of(Nokogiri::XML::Document)
+      expect(x.root.name).to eql('mods')
+      expect(x.root.namespace.href).to eql(Harvestdor::MODS_NAMESPACE)
+    end
   end    
 
   context "#public_xml" do
     it "#public_xml retrieves entire public xml as a Nokogiri::XML::Document when called with druid" do
-      px = Harvestdor.public_xml(@druid, @purl)
-      px.should be_kind_of(Nokogiri::XML::Document)
-      px.root.name.should == 'publicObject'
-      px.root.attributes['id'].text.should == "druid:#{@druid}"
+      VCR.use_cassette('public_xml') do
+        px = Harvestdor.public_xml(@druid, @purl)
+        expect(px).to be_kind_of(Nokogiri::XML::Document)
+        expect(px.root.name).to eql('publicObject')
+        expect(px.root.attributes['id'].text).to eql("druid:#{@druid}")
+      end
     end
     it "raises Harvestdor::Errors::MissingPurlPage if there is no purl page for the druid" do
-      expect { Harvestdor.public_xml(@fake_druid, @purl) }.to raise_error(Harvestdor::Errors::MissingPurlPage)
+      VCR.use_cassette('missing_purl') do
+        expect { Harvestdor.public_xml(@fake_druid, @purl) }.to raise_error(Harvestdor::Errors::MissingPurlPage)
+      end
     end
     it "raises Harvestdor::Errors::MissingPublicXML if purl page returns nil document" do
-      URI::HTTP.any_instance.should_receive(:open).and_return(nil)
+      expect_any_instance_of(URI::HTTP).to receive(:open).and_return(nil)
       expect { Harvestdor.public_xml(@fake_druid, @purl) }.to raise_error(Harvestdor::Errors::MissingPublicXml)
     end
   end
   
   context "#pub_xml" do
     it "retrieves public_xml via fetch when first arg is a druid" do
-      Harvestdor.should_receive(:public_xml).with(@druid, @purl)
+      expect(Harvestdor).to receive(:public_xml).with(@druid, @purl)
       Harvestdor.pub_xml(@druid, @purl)
     end
     it "returns the first arg if it is a Nokogiri::XML::Document" do
-      Harvestdor.pub_xml(@ng_pub_xml).should === @ng_pub_xml
+      expect(Harvestdor.pub_xml(@ng_pub_xml)).to eql(@ng_pub_xml)
     end
     it "raises error for unknown arg type" do
       expect { Harvestdor.pub_xml(Array.new)}.to raise_error(RuntimeError, "expected String or Nokogiri::XML::Document for first argument, got Array")
@@ -54,16 +60,18 @@ describe Harvestdor::Client do
   
   context "#content_metadata" do
     it "returns a Nokogiri::XML::Document from the public xml fetched with druid" do
-      cm = Harvestdor.content_metadata(@druid, @purl)
-      cm.should be_kind_of(Nokogiri::XML::Document)
-      cm.root.name.should == 'contentMetadata'
-      cm.root.attributes['objectId'].text.should == @druid
+      VCR.use_cassette('content_metadata') do
+        cm = Harvestdor.content_metadata(@druid, @purl)
+        expect(cm).to be_kind_of(Nokogiri::XML::Document)
+        expect(cm.root.name).to eql('contentMetadata')
+        expect(cm.root.attributes['objectId'].text).to eql(@druid)
+      end
     end
     it "returns a Nokogiri::XML::Document from passed Nokogiri::XML::Document and does no fetch" do
       cm = Harvestdor.content_metadata(@ng_pub_xml)
-      cm.should be_kind_of(Nokogiri::XML::Document)
-      cm.root.name.should == 'contentMetadata'
-      cm.root.attributes['objectId'].text.should == @druid
+      expect(cm).to be_kind_of(Nokogiri::XML::Document)
+      expect(cm.root.name).to eql('contentMetadata')
+      expect(cm.root.attributes['objectId'].text).to eql(@druid)
     end
     it "raises MissingContentMetadata error if there is no contentMetadata in the public_xml for the druid" do
       pub_xml = "<publicObject id='druid:#{@druid}'>#{@id_md_xml}#{@rights_md_xml}</publicObject>"
@@ -73,17 +81,19 @@ describe Harvestdor::Client do
   
   context "#identity_metadata" do
     it "returns a Nokogiri::XML::Document from the public xml fetched with druid" do
-      im = Harvestdor.identity_metadata(@druid, @purl)
-      im.should be_kind_of(Nokogiri::XML::Document)
-      im.root.name.should == 'identityMetadata'
-      im.root.xpath('objectId').text.should == "druid:#{@druid}"
+      VCR.use_cassette('identity_metadata') do
+        im = Harvestdor.identity_metadata(@druid, @purl)
+        expect(im).to be_kind_of(Nokogiri::XML::Document)
+        expect(im.root.name).to eql('identityMetadata')
+        expect(im.root.xpath('objectId').text).to eql("druid:#{@druid}")
+      end
     end
     it "returns a Nokogiri::XML::Document from passed Nokogiri::XML::Document and does no fetch" do
-      URI::HTTP.any_instance.should_not_receive(:open)
+      expect_any_instance_of(URI::HTTP).not_to receive(:open)
       im = Harvestdor.identity_metadata(@ng_pub_xml)
-      im.should be_kind_of(Nokogiri::XML::Document)
-      im.root.name.should == 'identityMetadata'
-      im.root.xpath('objectId').text.should == "druid:#{@druid}"
+      expect(im).to be_kind_of(Nokogiri::XML::Document)
+      expect(im.root.name).to eql('identityMetadata')
+      expect(im.root.xpath('objectId').text).to eql("druid:#{@druid}")
     end
     it "raises MissingIdentityMetadata error if there is no identityMetadata in the public_xml for the druid" do
       pub_xml = "<publicObject id='druid:#{@druid}'>#{@cntnt_md_xml}#{@rights_md_xml}</publicObject>"
@@ -93,15 +103,17 @@ describe Harvestdor::Client do
   
   context "#rights_metadata" do
     it "#rights_metadata returns a Nokogiri::XML::Document from the public xml fetched with druid" do
-      rm = Harvestdor.rights_metadata(@druid, @purl)
-      rm.should be_kind_of(Nokogiri::XML::Document)
-      rm.root.name.should == 'rightsMetadata'
+      VCR.use_cassette('rights_metadata') do
+        rm = Harvestdor.rights_metadata(@druid, @purl)
+        expect(rm).to be_kind_of(Nokogiri::XML::Document)
+        expect(rm.root.name).to eql('rightsMetadata')
+      end
     end
     it "returns a Nokogiri::XML::Document from passed Nokogiri::XML::Document and does no fetch" do
-      URI::HTTP.any_instance.should_not_receive(:open)
+      expect_any_instance_of(URI::HTTP).not_to receive(:open)
       rm = Harvestdor.rights_metadata(@ng_pub_xml)
-      rm.should be_kind_of(Nokogiri::XML::Document)
-      rm.root.name.should == 'rightsMetadata'
+      expect(rm).to be_kind_of(Nokogiri::XML::Document)
+      expect(rm.root.name).to eql('rightsMetadata')
     end
     it "raises MissingRightsMetadata error if there is no identityMetadata in the public_xml for the druid" do
       pub_xml = "<publicObject id='druid:#{@druid}'>#{@cntnt_md_xml}#{@id_md_xml}</publicObject>"
@@ -111,17 +123,19 @@ describe Harvestdor::Client do
   
   context "#rdf" do
     it "returns a Nokogiri::XML::Document from the public xml fetched with druid" do
-      rdf = Harvestdor.rdf(@druid, @purl)
-      rdf.should be_kind_of(Nokogiri::XML::Document)
-      rdf.root.name.should == 'RDF'
-      rdf.root.namespace.href.should == Harvestdor::RDF_NAMESPACE
+      VCR.use_cassette('rdf') do
+        rdf = Harvestdor.rdf(@druid, @purl)
+        expect(rdf).to be_kind_of(Nokogiri::XML::Document)
+        expect(rdf.root.name).to eql('RDF')
+        expect(rdf.root.namespace.href).to eql(Harvestdor::RDF_NAMESPACE)
+      end
     end
     it "returns a Nokogiri::XML::Document from passed Nokogiri::XML::Document and does no fetch" do
-      URI::HTTP.any_instance.should_not_receive(:open)
+      expect_any_instance_of(URI::HTTP).not_to receive(:open)
       rdf = Harvestdor.rdf(@ng_pub_xml)
-      rdf.should be_kind_of(Nokogiri::XML::Document)
-      rdf.root.name.should == 'RDF'
-      rdf.root.namespace.href.should == Harvestdor::RDF_NAMESPACE
+      expect(rdf).to be_kind_of(Nokogiri::XML::Document)
+      expect(rdf.root.name).to eql('RDF')
+      expect(rdf.root.namespace.href).to eql(Harvestdor::RDF_NAMESPACE)
     end
     it "raises MissingRDF error if there is no RDF in the public_xml for the druid" do
       pub_xml = "<publicObject id='druid:#{@druid}'>#{@cntnt_md_xml}#{@id_md_xml}</publicObject>"
@@ -131,17 +145,19 @@ describe Harvestdor::Client do
   
   context "#dc" do
     it "returns a Nokogiri::XML::Document from the public xml fetched with druid" do
-      dc = Harvestdor.dc(@druid, @purl)
-      dc.should be_kind_of(Nokogiri::XML::Document)
-      dc.root.name.should == 'dc'
-      dc.root.namespace.href.should == Harvestdor::OAI_DC_NAMESPACE
+      VCR.use_cassette('dc') do
+        dc = Harvestdor.dc(@druid, @purl)
+        expect(dc).to be_kind_of(Nokogiri::XML::Document)
+        expect(dc.root.name).to eql('dc')
+        expect(dc.root.namespace.href).to eql(Harvestdor::OAI_DC_NAMESPACE)
+      end
     end
     it "returns a Nokogiri::XML::Document from passed Nokogiri::XML::Document and does no fetch" do
-      URI::HTTP.any_instance.should_not_receive(:open)
+      expect_any_instance_of(URI::HTTP).not_to receive(:open)
       dc = Harvestdor.dc(@ng_pub_xml)
-      dc.should be_kind_of(Nokogiri::XML::Document)
-      dc.root.name.should == 'dc'
-      dc.root.namespace.href.should == Harvestdor::OAI_DC_NAMESPACE
+      expect(dc).to be_kind_of(Nokogiri::XML::Document)
+      expect(dc.root.name).to eql('dc')
+      expect(dc.root.namespace.href).to eql(Harvestdor::OAI_DC_NAMESPACE)
     end
     it "raises MissingDC error if there is no DC in the public_xml for the druid" do
       pub_xml = "<publicObject id='druid:#{@druid}'>#{@cntnt_md_xml}#{@id_md_xml}</publicObject>"
@@ -155,40 +171,40 @@ describe Harvestdor::Client do
       @druid = 'bb375wb8869'
     end
     it "public_xml calls Harvestdor.public_xml with config.purl" do
-      Harvestdor.should_receive(:public_xml).with(@druid, @client.config.purl)
+      expect(Harvestdor).to receive(:public_xml).with(@druid, @client.config.purl)
       @client.public_xml(@druid)
     end
     it "content_metadata calls Harvestdor.content_metadata with config.purl" do
-      Harvestdor.should_receive(:content_metadata).with(@druid, @client.config.purl)
+      expect(Harvestdor).to receive(:content_metadata).with(@druid, @client.config.purl)
       @client.content_metadata(@druid)
     end
     it "identity_metadata calls Harvestdor.identity_metadata with config.purl" do
-      Harvestdor.should_receive(:identity_metadata).with(@druid, @client.config.purl)
+      expect(Harvestdor).to receive(:identity_metadata).with(@druid, @client.config.purl)
       @client.identity_metadata(@druid)
     end
     it "rights_metadata calls Harvestdor.rights_metadata with config.purl" do
-      Harvestdor.should_receive(:rights_metadata).with(@druid, @client.config.purl)
+      expect(Harvestdor).to receive(:rights_metadata).with(@druid, @client.config.purl)
       @client.rights_metadata(@druid)
     end
     it "rdf calls Harvestdor.rdf with config.purl" do
-      Harvestdor.should_receive(:rdf).with(@druid, @client.config.purl)
+      expect(Harvestdor).to receive(:rdf).with(@druid, @client.config.purl)
       @client.rdf(@druid)
     end
     it "dc calls Harvestdor.dc with config.purl" do
-      Harvestdor.should_receive(:dc).with(@druid, @client.config.purl)
+      expect(Harvestdor).to receive(:dc).with(@druid, @client.config.purl)
       @client.dc(@druid)
     end
     it "mods calls Harvestdor.mods with config.purl" do
-      Harvestdor.should_receive(:mods).with(@druid, @client.config.purl)
+      expect(Harvestdor).to receive(:mods).with(@druid, @client.config.purl)
       @client.mods(@druid)
     end
     it "methods for parts of public_xml should work with Nokogiri::XML::Document arg (and not fetch)" do
-      URI::HTTP.any_instance.should_not_receive(:open)
-      @client.content_metadata(@ng_pub_xml).should be_kind_of(Nokogiri::XML::Document)
-      @client.identity_metadata(@ng_pub_xml).should be_kind_of(Nokogiri::XML::Document)
-      @client.rights_metadata(@ng_pub_xml).should be_kind_of(Nokogiri::XML::Document)
-      @client.rdf(@ng_pub_xml).should be_kind_of(Nokogiri::XML::Document)
-      @client.dc(@ng_pub_xml).should be_kind_of(Nokogiri::XML::Document)
+      expect_any_instance_of(URI::HTTP).not_to receive(:open)
+      expect(@client.content_metadata(@ng_pub_xml)).to be_kind_of(Nokogiri::XML::Document)
+      expect(@client.identity_metadata(@ng_pub_xml)).to be_kind_of(Nokogiri::XML::Document)
+      expect(@client.rights_metadata(@ng_pub_xml)).to be_kind_of(Nokogiri::XML::Document)
+      expect(@client.rdf(@ng_pub_xml)).to be_kind_of(Nokogiri::XML::Document)
+      expect(@client.dc(@ng_pub_xml)).to be_kind_of(Nokogiri::XML::Document)
     end
   end
 end