mods 2.0.1 → 2.0.2

data/spec/title_spec.rb

@@ -12,34 +12,34 @@ describe "Mods <titleInfo> element" do
     it "should recognize type attribute on titleInfo element" do
       Mods::TitleInfo::TYPES.each { |t|
         @mods_rec.from_str("<mods #{@ns_decl}><titleInfo type='#{t}'>hi</titleInfo></mods>")
-        @mods_rec.title_info.type_at.should == [t]
+        expect(@mods_rec.title_info.type_at).to eq([t])
       }
     end
     it "should recognize subelements" do
       Mods::TitleInfo::CHILD_ELEMENTS.each { |e|
         @mods_rec.from_str("<mods #{@ns_decl}><titleInfo><#{e}>oofda</#{e}></titleInfo></mods>")
-        @mods_rec.title_info.send(e).text.should == 'oofda'
+        expect(@mods_rec.title_info.send(e).text).to eq('oofda')
       }
     end
 
     context "short_title" do
       it "should start with nonSort element" do
         @mods_rec.from_str("<mods #{@ns_decl}><titleInfo><title>Jerk</title><nonSort>The</nonSort></titleInfo></mods>")
-        @mods_rec.title_info.short_title.should == ["The Jerk"]
+        expect(@mods_rec.title_info.short_title).to eq(["The Jerk"])
       end
       it "should not include subtitle" do
         @mods_rec.from_str("<mods #{@ns_decl}><titleInfo><title>Jerk</title><subTitle>A Tale of Tourettes</subTitle><nonSort>The</nonSort></titleInfo></mods>")
-        @mods_rec.title_info.short_title.should == ["The Jerk"]
+        expect(@mods_rec.title_info.short_title).to eq(["The Jerk"])
       end
       it "Mods::Record.short_titles convenience method should return an Array (multiple titles are legal in Mods)" do
         @mods_rec.from_str("<mods #{@ns_decl}><titleInfo><title>Jerk</title><nonSort>The</nonSort></titleInfo><titleInfo><title>Joke</title></titleInfo></mods>")
-        @mods_rec.short_titles.should == ["The Jerk", "Joke"]
+        expect(@mods_rec.short_titles).to eq(["The Jerk", "Joke"])
       end
       it "should not include alternative titles" do
         @mods_rec.from_str("<mods #{@ns_decl}><titleInfo type='alternative'><title>ta da!</title></titleInfo></mods>")
-        @mods_rec.short_titles.should_not include("ta da!")
+        expect(@mods_rec.short_titles).not_to include("ta da!")
         @mods_rec.from_str("<mods #{@ns_decl}><titleInfo type='alternative'><title>1</title></titleInfo><titleInfo><title>2</title></titleInfo></mods>")
-        @mods_rec.short_titles.should == ['2']
+        expect(@mods_rec.short_titles).to eq(['2'])
       end
       # note that Mods::Record.short_title tests are in record_spec
     end
@@ -47,15 +47,15 @@ describe "Mods <titleInfo> element" do
     context "full_title" do
       it "should start with nonSort element" do
         @mods_rec.from_str("<mods #{@ns_decl}><titleInfo><title>Jerk</title><nonSort>The</nonSort></titleInfo></mods>")
-        @mods_rec.title_info.full_title.should == ["The Jerk"]
+        expect(@mods_rec.title_info.full_title).to eq(["The Jerk"])
       end
       it "should include subtitle" do
         @mods_rec.from_str("<mods #{@ns_decl}><titleInfo><title>Jerk</title><subTitle>A Tale of Tourettes</subTitle><nonSort>The</nonSort></titleInfo></mods>")
-        @mods_rec.title_info.full_title.should == ["The Jerk A Tale of Tourettes"]
+        expect(@mods_rec.title_info.full_title).to eq(["The Jerk A Tale of Tourettes"])
       end
       it "Mods::Record.full_titles convenience method should return an Array (multiple titles are legal in Mods)" do
         @mods_rec.from_str("<mods #{@ns_decl}><titleInfo><title>Jerk</title><nonSort>The</nonSort></titleInfo><titleInfo><title>Joke</title></titleInfo></mods>")
-        @mods_rec.full_titles.should == ["The Jerk", "Joke"]
+        expect(@mods_rec.full_titles).to eq(["The Jerk", "Joke"])
       end
       # note that Mods::Record.full_title tests are in record_spec
     end
@@ -63,30 +63,30 @@ describe "Mods <titleInfo> element" do
     context "sort_title" do
       it "should skip nonSort element" do
         @mods_rec.from_str("<mods #{@ns_decl}><titleInfo><title>Jerk</title><nonSort>The</nonSort></titleInfo></mods>")
-        @mods_rec.title_info.sort_title.should == ["Jerk"]
+        expect(@mods_rec.title_info.sort_title).to eq(["Jerk"])
       end
       it "should contain title and subtitle" do
         @mods_rec.from_str("<mods #{@ns_decl}><titleInfo><title>Jerk</title><subTitle>A Tale of Tourettes</subTitle><nonSort>The</nonSort></titleInfo></mods>")
-        @mods_rec.title_info.sort_title.should == ["Jerk A Tale of Tourettes"]
+        expect(@mods_rec.title_info.sort_title).to eq(["Jerk A Tale of Tourettes"])
       end
       it "should be an alternative title if there are no other choices" do
         @mods_rec.from_str("<mods #{@ns_decl}><titleInfo type='alternative'><title>1</title></titleInfo></mods>")
-        @mods_rec.title_info.sort_title.should == ['1']
+        expect(@mods_rec.title_info.sort_title).to eq(['1'])
       end
       it "should not be an alternative title if there are other choices" do
         @mods_rec.from_str("<mods #{@ns_decl}><titleInfo type='alternative'><title>1</title></titleInfo><titleInfo><title>2</title></titleInfo></mods>")
-        @mods_rec.title_info.sort_title.should == ['2']
-        @mods_rec.sort_title.should == '2'
+        expect(@mods_rec.title_info.sort_title).to eq(['2'])
+        expect(@mods_rec.sort_title).to eq('2')
       end
       it "should have a configurable delimiter between title and subtitle" do
         m = Mods::Record.new(' : ')
         m.from_str("<mods #{@ns_decl}><titleInfo><title>Jerk</title><subTitle>A Tale of Tourettes</subTitle><nonSort>The</nonSort></titleInfo></mods>")
-        m.title_info.sort_title.should == ["Jerk : A Tale of Tourettes"]
+        expect(m.title_info.sort_title).to eq(["Jerk : A Tale of Tourettes"])
       end
       context "Mods::Record.sort_title convenience method" do
         it "convenience method sort_title in Mods::Record should return a string" do
           @mods_rec.from_str("<mods #{@ns_decl}><titleInfo><title>Jerk</title><subTitle>A Tale of Tourettes</subTitle><nonSort>The</nonSort></titleInfo></mods>")
-          @mods_rec.sort_title.should == "Jerk A Tale of Tourettes"
+          expect(@mods_rec.sort_title).to eq("Jerk A Tale of Tourettes")
         end
       end
       # note that Mods::Record.sort_title tests are in record_spec
@@ -95,21 +95,21 @@ describe "Mods <titleInfo> element" do
     context "alternative_title" do
       it "should get an alternative title, if it exists" do
         @mods_rec.from_str("<mods #{@ns_decl}><titleInfo type='alternative'><title>ta da!</title></titleInfo></mods>")
-        @mods_rec.title_info.alternative_title.should == ["ta da!"]
+        expect(@mods_rec.title_info.alternative_title).to eq(["ta da!"])
       end
       it "Mods::Record.alternative_titles convenience method for getting an Array of alternative titles when there are multiple elements" do
         @mods_rec.from_str("<mods #{@ns_decl}><titleInfo type='alternative'><title>1</title></titleInfo><titleInfo type='alternative'><title>2</title></titleInfo></mods>")
-        @mods_rec.alternative_titles.should == ['1', '2']
+        expect(@mods_rec.alternative_titles).to eq(['1', '2'])
         @mods_rec.from_str("<mods #{@ns_decl}><titleInfo type='alternative'><title>1</title><title>2</title></titleInfo></mods>")
-        @mods_rec.alternative_titles.should == ['12']
+        expect(@mods_rec.alternative_titles).to eq(['12'])
       end
       it "should not get an alternative title if type attribute is absent from titleInfo" do
         @mods_rec.from_str("<mods #{@ns_decl}><titleInfo><title>ta da!</title></titleInfo></mods>")
-        @mods_rec.alternative_titles.should == []
+        expect(@mods_rec.alternative_titles).to eq([])
       end
       it "should not get an alternative title if type attribute from titleInfo is not 'alternative'" do
         @mods_rec.from_str("<mods #{@ns_decl}><titleInfo type='uniform'><title>ta da!</title></titleInfo></mods>")
-        @mods_rec.alternative_titles.should == []
+        expect(@mods_rec.alternative_titles).to eq([])
       end
       # note that Mods::Record.alternative_title tests are in record_spec
     end
@@ -120,34 +120,34 @@ describe "Mods <titleInfo> element" do
     it "should recognize type attribute on titleInfo element" do
       Mods::TitleInfo::TYPES.each { |t|
         @mods_rec.from_str("<mods><titleInfo type='#{t}'>hi</titleInfo></mods>", false)
-        @mods_rec.title_info.type_at.should == [t]
+        expect(@mods_rec.title_info.type_at).to eq([t])
       }
     end
     it "should recognize subelements" do
       Mods::TitleInfo::CHILD_ELEMENTS.each { |e|
         @mods_rec.from_str("<mods><titleInfo><#{e}>oofda</#{e}></titleInfo></mods>", false)
-        @mods_rec.title_info.send(e).text.should == 'oofda'
+        expect(@mods_rec.title_info.send(e).text).to eq('oofda')
       }
     end
 
     context "short_title" do
       it "should start with nonSort element" do
         @mods_rec.from_str("<mods><titleInfo><title>Jerk</title><nonSort>The</nonSort></titleInfo></mods>", false)
-        @mods_rec.title_info.short_title.should == ["The Jerk"]
+        expect(@mods_rec.title_info.short_title).to eq(["The Jerk"])
       end
       it "should not include subtitle" do
         @mods_rec.from_str("<mods><titleInfo><title>Jerk</title><subTitle>A Tale of Tourettes</subTitle><nonSort>The</nonSort></titleInfo></mods>", false)
-        @mods_rec.title_info.short_title.should == ["The Jerk"]
+        expect(@mods_rec.title_info.short_title).to eq(["The Jerk"])
       end
       it "Mods::Record.short_titles convenience method should return an Array (multiple titles are legal in Mods)" do
         @mods_rec.from_str("<mods><titleInfo><title>Jerk</title><nonSort>The</nonSort></titleInfo><titleInfo><title>Joke</title></titleInfo></mods>", false)
-        @mods_rec.short_titles.should == ["The Jerk", "Joke"]
+        expect(@mods_rec.short_titles).to eq(["The Jerk", "Joke"])
       end
       it "should not include alternative titles" do
         @mods_rec.from_str("<mods><titleInfo type='alternative'><title>ta da!</title></titleInfo></mods>", false)
-        @mods_rec.short_titles.should_not include("ta da!")
+        expect(@mods_rec.short_titles).not_to include("ta da!")
         @mods_rec.from_str("<mods><titleInfo type='alternative'><title>1</title></titleInfo><titleInfo><title>2</title></titleInfo></mods>", false)
-        @mods_rec.short_titles.should == ['2']
+        expect(@mods_rec.short_titles).to eq(['2'])
       end
       # note that Mods::Record.short_title tests are in record_spec
     end
@@ -155,15 +155,15 @@ describe "Mods <titleInfo> element" do
     context "full_title" do
       it "should start with nonSort element" do
         @mods_rec.from_str("<mods><titleInfo><title>Jerk</title><nonSort>The</nonSort></titleInfo></mods>", false)
-        @mods_rec.title_info.full_title.should == ["The Jerk"]
+        expect(@mods_rec.title_info.full_title).to eq(["The Jerk"])
       end
       it "should include subtitle" do
         @mods_rec.from_str("<mods><titleInfo><title>Jerk</title><subTitle>A Tale of Tourettes</subTitle><nonSort>The</nonSort></titleInfo></mods>", false)
-        @mods_rec.title_info.full_title.should == ["The Jerk A Tale of Tourettes"]
+        expect(@mods_rec.title_info.full_title).to eq(["The Jerk A Tale of Tourettes"])
       end
       it "Mods::Record.full_titles convenience method should return an Array (multiple titles are legal in Mods)" do
         @mods_rec.from_str("<mods><titleInfo><title>Jerk</title><nonSort>The</nonSort></titleInfo><titleInfo><title>Joke</title></titleInfo></mods>", false)
-        @mods_rec.full_titles.should == ["The Jerk", "Joke"]
+        expect(@mods_rec.full_titles).to eq(["The Jerk", "Joke"])
       end
       # note that Mods::Record.full_title tests are in record_spec
     end
@@ -171,30 +171,30 @@ describe "Mods <titleInfo> element" do
     context "sort_title" do
       it "should skip nonSort element" do
         @mods_rec.from_str("<mods><titleInfo><title>Jerk</title><nonSort>The</nonSort></titleInfo></mods>", false)
-        @mods_rec.title_info.sort_title.should == ["Jerk"]
+        expect(@mods_rec.title_info.sort_title).to eq(["Jerk"])
       end
       it "should contain title and subtitle" do
         @mods_rec.from_str("<mods><titleInfo><title>Jerk</title><subTitle>A Tale of Tourettes</subTitle><nonSort>The</nonSort></titleInfo></mods>", false)
-        @mods_rec.title_info.sort_title.should == ["Jerk A Tale of Tourettes"]
+        expect(@mods_rec.title_info.sort_title).to eq(["Jerk A Tale of Tourettes"])
       end
       it "should be an alternative title if there are no other choices" do
         @mods_rec.from_str("<mods><titleInfo type='alternative'><title>1</title></titleInfo></mods>", false)
-        @mods_rec.title_info.sort_title.should == ['1']
+        expect(@mods_rec.title_info.sort_title).to eq(['1'])
       end
       it "should not be an alternative title if there are other choices" do
         @mods_rec.from_str("<mods><titleInfo type='alternative'><title>1</title></titleInfo><titleInfo><title>2</title></titleInfo></mods>", false)
-        @mods_rec.title_info.sort_title.should == ['2']
-        @mods_rec.sort_title.should == '2'
+        expect(@mods_rec.title_info.sort_title).to eq(['2'])
+        expect(@mods_rec.sort_title).to eq('2')
       end
       it "should have a configurable delimiter between title and subtitle" do
         m = Mods::Record.new(' : ')
         m.from_str("<mods><titleInfo><title>Jerk</title><subTitle>A Tale of Tourettes</subTitle><nonSort>The</nonSort></titleInfo></mods>", false)
-        m.title_info.sort_title.should == ["Jerk : A Tale of Tourettes"]
+        expect(m.title_info.sort_title).to eq(["Jerk : A Tale of Tourettes"])
       end
       context "Mods::Record.sort_title convenience method" do
         it "convenience method sort_title in Mods::Record should return a string" do
           @mods_rec.from_str("<mods><titleInfo><title>Jerk</title><subTitle>A Tale of Tourettes</subTitle><nonSort>The</nonSort></titleInfo></mods>", false)
-          @mods_rec.sort_title.should == "Jerk A Tale of Tourettes"
+          expect(@mods_rec.sort_title).to eq("Jerk A Tale of Tourettes")
         end
       end
       # note that Mods::Record.sort_title tests are in record_spec
@@ -203,21 +203,21 @@ describe "Mods <titleInfo> element" do
     context "alternative_title" do
       it "should get an alternative title, if it exists" do
         @mods_rec.from_str("<mods><titleInfo type='alternative'><title>ta da!</title></titleInfo></mods>", false)
-        @mods_rec.title_info.alternative_title.should == ["ta da!"]
+        expect(@mods_rec.title_info.alternative_title).to eq(["ta da!"])
       end
       it "Mods::Record.alternative_titles convenience method for getting an Array of alternative titles when there are multiple elements" do
         @mods_rec.from_str("<mods><titleInfo type='alternative'><title>1</title></titleInfo><titleInfo type='alternative'><title>2</title></titleInfo></mods>", false)
-        @mods_rec.alternative_titles.should == ['1', '2']
+        expect(@mods_rec.alternative_titles).to eq(['1', '2'])
         @mods_rec.from_str("<mods><titleInfo type='alternative'><title>1</title><title>2</title></titleInfo></mods>", false)
-        @mods_rec.alternative_titles.should == ['12']
+        expect(@mods_rec.alternative_titles).to eq(['12'])
       end
       it "should not get an alternative title if type attribute is absent from titleInfo" do
         @mods_rec.from_str("<mods><titleInfo><title>ta da!</title></titleInfo></mods>", false)
-        @mods_rec.alternative_titles.should == []
+        expect(@mods_rec.alternative_titles).to eq([])
       end
       it "should not get an alternative title if type attribute from titleInfo is not 'alternative'" do
         @mods_rec.from_str("<mods><titleInfo type='uniform'><title>ta da!</title></titleInfo></mods>", false)
-        @mods_rec.alternative_titles.should == []
+        expect(@mods_rec.alternative_titles).to eq([])
       end
       # note that Mods::Record.alternative_title tests are in record_spec
     end

data/spec/top_level_elmnts_simple_spec.rb

@@ -14,7 +14,7 @@ describe "Mods Top Level Elements that do not have Child Elements" do
     skip "to be implemented"
     Mods::TOP_LEVEL_ELEMENTS_COMPLEX.each { |elname|
       @mods_rec.from_str("<mods><#{elname}>hi</#{elname}></mods>", false)
-      @mods_rec.send(elname.to_sym).map { |e| e.text }.should == ["hi"]
+      expect(@mods_rec.send(elname.to_sym).map { |e| e.text }).to eq(["hi"])
     }
   end
 
@@ -23,22 +23,22 @@ describe "Mods Top Level Elements that do not have Child Elements" do
     it "should get the text contents of any single simple (cannot have child elements) top level element" do
       Mods::TOP_LEVEL_ELEMENTS_SIMPLE.each { |elname|
         @mods_rec.from_str("<mods><#{elname}>hi</#{elname}></mods>", false)
-        @mods_rec.send(elname.to_sym).map { |e| e.text }.should == ["hi"]
+        expect(@mods_rec.send(elname.to_sym).map { |e| e.text }).to eq(["hi"])
       }
     end
 
     it "should return an array of strings when there are multiple occurrences of simple top level elements" do
-      @mods_rec.from_str('<mods><note>hi</note><note>hello</note></mods>', false).note.map { |e| e.text }.should == ["hi", "hello"]
+      expect(@mods_rec.from_str('<mods><note>hi</note><note>hello</note></mods>', false).note.map { |e| e.text }).to eq(["hi", "hello"])
     end
 
     context "<abstract> child element" do
       it ".abstract.displayLabel should be an accessor for displayLabel attribute on abstract element: <abstract displayLabel='foo'>" do
         @mods_rec.from_str('<mods><abstract displayLabel="Summary">blah blah blah</abstract></mods>', false)
-        @mods_rec.abstract.displayLabel.should == ['Summary']
+        expect(@mods_rec.abstract.displayLabel).to eq(['Summary'])
       end
       it ".abstract.type_at should be an accessor for type attribute on abstract element: <abstract type='foo'>" do
         @mods_rec.from_str('<mods><abstract type="Scope and Contents note">blah blah blah</abstract></mods>', false)
-        @mods_rec.abstract.type_at.should == ['Scope and Contents note']
+        expect(@mods_rec.abstract.type_at).to eq(['Scope and Contents note'])
       end
     end
 
@@ -48,10 +48,10 @@ describe "Mods Top Level Elements that do not have Child Elements" do
         @acc_cond2 = @mods_rec.from_str('<mods><accessCondition type="useAndReproduction">All rights reserved.</accessCondition></mods>', false).accessCondition
       end
       it ".accessCondition.displayLabel should be an accessor for displayLabel attribute on accessCondition element: <accessCondition displayLabel='foo'>" do
-        @acc_cond.displayLabel.should == ['meh']
+        expect(@acc_cond.displayLabel).to eq(['meh'])
       end
       it ".accessCondition.type_at should be an accessor for type attribute on accessCondition element: <accessCondition type='foo'>" do
-        [@acc_cond, @acc_cond2].each { |ac| ac.type_at.should == ['useAndReproduction'] }
+        [@acc_cond, @acc_cond2].each { |ac| expect(ac.type_at).to eq(['useAndReproduction']) }
       end
     end
 
@@ -61,16 +61,16 @@ describe "Mods Top Level Elements that do not have Child Elements" do
         @class2 = @mods_rec.from_str('<mods><classification authority="lcc">JK609.M2</classification></mods>', false).classification
       end
       it ".classification.authority should be an accessor for authority attribute on classification element: <classification authority='foo'>" do
-        @class1.authority.should == ['ddc']
-        @class2.authority.should == ['lcc']
+        expect(@class1.authority).to eq(['ddc'])
+        expect(@class2.authority).to eq(['lcc'])
       end
       it ".classification.edition should be an accessor for edition attribute on classification element: <classification edition='foo'>" do
-        @class1.edition.should == ['11']
+        expect(@class1.edition).to eq(['11'])
       end
       it "should recognize all authority attributes" do
         Mods::AUTHORITY_ATTRIBS.each { |a|
           @mods_rec.from_str("<mods><classification #{a}='attr_val'>zzz</classification></mods>", false)
-          @mods_rec.classification.send(a.to_sym).should == ['attr_val']
+          expect(@mods_rec.classification.send(a.to_sym)).to eq(['attr_val'])
         }
       end
     end
@@ -83,27 +83,27 @@ describe "Mods Top Level Elements that do not have Child Elements" do
       end
       it ".extension.displayLabel should be an accessor for displayLabel attribute on extension element: <extension displayLabel='foo'>" do
         @mods_rec.from_str('<mods><extension displayLabel="something">blah blah blah</extension></mods>', false)
-        @mods_rec.extension.displayLabel.should == ['something']
+        expect(@mods_rec.extension.displayLabel).to eq(['something'])
       end
     end
 
     context "<genre> child element" do
       it ".genre.displayLabel should be an accessor for displayLabel attribute on genre element: <genre displayLabel='foo'>" do
         @mods_rec.from_str('<mods><genre displayLabel="something">blah blah blah</genre></mods>', false)
-        @mods_rec.genre.displayLabel.should == ['something']
+        expect(@mods_rec.genre.displayLabel).to eq(['something'])
       end
       it ".genre.type_at should be an accessor for type attribute on genre element: <genre type='foo'>" do
         @mods_rec.from_str('<mods><genre type="maybe">blah blah blah</genre></mods>', false)
-        @mods_rec.genre.type_at.should == ['maybe']
+        expect(@mods_rec.genre.type_at).to eq(['maybe'])
       end
       it ".genre.usage should be an accessor for usage attribute on genre element: <genre usage='foo'>" do
         @mods_rec.from_str('<mods><genre usage="fer sure">blah blah blah</genre></mods>', false)
-        @mods_rec.genre.usage.should == ['fer sure']
+        expect(@mods_rec.genre.usage).to eq(['fer sure'])
       end
       it "should recognize all authority attributes" do
         Mods::AUTHORITY_ATTRIBS.each { |a|
           @mods_rec.from_str("<mods><genre #{a}='attr_val'>zzz</genre></mods>", false)
-          @mods_rec.genre.send(a.to_sym).should == ['attr_val']
+          expect(@mods_rec.genre.send(a.to_sym)).to eq(['attr_val'])
         }
       end
     end
@@ -113,56 +113,56 @@ describe "Mods Top Level Elements that do not have Child Elements" do
         @id = @mods_rec.from_str('<mods><identifier displayLabel="book_number" type="local">70</identifier></mods>', false).identifier
       end
       it ".identifier.displayLabel should be an accessor for displayLabel attribute on identifier element: <identifier displayLabel='foo'>" do
-        @id.displayLabel.should == ['book_number']
+        expect(@id.displayLabel).to eq(['book_number'])
       end
       it ".identifier.invalid should be an accessor for invalid attribute on identifier element: <identifier invalid='foo'>" do
         @mods_rec.from_str('<mods> <identifier type="isbn" invalid="yes">0877780116</identifier></mods>', false)
-        @mods_rec.identifier.invalid.should == ['yes']
+        expect(@mods_rec.identifier.invalid).to eq(['yes'])
       end
       it ".identifier.type_at should be an accessor for type attribute on identifier element: <identifier type='foo'>" do
-        @id.type_at.should == ['local']
+        expect(@id.type_at).to eq(['local'])
       end
     end
 
     context "<note> child element" do
       it ".note.displayLabel should be an accessor for displayLabel attribute on note element: <note displayLabel='foo'>" do
         @mods_rec.from_str('<mods><note displayLabel="state_note">blah</note></mods>', false)
-        @mods_rec.note.displayLabel.should == ['state_note']
+        expect(@mods_rec.note.displayLabel).to eq(['state_note'])
       end
       it ".note.id_at should be an accessor for ID attribute on note element: <note ID='foo'>" do
         @mods_rec.from_str('<mods><note ID="foo">blah blah blah</note></mods>', false)
-        @mods_rec.note.id_at.should == ['foo']
+        expect(@mods_rec.note.id_at).to eq(['foo'])
       end
       it ".note.type_at should be an accessor for type attribute on note element: <note type='foo'>" do
         @mods_rec.from_str('<mods><note type="content">blah</note></mods>', false)
-        @mods_rec.note.type_at.should == ['content']
+        expect(@mods_rec.note.type_at).to eq(['content'])
       end
     end
 
     context "<tableOfContents> child element" do
       it ".tableOfContents.displayLabel should be an accessor for displayLabel attribute on tableOfContents element: <tableOfContents displayLabel='foo'>" do
         @mods_rec.from_str('<mods><tableOfContents displayLabel="Chapters included in book">blah blah</tableOfContents></mods>', false)
-        @mods_rec.tableOfContents.displayLabel.should == ['Chapters included in book']
+        expect(@mods_rec.tableOfContents.displayLabel).to eq(['Chapters included in book'])
       end
       it ".tableOfContents.shareable should be an accessor for shareable attribute on tableOfContents element: <tableOfContents shareable='foo'>" do
         @mods_rec.from_str('<mods><tableOfContents shareable="no">blah blah blah</tableOfContents></mods>', false)
-        @mods_rec.tableOfContents.shareable.should == ['no']
+        expect(@mods_rec.tableOfContents.shareable).to eq(['no'])
       end
       it ".tableOfContents.type_at should be an accessor for type attribute on tableOfContents element: <tableOfContents type='foo'>" do
         @mods_rec.from_str('<mods><tableOfContents type="partial contents">blah blah</tableOfContents></mods>', false)
-        @mods_rec.tableOfContents.type_at.should == ['partial contents']
+        expect(@mods_rec.tableOfContents.type_at).to eq(['partial contents'])
       end
     end
 
     context "<targetAudience> child element" do
       it ".targetAudience.displayLabel should be an accessor for displayLabel attribute on targetAudience element: <targetAudience displayLabel='foo'>" do
         @mods_rec.from_str('<mods><targetAudience displayLabel="ta da">blah blah</targetAudience></mods>', false)
-        @mods_rec.targetAudience.displayLabel.should == ['ta da']
+        expect(@mods_rec.targetAudience.displayLabel).to eq(['ta da'])
       end
       it "should recognize all authority attributes" do
         Mods::AUTHORITY_ATTRIBS.each { |a|
           @mods_rec.from_str("<mods><targetAudience #{a}='attr_val'>zzz</targetAudience></mods>", false)
-          @mods_rec.targetAudience.send(a.to_sym).should == ['attr_val']
+          expect(@mods_rec.targetAudience.send(a.to_sym)).to eq(['attr_val'])
         }
       end
     end
@@ -173,19 +173,19 @@ describe "Mods Top Level Elements that do not have Child Elements" do
       end
       it ".typeOfResource.collection should be an accessor for collection attribute on typeOfResource element: <typeOfResource collection='foo'>" do
         @mods_rec.from_str('<mods><typeOfResource collection="yes">blah blah blah</typeOfResource></mods>', false)
-        @mods_rec.typeOfResource.collection.should == ['yes']
+        expect(@mods_rec.typeOfResource.collection).to eq(['yes'])
       end
       it ".typeOfResource.displayLabel should be an accessor for displayLabel attribute on typeOfResource element: <typeOfResource displayLabel='foo'>" do
         @mods_rec.from_str('<mods><typeOfResource displayLabel="Summary">blah blah blah</typeOfResource></mods>', false)
-        @mods_rec.typeOfResource.displayLabel.should == ['Summary']
+        expect(@mods_rec.typeOfResource.displayLabel).to eq(['Summary'])
       end
       it ".typeOfResource.manuscript should be an accessor for manuscript attribute on typeOfResource element: <typeOfResource manuscript='foo'>" do
         @mods_rec.from_str('<mods><typeOfResource manuscript="yes">blah blah blah</typeOfResource></mods>', false)
-        @mods_rec.typeOfResource.manuscript.should == ['yes']
+        expect(@mods_rec.typeOfResource.manuscript).to eq(['yes'])
       end
       it ".typeOfResource.usage should be an accessor for usage attribute on typeOfResource element: <typeOfResource usage='foo'>" do
         @mods_rec.from_str('<mods><typeOfResource usage="fer sure">blah blah blah</typeOfResource></mods>', false)
-        @mods_rec.typeOfResource.usage.should == ['fer sure']
+        expect(@mods_rec.typeOfResource.usage).to eq(['fer sure'])
       end
     end
 
@@ -200,22 +200,22 @@ describe "Mods Top Level Elements that do not have Child Elements" do
     it "should get the text contents of any single simple (cannot have child elements) top level element" do
       Mods::TOP_LEVEL_ELEMENTS_SIMPLE.each { |elname|
         @mods_rec.from_str(@mods_el_w_ns + "<#{elname}>hi</#{elname}></mods>")
-        @mods_rec.send(elname.to_sym).map { |e| e.text }.should == ["hi"]
+        expect(@mods_rec.send(elname.to_sym).map { |e| e.text }).to eq(["hi"])
       }
     end
 
     it "should return an array of strings when there are multiple occurrences of simple top level elements" do
-      @mods_rec.from_str(@mods_el_w_ns + '<note>hi</note><note>hello</note></mods>').note.map { |e| e.text }.should == ["hi", "hello"]
+      expect(@mods_rec.from_str(@mods_el_w_ns + '<note>hi</note><note>hello</note></mods>').note.map { |e| e.text }).to eq(["hi", "hello"])
     end
 
     context "<abstract> child element" do
       it ".abstract.displayLabel should be an accessor for displayLabel attribute on abstract element: <abstract displayLabel='foo'>" do
         @mods_rec.from_str(@mods_el_w_ns + '<abstract displayLabel="Summary">blah blah blah</abstract></mods>')
-        @mods_rec.abstract.displayLabel.should == ['Summary']
+        expect(@mods_rec.abstract.displayLabel).to eq(['Summary'])
       end
       it ".abstract.type_at should be an accessor for type attribute on abstract element: <abstract type='foo'>" do
         @mods_rec.from_str(@mods_el_w_ns + '<abstract type="Scope and Contents note">blah blah blah</abstract></mods>')
-        @mods_rec.abstract.type_at.should == ['Scope and Contents note']
+        expect(@mods_rec.abstract.type_at).to eq(['Scope and Contents note'])
       end
     end
 
@@ -225,10 +225,10 @@ describe "Mods Top Level Elements that do not have Child Elements" do
         @acc_cond2 = @mods_rec.from_str(@mods_el_w_ns + '<accessCondition type="useAndReproduction">All rights reserved.</accessCondition></mods>').accessCondition
       end
       it ".accessCondition.displayLabel should be an accessor for displayLabel attribute on accessCondition element: <accessCondition displayLabel='foo'>" do
-        @acc_cond.displayLabel.should == ['meh']
+        expect(@acc_cond.displayLabel).to eq(['meh'])
       end
       it ".accessCondition.type_at should be an accessor for type attribute on accessCondition element: <accessCondition type='foo'>" do
-        [@acc_cond, @acc_cond2].each { |ac| ac.type_at.should == ['useAndReproduction'] }
+        [@acc_cond, @acc_cond2].each { |ac| expect(ac.type_at).to eq(['useAndReproduction']) }
       end
     end
 
@@ -238,16 +238,16 @@ describe "Mods Top Level Elements that do not have Child Elements" do
         @class2 = @mods_rec.from_str(@mods_el_w_ns + '<classification authority="lcc">JK609.M2</classification></mods>').classification
       end
       it ".classification.authority should be an accessor for authority attribute on classification element: <classification authority='foo'>" do
-        @class1.authority.should == ['ddc']
-        @class2.authority.should == ['lcc']
+        expect(@class1.authority).to eq(['ddc'])
+        expect(@class2.authority).to eq(['lcc'])
       end
       it ".classification.edition should be an accessor for edition attribute on classification element: <classification edition='foo'>" do
-        @class1.edition.should == ['11']
+        expect(@class1.edition).to eq(['11'])
       end
       it "should recognize all authority attributes" do
         Mods::AUTHORITY_ATTRIBS.each { |a|
           @mods_rec.from_str(@mods_el_w_ns + "<classification #{a}='attr_val'>zzz</classification></mods>")
-          @mods_rec.classification.send(a.to_sym).should == ['attr_val']
+          expect(@mods_rec.classification.send(a.to_sym)).to eq(['attr_val'])
         }
       end
     end
@@ -260,27 +260,27 @@ describe "Mods Top Level Elements that do not have Child Elements" do
       end
       it ".extension.displayLabel should be an accessor for displayLabel attribute on extension element: <extension displayLabel='foo'>" do
         @mods_rec.from_str(@mods_el_w_ns + '<extension displayLabel="something">blah blah blah</extension></mods>')
-        @mods_rec.extension.displayLabel.should == ['something']
+        expect(@mods_rec.extension.displayLabel).to eq(['something'])
       end
     end
 
     context "<genre> child element" do
       it ".genre.displayLabel should be an accessor for displayLabel attribute on genre element: <genre displayLabel='foo'>" do
         @mods_rec.from_str(@mods_el_w_ns + '<genre displayLabel="something">blah blah blah</genre></mods>')
-        @mods_rec.genre.displayLabel.should == ['something']
+        expect(@mods_rec.genre.displayLabel).to eq(['something'])
       end
       it ".genre.type_at should be an accessor for type attribute on genre element: <genre type='foo'>" do
         @mods_rec.from_str(@mods_el_w_ns + '<genre type="maybe">blah blah blah</genre></mods>')
-        @mods_rec.genre.type_at.should == ['maybe']
+        expect(@mods_rec.genre.type_at).to eq(['maybe'])
       end
       it ".genre.usage should be an accessor for usage attribute on genre element: <genre usage='foo'>" do
         @mods_rec.from_str(@mods_el_w_ns + '<genre usage="fer sure">blah blah blah</genre></mods>')
-        @mods_rec.genre.usage.should == ['fer sure']
+        expect(@mods_rec.genre.usage).to eq(['fer sure'])
       end
       it "should recognize all authority attributes" do
         Mods::AUTHORITY_ATTRIBS.each { |a|
           @mods_rec.from_str(@mods_el_w_ns + "<genre #{a}='attr_val'>zzz</genre></mods>")
-          @mods_rec.genre.send(a.to_sym).should == ['attr_val']
+          expect(@mods_rec.genre.send(a.to_sym)).to eq(['attr_val'])
         }
       end
     end
@@ -290,56 +290,56 @@ describe "Mods Top Level Elements that do not have Child Elements" do
         @id = @mods_rec.from_str(@mods_el_w_ns + '<identifier displayLabel="book_number" type="local">70</identifier></mods>').identifier
       end
       it ".identifier.displayLabel should be an accessor for displayLabel attribute on identifier element: <identifier displayLabel='foo'>" do
-        @id.displayLabel.should == ['book_number']
+        expect(@id.displayLabel).to eq(['book_number'])
       end
       it ".identifier.invalid should be an accessor for invalid attribute on identifier element: <identifier invalid='foo'>" do
         @mods_rec.from_str(@mods_el_w_ns + '<identifier type="isbn" invalid="yes">0877780116</identifier></mods>')
-        @mods_rec.identifier.invalid.should == ['yes']
+        expect(@mods_rec.identifier.invalid).to eq(['yes'])
       end
       it ".identifier.type_at should be an accessor for type attribute on identifier element: <identifier type='foo'>" do
-        @id.type_at.should == ['local']
+        expect(@id.type_at).to eq(['local'])
       end
     end
 
     context "<note> child element" do
       it ".note.displayLabel should be an accessor for displayLabel attribute on note element: <note displayLabel='foo'>" do
         @mods_rec.from_str(@mods_el_w_ns + '<note displayLabel="state_note">blah</note></mods>')
-        @mods_rec.note.displayLabel.should == ['state_note']
+        expect(@mods_rec.note.displayLabel).to eq(['state_note'])
       end
       it ".note.id_at should be an accessor for ID attribute on note element: <note ID='foo'>" do
         @mods_rec.from_str(@mods_el_w_ns + '<note ID="foo">blah blah blah</note></mods>')
-        @mods_rec.note.id_at.should == ['foo']
+        expect(@mods_rec.note.id_at).to eq(['foo'])
       end
       it ".note.type_at should be an accessor for type attribute on note element: <note type='foo'>" do
         @mods_rec.from_str(@mods_el_w_ns + '<note type="content">blah</note></mods>')
-        @mods_rec.note.type_at.should == ['content']
+        expect(@mods_rec.note.type_at).to eq(['content'])
       end
     end
 
     context "<tableOfContents> child element" do
       it ".tableOfContents.displayLabel should be an accessor for displayLabel attribute on tableOfContents element: <tableOfContents displayLabel='foo'>" do
         @mods_rec.from_str(@mods_el_w_ns + '<tableOfContents displayLabel="Chapters included in book">blah blah</tableOfContents></mods>')
-        @mods_rec.tableOfContents.displayLabel.should == ['Chapters included in book']
+        expect(@mods_rec.tableOfContents.displayLabel).to eq(['Chapters included in book'])
       end
       it ".tableOfContents.shareable should be an accessor for shareable attribute on tableOfContents element: <tableOfContents shareable='foo'>" do
         @mods_rec.from_str(@mods_el_w_ns + '<tableOfContents shareable="no">blah blah blah</tableOfContents></mods>')
-        @mods_rec.tableOfContents.shareable.should == ['no']
+        expect(@mods_rec.tableOfContents.shareable).to eq(['no'])
       end
       it ".tableOfContents.type_at should be an accessor for type attribute on tableOfContents element: <tableOfContents type='foo'>" do
         @mods_rec.from_str(@mods_el_w_ns + '<tableOfContents type="partial contents">blah blah</tableOfContents></mods>')
-        @mods_rec.tableOfContents.type_at.should == ['partial contents']
+        expect(@mods_rec.tableOfContents.type_at).to eq(['partial contents'])
       end
     end
 
     context "<targetAudience> child element" do
       it ".targetAudience.displayLabel should be an accessor for displayLabel attribute on targetAudience element: <targetAudience displayLabel='foo'>" do
         @mods_rec.from_str(@mods_el_w_ns + '<targetAudience displayLabel="ta da">blah blah</targetAudience></mods>')
-        @mods_rec.targetAudience.displayLabel.should == ['ta da']
+        expect(@mods_rec.targetAudience.displayLabel).to eq(['ta da'])
       end
       it "should recognize all authority attributes" do
         Mods::AUTHORITY_ATTRIBS.each { |a|
           @mods_rec.from_str(@mods_el_w_ns + "<targetAudience #{a}='attr_val'>zzz</targetAudience></mods>")
-          @mods_rec.targetAudience.send(a.to_sym).should == ['attr_val']
+          expect(@mods_rec.targetAudience.send(a.to_sym)).to eq(['attr_val'])
         }
       end
     end
@@ -347,19 +347,19 @@ describe "Mods Top Level Elements that do not have Child Elements" do
     context "<typeOfResource> child element" do
       it ".typeOfResource.collection should be an accessor for collection attribute on typeOfResource element: <typeOfResource collection='foo'>" do
         @mods_rec.from_str(@mods_el_w_ns + '<typeOfResource collection="yes">blah blah blah</typeOfResource></mods>')
-        @mods_rec.typeOfResource.collection.should == ['yes']
+        expect(@mods_rec.typeOfResource.collection).to eq(['yes'])
       end
       it ".typeOfResource.displayLabel should be an accessor for displayLabel attribute on typeOfResource element: <typeOfResource displayLabel='foo'>" do
         @mods_rec.from_str(@mods_el_w_ns + '<typeOfResource displayLabel="Summary">blah blah blah</typeOfResource></mods>')
-        @mods_rec.typeOfResource.displayLabel.should == ['Summary']
+        expect(@mods_rec.typeOfResource.displayLabel).to eq(['Summary'])
       end
       it ".typeOfResource.manuscript should be an accessor for manuscript attribute on typeOfResource element: <typeOfResource manuscript='foo'>" do
         @mods_rec.from_str(@mods_el_w_ns + '<typeOfResource manuscript="yes">blah blah blah</typeOfResource></mods>')
-        @mods_rec.typeOfResource.manuscript.should == ['yes']
+        expect(@mods_rec.typeOfResource.manuscript).to eq(['yes'])
       end
       it ".typeOfResource.usage should be an accessor for usage attribute on typeOfResource element: <typeOfResource usage='foo'>" do
         @mods_rec.from_str(@mods_el_w_ns + '<typeOfResource usage="fer sure">blah blah blah</typeOfResource></mods>')
-        @mods_rec.typeOfResource.usage.should == ['fer sure']
+        expect(@mods_rec.typeOfResource.usage).to eq(['fer sure'])
       end
     end