om 1.8.1 → 1.9.0.pre1

data/spec/spec_helper.rb

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

data/spec/unit/container_spec.rb

@@ -1,79 +1,80 @@
 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
-    expect(subject).to respond_to(:ng_xml)
-    expect(subject).to respond_to(:ng_xml=)
+    subject.should respond_to(:ng_xml)
+    subject.should respond_to(:ng_xml=)    
   end
 
   it "should initialize" do
-    expect(ContainerTest.new.ng_xml).to be_a_kind_of Nokogiri::XML::Document
+    ContainerTest.new.ng_xml.should be_a_kind_of Nokogiri::XML::Document
   end
-
+  
   describe "new" do
     it "should populate ng_xml with an instance of Nokogiri::XML::Document" do
-      expect(subject.ng_xml.class).to eq(Nokogiri::XML::Document)
+      subject.ng_xml.class.should == Nokogiri::XML::Document
     end
   end
 
   describe "#from_xml" do
     it "should accept a String, parse it and store it in .ng_xml" do
-      expect(Nokogiri::XML::Document).to receive(:parse).and_return("parsed xml")
+      Nokogiri::XML::Document.should_receive(:parse).and_return("parsed xml")
       container1 = ContainerTest.from_xml("<foo><bar>1</bar></foo>")
-      expect(container1.ng_xml).to eq("parsed xml")
+      container1.ng_xml.should == "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"))
-      expect(Nokogiri::XML::Document).to receive(:parse).and_return("parsed xml")
+      Nokogiri::XML::Document.should_receive(:parse).and_return("parsed xml")
       container1 = ContainerTest.from_xml(file)
-      expect(container1.ng_xml).to eq("parsed xml")
+      container1.ng_xml.should == "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)
-      expect(container1.ng_xml).to eq(parsed_xml)
+      container1.ng_xml.should == parsed_xml
     end
   end
-
+  
   describe ".to_xml" do
     it  "should call .ng_xml.to_xml" do
-      expect(subject.ng_xml).to receive(:to_xml).and_return("ng xml")
-      expect(subject.to_xml).to eq("ng xml")
+      subject.ng_xml.should_receive(:to_xml).and_return("ng xml")
+      subject.to_xml.should == "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 = double("new node")
-      expect(doc.root).to receive(:add_child).with(subject.ng_xml.root).and_return(mock_new_node)
+      mock_new_node = mock("new node")
+      doc.root.should_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/>")
-      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")
+      subject.to_xml(doc).should == "<?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 = double("new node")
-      allow(mock_new_node).to receive(:to_xml).and_return("foo")
+      mock_new_node = mock("new node")
+      mock_new_node.stub(:to_xml).and_return("foo")
+      
       doc = Nokogiri::XML::Document.parse("<test_document/>")
-      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)
+      el = Nokogiri::XML::Node.new("test_element", Nokogiri::XML::Document.new)
+      doc.root.should_receive(:add_child).with(subject.ng_xml.root).and_return(mock_new_node)
+      el.should_receive(:add_child).with(subject.ng_xml.root).and_return(mock_new_node)
+      subject.to_xml(doc).should 
       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
-
-      include OM::XML::Document
+    #ModsHelpers.name_("Beethoven, Ludwig van", :date=>"1770-1827", :role=>"creator")
+    class DocumentTest 
 
-      # Could add support for multiple root declarations.
+      include OM::XML::Document    
+      
+      # 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,103 +59,104 @@ 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
-    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)
+    DocumentTest.included_modules.should include(OM::XML::Container)
+    DocumentTest.included_modules.should include(OM::XML::TermValueOperators)
+    DocumentTest.included_modules.should include(OM::XML::Validation)
   end
-
+  
   describe ".ox_namespaces" do
     it "should merge terminology namespaces with document namespaces" do
-      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"})
+      @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"}
     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
-      skip "better to get an informative error?"
-      expect(@fixturemods.find_by_terms_and_value(:nobody_home)).to eq([])
+      pending "better to get an informative error?"
+      @fixturemods.find_by_terms_and_value(:nobody_home).should == []
     end
     it "should use Nokogiri to retrieve a NodeSet corresponding to the term pointers" do
-      expect(@mods_article.find_by_terms_and_value( :person ).length).to eq(2)
+      @mods_article.find_by_terms_and_value( :person ).length.should == 2
     end
 
     it "should allow you to search by term pointer" do
-      expect(@fixturemods.ng_xml).to receive(:xpath).with('//oxns:name[@type="personal"]', @fixturemods.ox_namespaces)
+      @fixturemods.ng_xml.should_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
-      expect(@fixturemods.ng_xml).to receive(:xpath).with('//oxns:name[@type="personal" and contains(., "Beethoven, Ludwig van")]', @fixturemods.ox_namespaces)
+      @fixturemods.ng_xml.should_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
-      expect(@fixturemods.ng_xml).to receive(:xpath).with('//oxns:name[@type="personal"]/oxns:namePart[@type="date" and contains(., "2010")]', @fixturemods.ox_namespaces)
+      @fixturemods.ng_xml.should_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")
-      expect(@fixturemods.ng_xml).to receive(:xpath).with('//oxns:name[@type="personal"]/oxns:role[contains(., "donor")]', @fixturemods.ox_namespaces)
+      
+      @fixturemods.ng_xml.should_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
-      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")
+      @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"
     end
     it "should find a NodeSet where a terminology attribute has been set to :none" do
-      expect(@mods_article.find_by_terms( {:person=>1}, :person_id).first.text).to eq("123987")
+      @mods_article.find_by_terms( {:person=>1}, :person_id).first.text.should == "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"
-      expect(DocumentTest.terminology.retrieve_term(:title_info, :language).path).to eq({:attribute=>"lang"})
+      DocumentTest.terminology.retrieve_term(:title_info, :language).path.should == {:attribute=>"lang"}
       # @sample.retrieve( :title, 1 ).first.text.should == "Artikkelin otsikko Hydrangea artiklan 1"
-      expect(@mods_article.find_by_terms( {:title_info=>1}, :language ).first.text).to eq("finnish")
+      @mods_article.find_by_terms( {:title_info=>1}, :language ).first.text.should == "finnish"
     end
-
+    
     it "should support xpath queries as the pointer" do
-      expect(@mods_article.find_by_terms('//oxns:name[@type="personal"][1]/oxns:namePart[1]').first.text).to eq("FAMILY NAME")
+      @mods_article.find_by_terms('//oxns:name[@type="personal"][1]/oxns:namePart[1]').first.text.should == "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."
-      expect(@mods_article.find_by_terms( {:foo=>20}, :bar )).to eq(nil)
+      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
     end
-
+    
     it "should support terms that point to attributes instead of nodes" do
-      expect(@mods_article.find_by_terms( {:title_info=>1}, :language ).first.text).to eq("finnish")
+      @mods_article.find_by_terms( {:title_info=>1}, :language ).first.text.should == "finnish"
     end
 
     it "should support xpath queries as the pointer" do
-      expect(@mods_article.find_by_terms('//oxns:name[@type="personal"][1]/oxns:namePart[1]').first.text).to eq("FAMILY NAME")
+      @mods_article.find_by_terms('//oxns:name[@type="personal"][1]/oxns:namePart[1]').first.text.should == "FAMILY NAME"
     end
   end
-
+  
   describe "node_exists?" do
     it "should return true if any nodes are found" do
-      expect(@mods_article.node_exists?( {:person=>1}, :first_name)).to be_truthy
+      @mods_article.node_exists?( {:person=>1}, :first_name).should be_true
     end
     it "should return false if no nodes are found" do
-      expect(@mods_article.node_exists?( {:person=>8}, :first_name )).to be_falsey
+      @mods_article.node_exists?( {:person=>8}, :first_name ).should be_false
     end
     it "should support xpath queries" do
-      expect(@mods_article.node_exists?('//oxns:name[@type="personal"][1]/oxns:namePart[1]')).to be_truthy
+      @mods_article.node_exists?('//oxns:name[@type="personal"][1]/oxns:namePart[1]').should be_true
     end
   end
-
+   
 end

data/spec/unit/dynamic_node_spec.rb

@@ -23,133 +23,121 @@ describe "OM::XML::DynamicNode" do
     end
     it "should create templates for dynamic nodes" do
       @sample.creator = "Foo"
-      expect(@sample.creator).to eq(['Foo'])
+      @sample.creator.should == ['Foo']
     end
     it "should create templates for dynamic nodes with multiple values" do
       @sample.creator = ["Foo", "Bar"]
-      expect(@sample.creator).to eq(['Foo', 'Bar'])
+      @sample.creator.should == ['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
-        expect(result.length).to eq(expected_values.length)
-        expected_values.each {|v| expect(result).to include(v)}
+        result.length.should == expected_values.length
+        expected_values.each {|v| result.should include(v)}
       end
 
       it "should be able to set first level elements" do
         @article.abstract = "My Abstract"
-        expect(@article.abstract).to eq(["My Abstract"])
+        @article.abstract.should == ["My Abstract"]
       end
 
       it "should be able to set first level elements that are arrays" do
         @article.abstract = ["My Abstract", "two"]
-        expect(@article.abstract).to eq(["My Abstract", 'two'])
+        @article.abstract.should == ["My Abstract", 'two']
       end
 
       it "should delegate all methods (i.e. to_s, first, etc.) to the found array" do
-        expect(@article.person.last_name.to_s).to eq(["FAMILY NAME", "Gautama"].to_s)
-        expect(@article.person.last_name.first).to eq("FAMILY NAME")
+        @article.person.last_name.to_s.should == ["FAMILY NAME", "Gautama"].to_s
+        @article.person.last_name.first.should == "FAMILY NAME"
       end
 
       it "should delegate with blocks to the found array" do
         arr = []
         @article.person.last_name.each{|x| arr << x}
-        expect(arr).to eq(["FAMILY NAME", "Gautama"])
+        arr.should == ["FAMILY NAME", "Gautama"]
       end
 
+
       describe "setting attributes" do
         it "when they exist" do
           @article.title_info(0).main_title.main_title_lang = "ger"
-          expect(@article.title_info(0).main_title.main_title_lang).to eq(["ger"])
+          @article.title_info(0).main_title.main_title_lang.should == ["ger"]
         end
         it "when they don't exist" do
           title = @article.title_info(0)
           title.language = "rus"
-          expect(@article.title_info(0).language).to eq(["rus"])
+          @article.title_info(0).language.should == ["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.
-        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')
+      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"]
       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/
+      it "should not find elements that don't  exist" do
+        lambda {@article.name.hedgehog}.should raise_exception NoMethodError
       end
 
       it "should allow you to call methods on the return value" do
-        expect(@article.name.name_content.first).to eq("Describes a person")
+        @article.name.name_content.first.should == "Describes a person"
       end
 
       it "Should work with proxies" do
-        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"])
+        @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"]
       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}]
-        expect(@article.journal(0).issue.length).to eq(2)
+        @article.journal(0).issue.length.should == 2
         @article.journal(0).issue(1).pages.to_pointer == [{: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")
-        expect(@article.subject.topic(1)).to eq(["TOPIC 2"])
-        expect(@article.subject.topic(1).xpath).to eq("//oxns:subject/oxns:topic[2]")
-      end
+        @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]"
+      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
-          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)
+          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
         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..
-        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
+      it "should append nodes at the specified index if possible" do
         @article.journal.title_info = ["all", "for", "the"]
         @article.journal.title_info(3, 'glory')
-        expect(@article.term_values(:journal, :title_info)).to eq(["all", "for", "the", "glory"])
-        expect(@article).to be_changed
+        @article.term_values(:journal, :title_info).should == ["all", "for", "the", "glory"]
+        @article.should be_changed
       end
-
+    
     end
   end
 end