om 1.8.0 → 1.8.1

data/spec/integration/xpathy_stuff_spec.rb

@@ -8,7 +8,7 @@ describe "an example of xpath-y stuff, also using :proxy and :ref and namespaces
         include OM::XML::Document
 
         set_terminology do |t|
-          t.root(:path=>"contentMetadata", :xmlns => '', :namespace_prefix => nil) 
+          t.root(:path=>"contentMetadata", :xmlns => '', :namespace_prefix => nil)
 
           t.resource(:namespace_prefix => nil) {
             t.file(:ref=>[:file], :namespace_prefix => nil)
@@ -51,11 +51,11 @@ describe "an example of xpath-y stuff, also using :proxy and :ref and namespaces
     end
 
     it "should have a content term" do
-      subject.content.first.should =~ /content/
+      expect(subject.content.first).to match(/content/)
     end
 
     it "should have an html term" do
-      subject.html.first.should =~ /html/
+      expect(subject.html.first).to match(/html/)
     end
 
 
@@ -63,7 +63,7 @@ describe "an example of xpath-y stuff, also using :proxy and :ref and namespaces
 
   describe "an example from MODS" do
     before(:all) do
-      class ModsXpathyStuffTerminology 
+      class ModsXpathyStuffTerminology
         include OM::XML::Document
 
         set_terminology do |t|
@@ -120,15 +120,15 @@ describe "an example of xpath-y stuff, also using :proxy and :ref and namespaces
     end
 
     it "should have the terms :author_given and :author_family to get the author name" do
-      pending "This doesn't seem to work?"
-      subject.author_given.should include("Mary")
-      subject.author_family.should include("Pickral")
+      skip "This doesn't seem to work?"
+      expect(subject.author_given).to include("Mary")
+      expect(subject.author_family).to include("Pickral")
     end
 
     it "should have the terms :advisor_given and :advisor_family to get the advisor name" do
-      pending "This doesn't seem to work?"
-      subject.advisor_given.should include("David")
-      subject.advisor_family.should include("Small")
+      skip "This doesn't seem to work?"
+      expect(subject.advisor_given).to include("David")
+      expect(subject.advisor_family).to include("Small")
     end
 
   end
@@ -136,7 +136,7 @@ describe "an example of xpath-y stuff, also using :proxy and :ref and namespaces
   describe "more MODS examples, with a given namespace prefix?" do
 
     before(:all) do
-      class ModsXpathyStuffTerminology 
+      class ModsXpathyStuffTerminology
         include OM::XML::Document
 
         set_terminology do |t|
@@ -153,7 +153,7 @@ describe "an example of xpath-y stuff, also using :proxy and :ref and namespaces
             t.role_term_text(:path=>"roleTerm", :attributes=>{:type=>"text"})
           }
 
-          t.person_full(:ref=>:name, :attributes=>{:type=>"personal"}) 
+          t.person_full(:ref=>:name, :attributes=>{:type=>"personal"})
           t.person(:proxy=>[:person_full, :name_part])
           t.creator(:ref=>:person, :path=>'name[mods:role/mods:roleTerm="creator"]', :xmlns=>"http://www.loc.gov/mods/v3", :namespace_prefix => "mods")
 
@@ -185,19 +185,19 @@ describe "an example of xpath-y stuff, also using :proxy and :ref and namespaces
     end
 
     it "should give a creator value" do
-      subject.creator.should include "David Small"
+      expect(subject.creator).to include "David Small"
     end
 
     it "should give a repository value" do
-      subject.repository.should include "Graphic Novel Repository"
+      expect(subject.repository).to include "Graphic Novel Repository"
     end
 
     it "should have a person term 'for more generic xml'" do
-      subject.person.should include "David Small"
+      expect(subject.person).to include "David Small"
     end
 
     it "should have a corporate term 'for more generic xml'" do
-      subject.corporate.should include "Graphic Novel Repository"
+      expect(subject.corporate).to include "Graphic Novel Repository"
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,7 +1,6 @@
-if ENV['COVERAGE'] and RUBY_VERSION =~ /^1.9/
+if ENV['COVERAGE'] && RUBY_VERSION =~ /^1.9/
   require 'simplecov'
   require 'simplecov-rcov'
-
   SimpleCov.formatter = SimpleCov::Formatter::RcovFormatter
   SimpleCov.start
 end
@@ -11,7 +10,7 @@ require 'rspec'
 require 'equivalent-xml/rspec_matchers'
 
 RSpec.configure do |config|
-  config.mock_with :mocha
+
 end
 
 def fixture(file)

data/spec/unit/container_spec.rb

@@ -1,80 +1,79 @@
 require 'spec_helper'
 
 describe "OM::XML::Container" do
-  
+
   before(:all) do
     class ContainerTest
       include OM::XML::Container
     end
   end
-  
+
   subject {
     ContainerTest.from_xml("<foo><bar>1</bar></foo>")
   }
 
   it "should add .ng_xml accessor" do
-    subject.should respond_to(:ng_xml)
-    subject.should respond_to(:ng_xml=)    
+    expect(subject).to respond_to(:ng_xml)
+    expect(subject).to respond_to(:ng_xml=)
   end
 
   it "should initialize" do
-    ContainerTest.new.ng_xml.should be_a_kind_of Nokogiri::XML::Document
+    expect(ContainerTest.new.ng_xml).to be_a_kind_of Nokogiri::XML::Document
   end
-  
+
   describe "new" do
     it "should populate ng_xml with an instance of Nokogiri::XML::Document" do
-      subject.ng_xml.class.should == Nokogiri::XML::Document
+      expect(subject.ng_xml.class).to eq(Nokogiri::XML::Document)
     end
   end
 
   describe "#from_xml" do
     it "should accept a String, parse it and store it in .ng_xml" do
-      Nokogiri::XML::Document.expects(:parse).returns("parsed xml")
+      expect(Nokogiri::XML::Document).to receive(:parse).and_return("parsed xml")
       container1 = ContainerTest.from_xml("<foo><bar>1</bar></foo>")
-      container1.ng_xml.should == "parsed xml"
+      expect(container1.ng_xml).to eq("parsed xml")
     end
     it "should accept a File, parse it and store it in .ng_xml" do
       file = fixture(File.join("mods_articles", "hydrangea_article1.xml"))
-      Nokogiri::XML::Document.expects(:parse).returns("parsed xml")
+      expect(Nokogiri::XML::Document).to receive(:parse).and_return("parsed xml")
       container1 = ContainerTest.from_xml(file)
-      container1.ng_xml.should == "parsed xml"
+      expect(container1.ng_xml).to eq("parsed xml")
     end
     it "should accept Nokogiri nodes as input and leave them as-is" do
       parsed_xml = Nokogiri::XML::Document.parse("<foo><bar>1</bar></foo>")
       container1 = ContainerTest.from_xml(parsed_xml)
-      container1.ng_xml.should == parsed_xml
+      expect(container1.ng_xml).to eq(parsed_xml)
     end
   end
-  
+
   describe ".to_xml" do
     it  "should call .ng_xml.to_xml" do
-      subject.ng_xml.expects(:to_xml).returns("ng xml")
-      subject.to_xml.should == "ng xml"
+      expect(subject.ng_xml).to receive(:to_xml).and_return("ng xml")
+      expect(subject.to_xml).to eq("ng xml")
     end
-    
+
     it 'should accept an optional Nokogiri::XML Document as an argument and insert its fields into that (mocked test)' do
       doc = Nokogiri::XML::Document.parse("<test_xml/>")
-      mock_new_node = mock("new node")
-      doc.root.expects(:add_child).with(subject.ng_xml.root).returns(mock_new_node)
+      mock_new_node = double("new node")
+      expect(doc.root).to receive(:add_child).with(subject.ng_xml.root).and_return(mock_new_node)
       result = subject.to_xml(doc)
     end
-    
+
     it 'should accept an optional Nokogiri::XML Document as an argument and insert its fields into that (functional test)' do
       doc = Nokogiri::XML::Document.parse("<test_xml/>")
-      subject.to_xml(doc).should == "<?xml version=\"1.0\"?>\n<test_xml>\n  <foo>\n    <bar>1</bar>\n  </foo>\n</test_xml>\n"
+      expect(subject.to_xml(doc)).to eq("<?xml version=\"1.0\"?>\n<test_xml>\n  <foo>\n    <bar>1</bar>\n  </foo>\n</test_xml>\n")
     end
-    
+
     it 'should add to root of Nokogiri::XML::Documents, but add directly to the elements if a Nokogiri::XML::Node is passed in' do
-      mock_new_node = mock("new node")
-      mock_new_node.stubs(:to_xml).returns("foo")
-      
+      mock_new_node = double("new node")
+      allow(mock_new_node).to receive(:to_xml).and_return("foo")
       doc = Nokogiri::XML::Document.parse("<test_document/>")
-      el = Nokogiri::XML::Node.new("test_element", Nokogiri::XML::Document.new)
-      doc.root.expects(:add_child).with(subject.ng_xml.root).returns(mock_new_node)
-      el.expects(:add_child).with(subject.ng_xml.root).returns(mock_new_node)
-      subject.to_xml(doc).should 
+      el  = Nokogiri::XML::Node.new("test_element", Nokogiri::XML::Document.new)
+      expect(doc.root).to receive(:add_child).with(subject.ng_xml.root).and_return(mock_new_node)
+      expect(el).to receive(:add_child).with(subject.ng_xml.root).and_return(mock_new_node)
+      subject.to_xml(doc)
       subject.to_xml(el)
     end
   end
-  
+
 end

data/spec/unit/document_spec.rb

@@ -1,26 +1,26 @@
 require 'spec_helper'
 
 describe "OM::XML::Document" do
-  
+
   before(:all) do
-    #ModsHelpers.name_("Beethoven, Ludwig van", :date=>"1770-1827", :role=>"creator")
-    class DocumentTest 
+    # ModsHelpers.name_("Beethoven, Ludwig van", :date=>"1770-1827", :role=>"creator")
+    class DocumentTest
+
+      include OM::XML::Document
 
-      include OM::XML::Document    
-      
-      # Could add support for multiple root declarations.  
+      # Could add support for multiple root declarations.
       #  For now, assume that any modsCollections have already been broken up and fed in as individual mods documents
-      # root :mods_collection, :path=>"modsCollection", 
+      # root :mods_collection, :path=>"modsCollection",
       #           :attributes=>[],
       #           :subelements => :mods
-      
+
       set_terminology do |t|
         t.root(:path=>"mods", :xmlns=>"http://www.loc.gov/mods/v3", :schema=>"http://www.loc.gov/standards/mods/v3/mods-3-2.xsd")
 
         t.title_info(:path=>"titleInfo") {
           t.main_title(:path=>"title", :label=>"title")
           t.language(:path=>{:attribute=>"lang"})
-        }                 
+        }
         # This is a mods:name.  The underscore is purely to avoid namespace conflicts.
         t.name_ {
           # this is a namepart
@@ -36,7 +36,7 @@ describe "OM::XML::Document" do
           t.terms_of_address(:path=>"namePart", :attributes=>{:type=>"termsOfAddress"})
           t.person_id(:path=>"namePart", :attributes=>{:type=>:none})
         }
-        # lookup :person, :first_name        
+        # lookup :person, :first_name
         t.person(:ref=>:name, :attributes=>{:type=>"personal"})
 
         t.role {
@@ -59,104 +59,103 @@ describe "OM::XML::Document" do
           t.publication_date(:path=>"date")
         }
       end
-           
+
     end
-        
+
   end
-  
+
   before(:each) do
     @fixturemods = DocumentTest.from_xml( fixture( File.join("CBF_MODS", "ARS0025_016.xml") ) )
     article_xml = fixture( File.join("mods_articles", "hydrangea_article1.xml") )
     @mods_article = DocumentTest.from_xml(article_xml)
   end
-  
+
   after(:all) do
     Object.send(:remove_const, :DocumentTest)
   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
-  
-  
+
+
   describe ".find_by_terms_and_value" do
     it "should fail gracefully if you try to look up nodes for an undefined property" do
-      pending "better to get an informative error?"
-      @fixturemods.find_by_terms_and_value(:nobody_home).should == []
+      skip "better to get an informative error?"
+      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.expects(: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.expects(: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.expects(: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.expects(: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
       # pending "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
-      pending "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
+      skip "Can't decide if it's better to return nil or raise an error.  Choosing informative errors for now."
+      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_truthy
     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_falsey
     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_truthy
     end
   end
-   
+
 end

data/spec/unit/dynamic_node_spec.rb

@@ -23,125 +23,133 @@ describe "OM::XML::DynamicNode" do
     end
     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
   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 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 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
-        lambda {@article.name.hedgehog}.should raise_exception NoMethodError
+      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']
-
-        @article.title(1).to_pointer.should == [{: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.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'])
+        expect(@article.title(1).to_pointer).to eq([{:title => 1}])
+        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]=>{"0"=>"434"} })
 
         @article.subject.topic(1).to_pointer == [:subject, {:topic => 1}]
-        @article.journal(0).issue.length.should == 2
+        expect(@article.journal(0).issue.length).to eq(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"
-
-        @article.subject.topic(1).should == ["TOPIC 2"]
-        @article.subject.topic(1).xpath.should == "//oxns:subject/oxns:topic[2]"
+        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")
+        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]=>{"0"=>"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, setting dirty to true if the object responds to dirty" do
         # backwards-compatible stuff..
-        @article.stubs(:respond_to?).with(:dirty=).returns(true)
-        @article.expects(:dirty=).with(true).at_least(2)
-
+        allow(@article).to receive(:respond_to?).with(any_args).and_call_original
+        allow(@article).to receive(:respond_to?).with(:dirty=).and_return(true)
+        expect(@article).to receive(:dirty=).with(true).at_least(2).times
         @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
-    
+
     end
   end
 end