om 1.8.0 → 1.8.1

data/spec/unit/term_builder_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 describe "OM::XML::Term::Builder" do
-  
+
   before(:each) do
     @test_terminology_builder = OM::XML::Terminology::Builder.new do |t|
       t.fruit_trees {
         t.citrus(:attributes=>{"citric_acid"=>"true"}, :index_as=>[:facetable]) {
           t.randomness
         }
-        t.stone_fruit(:path=>"prunus", :attributes=>{:genus=>"Prunus"}) 
+        t.stone_fruit(:path=>"prunus", :attributes=>{:genus=>"Prunus"})
         t.peach(:ref=>[:fruit_trees, :stone_fruit], :attributes=>{:subgenus=>"Amygdalus", :species=>"Prunus persica"})
         t.nectarine(:ref=>[:fruit_trees, :peach], :attributes=>{:cultivar=>"nectarine"})
         t.almond(:ref=>[:fruit_trees, :peach], :attributes=>{:species=>"Prunus dulcis"})
@@ -17,184 +17,184 @@ describe "OM::XML::Term::Builder" do
       t.banana(:ref=>:coconut)
       t.pineapple(:ref=>:banana)
     end
-    
-    @citrus = @test_terminology_builder.retrieve_term_builder(:fruit_trees, :citrus)
+
+    @citrus      = @test_terminology_builder.retrieve_term_builder(:fruit_trees, :citrus)
     @stone_fruit = @test_terminology_builder.retrieve_term_builder(:fruit_trees, :stone_fruit)
-    @peach = @test_terminology_builder.retrieve_term_builder(:fruit_trees, :peach)
-    @nectarine = @test_terminology_builder.retrieve_term_builder(:fruit_trees, :nectarine)
-    @almond = @test_terminology_builder.retrieve_term_builder(:fruit_trees, :almond)
-    @pineapple = @test_terminology_builder.retrieve_term_builder(:pineapple)
+    @peach       = @test_terminology_builder.retrieve_term_builder(:fruit_trees, :peach)
+    @nectarine   = @test_terminology_builder.retrieve_term_builder(:fruit_trees, :nectarine)
+    @almond      = @test_terminology_builder.retrieve_term_builder(:fruit_trees, :almond)
+    @pineapple   = @test_terminology_builder.retrieve_term_builder(:pineapple)
   end
-  
+
   before(:each) do
-    @test_builder = OM::XML::Term::Builder.new("term1")
+    @test_builder   = OM::XML::Term::Builder.new("term1")
     @test_builder_2 = OM::XML::Term::Builder.new("term2")
   end
-  
+
   describe '#new' do
    it "should set terminology_builder attribute if provided" do
-     mock_terminology_builder = mock("TerminologyBuilder")
-     OM::XML::Term::Builder.new("term1", mock_terminology_builder).terminology_builder.should == mock_terminology_builder
+     mock_terminology_builder = double("TerminologyBuilder")
+     expect(OM::XML::Term::Builder.new("term1", mock_terminology_builder).terminology_builder).to eq(mock_terminology_builder)
    end
   end
-  
+
   describe "configuration methods" do
     it "should set the corresponding .settings value return the mapping object" do
       [:path, :index_as, :required, :type, :variant_of, :path, :attributes, :default_content_path].each do |method_name|
-        @test_builder.send(method_name, "#{method_name.to_s}foo").should == @test_builder
-        @test_builder.settings[method_name].should == "#{method_name.to_s}foo"
+        expect(@test_builder.send(method_name, "#{method_name.to_s}foo")).to eq(@test_builder)
+        expect(@test_builder.settings[method_name]).to eq("#{method_name.to_s}foo")
       end
     end
     it "should be chainable" do
-      test_builder = OM::XML::Term::Builder.new("chainableTerm").index_as(:facetable, :searchable, :sortable, :displayable).required(true).type(:text)  
+      test_builder = OM::XML::Term::Builder.new("chainableTerm").index_as(:facetable, :searchable, :sortable, :displayable).required(true).type(:text)
       resulting_settings = test_builder.settings
-      resulting_settings[:index_as].should == [:facetable, :searchable, :sortable, :displayable]
-      resulting_settings[:required].should == true 
-      resulting_settings[:type].should == :text
+      expect(resulting_settings[:index_as]).to eq([:facetable, :searchable, :sortable, :displayable])
+      expect(resulting_settings[:required]).to eq(true)
+      expect(resulting_settings[:type]).to eq(:text)
     end
   end
 
   describe "settings" do
     describe "defaults" do
       it "should be set" do
-        @test_builder.settings[:required].should == false
-        @test_builder.settings[:type].should == :string
-        @test_builder.settings[:variant_of].should be_nil
-        @test_builder.settings[:attributes].should be_nil
-        @test_builder.settings[:default_content_path].should be_nil
+        expect(@test_builder.settings[:required]).to eq(false)
+        expect(@test_builder.settings[:type]).to eq(:string)
+        expect(@test_builder.settings[:variant_of]).to be_nil
+        expect(@test_builder.settings[:attributes]).to be_nil
+        expect(@test_builder.settings[:default_content_path]).to be_nil
       end
     end
     describe ":data_type" do
       it "is deprecated and should be assinged to the :type setting" do
         deprecated_term = OM::XML::Term::Builder.new("depreated_term").data_type(:thing)
-        deprecated_term.settings[:type].should == :thing
-      end 
+        expect(deprecated_term.settings[:type]).to eq(:thing)
+      end
     end
   end
-  
+
   describe ".add_child" do
     it "should insert the given Term Builder into the current Term Builder's children" do
       @test_builder.add_child(@test_builder_2)
-      @test_builder.children[@test_builder_2.name].should == @test_builder_2
-      @test_builder.ancestors.should include(@test_builder_2)
+      expect(@test_builder.children[@test_builder_2.name]).to eq(@test_builder_2)
+      expect(@test_builder.ancestors).to include(@test_builder_2)
     end
   end
   describe ".retrieve_child" do
     it "should fetch the child identified by the given name" do
       @test_builder.add_child(@test_builder_2)
-      @test_builder.retrieve_child(@test_builder_2.name).should == @test_builder.children[@test_builder_2.name]
+      expect(@test_builder.retrieve_child(@test_builder_2.name)).to eq(@test_builder.children[@test_builder_2.name])
     end
   end
   describe ".children" do
     it "should return a hash of Term Builders that are the children of the current object, indexed by name" do
       @test_builder.add_child(@test_builder_2)
-      @test_builder.children[@test_builder_2.name].should == @test_builder_2
+      expect(@test_builder.children[@test_builder_2.name]).to eq(@test_builder_2)
     end
   end
-  
+
   describe ".build" do
     it "should build a Term with the given settings and generate its xpath values" do
-      test_builder = OM::XML::Term::Builder.new("requiredTextFacet").index_as([:facetable, :searchable, :sortable, :displayable]).required(true).type(:text)  
+      test_builder = OM::XML::Term::Builder.new("requiredTextFacet").index_as([:facetable, :searchable, :sortable, :displayable]).required(true).type(:text)
       result = test_builder.build
-      result.should be_instance_of OM::XML::Term
-      result.index_as.should == [:facetable, :searchable, :sortable, :displayable]
-      result.required.should == true 
-      result.type.should == :text
-      
-      result.xpath.should == OM::XML::TermXpathGenerator.generate_absolute_xpath(result)
-      result.xpath_constrained.should == OM::XML::TermXpathGenerator.generate_constrained_xpath(result)
-      result.xpath_relative.should == OM::XML::TermXpathGenerator.generate_relative_xpath(result)
+      expect(result).to be_instance_of OM::XML::Term
+      expect(result.index_as).to eq([:facetable, :searchable, :sortable, :displayable])
+      expect(result.required).to eq(true)
+      expect(result.type).to eq(:text)
+
+      expect(result.xpath).to eq(OM::XML::TermXpathGenerator.generate_absolute_xpath(result))
+      expect(result.xpath_constrained).to eq(OM::XML::TermXpathGenerator.generate_constrained_xpath(result))
+      expect(result.xpath_relative).to eq(OM::XML::TermXpathGenerator.generate_relative_xpath(result))
     end
     it "should create proxy terms if :proxy is set" do
       test_builder = OM::XML::Term::Builder.new("my_proxy").proxy([:foo, :bar])
       result = test_builder.build
-      result.should be_kind_of OM::XML::NamedTermProxy
+      expect(result).to be_kind_of OM::XML::NamedTermProxy
     end
     it "should set path to match name if it is empty" do
-      @test_builder.settings[:path].should be_nil
-      @test_builder.build.path.should == @test_builder.name.to_s
+      expect(@test_builder.settings[:path]).to be_nil
+      expect(@test_builder.build.path).to eq(@test_builder.name.to_s)
     end
     it "should work recursively, calling .build on any of its children" do
-      OM::XML::Term.any_instance.stubs(:generate_xpath_queries!)
+      allow_any_instance_of(OM::XML::Term).to receive(:generate_xpath_queries!)
       built_child1 = OM::XML::Term.new("child1")
       built_child2 = OM::XML::Term.new("child2")
 
-      mock1 = mock("Builder1", :build => built_child1 )
-      mock2 = mock("Builder2", :build => built_child2 )
-      mock1.stubs(:name).returns("child1")
-      mock2.stubs(:name).returns("child2")
+      mock1 = double("Builder1", :build => built_child1 )
+      mock2 = double("Builder2", :build => built_child2 )
+      allow(mock1).to receive(:name).and_return("child1")
+      allow(mock2).to receive(:name).and_return("child2")
 
       @test_builder.children = {:mock1=>mock1, :mock2=>mock2}
       result = @test_builder.build
-      result.children[:child1].should == built_child1
-      result.children[:child2].should == built_child2
-      result.children.length.should == 2
+      expect(result.children[:child1]).to eq(built_child1)
+      expect(result.children[:child2]).to eq(built_child2)
+      expect(result.children.length).to eq(2)
     end
   end
-  
+
   describe ".lookup_refs" do
     it "should return an empty array if no refs are declared" do
-      @test_builder.lookup_refs.should == []
+      expect(@test_builder.lookup_refs).to eq([])
     end
     it "should should look up the referenced TermBuilder from the terminology_builder" do
-       @peach.lookup_refs.should == [@stone_fruit]
+       expect(@peach.lookup_refs).to eq([@stone_fruit])
     end
     it "should support recursive refs" do
-	    @almond.lookup_refs.should == [@peach, @stone_fruit]
+	    expect(@almond.lookup_refs).to eq([@peach, @stone_fruit])
 	  end
   	it "should raise an error if the TermBuilder does not have a reference to a terminology builder" do
-  	  lambda { OM::XML::Term::Builder.new("referrer").ref("bongos").lookup_refs }.should raise_error(StandardError,"Cannot perform lookup_ref for the referrer builder.  It doesn't have a reference to any terminology builder")
+  	  expect { OM::XML::Term::Builder.new("referrer").ref("bongos").lookup_refs }.to raise_error(StandardError,"Cannot perform lookup_ref for the referrer builder.  It doesn't have a reference to any terminology builder")
 	  end
     it "should raise an error if the referece points to a nonexistent term builder" do
       tb = OM::XML::Term::Builder.new("mork",@test_terminology_builder).ref(:characters, :aliens)
-      lambda { tb.lookup_refs }.should raise_error(OM::XML::Terminology::BadPointerError,"This TerminologyBuilder does not have a root TermBuilder defined that corresponds to \":characters\"")
+      expect { tb.lookup_refs }.to raise_error(OM::XML::Terminology::BadPointerError,"This TerminologyBuilder does not have a root TermBuilder defined that corresponds to \":characters\"")
     end
     it "should raise an error with informative error when given circular references" do
-      lambda { @pineapple.lookup_refs }.should raise_error(OM::XML::Terminology::CircularReferenceError,"Circular reference in Terminology: :pineapple => :banana => :coconut => :pineapple")
+      expect { @pineapple.lookup_refs }.to raise_error(OM::XML::Terminology::CircularReferenceError,"Circular reference in Terminology: :pineapple => :banana => :coconut => :pineapple")
     end
   end
-  
-  describe ".resolve_refs!" do 
+
+  describe ".resolve_refs!" do
     it "should do nothing if settings don't include a :ref" do
       settings_pre = @test_builder.settings
       children_pre = @test_builder.children
 
       @test_builder.resolve_refs!
-      @test_builder.settings.should == settings_pre
-      @test_builder.children.should == children_pre
+      expect(@test_builder.settings).to eq(settings_pre)
+      expect(@test_builder.children).to eq(children_pre)
     end
     it "should should look up the referenced TermBuilder, use its settings and duplicate its children without changing the name" do
       term_builder = OM::XML::Term::Builder.new("orange",@test_terminology_builder).ref(:fruit_trees, :citrus)
       term_builder.resolve_refs!
       # Make sure children and settings were copied
-      term_builder.settings.should == @citrus.settings.merge(:path=>"citrus")
-  	  term_builder.children.should == @citrus.children
-  	  
+      expect(term_builder.settings).to eq(@citrus.settings.merge(:path=>"citrus"))
+  	  expect(term_builder.children).to eq(@citrus.children)
+
   	  # Make sure name and parent of both the term_builder and its target were left alone
-  	  term_builder.name.should == :orange
-  	  @citrus.name.should == :citrus
+  	  expect(term_builder.name).to eq(:orange)
+  	  expect(@citrus.name).to eq(:citrus)
     end
     it "should set path based on the ref's path if set" do
       [@peach,@almond].each { |x| x.resolve_refs! }
-      @peach.settings[:path].should == "prunus"
-      @almond.settings[:path].should == "prunus"
+      expect(@peach.settings[:path]).to eq("prunus")
+      expect(@almond.settings[:path]).to eq("prunus")
     end
     it "should set path based on the first ref's name if no path is set" do
       orange_builder = OM::XML::Term::Builder.new("orange",@test_terminology_builder).ref(:fruit_trees, :citrus)
       orange_builder.resolve_refs!
-      orange_builder.settings[:path].should == "citrus"
+      expect(orange_builder.settings[:path]).to eq("citrus")
     end
-    # It should not be a problem if multiple TermBuilders refer to the same child TermBuilder since the parent-child relationship is set up after calling TermBuilder.build 
-    it "should result in clean trees of Terms after building" 
-    
+    # It should not be a problem if multiple TermBuilders refer to the same child TermBuilder since the parent-child relationship is set up after calling TermBuilder.build
+    # it "should result in clean trees of Terms after building"
+
   	it "should preserve any extra settings specific to this builder (for variant terms)" do
   	  tb = OM::XML::Term::Builder.new("orange",@test_terminology_builder).ref(:fruit_trees, :citrus).attributes(:color=>"orange").required(true)
   	  tb.resolve_refs!
-  	  tb.settings.should == {:path=>"citrus", :attributes=>{"citric_acid"=>"true", :color=>"orange"}, :required=>true, :type=>:string, :index_as=>[:facetable]}
+  	  expect(tb.settings).to eq({:path=>"citrus", :attributes=>{"citric_acid"=>"true", :color=>"orange"}, :required=>true, :type=>:string, :index_as=>[:facetable]})
 	  end
 	  it "should aggregate all settings from refs, combining them with a cascading approach" do
 	    @almond.resolve_refs!
-	    @almond.settings[:attributes].should == {:genus=>"Prunus",:subgenus=>"Amygdalus", :species=>"Prunus dulcis"}
+	    expect(@almond.settings[:attributes]).to eq({:genus=>"Prunus",:subgenus=>"Amygdalus", :species=>"Prunus dulcis"})
     end
   end
 end

data/spec/unit/term_spec.rb

@@ -3,46 +3,54 @@ require 'spec_helper'
 describe OM::XML::Term do
   describe "without a type" do
     subject { OM::XML::Term.new(:test_term) }
-    its (:type) { should == :string }
+
+    describe (:type) do
+      subject { super().send((:type)) }
+      it { is_expected.to eq(:string) }
+    end
   end
   describe "when type is specified" do
     subject { OM::XML::Term.new(:test_term, :type=>:date)}
-    its (:type) { should == :date }
+
+    describe (:type) do
+      subject { super().send((:type)) }
+      it { is_expected.to eq(:date) }
+    end
   end
 
   describe "a big test" do
     before(:each) do
-      @test_name_part = OM::XML::Term.new(:namePart, {}).generate_xpath_queries!
-      @test_volume = OM::XML::Term.new(:volume, :path=>"detail", :attributes=>{:type=>"volume"}, :default_content_path=>"number")
-      @test_date = OM::XML::Term.new(:namePart, :attributes=>{:type=> "date"})
-      @test_person = OM::XML::Term.new(:namePart, :attributes=>{:type=> :none})
+      @test_name_part   = OM::XML::Term.new(:namePart, {}).generate_xpath_queries!
+      @test_volume      = OM::XML::Term.new(:volume, :path=>"detail", :attributes=>{:type=>"volume"}, :default_content_path=>"number")
+      @test_date        = OM::XML::Term.new(:namePart, :attributes=>{:type=> "date"})
+      @test_person      = OM::XML::Term.new(:namePart, :attributes=>{:type=> :none})
       @test_affiliation = OM::XML::Term.new(:affiliation)
-      @test_role_code = OM::XML::Term.new(:roleTerm, :attributes=>{:type=>"code"})
-      @test_type = OM::XML::Term.new(:class)
+      @test_role_code   = OM::XML::Term.new(:roleTerm, :attributes=>{:type=>"code"})
+      @test_type        = OM::XML::Term.new(:class)
     end
 
     describe '#new' do
       it "should set path from mapper name if no path is provided" do
-        @test_name_part.path.should == "namePart"
+        expect(@test_name_part.path).to eq("namePart")
       end
       it "should populate the xpath values if no options are provided" do
         local_mapping = OM::XML::Term.new(:namePart)
-        local_mapping.xpath_relative.should be_nil
-        local_mapping.xpath.should be_nil
-        local_mapping.xpath_constrained.should be_nil
+        expect(local_mapping.xpath_relative).to be_nil
+        expect(local_mapping.xpath).to be_nil
+        expect(local_mapping.xpath_constrained).to be_nil
       end
     end
 
     describe 'inner_xml' do
       it "should be a kind of Nokogiri::XML::Node" do
-        pending
-        @test_mapping.inner_xml.should be_kind_of(Nokogiri::XML::Node)
+        skip
+        expect(@test_mapping.inner_xml).to be_kind_of(Nokogiri::XML::Node)
       end
     end
 
     describe '#from_node' do
       it "should create a mapper from a nokogiri node" do
-        pending "probably should do this in the Builder"
+        skip "probably should do this in the Builder"
         ng_builder = Nokogiri::XML::Builder.new do |xml|
           xml.mapper(:name=>"person", :path=>"name") {
             xml.attribute(:name=>"type", :value=>"personal")
@@ -55,17 +63,17 @@ describe OM::XML::Term do
         # node = Nokogiri::XML::Document.parse( '<mapper name="first_name" path="namePart"><attribute name="type" value="given"/><attribute name="another_attribute" value="myval"/></mapper>' ).root
         node = ng_builder.doc.root
         mapper = OM::XML::Term.from_node(node)
-        mapper.name.should == :person
-        mapper.path.should == "name"
-        mapper.attributes.should == {:type=>"personal"}
-        mapper.internal_xml.should == node
+        expect(mapper.name).to eq(:person)
+        expect(mapper.path).to eq("name")
+        expect(mapper.attributes).to eq({:type=>"personal"})
+        expect(mapper.internal_xml).to eq(node)
 
         child = mapper.children[:first_name]
 
-        child.name.should == :first_name
-        child.path.should == "namePart"
-        child.attributes.should == {:type=>"given", :another_attribute=>"myval"}
-        child.internal_xml.should == node.xpath("./mapper").first
+        expect(child.name).to eq(:first_name)
+        expect(child.path).to eq("namePart")
+        expect(child.attributes).to eq({:type=>"given", :another_attribute=>"myval"})
+        expect(child.internal_xml).to eq(node.xpath("./mapper").first)
       end
     end
 
@@ -75,20 +83,20 @@ describe OM::XML::Term do
 
     describe ".retrieve_term" do
       it "should crawl down into mapper children to find the desired term" do
-        mock_role = mock("mapper", :children =>{:text=>"the target"})
-        mock_conference = mock("mapper", :children =>{:role=>mock_role})
-        @test_name_part.expects(:children).returns({:conference=>mock_conference})
-        @test_name_part.retrieve_term(:conference, :role, :text).should == "the target"
+        mock_role = double("mapper", :children =>{:text=>"the target"})
+        mock_conference = double("mapper", :children =>{:role=>mock_role})
+        expect(@test_name_part).to receive(:children).and_return({:conference=>mock_conference})
+        expect(@test_name_part.retrieve_term(:conference, :role, :text)).to eq("the target")
       end
       it "should return an empty hash if no term can be found" do
-        @test_name_part.retrieve_term(:journal, :issue, :end_page).should == nil
+        expect(@test_name_part.retrieve_term(:journal, :issue, :end_page)).to eq(nil)
       end
     end
 
     describe 'inner_xml' do
       it "should be a kind of Nokogiri::XML::Node" do
-        pending
-        @test_name_part.inner_xml.should be_kind_of(Nokogiri::XML::Node)
+        skip
+        expect(@test_name_part.inner_xml).to be_kind_of(Nokogiri::XML::Node)
       end
     end
 
@@ -96,8 +104,8 @@ describe OM::XML::Term do
       it "should set the corresponding .settings value and return the current value" do
         # :index_as is a special case
         [:path, :required, :type, :variant_of, :path, :attributes, :default_content_path, :namespace_prefix].each do |method_name|
-          @test_name_part.send(method_name.to_s+"=", "#{method_name.to_s}foo").should == "#{method_name.to_s}foo"
-          @test_name_part.send(method_name).should == "#{method_name.to_s}foo"
+          expect(@test_name_part.send(method_name.to_s+"=", "#{method_name.to_s}foo")).to eq("#{method_name.to_s}foo")
+          expect(@test_name_part.send(method_name)).to eq("#{method_name.to_s}foo")
         end
       end
     end
@@ -106,7 +114,7 @@ describe OM::XML::Term do
       subject {
         class TestTerminology
           include OM::XML::Document
-          
+
           set_terminology do |t|
             t.as_array :index_as => [:not_searchable]
             t.as_symbol :index_as => :not_searchable
@@ -117,77 +125,75 @@ describe OM::XML::Term do
       }
 
       it "should accept an array as an :index_as value" do
-        subject.terminology.terms[:as_array].index_as.should be_a_kind_of(Array)
-        subject.terminology.terms[:as_array].index_as.should == [:not_searchable]
+        expect(subject.terminology.terms[:as_array].index_as).to be_a_kind_of(Array)
+        expect(subject.terminology.terms[:as_array].index_as).to eq([:not_searchable])
       end
       it "should accept a plain symbol as a value to :index_as" do
-        subject.terminology.terms[:as_symbol].index_as.should be_a_kind_of(Array)
-        subject.terminology.terms[:as_symbol].index_as.should == [:not_searchable]
+        expect(subject.terminology.terms[:as_symbol].index_as).to be_a_kind_of(Array)
+        expect(subject.terminology.terms[:as_symbol].index_as).to eq([:not_searchable])
       end
     end
     it "should have a .terminology attribute accessor" do
-      @test_volume.should respond_to :terminology
-      @test_volume.should respond_to :terminology=
+      expect(@test_volume).to respond_to :terminology
+      expect(@test_volume).to respond_to :terminology=
     end
     describe ".ancestors" do
       it "should return an array of Terms that are the ancestors of the current object, ordered from the top/root of the hierarchy" do
         @test_volume.set_parent(@test_name_part)
-        @test_volume.ancestors.should == [@test_name_part]
+        expect(@test_volume.ancestors).to eq([@test_name_part])
       end
     end
     describe ".parent" do
       it "should retrieve the immediate parent of the given object from the ancestors array" do
         # @test_name_part.expects(:ancestors).returns(["ancestor1","ancestor2","ancestor3"])
         @test_name_part.ancestors = ["ancestor1","ancestor2","ancestor3"]
-        @test_name_part.parent.should == "ancestor3"
+        expect(@test_name_part.parent).to eq("ancestor3")
       end
     end
     describe ".children" do
       it "should return a hash of Terms that are the children of the current object, indexed by name" do
         @test_volume.add_child(@test_name_part)
-        @test_volume.children[@test_name_part.name].should == @test_name_part
+        expect(@test_volume.children[@test_name_part.name]).to eq(@test_name_part)
       end
     end
     describe ".retrieve_child" do
       it "should fetch the child identified by the given name" do
         @test_volume.add_child(@test_name_part)
-        @test_volume.retrieve_child(@test_name_part.name).should == @test_volume.children[@test_name_part.name]
+        expect(@test_volume.retrieve_child(@test_name_part.name)).to eq(@test_volume.children[@test_name_part.name])
       end
     end
     describe ".set_parent" do
       it "should insert the mapper into the given parent" do
         @test_name_part.set_parent(@test_volume)
-        @test_name_part.ancestors.should include(@test_volume)
-        @test_volume.children[@test_name_part.name].should == @test_name_part
+        expect(@test_name_part.ancestors).to include(@test_volume)
+        expect(@test_volume.children[@test_name_part.name]).to eq(@test_name_part)
       end
     end
     describe ".add_child" do
       it "should insert the given mapper into the current mappers children" do
         @test_volume.add_child(@test_name_part)
-        @test_volume.children[@test_name_part.name].should == @test_name_part
-        @test_name_part.ancestors.should include(@test_volume)
+        expect(@test_volume.children[@test_name_part.name]).to eq(@test_name_part)
+        expect(@test_name_part.ancestors).to include(@test_volume)
       end
     end
 
     describe "generate_xpath_queries!" do
       it "should return the current object" do
-        @test_name_part.generate_xpath_queries!.should == @test_name_part
+        expect(@test_name_part.generate_xpath_queries!).to eq(@test_name_part)
       end
       it "should regenerate the xpath values" do
-        @test_volume.xpath_relative.should be_nil
-        @test_volume.xpath.should be_nil
-        @test_volume.xpath_constrained.should be_nil
-
-        @test_volume.generate_xpath_queries!.should == @test_volume
-
-        @test_volume.xpath_relative.should == 'detail[@type="volume"]'
-        @test_volume.xpath.should == '//detail[@type="volume"]'
-        @test_volume.xpath_constrained.should == '//detail[@type="volume" and contains(number, "#{constraint_value}")]'.gsub('"', '\"')
+        expect(@test_volume.xpath_relative).to be_nil
+        expect(@test_volume.xpath).to be_nil
+        expect(@test_volume.xpath_constrained).to be_nil
+        expect(@test_volume.generate_xpath_queries!).to eq(@test_volume)
+        expect(@test_volume.xpath_relative).to eq('detail[@type="volume"]')
+        expect(@test_volume.xpath).to eq('//detail[@type="volume"]')
+        expect(@test_volume.xpath_constrained).to eq('//detail[@type="volume" and contains(number, "#{constraint_value}")]'.gsub('"', '\"'))
       end
       it "should trigger update on any child objects" do
-        mock_child = mock("child term")
-        mock_child.expects(:generate_xpath_queries!).times(3)
-        @test_name_part.expects(:children).returns({1=>mock_child, 2=>mock_child, 3=>mock_child})
+        mock_child = double("child term")
+        expect(mock_child).to receive(:generate_xpath_queries!).exactly(3).times
+        expect(@test_name_part).to receive(:children).and_return({1=>mock_child, 2=>mock_child, 3=>mock_child})
         @test_name_part.generate_xpath_queries!
       end
     end
@@ -195,9 +201,9 @@ describe OM::XML::Term do
     describe "#xml_builder_template" do
 
       it "should generate a template call for passing into the builder block (assumes 'xml' as the argument for the block)" do
-        @test_date.xml_builder_template.should == 'xml.namePart( \'#{builder_new_value}\', \'type\'=>\'date\' )'
-        @test_person.xml_builder_template.should == 'xml.namePart( \'#{builder_new_value}\' )'
-        @test_affiliation.xml_builder_template.should == 'xml.affiliation( \'#{builder_new_value}\' )'
+        expect(@test_date.xml_builder_template).to eq('xml.namePart( \'#{builder_new_value}\', \'type\'=>\'date\' )')
+        expect(@test_person.xml_builder_template).to eq('xml.namePart( \'#{builder_new_value}\' )')
+        expect(@test_affiliation.xml_builder_template).to eq('xml.affiliation( \'#{builder_new_value}\' )')
       end
 
       it "should accept extra options" do
@@ -206,37 +212,37 @@ describe OM::XML::Term do
         e1 = %q{xml.roleTerm( '#{builder_new_value}', 'type'=>'code', 'authority'=>'marcrelator' )}
         e2 = %q{xml.roleTerm( '#{builder_new_value}', 'authority'=>'marcrelator', 'type'=>'code' )}
         got = @test_role_code.xml_builder_template(:attributes=>{"authority"=>"marcrelator"})
-        [e1, e2].should include(got)
+        expect([e1, e2]).to include(got)
       end
 
       it "should work for namespaced nodes" do
         @ical_date = OM::XML::Term.new(:ical_date, :path=>"ical:date")
-        @ical_date.xml_builder_template.should == "xml[\'ical\'].date( '\#{builder_new_value}' )"
+        expect(@ical_date.xml_builder_template).to eq("xml[\'ical\'].date( '\#{builder_new_value}' )")
         @ical_date = OM::XML::Term.new(:ical_date, :path=>"date", :namespace_prefix=>"ical")
-        @ical_date.xml_builder_template.should == "xml[\'ical\'].date( '\#{builder_new_value}' )"
+        expect(@ical_date.xml_builder_template).to eq("xml[\'ical\'].date( '\#{builder_new_value}' )")
       end
 
       it "should work for nodes with default_content_path" do
-        @test_volume.xml_builder_template.should == "xml.detail( \'type\'=>'volume' ) { xml.number( '\#{builder_new_value}' ) }"
+        expect(@test_volume.xml_builder_template).to eq("xml.detail( \'type\'=>'volume' ) { xml.number( '\#{builder_new_value}' ) }")
       end
 
       it "should support terms that are attributes" do
         @type_attribute_term = OM::XML::Term.new(:type_attribute, :path=>{:attribute=>:type})
-        @type_attribute_term.xml_builder_template.should == "xml.@type( '\#{builder_new_value}' )"
+        expect(@type_attribute_term.xml_builder_template).to eq("xml.@type( '\#{builder_new_value}' )")
       end
 
       it "should support terms with namespaced attributes" do
         @french_title = OM::XML::Term.new(:french_title, :path=>"title", :attributes=>{"xml:lang"=>"fre"})
-        @french_title.xml_builder_template.should == "xml.title( '\#{builder_new_value}', 'xml:lang'=>'fre' )"
+        expect(@french_title.xml_builder_template).to eq("xml.title( '\#{builder_new_value}', 'xml:lang'=>'fre' )")
       end
 
       it "should support terms that are namespaced attributes" do
         @xml_lang_attribute_term = OM::XML::Term.new(:xml_lang_attribute, :path=>{:attribute=>"xml:lang"})
-        @xml_lang_attribute_term.xml_builder_template.should == "xml.@xml:lang( '\#{builder_new_value}' )"
+        expect(@xml_lang_attribute_term.xml_builder_template).to eq("xml.@xml:lang( '\#{builder_new_value}' )")
       end
-      
+
       it "should generate a template call for passing into the builder block (assumes 'xml' as the argument for the block) for terms that share a name with an existing method on the builder" do
-        @test_type.xml_builder_template.should == 'xml.class_( \'#{builder_new_value}\' )'
+        expect(@test_type.xml_builder_template).to eq('xml.class_( \'#{builder_new_value}\' )')
       end
     end
   end