mods 2.0.1 → 2.0.2

data/spec/physical_description_spec.rb

@@ -12,7 +12,7 @@ describe "Mods <physicalDescription> Element" do
 
       it "extent child element" do
         @mods_rec.from_str("<mods #{@ns_decl}><physicalDescription><extent>extent</extent></physicalDescription></mods>")
-        @mods_rec.physical_description.extent.map { |n| n.text }.should == ["extent"]
+        expect(@mods_rec.physical_description.extent.map { |n| n.text }).to eq(["extent"])
       end
 
       context "note child element" do
@@ -26,10 +26,10 @@ describe "Mods <physicalDescription> Element" do
           @mods_rec.from_str(forms_and_notes)
         end
         it "should understand note element" do
-          @mods_rec.physical_description.note.map { |n| n.text }.should == ["dimension text", "condition text"]
+          expect(@mods_rec.physical_description.note.map { |n| n.text }).to eq(["dimension text", "condition text"])
         end
         it "should understand displayLabel attribute on note element" do
-          @mods_rec.physical_description.note.displayLabel.should == ["Dimensions", "Condition"]
+          expect(@mods_rec.physical_description.note.displayLabel).to eq(["Dimensions", "Condition"])
         end
       end
 
@@ -43,13 +43,13 @@ describe "Mods <physicalDescription> Element" do
           @mods_rec.from_str(forms_and_extent)
         end
         it "should understand form element" do
-          @mods_rec.physical_description.form.map { |n| n.text }.should == ["map", "foo"]
+          expect(@mods_rec.physical_description.form.map { |n| n.text }).to eq(["map", "foo"])
         end
         it "should understand authority attribute on form element" do
-          @mods_rec.physical_description.form.authority.should == ["smd"]
+          expect(@mods_rec.physical_description.form.authority).to eq(["smd"])
         end
         it "should understand type attribute on form element" do
-          @mods_rec.physical_description.form.type_at.should == ["material"]
+          expect(@mods_rec.physical_description.form.type_at).to eq(["material"])
         end
       end
 
@@ -63,13 +63,13 @@ describe "Mods <physicalDescription> Element" do
           @mods_rec.from_str(digital)
         end
         it "should understand reformattingQuality child element" do
-          @mods_rec.physical_description.reformattingQuality.map { |n| n.text }.should == ["preservation"]
+          expect(@mods_rec.physical_description.reformattingQuality.map { |n| n.text }).to eq(["preservation"])
         end
         it "should understand digitalOrigin child element" do
-          @mods_rec.physical_description.digitalOrigin.map { |n| n.text }.should == ["reformatted digital"]
+          expect(@mods_rec.physical_description.digitalOrigin.map { |n| n.text }).to eq(["reformatted digital"])
         end
         it "should understand internetMediaType child element" do
-          @mods_rec.physical_description.internetMediaType.map { |n| n.text }.should == ["image/jp2"]
+          expect(@mods_rec.physical_description.internetMediaType.map { |n| n.text }).to eq(["image/jp2"])
         end
       end
     end # WITH namespaces
@@ -77,7 +77,7 @@ describe "Mods <physicalDescription> Element" do
     context "WITHOUT namespaces" do
       it "extent child element" do
         @mods_rec.from_str('<mods><physicalDescription><extent>extent</extent></physicalDescription></mods>', false)
-        @mods_rec.physical_description.extent.map { |n| n.text }.should == ["extent"]
+        expect(@mods_rec.physical_description.extent.map { |n| n.text }).to eq(["extent"])
       end
 
       context "note child element" do
@@ -91,10 +91,10 @@ describe "Mods <physicalDescription> Element" do
           @mods_rec.from_str(forms_and_notes, false)
         end
         it "should understand note element" do
-          @mods_rec.physical_description.note.map { |n| n.text }.should == ["dimension text", "condition text"]
+          expect(@mods_rec.physical_description.note.map { |n| n.text }).to eq(["dimension text", "condition text"])
         end
         it "should understand displayLabel attribute on note element" do
-          @mods_rec.physical_description.note.displayLabel.should == ["Dimensions", "Condition"]
+          expect(@mods_rec.physical_description.note.displayLabel).to eq(["Dimensions", "Condition"])
         end
       end
 
@@ -108,13 +108,13 @@ describe "Mods <physicalDescription> Element" do
           @mods_rec.from_str(forms_and_extent, false)
         end
         it "should understand form element" do
-          @mods_rec.physical_description.form.map { |n| n.text }.should == ["map", "foo"]
+          expect(@mods_rec.physical_description.form.map { |n| n.text }).to eq(["map", "foo"])
         end
         it "should understand authority attribute on form element" do
-          @mods_rec.physical_description.form.authority.should == ["smd"]
+          expect(@mods_rec.physical_description.form.authority).to eq(["smd"])
         end
         it "should understand type attribute on form element" do
-          @mods_rec.physical_description.form.type_at.should == ["material"]
+          expect(@mods_rec.physical_description.form.type_at).to eq(["material"])
         end
       end
 
@@ -128,13 +128,13 @@ describe "Mods <physicalDescription> Element" do
           @mods_rec.from_str(digital, false)
         end
         it "should understand reformattingQuality child element" do
-          @mods_rec.physical_description.reformattingQuality.map { |n| n.text }.should == ["preservation"]
+          expect(@mods_rec.physical_description.reformattingQuality.map { |n| n.text }).to eq(["preservation"])
         end
         it "should understand digitalOrigin child element" do
-          @mods_rec.physical_description.digitalOrigin.map { |n| n.text }.should == ["reformatted digital"]
+          expect(@mods_rec.physical_description.digitalOrigin.map { |n| n.text }).to eq(["reformatted digital"])
         end
         it "should understand internetMediaType child element" do
-          @mods_rec.physical_description.internetMediaType.map { |n| n.text }.should == ["image/jp2"]
+          expect(@mods_rec.physical_description.internetMediaType.map { |n| n.text }).to eq(["image/jp2"])
         end
       end
     end # WITHOUT namespaces

data/spec/reader_spec.rb

@@ -8,21 +8,21 @@ describe "Mods::Reader" do
     # url is for a namespaced document
     @example_url = 'http://www.loc.gov/standards/mods/v3/mods99042030_linkedDataAdded.xml'
     @example_default_ns_str = '<mods xmlns="http://www.loc.gov/mods/v3"><note>default ns</note></mods>'
-    @example_ns_str = '<mods:mods xmlns:mods="http://www.loc.gov/mods/v3"><mods:note>ns</mods:note></mods:mods>'
-    @example_no_ns_str = '<mods><note>no ns</note></mods>'
-    @example_wrong_ns_str = '<mods xmlns="wrong"><note>wrong ns</note></mods>'
+    @example_ns_str         = '<mods:mods xmlns:mods="http://www.loc.gov/mods/v3"><mods:note>ns</mods:note></mods:mods>'
+    @example_no_ns_str      = '<mods><note>no ns</note></mods>'
+    @example_wrong_ns_str   = '<mods xmlns="wrong"><note>wrong ns</note></mods>'
     @doc_from_str_default_ns = Mods::Reader.new.from_str(@example_ns_str)
-    @doc_from_str_ns = Mods::Reader.new.from_str(@example_ns_str)
-    @doc_from_str_no_ns = Mods::Reader.new.from_str(@example_no_ns_str)
-    @doc_from_str_wrong_ns = Mods::Reader.new.from_str(@example_wrong_ns_str)
+    @doc_from_str_ns         = Mods::Reader.new.from_str(@example_ns_str)
+    @doc_from_str_no_ns      = Mods::Reader.new.from_str(@example_no_ns_str)
+    @doc_from_str_wrong_ns   = Mods::Reader.new.from_str(@example_wrong_ns_str)
     @from_url = Mods::Reader.new.from_url(@example_url)
   end
 
   it "from_str should turn an xml string into a Nokogiri::XML::Document object" do
     expect(@doc_from_str_default_ns).to be_instance_of(Nokogiri::XML::Document)
-    expect(@doc_from_str_ns).to be_instance_of(Nokogiri::XML::Document)
-    expect(@doc_from_str_no_ns).to be_instance_of(Nokogiri::XML::Document)
-    expect(@doc_from_str_wrong_ns).to be_instance_of(Nokogiri::XML::Document)
+    expect(@doc_from_str_ns        ).to be_instance_of(Nokogiri::XML::Document)
+    expect(@doc_from_str_no_ns     ).to be_instance_of(Nokogiri::XML::Document)
+    expect(@doc_from_str_wrong_ns  ).to be_instance_of(Nokogiri::XML::Document)
   end
 
   context "from_url" do
@@ -48,32 +48,32 @@ describe "Mods::Reader" do
   context "namespace awareness" do
     it "should care about namespace by default" do
       r = Mods::Reader.new
-      r.namespace_aware.should == true
-      @doc_from_str_default_ns.root.namespace.href.should ==  Mods::MODS_NS
-      @doc_from_str_default_ns.xpath('/m:mods/m:note', @ns_hash).text.should == "ns"
-      @doc_from_str_default_ns.xpath('/mods/note').size.should == 0
-      @doc_from_str_ns.root.namespace.href.should ==  Mods::MODS_NS
-      @doc_from_str_ns.xpath('/m:mods/m:note', @ns_hash).text.should == "ns"
-      @doc_from_str_ns.xpath('/mods/note').size.should == 0
-      @doc_from_str_no_ns.xpath('/m:mods/m:note', @ns_hash).size.should == 0
-      @doc_from_str_no_ns.xpath('/mods/note').text.should == "no ns"
-      @doc_from_str_wrong_ns.root.namespace.href.should ==  "wrong"
-      @doc_from_str_wrong_ns.xpath('/m:mods/m:note', @ns_hash).size.should == 0
-      @doc_from_str_wrong_ns.xpath('/mods/note').size.should == 0
+      expect(r.namespace_aware).to be_truthy
+      expect(@doc_from_str_default_ns.root.namespace.href).to eq(Mods::MODS_NS)
+      expect(@doc_from_str_default_ns.xpath('/m:mods/m:note', @ns_hash).text).to eq("ns")
+      expect(@doc_from_str_default_ns.xpath('/mods/note').size).to eq(0)
+      expect(@doc_from_str_ns.root.namespace.href).to eq(Mods::MODS_NS)
+      expect(@doc_from_str_ns.xpath('/m:mods/m:note', @ns_hash).text).to eq("ns")
+      expect(@doc_from_str_ns.xpath('/mods/note').size).to eq(0)
+      expect(@doc_from_str_no_ns.xpath('/m:mods/m:note', @ns_hash).size).to eq(0)
+      expect(@doc_from_str_no_ns.xpath('/mods/note').text).to eq("no ns")
+      expect(@doc_from_str_wrong_ns.root.namespace.href).to eq("wrong")
+      expect(@doc_from_str_wrong_ns.xpath('/m:mods/m:note', @ns_hash).size).to eq(0)
+      expect(@doc_from_str_wrong_ns.xpath('/mods/note').size).to eq(0)
     end
 
     it "should be allowed not to care about namespaces" do
       r = Mods::Reader.new(false)
-      r.namespace_aware.should == false
+      expect(r.namespace_aware).to be_falsey
       my_from_str_ns = r.from_str(@example_ns_str)
-      my_from_str_ns.xpath('/m:mods/m:note', @ns_hash).size.should == 0
-      my_from_str_ns.xpath('/mods/note').text.should == "ns"
+      expect(my_from_str_ns.xpath('/m:mods/m:note', @ns_hash).size).to eq(0)
+      expect(my_from_str_ns.xpath('/mods/note').text).to eq("ns")
       my_from_str_no_ns = r.from_str(@example_no_ns_str)
-      my_from_str_no_ns.xpath('/m:mods/m:note', @ns_hash).size.should == 0
-      my_from_str_no_ns.xpath('/mods/note').text.should == "no ns"
+      expect(my_from_str_no_ns.xpath('/m:mods/m:note', @ns_hash).size).to eq(0)
+      expect(my_from_str_no_ns.xpath('/mods/note').text).to eq("no ns")
       my_from_str_wrong_ns = r.from_str(@example_wrong_ns_str)
-      my_from_str_wrong_ns.xpath('/m:mods/m:note', @ns_hash).size.should == 0
-      my_from_str_wrong_ns.xpath('/mods/note').text.should == "wrong ns"
+      expect(my_from_str_wrong_ns.xpath('/m:mods/m:note', @ns_hash).size).to eq(0)
+      expect(my_from_str_wrong_ns.xpath('/mods/note').text).to eq("wrong ns")
     end
   end
 
@@ -92,20 +92,20 @@ describe "Mods::Reader" do
                     </mods:name>
                   </mods:mods>'
       reader = Mods::Reader.new.from_str(utf_mods)
-      reader.encoding.should eql("UTF-8")
+      expect(reader.encoding).to eql("UTF-8")
     end
     it "should remove xsi:schemaLocation attribute from mods element if removing namespaces" do
       str = '<ns3:mods xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:ns3="http://www.loc.gov/mods/v3" xsi:schemaLocation="http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/v3/mods-3-2.xsd">
-				<ns3:note>be very frightened</ns3:note></ns3:mods>'
-			ng_xml = Nokogiri::XML(str)
-			# Nokogiri treats namespaced attributes differently in jruby than in ruby
-			(ng_xml.root.has_attribute?('schemaLocation') || ng_xml.root.has_attribute?('xsi:schemaLocation')).should == true
-			r = Mods::Reader.new
+        <ns3:note>be very frightened</ns3:note></ns3:mods>'
+      ng_xml = Nokogiri::XML(str)
+      # Nokogiri treats namespaced attributes differently in jruby than in ruby
+      expect(ng_xml.root.has_attribute?('schemaLocation') || ng_xml.root.has_attribute?('xsi:schemaLocation')).to be_truthy
+      r = Mods::Reader.new
       r.namespace_aware = false
       r.from_nk_node(ng_xml)
       # the below are different depending on jruby or ruby ... oy
-      r.mods_ng_xml.root.attributes.keys.should_not include('schemaLocation')
-      r.mods_ng_xml.root.attributes.keys.should_not include('xsi:schemaLocation')
+      expect(r.mods_ng_xml.root.attributes.keys).not_to include('schemaLocation')
+      expect(r.mods_ng_xml.root.attributes.keys).not_to include('xsi:schemaLocation')
     end
   end
 
@@ -137,16 +137,17 @@ describe "Mods::Reader" do
       @mods_ng_doc = @r.from_nk_node(@mods_node)
     end
     it "should turn the Nokogiri::XML::Node into a Nokogiri::XML::Document object" do
-      @mods_ng_doc.should be_kind_of(Nokogiri::XML::Document)
+      expect(@mods_ng_doc).to be_kind_of(Nokogiri::XML::Document)
     end
     it "should care about namespace by default" do
-      @mods_ng_doc.xpath('/m:mods/m:titleInfo/m:title', @ns_hash).text.should == "boo"
+      expect(@mods_ng_doc.xpath('/m:mods/m:titleInfo/m:title', @ns_hash).text).to eq("boo")
     end
     it "should be able not to care about namespaces" do
       @r.namespace_aware = false
       mods_ng_doc = @r.from_nk_node(@mods_node)
-      mods_ng_doc.xpath('/m:mods/m:titleInfo/m:title', @ns_hash).size.should == 0
-      mods_ng_doc.xpath('/mods/titleInfo/title').text.should == "boo"
+      expect(mods_ng_doc).to be_kind_of(Nokogiri::XML::Document)
+      expect(mods_ng_doc.xpath('/m:mods/m:titleInfo/m:title', @ns_hash).size).to eq(0)
+      expect(mods_ng_doc.xpath('/mods/titleInfo/title').text).to eq("boo")
       @r.namespace_aware = true
     end
   end # context from_nk_node

data/spec/record_info_spec.rb

@@ -51,153 +51,153 @@ describe "Mods <recordInfo> Element" do
       end
 
       it "should be a NodeSet" do
-        [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.should be_an_instance_of(Nokogiri::XML::NodeSet) }
+        [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri).to be_an_instance_of(Nokogiri::XML::NodeSet) }
       end
       it "should have as many members as there are <recordInfo> elements in the xml" do
-        [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.size.should == 1 }
+        [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri.size).to eq(1) }
       end
       it "should recognize language attributes on <recordInfo> element" do
         skip "problem with xml:lang"
         Mods::LANG_ATTRIBS.each { |a|
           @mods_rec.from_str("<mods #{@ns_decl}><recordInfo #{a}='val'><recordOrigin>nowhere</recordOrigin></recordInfo></mods>")
-          @mods_rec.record_info.send(a.to_sym).should == ['val']
+          expect(@mods_rec.record_info.send(a.to_sym)).to eq(['val'])
         }
       end
       it "should recognize displayLabel attribute on <recordInfo> element" do
         @mods_rec.from_str("<mods #{@ns_decl}><recordInfo displayLabel='val'><recordOrigin>nowhere</recordOrigin></recordInfo></mods>")
-        @mods_rec.record_info.displayLabel.should == ['val']
+        expect(@mods_rec.record_info.displayLabel).to eq(['val'])
       end
 
       context "<recordContentSource> child element" do
         it "should be a NodeSet" do
-          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.recordContentSource.should be_an_instance_of(Nokogiri::XML::NodeSet) }
+          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri.recordContentSource).to be_an_instance_of(Nokogiri::XML::NodeSet) }
         end
         it "recordContentSource NodeSet should have as many Nodes as there are <recordContentSource> elements in the xml" do
-          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.recordContentSource.size.should == 1 }
+          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri.recordContentSource.size).to eq(1) }
         end
         it "text should get element value" do
-          @rec_info.recordContentSource.map { |n| n.text }.should == ["RQE"]
-          @rec_info2.recordContentSource.map { |n| n.text }.should == ["AU@"]
-          @bnf.recordContentSource.map { |n| n.text }.should == ["TEI Description"]
-          @rlin.recordContentSource.map { |n| n.text }.should == ["CSt"]
+          expect(@rec_info.recordContentSource.map { |n| n.text }).to eq(["RQE"])
+          expect(@rec_info2.recordContentSource.map { |n| n.text }).to eq(["AU@"])
+          expect(@bnf.recordContentSource.map { |n| n.text }).to eq(["TEI Description"])
+          expect(@rlin.recordContentSource.map { |n| n.text }).to eq(["CSt"])
         end
         it "should recognize authority attribute" do
-          [@rec_info, @rec_info2, @rlin].each { |ri| ri.recordContentSource.authority.should == ['marcorg'] }
-          @bnf.recordContentSource.authority.size.should == 0
+          [@rec_info, @rec_info2, @rlin].each { |ri| expect(ri.recordContentSource.authority).to eq(['marcorg']) }
+          expect(@bnf.recordContentSource.authority.size).to eq(0)
         end
         it "should recognize all authority attributes" do
           Mods::AUTHORITY_ATTRIBS.each { |a|
             @mods_rec.from_str("<mods #{@ns_decl}><recordInfo><recordContentSource #{a}='attr_val'>zzz</recordContentSource></recordInfo></mods>")
-            @mods_rec.record_info.recordContentSource.send(a.to_sym).should == ['attr_val']
+            expect(@mods_rec.record_info.recordContentSource.send(a.to_sym)).to eq(['attr_val'])
           }
         end
       end # <recordContentSource>
 
       context "<recordCreationDate> child element" do
         it "should be a NodeSet" do
-          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.recordCreationDate.should be_an_instance_of(Nokogiri::XML::NodeSet) }
+          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri.recordCreationDate).to be_an_instance_of(Nokogiri::XML::NodeSet) }
         end
         it "recordCreationDate NodeSet should have as many Nodes as there are <recordCreationDate> elements in the xml" do
-          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.recordCreationDate.size.should == 1 }
+          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri.recordCreationDate.size).to eq(1) }
         end
         it "text should get element value" do
-          @rec_info.recordCreationDate.map { |n| n.text }.should == ['890517']
-          @rec_info2.recordCreationDate.map { |n| n.text }.should == ['050921']
-          @bnf.recordCreationDate.map { |n| n.text }.should == ['2011-12-07']
-          @rlin.recordCreationDate.map { |n| n.text }.should == ['850416']
+          expect(@rec_info.recordCreationDate.map { |n| n.text }).to eq(['890517'])
+          expect(@rec_info2.recordCreationDate.map { |n| n.text }).to eq(['050921'])
+          expect(@bnf.recordCreationDate.map { |n| n.text }).to eq(['2011-12-07'])
+          expect(@rlin.recordCreationDate.map { |n| n.text }).to eq(['850416'])
         end
         it "should recognize encoding attribute" do
-          [@rec_info, @rec_info2, @rlin].each { |ri| ri.recordCreationDate.encoding.should == ['marc'] }
-          @bnf.recordCreationDate.encoding.should == ['w3cdtf']
+          [@rec_info, @rec_info2, @rlin].each { |ri| expect(ri.recordCreationDate.encoding).to eq(['marc']) }
+          expect(@bnf.recordCreationDate.encoding).to eq(['w3cdtf'])
         end
         it "should recognize all date attributes" do
           Mods::DATE_ATTRIBS.each { |a|
             @mods_rec.from_str("<mods #{@ns_decl}><recordInfo><recordCreationDate #{a}='attr_val'>zzz</recordCreationDate></recordInfo></mods>")
-            @mods_rec.record_info.recordCreationDate.send(a.to_sym).should == ['attr_val']
+            expect(@mods_rec.record_info.recordCreationDate.send(a.to_sym)).to eq(['attr_val'])
           }
         end
       end # <recordCreationDate>
 
       context "<recordChangeDate> child element" do
         it "should be a NodeSet" do
-          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.recordChangeDate.should be_an_instance_of(Nokogiri::XML::NodeSet) }
+          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri.recordChangeDate).to be_an_instance_of(Nokogiri::XML::NodeSet) }
         end
         it "recordChangeDate NodeSet should have as many Nodes as there are <recordChangeDate> elements in the xml" do
-          [@rec_info, @rec_info2, @bnf].each { |ri| ri.recordChangeDate.size.should == 0 }
-          @rlin.recordChangeDate.size.should == 1
+          [@rec_info, @rec_info2, @bnf].each { |ri| expect(ri.recordChangeDate.size).to eq(0) }
+          expect(@rlin.recordChangeDate.size).to eq(1)
         end
         it "text should get element value" do
-          @rlin.recordChangeDate.map { |n| n.text }.should == ['19991012150824.0']
+          expect(@rlin.recordChangeDate.map { |n| n.text }).to eq(['19991012150824.0'])
         end
         it "should recognize encoding attribute" do
-          @rlin.recordChangeDate.encoding.should == ['iso8601']
+          expect(@rlin.recordChangeDate.encoding).to eq(['iso8601'])
         end
         it "should recognize all date attributes" do
           Mods::DATE_ATTRIBS.each { |a|
             @mods_rec.from_str("<mods #{@ns_decl}><recordInfo><recordChangeDate #{a}='attr_val'>zzz</recordChangeDate></recordInfo></mods>")
-            @mods_rec.record_info.recordChangeDate.send(a.to_sym).should == ['attr_val']
+            expect(@mods_rec.record_info.recordChangeDate.send(a.to_sym)).to eq(['attr_val'])
           }
         end
       end # <recordChangeDate>
 
       context "<recordIdentifier> child element" do
         it "should be a NodeSet" do
-          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.recordIdentifier.should be_an_instance_of(Nokogiri::XML::NodeSet) }
+          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri.recordIdentifier).to be_an_instance_of(Nokogiri::XML::NodeSet) }
         end
         it "recordIdentifier NodeSet should have as many Nodes as there are <recordIdentifier> elements in the xml" do
-          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.recordIdentifier.size.should == 1 }
+          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri.recordIdentifier.size).to eq(1) }
         end
         it "text should get element value" do
-          @rec_info.recordIdentifier.map { |n| n.text }.should == ['a9079953']
-          @rec_info2.recordIdentifier.map { |n| n.text }.should == ['a8837534']
-          @bnf.recordIdentifier.map { |n| n.text }.should == ['']
-          @rlin.recordIdentifier.map { |n| n.text }.should == ['a4083219']
+          expect(@rec_info.recordIdentifier.map { |n| n.text }).to eq(['a9079953'])
+          expect(@rec_info2.recordIdentifier.map { |n| n.text }).to eq(['a8837534'])
+          expect(@bnf.recordIdentifier.map { |n| n.text }).to eq([''])
+          expect(@rlin.recordIdentifier.map { |n| n.text }).to eq(['a4083219'])
         end
         it "should recognize source attribute" do
-          [@rec_info, @rec_info2].each { |ri| ri.recordIdentifier.source.should == ['SIRSI'] }
-          @bnf.recordIdentifier.source.should == ['BNF 2166']
-          @rlin.recordIdentifier.source.should == ['CStRLIN']
+          [@rec_info, @rec_info2].each { |ri| expect(ri.recordIdentifier.source).to eq(['SIRSI']) }
+          expect(@bnf.recordIdentifier.source).to eq(['BNF 2166'])
+          expect(@rlin.recordIdentifier.source).to eq(['CStRLIN'])
         end
         it "should allow a source attribute without element content" do
-          @bnf.recordIdentifier.source.should == ['BNF 2166']
-          @bnf.recordIdentifier.map { |n| n.text }.should == ['']
+          expect(@bnf.recordIdentifier.source).to eq(['BNF 2166'])
+          expect(@bnf.recordIdentifier.map { |n| n.text }).to eq([''])
         end
       end # <recordIdentifier>
 
       context "<recordOrigin> child element" do
         it "should be a NodeSet" do
-          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.recordOrigin.should be_an_instance_of(Nokogiri::XML::NodeSet) }
+          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri.recordOrigin).to be_an_instance_of(Nokogiri::XML::NodeSet) }
         end
         it "recordOrigin NodeSet should have as many Nodes as there are <recordOrigin> elements in the xml" do
-          [@rec_info, @rec_info2, @rlin].each { |ri| ri.recordOrigin.size.should == 0 }
-          @bnf.recordOrigin.size.should == 1
+          [@rec_info, @rec_info2, @rlin].each { |ri| expect(ri.recordOrigin.size).to eq(0) }
+          expect(@bnf.recordOrigin.size).to eq(1)
         end
         it "text should get element value" do
           @mods_rec.from_str("<mods #{@ns_decl}><recordInfo><recordOrigin>human prepared</recordOrigin></recordInfo></mods>")
-          @mods_rec.record_info.recordOrigin.map {|n| n.text }.should == ['human prepared']
-          @bnf.recordOrigin.map { |n| n.text }.should == ['']
+          expect(@mods_rec.record_info.recordOrigin.map {|n| n.text }).to eq(['human prepared'])
+          expect(@bnf.recordOrigin.map { |n| n.text }).to eq([''])
         end
       end # <recordOrigin>
 
       context "<languageOfCataloging> child element" do
         it "should be a NodeSet" do
-          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.languageOfCataloging.should be_an_instance_of(Nokogiri::XML::NodeSet) }
+          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri.languageOfCataloging).to be_an_instance_of(Nokogiri::XML::NodeSet) }
         end
         it "languageOfCataloging NodeSet should have as many Nodes as there are <languageOfCataloging> elements in the xml" do
-          [@rec_info2, @bnf].each { |ri| ri.languageOfCataloging.size.should == 1 }
-          [@rec_info, @rlin].each { |ri| ri.languageOfCataloging.size.should == 0 }
+          [@rec_info2, @bnf].each { |ri| expect(ri.languageOfCataloging.size).to eq(1) }
+          [@rec_info, @rlin].each { |ri| expect(ri.languageOfCataloging.size).to eq(0) }
         end
         it "text should get element value" do
           # this example is from   http://www.loc.gov/standards/mods/v3/mods-userguide-elements.html
           #   though it doesn't match the doc at http://www.loc.gov/standards/mods/mods-outline.html#recordInfo
           @mods_rec.from_str("<mods #{@ns_decl}><recordInfo><languageOfCataloging authority='iso639-2b'>fre</languageOfCataloging></recordInfo></mods>")
-          @mods_rec.record_info.languageOfCataloging.map { |n| n.text }.should == ['fre']
+          expect(@mods_rec.record_info.languageOfCataloging.map { |n| n.text }).to eq(['fre'])
         end
         it "authority should get attribute value" do
           # this example is from   http://www.loc.gov/standards/mods/v3/mods-userguide-elements.html
           #   though it doesn't match the doc at http://www.loc.gov/standards/mods/mods-outline.html#recordInfo
           @mods_rec.from_str("<mods #{@ns_decl}><recordInfo><languageOfCataloging authority='iso639-2b'>fre</languageOfCataloging></recordInfo></mods>")
-          @mods_rec.record_info.languageOfCataloging.authority.should == ['iso639-2b']
+          expect(@mods_rec.record_info.languageOfCataloging.authority).to eq(['iso639-2b'])
         end
 
         # from http://www.loc.gov/standards/mods/userguide/recordinfo.html#languageofcataloging
@@ -208,17 +208,17 @@ describe "Mods <recordInfo> Element" do
 
         context "<languageTerm> child element" do
           it "text should get element value" do
-            @rec_info2.languageOfCataloging.languageTerm.map { |n| n.text }.should == ['eng']
-            @bnf.languageOfCataloging.languageTerm.map { |n| n.text }.should == ['fra']
+            expect(@rec_info2.languageOfCataloging.languageTerm.map { |n| n.text }).to eq(['eng'])
+            expect(@bnf.languageOfCataloging.languageTerm.map { |n| n.text }).to eq(['fra'])
           end
           it "should recognize all authority attributes" do
             Mods::AUTHORITY_ATTRIBS.each { |a|
               @mods_rec.from_str("<mods #{@ns_decl}><recordInfo><languageOfCataloging><languageTerm #{a}='attr_val'>zzz</languageTerm></languageOfCataloging></recordInfo></mods>")
-              @mods_rec.record_info.languageOfCataloging.languageTerm.send(a.to_sym).should == ['attr_val']
+              expect(@mods_rec.record_info.languageOfCataloging.languageTerm.send(a.to_sym)).to eq(['attr_val'])
             }
           end
           it "should recognize the type attribute with type_at term" do
-            @rec_info2.languageOfCataloging.languageTerm.type_at.should == ['code']
+            expect(@rec_info2.languageOfCataloging.languageTerm.type_at).to eq(['code'])
           end
         end # <languageTerm>
 
@@ -231,21 +231,21 @@ describe "Mods <recordInfo> Element" do
 
       context "<descriptionStandard> child element" do
         it "should be a NodeSet" do
-          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.descriptionStandard.should be_an_instance_of(Nokogiri::XML::NodeSet) }
+          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri.descriptionStandard).to be_an_instance_of(Nokogiri::XML::NodeSet) }
         end
         it "descriptionStandard NodeSet should have as many Nodes as there are <descriptionStandard> elements in the xml" do
-          [@rec_info, @bnf].each { |ri| ri.descriptionStandard.size.should == 0 }
-          [@rec_info2, @rlin].each { |ri| ri.descriptionStandard.size.should == 1 }
+          [@rec_info, @bnf].each { |ri| expect(ri.descriptionStandard.size).to eq(0) }
+          [@rec_info2, @rlin].each { |ri| expect(ri.descriptionStandard.size).to eq(1) }
         end
         it "text should get element value" do
-          @rec_info2.descriptionStandard.map { |n| n.text }.should == ['aacr2']
-          @rlin.descriptionStandard.map { |n| n.text }.should == ['appm']
-          @bnf.descriptionStandard.map { |n| n.text }.should == []
+          expect(@rec_info2.descriptionStandard.map { |n| n.text }).to eq(['aacr2'])
+          expect(@rlin.descriptionStandard.map { |n| n.text }).to eq(['appm'])
+          expect(@bnf.descriptionStandard.map { |n| n.text }).to eq([])
         end
         it "should recognize all authority attributes" do
           Mods::AUTHORITY_ATTRIBS.each { |a|
             @mods_rec.from_str("<mods #{@ns_decl}><recordInfo><descriptionStandard #{a}='attr_val'>zzz</descriptionStandard></recordInfo></mods>")
-            @mods_rec.record_info.descriptionStandard.send(a.to_sym).should == ['attr_val']
+            expect(@mods_rec.record_info.descriptionStandard.send(a.to_sym)).to eq(['attr_val'])
           }
         end
       end # <descriptionStandard>
@@ -287,153 +287,153 @@ describe "Mods <recordInfo> Element" do
       end
 
       it "should be a NodeSet" do
-        [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.should be_an_instance_of(Nokogiri::XML::NodeSet) }
+        [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri).to be_an_instance_of(Nokogiri::XML::NodeSet) }
       end
       it "should have as many members as there are <recordInfo> elements in the xml" do
-        [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.size.should == 1 }
+        [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri.size).to eq(1) }
       end
       it "should recognize language attributes on <recordInfo> element" do
         skip "problem with xml:lang"
         Mods::LANG_ATTRIBS.each { |a|
           @mods_rec.from_str("<mods><recordInfo #{a}='val'><recordOrigin>nowhere</recordOrigin></recordInfo></mods>", false)
-          @mods_rec.record_info.send(a.to_sym).should == ['val']
+          expect(@mods_rec.record_info.send(a.to_sym)).to eq(['val'])
         }
       end
       it "should recognize displayLabel attribute on <recordInfo> element" do
         @mods_rec.from_str("<mods><recordInfo displayLabel='val'><recordOrigin>nowhere</recordOrigin></recordInfo></mods>", false)
-        @mods_rec.record_info.displayLabel.should == ['val']
+        expect(@mods_rec.record_info.displayLabel).to eq(['val'])
       end
 
       context "<recordContentSource> child element" do
         it "should be a NodeSet" do
-          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.recordContentSource.should be_an_instance_of(Nokogiri::XML::NodeSet) }
+          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri.recordContentSource).to be_an_instance_of(Nokogiri::XML::NodeSet) }
         end
         it "recordContentSource NodeSet should have as many Nodes as there are <recordContentSource> elements in the xml" do
-          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.recordContentSource.size.should == 1 }
+          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri.recordContentSource.size).to eq(1) }
         end
         it "text should get element value" do
-          @rec_info.recordContentSource.map { |n| n.text }.should == ["RQE"]
-          @rec_info2.recordContentSource.map { |n| n.text }.should == ["AU@"]
-          @bnf.recordContentSource.map { |n| n.text }.should == ["TEI Description"]
-          @rlin.recordContentSource.map { |n| n.text }.should == ["CSt"]
+          expect(@rec_info.recordContentSource.map { |n| n.text }).to eq(["RQE"])
+          expect(@rec_info2.recordContentSource.map { |n| n.text }).to eq(["AU@"])
+          expect(@bnf.recordContentSource.map { |n| n.text }).to eq(["TEI Description"])
+          expect(@rlin.recordContentSource.map { |n| n.text }).to eq(["CSt"])
         end
         it "should recognize authority attribute" do
-          [@rec_info, @rec_info2, @rlin].each { |ri| ri.recordContentSource.authority.should == ['marcorg'] }
-          @bnf.recordContentSource.authority.size.should == 0
+          [@rec_info, @rec_info2, @rlin].each { |ri| expect(ri.recordContentSource.authority).to eq(['marcorg']) }
+          expect(@bnf.recordContentSource.authority.size).to eq(0)
         end
         it "should recognize all authority attributes" do
           Mods::AUTHORITY_ATTRIBS.each { |a|
             @mods_rec.from_str("<mods><recordInfo><recordContentSource #{a}='attr_val'>zzz</recordContentSource></recordInfo></mods>", false)
-            @mods_rec.record_info.recordContentSource.send(a.to_sym).should == ['attr_val']
+            expect(@mods_rec.record_info.recordContentSource.send(a.to_sym)).to eq(['attr_val'])
           }
         end
       end # <recordContentSource>
 
       context "<recordCreationDate> child element" do
         it "should be a NodeSet" do
-          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.recordCreationDate.should be_an_instance_of(Nokogiri::XML::NodeSet) }
+          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri.recordCreationDate).to be_an_instance_of(Nokogiri::XML::NodeSet) }
         end
         it "recordCreationDate NodeSet should have as many Nodes as there are <recordCreationDate> elements in the xml" do
-          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.recordCreationDate.size.should == 1 }
+          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri.recordCreationDate.size).to eq(1) }
         end
         it "text should get element value" do
-          @rec_info.recordCreationDate.map { |n| n.text }.should == ['890517']
-          @rec_info2.recordCreationDate.map { |n| n.text }.should == ['050921']
-          @bnf.recordCreationDate.map { |n| n.text }.should == ['2011-12-07']
-          @rlin.recordCreationDate.map { |n| n.text }.should == ['850416']
+          expect(@rec_info.recordCreationDate.map { |n| n.text }).to eq(['890517'])
+          expect(@rec_info2.recordCreationDate.map { |n| n.text }).to eq(['050921'])
+          expect(@bnf.recordCreationDate.map { |n| n.text }).to eq(['2011-12-07'])
+          expect(@rlin.recordCreationDate.map { |n| n.text }).to eq(['850416'])
         end
         it "should recognize encoding attribute" do
-          [@rec_info, @rec_info2, @rlin].each { |ri| ri.recordCreationDate.encoding.should == ['marc'] }
-          @bnf.recordCreationDate.encoding.should == ['w3cdtf']
+          [@rec_info, @rec_info2, @rlin].each { |ri| expect(ri.recordCreationDate.encoding).to eq(['marc']) }
+          expect(@bnf.recordCreationDate.encoding).to eq(['w3cdtf'])
         end
         it "should recognize all date attributes" do
           Mods::DATE_ATTRIBS.each { |a|
             @mods_rec.from_str("<mods><recordInfo><recordCreationDate #{a}='attr_val'>zzz</recordCreationDate></recordInfo></mods>", false)
-            @mods_rec.record_info.recordCreationDate.send(a.to_sym).should == ['attr_val']
+            expect(@mods_rec.record_info.recordCreationDate.send(a.to_sym)).to eq(['attr_val'])
           }
         end
       end # <recordCreationDate>
 
       context "<recordChangeDate> child element" do
         it "should be a NodeSet" do
-          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.recordChangeDate.should be_an_instance_of(Nokogiri::XML::NodeSet) }
+          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri.recordChangeDate).to be_an_instance_of(Nokogiri::XML::NodeSet) }
         end
         it "recordChangeDate NodeSet should have as many Nodes as there are <recordChangeDate> elements in the xml" do
-          [@rec_info, @rec_info2, @bnf].each { |ri| ri.recordChangeDate.size.should == 0 }
-          @rlin.recordChangeDate.size.should == 1
+          [@rec_info, @rec_info2, @bnf].each { |ri| expect(ri.recordChangeDate.size).to eq(0) }
+          expect(@rlin.recordChangeDate.size).to eq(1)
         end
         it "text should get element value" do
-          @rlin.recordChangeDate.map { |n| n.text }.should == ['19991012150824.0']
+          expect(@rlin.recordChangeDate.map { |n| n.text }).to eq(['19991012150824.0'])
         end
         it "should recognize encoding attribute" do
-          @rlin.recordChangeDate.encoding.should == ['iso8601']
+          expect(@rlin.recordChangeDate.encoding).to eq(['iso8601'])
         end
         it "should recognize all date attributes" do
           Mods::DATE_ATTRIBS.each { |a|
             @mods_rec.from_str("<mods><recordInfo><recordChangeDate #{a}='attr_val'>zzz</recordChangeDate></recordInfo></mods>", false)
-            @mods_rec.record_info.recordChangeDate.send(a.to_sym).should == ['attr_val']
+            expect(@mods_rec.record_info.recordChangeDate.send(a.to_sym)).to eq(['attr_val'])
           }
         end
       end # <recordChangeDate>
 
       context "<recordIdentifier> child element" do
         it "should be a NodeSet" do
-          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.recordIdentifier.should be_an_instance_of(Nokogiri::XML::NodeSet) }
+          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri.recordIdentifier).to be_an_instance_of(Nokogiri::XML::NodeSet) }
         end
         it "recordIdentifier NodeSet should have as many Nodes as there are <recordIdentifier> elements in the xml" do
-          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.recordIdentifier.size.should == 1 }
+          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri.recordIdentifier.size).to eq(1) }
         end
         it "text should get element value" do
-          @rec_info.recordIdentifier.map { |n| n.text }.should == ['a9079953']
-          @rec_info2.recordIdentifier.map { |n| n.text }.should == ['a8837534']
-          @bnf.recordIdentifier.map { |n| n.text }.should == ['']
-          @rlin.recordIdentifier.map { |n| n.text }.should == ['a4083219']
+          expect(@rec_info.recordIdentifier.map { |n| n.text }).to eq(['a9079953'])
+          expect(@rec_info2.recordIdentifier.map { |n| n.text }).to eq(['a8837534'])
+          expect(@bnf.recordIdentifier.map { |n| n.text }).to eq([''])
+          expect(@rlin.recordIdentifier.map { |n| n.text }).to eq(['a4083219'])
         end
         it "should recognize source attribute" do
-          [@rec_info, @rec_info2].each { |ri| ri.recordIdentifier.source.should == ['SIRSI'] }
-          @bnf.recordIdentifier.source.should == ['BNF 2166']
-          @rlin.recordIdentifier.source.should == ['CStRLIN']
+          [@rec_info, @rec_info2].each { |ri| expect(ri.recordIdentifier.source).to eq(['SIRSI']) }
+          expect(@bnf.recordIdentifier.source).to eq(['BNF 2166'])
+          expect(@rlin.recordIdentifier.source).to eq(['CStRLIN'])
         end
         it "should allow a source attribute without element content" do
-          @bnf.recordIdentifier.source.should == ['BNF 2166']
-          @bnf.recordIdentifier.map { |n| n.text }.should == ['']
+          expect(@bnf.recordIdentifier.source).to eq(['BNF 2166'])
+          expect(@bnf.recordIdentifier.map { |n| n.text }).to eq([''])
         end
       end # <recordIdentifier>
 
       context "<recordOrigin> child element" do
         it "should be a NodeSet" do
-          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.recordOrigin.should be_an_instance_of(Nokogiri::XML::NodeSet) }
+          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri.recordOrigin).to be_an_instance_of(Nokogiri::XML::NodeSet) }
         end
         it "recordOrigin NodeSet should have as many Nodes as there are <recordOrigin> elements in the xml" do
-          [@rec_info, @rec_info2, @rlin].each { |ri| ri.recordOrigin.size.should == 0 }
-          @bnf.recordOrigin.size.should == 1
+          [@rec_info, @rec_info2, @rlin].each { |ri| expect(ri.recordOrigin.size).to eq(0) }
+          expect(@bnf.recordOrigin.size).to eq(1)
         end
         it "text should get element value" do
           @mods_rec.from_str("<mods><recordInfo><recordOrigin>human prepared</recordOrigin></recordInfo></mods>", false)
-          @mods_rec.record_info.recordOrigin.map {|n| n.text }.should == ['human prepared']
-          @bnf.recordOrigin.map { |n| n.text }.should == ['']
+          expect(@mods_rec.record_info.recordOrigin.map {|n| n.text }).to eq(['human prepared'])
+          expect(@bnf.recordOrigin.map { |n| n.text }).to eq([''])
         end
       end # <recordOrigin>
 
       context "<languageOfCataloging> child element" do
         it "should be a NodeSet" do
-          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.languageOfCataloging.should be_an_instance_of(Nokogiri::XML::NodeSet) }
+          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri.languageOfCataloging).to be_an_instance_of(Nokogiri::XML::NodeSet) }
         end
         it "languageOfCataloging NodeSet should have as many Nodes as there are <languageOfCataloging> elements in the xml" do
-          [@rec_info2, @bnf].each { |ri| ri.languageOfCataloging.size.should == 1 }
-          [@rec_info, @rlin].each { |ri| ri.languageOfCataloging.size.should == 0 }
+          [@rec_info2, @bnf].each { |ri| expect(ri.languageOfCataloging.size).to eq(1) }
+          [@rec_info, @rlin].each { |ri| expect(ri.languageOfCataloging.size).to eq(0) }
         end
         it "text should get element value" do
           # this example is from   http://www.loc.gov/standards/mods/v3/mods-userguide-elements.html
           #   though it doesn't match the doc at http://www.loc.gov/standards/mods/mods-outline.html#recordInfo
           @mods_rec.from_str("<mods><recordInfo><languageOfCataloging authority='iso639-2b'>fre</languageOfCataloging></recordInfo></mods>", false)
-          @mods_rec.record_info.languageOfCataloging.map { |n| n.text }.should == ['fre']
+          expect(@mods_rec.record_info.languageOfCataloging.map { |n| n.text }).to eq(['fre'])
         end
         it "authority should get attribute value" do
           # this example is from   http://www.loc.gov/standards/mods/v3/mods-userguide-elements.html
           #   though it doesn't match the doc at http://www.loc.gov/standards/mods/mods-outline.html#recordInfo
           @mods_rec.from_str("<mods><recordInfo><languageOfCataloging authority='iso639-2b'>fre</languageOfCataloging></recordInfo></mods>", false)
-          @mods_rec.record_info.languageOfCataloging.authority.should == ['iso639-2b']
+          expect(@mods_rec.record_info.languageOfCataloging.authority).to eq(['iso639-2b'])
         end
 
         # from http://www.loc.gov/standards/mods/userguide/recordinfo.html#languageofcataloging
@@ -444,17 +444,17 @@ describe "Mods <recordInfo> Element" do
 
         context "<languageTerm> child element" do
           it "text should get element value" do
-            @rec_info2.languageOfCataloging.languageTerm.map { |n| n.text }.should == ['eng']
-            @bnf.languageOfCataloging.languageTerm.map { |n| n.text }.should == ['fra']
+            expect(@rec_info2.languageOfCataloging.languageTerm.map { |n| n.text }).to eq(['eng'])
+            expect(@bnf.languageOfCataloging.languageTerm.map { |n| n.text }).to eq(['fra'])
           end
           it "should recognize all authority attributes" do
             Mods::AUTHORITY_ATTRIBS.each { |a|
               @mods_rec.from_str("<mods><recordInfo><languageOfCataloging><languageTerm #{a}='attr_val'>zzz</languageTerm></languageOfCataloging></recordInfo></mods>", false)
-              @mods_rec.record_info.languageOfCataloging.languageTerm.send(a.to_sym).should == ['attr_val']
+              expect(@mods_rec.record_info.languageOfCataloging.languageTerm.send(a.to_sym)).to eq(['attr_val'])
             }
           end
           it "should recognize the type attribute with type_at term" do
-            @rec_info2.languageOfCataloging.languageTerm.type_at.should == ['code']
+            expect(@rec_info2.languageOfCataloging.languageTerm.type_at).to eq(['code'])
           end
         end # <languageTerm>
 
@@ -467,21 +467,21 @@ describe "Mods <recordInfo> Element" do
 
       context "<descriptionStandard> child element" do
         it "should be a NodeSet" do
-          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| ri.descriptionStandard.should be_an_instance_of(Nokogiri::XML::NodeSet) }
+          [@rec_info, @rec_info2, @bnf, @rlin].each { |ri| expect(ri.descriptionStandard).to be_an_instance_of(Nokogiri::XML::NodeSet) }
         end
         it "descriptionStandard NodeSet should have as many Nodes as there are <descriptionStandard> elements in the xml" do
-          [@rec_info, @bnf].each { |ri| ri.descriptionStandard.size.should == 0 }
-          [@rec_info2, @rlin].each { |ri| ri.descriptionStandard.size.should == 1 }
+          [@rec_info, @bnf].each { |ri| expect(ri.descriptionStandard.size).to eq(0) }
+          [@rec_info2, @rlin].each { |ri| expect(ri.descriptionStandard.size).to eq(1) }
         end
         it "text should get element value" do
-          @rec_info2.descriptionStandard.map { |n| n.text }.should == ['aacr2']
-          @rlin.descriptionStandard.map { |n| n.text }.should == ['appm']
-          @bnf.descriptionStandard.map { |n| n.text }.should == []
+          expect(@rec_info2.descriptionStandard.map { |n| n.text }).to eq(['aacr2'])
+          expect(@rlin.descriptionStandard.map { |n| n.text }).to eq(['appm'])
+          expect(@bnf.descriptionStandard.map { |n| n.text }).to eq([])
         end
         it "should recognize all authority attributes" do
           Mods::AUTHORITY_ATTRIBS.each { |a|
             @mods_rec.from_str("<mods><recordInfo><descriptionStandard #{a}='attr_val'>zzz</descriptionStandard></recordInfo></mods>", false)
-            @mods_rec.record_info.descriptionStandard.send(a.to_sym).should == ['attr_val']
+            expect(@mods_rec.record_info.descriptionStandard.send(a.to_sym)).to eq(['attr_val'])
           }
         end
       end # <descriptionStandard>