om 3.1.0 → 3.1.1

data/spec/unit/document_spec.rb

@@ -75,14 +75,14 @@ describe "OM::XML::Document" do
   end
   
   it "should automatically include the necessary modules" do
-    DocumentTest.included_modules.should include(OM::XML::Container)
-    DocumentTest.included_modules.should include(OM::XML::TermValueOperators)
-    DocumentTest.included_modules.should include(OM::XML::Validation)
+    expect(DocumentTest.included_modules).to include(OM::XML::Container)
+    expect(DocumentTest.included_modules).to include(OM::XML::TermValueOperators)
+    expect(DocumentTest.included_modules).to include(OM::XML::Validation)
   end
   
   describe ".ox_namespaces" do
     it "should merge terminology namespaces with document namespaces" do
-      @fixturemods.ox_namespaces.should == {"oxns"=>"http://www.loc.gov/mods/v3", "xmlns:ns2"=>"http://www.w3.org/1999/xlink", "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance", "xmlns:ns3"=>"http://www.loc.gov/mods/v3", "xmlns"=>"http://www.loc.gov/mods/v3"}
+      expect(@fixturemods.ox_namespaces).to eq({"oxns"=>"http://www.loc.gov/mods/v3", "xmlns:ns2"=>"http://www.w3.org/1999/xlink", "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance", "xmlns:ns3"=>"http://www.loc.gov/mods/v3", "xmlns"=>"http://www.loc.gov/mods/v3"})
     end
   end
   
@@ -90,72 +90,72 @@ describe "OM::XML::Document" do
   describe ".find_by_terms_and_value" do
     it "should fail gracefully if you try to look up nodes for an undefined property" do
       skip "better to get an informative error?"
-      @fixturemods.find_by_terms_and_value(:nobody_home).should == []
+      expect(@fixturemods.find_by_terms_and_value(:nobody_home)).to eq []
     end
     it "should use Nokogiri to retrieve a NodeSet corresponding to the term pointers" do
-      @mods_article.find_by_terms_and_value( :person ).length.should == 2
+      expect(@mods_article.find_by_terms_and_value( :person ).length).to eq 2
     end
 
     it "should allow you to search by term pointer" do
-      @fixturemods.ng_xml.should_receive(:xpath).with('//oxns:name[@type="personal"]', @fixturemods.ox_namespaces)
+      expect(@fixturemods.ng_xml).to receive(:xpath).with('//oxns:name[@type="personal"]', @fixturemods.ox_namespaces)
       @fixturemods.find_by_terms_and_value(:person)
     end
     it "should allow you to constrain your searches" do
-      @fixturemods.ng_xml.should_receive(:xpath).with('//oxns:name[@type="personal" and contains(., "Beethoven, Ludwig van")]', @fixturemods.ox_namespaces)
+      expect(@fixturemods.ng_xml).to receive(:xpath).with('//oxns:name[@type="personal" and contains(., "Beethoven, Ludwig van")]', @fixturemods.ox_namespaces)
       @fixturemods.find_by_terms_and_value(:person, "Beethoven, Ludwig van")
     end
     it "should allow you to use complex constraints" do
-      @fixturemods.ng_xml.should_receive(:xpath).with('//oxns:name[@type="personal"]/oxns:namePart[@type="date" and contains(., "2010")]', @fixturemods.ox_namespaces)
+      expect(@fixturemods.ng_xml).to receive(:xpath).with('//oxns:name[@type="personal"]/oxns:namePart[@type="date" and contains(., "2010")]', @fixturemods.ox_namespaces)
       @fixturemods.find_by_terms_and_value(:person, :date=>"2010")
       
-      @fixturemods.ng_xml.should_receive(:xpath).with('//oxns:name[@type="personal"]/oxns:role[contains(., "donor")]', @fixturemods.ox_namespaces)
+      expect(@fixturemods.ng_xml).to receive(:xpath).with('//oxns:name[@type="personal"]/oxns:role[contains(., "donor")]', @fixturemods.ox_namespaces)
       @fixturemods.find_by_terms_and_value(:person, :role=>"donor")
     end
   end
   describe ".find_by_terms" do
     it "should use Nokogiri to retrieve a NodeSet corresponding to the combination of term pointers and array/nodeset indexes" do
-      @mods_article.find_by_terms( :person ).length.should == 2
-      @mods_article.find_by_terms( {:person=>1} ).first.should == @mods_article.ng_xml.xpath('//oxns:name[@type="personal"][2]', "oxns"=>"http://www.loc.gov/mods/v3").first
-      @mods_article.find_by_terms( {:person=>1}, :first_name ).class.should == Nokogiri::XML::NodeSet
-      @mods_article.find_by_terms( {:person=>1}, :first_name ).first.text.should == "Siddartha"
+      expect(@mods_article.find_by_terms( :person ).length).to eq 2
+      expect(@mods_article.find_by_terms( {:person=>1} ).first).to eq @mods_article.ng_xml.xpath('//oxns:name[@type="personal"][2]', "oxns"=>"http://www.loc.gov/mods/v3").first
+      expect(@mods_article.find_by_terms( {:person=>1}, :first_name ).class).to eq Nokogiri::XML::NodeSet
+      expect(@mods_article.find_by_terms( {:person=>1}, :first_name ).first.text).to eq "Siddartha"
     end
     it "should find a NodeSet where a terminology attribute has been set to :none" do
-      @mods_article.find_by_terms( {:person=>1}, :person_id).first.text.should == "123987"
+      expect(@mods_article.find_by_terms( {:person=>1}, :person_id).first.text).to eq "123987"
     end
     it "should support accessors whose relative_xpath is a lookup array instead of an xpath string" do
       # skip "this only impacts scenarios where we want to display & edit"
-      DocumentTest.terminology.retrieve_term(:title_info, :language).path.should == {:attribute=>"lang"}
+      expect(DocumentTest.terminology.retrieve_term(:title_info, :language).path).to eq({:attribute=>"lang"})
       # @sample.retrieve( :title, 1 ).first.text.should == "Artikkelin otsikko Hydrangea artiklan 1"
-      @mods_article.find_by_terms( {:title_info=>1}, :language ).first.text.should == "finnish"
+      expect(@mods_article.find_by_terms( {:title_info=>1}, :language ).first.text).to eq "finnish"
     end
     
     it "should support xpath queries as the pointer" do
-      @mods_article.find_by_terms('//oxns:name[@type="personal"][1]/oxns:namePart[1]').first.text.should == "FAMILY NAME"
+      expect(@mods_article.find_by_terms('//oxns:name[@type="personal"][1]/oxns:namePart[1]').first.text).to eq "FAMILY NAME"
     end
     
     it "should return nil if the xpath fails to generate" do
       skip "Can't decide if it's better to return nil or raise an error.  Choosing informative errors for now."
-      @mods_article.find_by_terms( {:foo=>20}, :bar ).should == nil
+      expect(@mods_article.find_by_terms( {:foo=>20}, :bar )).to eq nil
     end
     
     it "should support terms that point to attributes instead of nodes" do
-      @mods_article.find_by_terms( {:title_info=>1}, :language ).first.text.should == "finnish"
+      expect(@mods_article.find_by_terms( {:title_info=>1}, :language ).first.text).to eq "finnish"
     end
 
     it "should support xpath queries as the pointer" do
-      @mods_article.find_by_terms('//oxns:name[@type="personal"][1]/oxns:namePart[1]').first.text.should == "FAMILY NAME"
+      expect(@mods_article.find_by_terms('//oxns:name[@type="personal"][1]/oxns:namePart[1]').first.text).to eq "FAMILY NAME"
     end
   end
   
   describe "node_exists?" do
     it "should return true if any nodes are found" do
-      @mods_article.node_exists?( {:person=>1}, :first_name).should be true
+      expect(@mods_article.node_exists?( {:person=>1}, :first_name)).to be true
     end
     it "should return false if no nodes are found" do
-      @mods_article.node_exists?( {:person=>8}, :first_name ).should be false
+      expect(@mods_article.node_exists?( {:person=>8}, :first_name )).to be false
     end
     it "should support xpath queries" do
-      @mods_article.node_exists?('//oxns:name[@type="personal"][1]/oxns:namePart[1]').should be true
+      expect(@mods_article.node_exists?('//oxns:name[@type="personal"][1]/oxns:namePart[1]')).to be true
     end
   end
    

data/spec/unit/dynamic_node_spec.rb

@@ -26,26 +26,26 @@ describe "OM::XML::DynamicNode" do
 
     it "should create templates for dynamic nodes" do
       @sample.creator = "Foo"
-      @sample.creator.should == ['Foo']
+      expect(@sample.creator).to eq ['Foo']
     end
     it "should create templates for dynamic nodes with multiple values" do
       @sample.creator = ["Foo", "Bar"]
-      @sample.creator.should == ['Foo', 'Bar']
+      expect(@sample.creator).to eq ['Foo', 'Bar']
     end
 
     it "should create templates for dynamic nodes with empty string values" do
       @sample.creator = ['']
-      @sample.creator.should == ['']
+      expect(@sample.creator).to eq ['']
     end
 
     it "should create templates for plain nodes" do
       @sample.foo = ['in a galaxy far far away']
-      @sample.foo.should == ['in a galaxy far far away']
+      expect(@sample.foo).to eq ['in a galaxy far far away']
     end
 
     it "should create templates for dynamic nodes with a period in the element name" do
       @sample.date_created = ['A long time ago']
-      @sample.date_created.should == ['A long time ago']
+      expect(@sample.date_created).to eq ['A long time ago']
     end
 
     it "checks inequality" do
@@ -53,36 +53,36 @@ describe "OM::XML::DynamicNode" do
       expect(@sample.foo != ['nearby']).to be true
     end
   end
-        
-  
+
+
   describe "with a template" do
     before(:each) do
       @sample = OM::Samples::ModsArticle.from_xml( fixture( File.join("test_dummy_mods.xml") ) )
       @article = OM::Samples::ModsArticle.from_xml( fixture( File.join("mods_articles","hydrangea_article1.xml") ) )
     end
-    
+
     describe "dynamically created nodes" do
 
       it "should return build an array of values from the nodeset corresponding to the given term" do
         expected_values = ["Berners-Lee", "Jobs", "Wozniak", "Klimt"]
         result = @sample.person.last_name
-        result.length.should == expected_values.length
-        expected_values.each {|v| result.should include(v)}
+        expect(result.length).to eq expected_values.length
+        expected_values.each {|v| expect(result).to include(v)}
       end
 
       it "should be able to set first level elements" do
         @article.abstract = "My Abstract"
-        @article.abstract.should == ["My Abstract"]
+        expect(@article.abstract).to eq ["My Abstract"]
       end
 
       it "should be able to set first level elements that are arrays" do
         @article.abstract = ["My Abstract", "two"]
-        @article.abstract.should == ["My Abstract", 'two']
+        expect(@article.abstract).to eq ["My Abstract", 'two']
       end
 
       it "should delegate all methods (i.e. to_s, first, etc.) to the found array" do
-        @article.person.last_name.to_s.should == ["FAMILY NAME", "Gautama"].to_s
-        @article.person.last_name.first.should == "FAMILY NAME"
+        expect(@article.person.last_name.to_s).to eq ["FAMILY NAME", "Gautama"].to_s
+        expect(@article.person.last_name.first).to eq "FAMILY NAME"
       end
 
       it "should respond_to? things an array can do" do
@@ -92,98 +92,109 @@ describe "OM::XML::DynamicNode" do
       it "should delegate with blocks to the found array" do
         arr = []
         @article.person.last_name.each{|x| arr << x}
-        arr.should == ["FAMILY NAME", "Gautama"]
+        expect(arr).to eq ["FAMILY NAME", "Gautama"]
       end
 
-
       describe "setting attributes" do
         it "when they exist" do
           @article.title_info(0).main_title.main_title_lang = "ger"
-          @article.title_info(0).main_title.main_title_lang.should == ["ger"]
+          expect(@article.title_info(0).main_title.main_title_lang).to eq ["ger"]
         end
         it "when they don't exist" do
           title = @article.title_info(0)
           title.language = "rus"
-          @article.title_info(0).language.should == ["rus"]
+          expect(@article.title_info(0).language).to eq ["rus"]
         end
-
       end
 
       it "should find elements two deep" do
-        #TODO reimplement so that method_missing with name is only called once.  Create a new method for name.
-        @article.name.name_content.val.should == ["Describes a person"]
-        @article.name.name_content.should == ["Describes a person"]
-        @article.name.name_content(0).should == ["Describes a person"]
+        # TODO reimplement so that method_missing with name is only called once.  Create a new method for name.
+        expect(@article.name.name_content.val).to eq(["Describes a person"])
+        expect(@article.name.name_content    ).to eq(["Describes a person"])
+        expect(@article.name.name_content(0) ).to eq(["Describes a person"])
       end
 
-      it "should not find elements that don't  exist" do
-        lambda {@article.name.hedgehog}.should raise_exception NoMethodError
+      it 'should offer some awareness for respond_to?' do
+        expect(@article.name.name_content.include?('Describes a person')).to be_truthy
+        expect(@article.name.name_content.respond_to?(:include?)).to be_truthy
+        expect(@article.name.name_content).to include('Describes a person')
+      end
+
+      it "should not find elements that don't exist" do
+        expect{@article.name.hedgehog     }.to raise_exception NoMethodError, /hedgehog/
+        expect{@article.name.hedgehog = 5 }.to raise_exception NoMethodError, /hedgehog/
+        expect{@article.name.hedgehog(5)  }.to raise_exception NoMethodError, /hedgehog/
+        expect{@article.name.hedgehog(5,1)}.to raise_exception NoMethodError, /hedgehog/
+        expect{@article.name.name_content.hedgehog         }.to raise_exception NoMethodError, /hedgehog/
+        expect{@article.name.name_content.hedgehog = 'foo' }.to raise_exception NoMethodError, /hedgehog/
+        expect{@article.name.name_content.hedgehog(1)      }.to raise_exception NoMethodError, /hedgehog/
+        expect{@article.name.name_content.hedgehog(1,'foo')}.to raise_exception NoMethodError, /hedgehog/
       end
 
       it "should allow you to call methods on the return value" do
-        @article.name.name_content.first.should == "Describes a person"
+        expect(@article.name.name_content.first).to eq "Describes a person"
       end
 
       it "Should work with proxies" do
-        @article.title.should == ["ARTICLE TITLE HYDRANGEA ARTICLE 1", "Artikkelin otsikko Hydrangea artiklan 1", "TITLE OF HOST JOURNAL"]
-        @article.title.main_title_lang.should == ['eng']
+        expect(@article.title).to eq(["ARTICLE TITLE HYDRANGEA ARTICLE 1", "Artikkelin otsikko Hydrangea artiklan 1", "TITLE OF HOST JOURNAL"])
+        expect(@article.title.main_title_lang).to eq ['eng']
 
-        @article.title(1).to_pointer.should == [{:title => 1}]
+        expect(@article.title(1).to_pointer).to eq [{:title => 1}]
 
-        @article.journal_title.xpath.should == "//oxns:relatedItem[@type=\"host\"]/oxns:titleInfo/oxns:title"
-        @article.journal_title.should == ["TITLE OF HOST JOURNAL"]
+        expect(@article.journal_title.xpath).to eq "//oxns:relatedItem[@type=\"host\"]/oxns:titleInfo/oxns:title"
+        expect(@article.journal_title).to eq ["TITLE OF HOST JOURNAL"]
       end
 
       it "Should be addressable to a specific node" do
         @article.update_values( {[{:journal=>0}, {:issue=>3}, :pages, :start]=>"434"})
 
         @article.subject.topic(1).to_pointer == [:subject, {:topic => 1}]
-        @article.journal(0).issue.length.should == 2
-        @article.journal(0).issue(1).pages.to_pointer == [{:journal=>0}, {:issue=>1}, :pages]
-        @article.journal(0).issue(1).pages.length.should == 1
-        @article.journal(0).issue(1).pages.start.length.should == 1
-        @article.journal(0).issue(1).pages.start.first.should == "434"
+        expect(@article.journal(0).issue.length).to eq 2
+        expect(@article.journal(0).issue(1).pages.to_pointer).to eq [{:journal=>0}, {:issue=>1}, :pages]
+        expect(@article.journal(0).issue(1).pages.length).to eq 1
+        expect(@article.journal(0).issue(1).pages.start.length).to eq 1
+        expect(@article.journal(0).issue(1).pages.start.first).to eq "434"
 
-        @article.subject.topic(1).should == ["TOPIC 2"]
-        @article.subject.topic(1).xpath.should == "//oxns:subject/oxns:topic[2]"
+        expect(@article.subject.topic(1)).to eq ["TOPIC 2"]
+        expect(@article.subject.topic(1).xpath).to eq "//oxns:subject/oxns:topic[2]"
       end
-      
+
       describe ".nodeset" do
         it "should return a Nokogiri NodeSet" do
           @article.update_values( {[{:journal=>0}, {:issue=>3}, :pages, :start]=>"434" })
           nodeset = @article.journal(0).issue(1).pages.start.nodeset
-          nodeset.should be_kind_of Nokogiri::XML::NodeSet
-          nodeset.length.should == @article.journal(0).issue(1).pages.start.length
-          nodeset.first.text.should == @article.journal(0).issue(1).pages.start.first
+          expect(nodeset).to be_kind_of Nokogiri::XML::NodeSet
+          expect(nodeset.length).to eq @article.journal(0).issue(1).pages.start.length
+          expect(nodeset.first.text).to eq @article.journal(0).issue(1).pages.start.first
         end
       end
 
       it "should append nodes at the specified index if possible" do
         @article.journal.title_info = ["all", "for", "the"]
         @article.journal.title_info(3, 'glory')
-        @article.term_values(:journal, :title_info).should == ["all", "for", "the", "glory"]
-        @article.should be_changed
+        expect(@article.term_values(:journal, :title_info)).to eq ["all", "for", "the", "glory"]
+        expect(@article).to be_changed
       end
-    
+
       it "should remove extra nodes if fewer are given than currently exist" do
         @article.journal.title_info = %W(one two three four five)
         @article.journal.title_info = %W(six seven)
-        @article.journal.title_info.should == ["six", "seven"]
+        expect(@article.journal.title_info).to eq ["six", "seven"]
       end
 
       describe '==' do
         it "returns true when values of dynamic nodes are equal." do
           @article.name(0).last_name = "Steven"
           @article.name(0).first_name = "Steven"
-          (@article.name(0).last_name == @article.name(0).first_name).should == true
+          expect(@article.name(0).last_name).to eq @article.name(0).first_name
         end
 
         it 'returns false when values of dynamic nodes are not equal.' do
           @article.name(0).first_name = "Horatio"
           @article.name(0).last_name = "Hogginobble"
-          (@article.name(0).last_name == @article.name(0).first_name).should == false
+          expect(@article.name(0).last_name == @article.name(0).first_name).to be false
         end
-      end 
+      end
     end
   end
 end

data/spec/unit/named_term_proxy_spec.rb

@@ -31,25 +31,30 @@ describe "OM::XML::NamedTermProxy" do
     
   it "should proxy all extra methods to the proxied object" do
     [:xpath, :xpath_relative, :xml_builder_template].each do |method|
-      @proxied_term.should_receive(method)
+      expect(@proxied_term).to receive(method)
       @test_proxy.send(method)
     end
   end
+
   it "should proxy the term specified by the builder" do
-    @test_proxy.proxied_term.should == @test_terminology.retrieve_term(:parent, :foo, :bar)
-    @test_proxy.xpath.should == "//oxns:parent/oxns:foo/oxns:bar"
+    expect(@test_proxy.proxied_term).to eq(@test_terminology.retrieve_term(:parent, :foo, :bar))
+    expect(@test_proxy.xpath).to eq "//oxns:parent/oxns:foo/oxns:bar"
   end
+
   it "should search relative to the parent term when finding the term to proxy" do
     proxy2 = @test_terminology.retrieve_term(:adoptive_parent, :my_proxy)    
-    proxy2.proxied_term.should == @test_terminology.retrieve_term(:adoptive_parent, :foo, :bar)
-    proxy2.xpath.should == '//oxns:parent[@type="adoptive"]/oxns:foo/oxns:bar'
+    expect(proxy2.proxied_term).to eq @test_terminology.retrieve_term(:adoptive_parent, :foo, :bar)
+    expect(proxy2.xpath).to eq '//oxns:parent[@type="adoptive"]/oxns:foo/oxns:bar'
   end
+
   it "should support NamedTermProxies that point to root terms" do
-    @test_terminology.xpath_for(:parentfoobarproxy).should == "//oxns:parent/oxns:foo/oxns:bar"
+    expect(@test_terminology.xpath_for(:parentfoobarproxy)).to eq("//oxns:parent/oxns:foo/oxns:bar")
   end
+
   it "should be usable in update_values" do
     document = NamedProxyTestDocument.from_xml(NamedProxyTestDocument.xml_template)
     document.update_values([:parentfoobarproxy] => "FOObar!")
-    document.term_values(:parentfoobarproxy).should == ["FOObar!"]
+    expect(document.term_values(:parentfoobarproxy)).to eq ["FOObar!"]
   end
+  
 end

data/spec/unit/node_generator_spec.rb

@@ -10,17 +10,17 @@ describe "OM::XML::NodeGenerator" do
   
   describe '#generate' do
     it "should use the corresponding builder template(s) to generate the node" do
-      OM::XML::NodeGenerator.generate(@test_mods_term, "foo").root.to_xml.should == "<mods>foo</mods>"
+      expect(OM::XML::NodeGenerator.generate(@test_mods_term, "foo").root.to_xml).to eq "<mods>foo</mods>"
       generated_node = OM::XML::NodeGenerator.generate(@test_volume_term, "108", {:attributes=>{"extraAttr"=>"my value"}})
-      generated_node.xpath('./detail[@type="volume"][@extraAttr="my value"]').xpath("./number").text.should == "108"
+      expect(generated_node.xpath('./detail[@type="volume"][@extraAttr="my value"]').xpath("./number").text).to eq "108"
       # Would be great if we wrote a have_node custom rspec matcher...
       # generated_node.should have_node 'role[@authority="marcrelator"][@type="code"]' do
       #   with_node "roleTerm", "creator"
       # end
     end
+
     it "should return Nokogiri Documents" do
-      OM::XML::NodeGenerator.generate(@test_mods_term, "foo").class.should == Nokogiri::XML::Document
+      expect(OM::XML::NodeGenerator.generate(@test_mods_term, "foo").class).to eq Nokogiri::XML::Document
     end
   end
-  
 end

data/spec/unit/nokogiri_sanity_spec.rb

@@ -8,7 +8,7 @@ describe "OM::XML::TermValueOperators" do
     end
   
     it "should do" do
-      @article.find_by_terms({:journal=>0}).length.should == 1
+      expect(@article.find_by_terms({:journal=>0}).length).to eq 1
     end
   end
   
@@ -20,56 +20,55 @@ describe "OM::XML::TermValueOperators" do
     it "should respond with a hash of updated values and their indexes" do
       test_args = {[{"person"=>"0"},"description"]=>["mork", "york"]}      
       result = @article.update_values(test_args)
-      result.should == {"person_0_description"=>["mork", "york"]}
+      expect(result).to eq({"person_0_description"=>["mork", "york"]})
     end
     
     it "should update the xml in the specified datastream and know that changes have been made" do
-      @article.term_values({:person=>0}, :first_name).should == ["GIVEN NAMES"]
+      expect(@article.term_values({:person=>0}, :first_name)).to eq ["GIVEN NAMES"]
       test_args = {[{:person=>0}, :first_name]=>"Replacement FirstName"}
       @article.update_values(test_args)
-      @article.term_values({:person=>0}, :first_name).should == ["Replacement FirstName"]
-      @article.should be_changed
+      expect(@article.term_values({:person=>0}, :first_name)).to eq ["Replacement FirstName"]
+      expect(@article).to be_changed
     end
     
     it "should update the xml according to the find_by_terms_and_values in the given hash" do
       terms_attributes = {[{":person"=>"0"}, "affiliation"]=>["affiliation1", "affiliation2", "affiliation3"]}
       result = @article.update_values(terms_attributes)
-      result.should == {"person_0_affiliation"=>["affiliation1", "affiliation2", "affiliation3"]}
+      expect(result).to eq({"person_0_affiliation"=>["affiliation1", "affiliation2", "affiliation3"]})
       
       # Trying again with a more complex update hash
       terms_attributes = {[{":person"=>"0"}, "affiliation"]=>["affiliation1", "affiliation2", "affiliation3"], [{:person=>1}, :last_name]=>"Andronicus", [{"person"=>"1"},:first_name]=>["Titus"],[{:person=>1},:role]=>["otherrole1","otherrole2"] }
       result = @article.update_values(terms_attributes)
-      result.should == {"person_0_affiliation"=>["affiliation1", "affiliation2", "affiliation3"], "person_1_last_name"=>["Andronicus"],"person_1_first_name"=>["Titus"], "person_1_role"=>["otherrole1","otherrole2"]}
-      @article.should be_changed
+      expect(result).to eq({"person_0_affiliation"=>["affiliation1", "affiliation2", "affiliation3"], "person_1_last_name"=>["Andronicus"],"person_1_first_name"=>["Titus"], "person_1_role"=>["otherrole1","otherrole2"]})
+      expect(@article).to be_changed
     end
     
     it "should work when you re-run the command" do
       terms_attributes = {[{":person"=>"0"}, "affiliation"]=>["affiliation1", "affiliation2", "affiliation3"]}
       result = @article.update_values(terms_attributes)
-      @article.term_values( {":person"=>"0"}, "affiliation" ).should == ["affiliation1", "affiliation2", "affiliation3"]
-      result.should == {"person_0_affiliation"=>["affiliation1", "affiliation2", "affiliation3"]}
+
+      expect(@article.term_values( {":person"=>"0"}, "affiliation" )).to eq ["affiliation1", "affiliation2", "affiliation3"]
+      expect(result).to eq({"person_0_affiliation"=>["affiliation1", "affiliation2", "affiliation3"]})
       
       terms_attributes = {[{":person"=>"0"}, "affiliation"]=>["affiliation1", "affiliation2", "affiliation3"]}
       @article = OM::Samples::ModsArticle.from_xml( fixture( File.join("mods_articles","hydrangea_article1.xml") ) )
       result = @article.update_values(terms_attributes)
-      @article.term_values( {":person"=>"0"}, "affiliation" ).should == ["affiliation1", "affiliation2", "affiliation3"]
-      result.should == {"person_0_affiliation"=>["affiliation1", "affiliation2", "affiliation3"]}
+      expect(@article.term_values( {":person"=>"0"}, "affiliation" )).to eq ["affiliation1", "affiliation2", "affiliation3"]
+      expect(result).to eq({"person_0_affiliation"=>["affiliation1", "affiliation2", "affiliation3"]})
       result = @article.update_values(terms_attributes)
       
       terms_attributes = {[{":person"=>"0"}, "affiliation"]=>["affiliation1", "affiliation2", "affiliation3"]}
       @article = OM::Samples::ModsArticle.from_xml( fixture( File.join("mods_articles","hydrangea_article1.xml") ) )
       result = @article.update_values(terms_attributes)
-      @article.term_values( {":person"=>"0"}, "affiliation" ).should == ["affiliation1", "affiliation2", "affiliation3"]
-      result.should == {"person_0_affiliation"=>["affiliation1", "affiliation2", "affiliation3"]}
+      expect(@article.term_values( {":person"=>"0"}, "affiliation" )).to eq ["affiliation1", "affiliation2", "affiliation3"]
+      expect(result).to eq({"person_0_affiliation"=>["affiliation1", "affiliation2", "affiliation3"]})
       
       # Trying again with a more complex update hash
       terms_attributes = {[{":person"=>"0"}, "affiliation"]=>["affiliation1", "affiliation2", "affiliation3"], [{:person=>1}, :last_name]=>"Andronicus", [{"person"=>"1"},:first_name]=>["Titus"],[{:person=>1},:role]=>["otherrole1","otherrole2"] }
       result = @article.update_values(terms_attributes)
-      result.should == {"person_0_affiliation"=>["affiliation1", "affiliation2", "affiliation3"], "person_1_last_name"=>["Andronicus"],"person_1_first_name"=>["Titus"], "person_1_role"=>["otherrole1", "otherrole2"]}
-      @article.should be_changed
+      expect(result).to eq({"person_0_affiliation"=>["affiliation1", "affiliation2", "affiliation3"], "person_1_last_name"=>["Andronicus"],"person_1_first_name"=>["Titus"], "person_1_role"=>["otherrole1", "otherrole2"]})
+      expect(@article).to be_changed
     end
   end
-  
 
-  
 end