om 3.1.0 → 3.1.1

data/spec/integration/proxies_and_ref_spec.rb

@@ -68,21 +68,21 @@ describe "an example with :proxy and :ref" do
 
     describe "image" do
       it "should have the right proxy terms" do
-        subject.ead_fedora_pid.should include "hypatia:ead_file_asset_fixture"
-        subject.ead_ds_label.should include "my_ead.xml"
-        subject.ead_size.should include "47570"
-        subject.ead_md5.should include "123"
-        subject.ead_sha1.should include "456"
+        expect(subject.ead_fedora_pid).to include "hypatia:ead_file_asset_fixture"
+        expect(subject.ead_ds_label).to include "my_ead.xml"
+        expect(subject.ead_size).to include "47570"
+        expect(subject.ead_md5).to include "123"
+        expect(subject.ead_sha1).to include "456"
       end
     end
 
     describe "ead" do
       it "should have the right proxy terms" do
-        subject.image_fedora_pid.should include "hypatia:coll_img_file_asset_fixture"
-        subject.image_ds_label.should include "my_image.jpg"
-        subject.image_size.should include "302080"
-        subject.image_md5.should include "789"
-        subject.image_sha1.should include "666"
+        expect(subject.image_fedora_pid).to include "hypatia:coll_img_file_asset_fixture"
+        expect(subject.image_ds_label).to include "my_image.jpg"
+        expect(subject.image_size).to include "302080"
+        expect(subject.image_md5).to include "789"
+        expect(subject.image_sha1).to include "666"
       end
     end
   end

data/spec/integration/querying_documents_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "Rspec tests for QUERYING_DOCUMENTS.textile" do
+describe "Rspec tests for QUERYING_DOCUMENTS.md" do
 
   before(:all) do
     @xml_file = "mods_articles/hydrangea_article1.xml"
@@ -11,31 +11,26 @@ describe "Rspec tests for QUERYING_DOCUMENTS.textile" do
   end
 
   it "xpath_for()" do
-    @term.xpath_for(:name).should == 
-      '//oxns:name'
-    @term.xpath_for(:person).should == 
-      '//oxns:name[@type="personal"]'
-    @term.xpath_for(:organization).should == 
-      '//oxns:name[@type="corporate"]'
-    @term.xpath_for(:person, :first_name).should ==
-      '//oxns:name[@type="personal"]/oxns:namePart[@type="given"]'
-    @term.xpath_for(:journal, :issue, :pages, :start).should ==
-      '//oxns:relatedItem[@type="host"]/oxns:part/oxns:extent[@unit="pages"]/oxns:start'
+    expect(@term.xpath_for(:name)).to eq '//oxns:name'
+    expect(@term.xpath_for(:person)).to eq '//oxns:name[@type="personal"]'
+    expect(@term.xpath_for(:organization)).to eq '//oxns:name[@type="corporate"]'
+    expect(@term.xpath_for(:person, :first_name)).to eq '//oxns:name[@type="personal"]/oxns:namePart[@type="given"]'
+    expect(@term.xpath_for(:journal, :issue, :pages, :start)).to eq '//oxns:relatedItem[@type="host"]/oxns:part/oxns:extent[@unit="pages"]/oxns:start'
   end
 
   it "term_values()" do
-    @doc.term_values(:person, :first_name).should == ["GIVEN NAMES", "Siddartha"]
-    @doc.term_values(:person, :last_name).should == ["FAMILY NAME", "Gautama"]
-    @doc.term_values(:organization, :namePart).should == ['NSF']
-    @doc.term_values(:journal, :issue, :pages, :start).should == ['195']
-    @doc.term_values(:journal, :title_info, :main_title).should == ["TITLE OF HOST JOURNAL"]
+    expect(@doc.term_values(:person, :first_name)).to eq ["GIVEN NAMES", "Siddartha"]
+    expect(@doc.term_values(:person, :last_name)).to eq ["FAMILY NAME", "Gautama"]
+    expect(@doc.term_values(:organization, :namePart)).to eq ['NSF']
+    expect(@doc.term_values(:journal, :issue, :pages, :start)).to eq ['195']
+    expect(@doc.term_values(:journal, :title_info, :main_title)).to eq ["TITLE OF HOST JOURNAL"]
   end
 
   it "xpath_for(): relative vs absolute" do
     xp_rel = '//oxns:titleInfo/oxns:title'
     xp_abs = '//oxns:mods/oxns:titleInfo/oxns:title'
-    @term.xpath_for(       :title_info, :main_title).should == xp_rel
-    @term.xpath_for(:mods, :title_info, :main_title).should == xp_abs
+    expect(@term.xpath_for(       :title_info, :main_title)).to eq xp_rel
+    expect(@term.xpath_for(:mods, :title_info, :main_title)).to eq xp_abs
   end
 
   it "term_values(): relative vs absolute" do
@@ -45,16 +40,16 @@ describe "Rspec tests for QUERYING_DOCUMENTS.textile" do
       "TITLE OF HOST JOURNAL",
     ]
     xp_abs = '//oxns:mods/oxns:titleInfo/oxns:title'
-    @doc.term_values(       :title_info, :main_title).should == exp
-    @doc.term_values(:mods, :title_info, :main_title).should == exp[0..1]
+    expect(@doc.term_values(       :title_info, :main_title)).to eq exp
+    expect(@doc.term_values(:mods, :title_info, :main_title)).to eq exp[0..1]
   end
 
   it "find_by_terms()" do
     exp_xml_role  = '<role><roleTerm authority="marcrelator" type="text">funder</roleTerm></role>'
     exp_xml_start = '<start>195</start>'
-    @doc.find_by_terms(:organization, :role).class.should == Nokogiri::XML::NodeSet
-    @doc.find_by_terms(:organization, :role).to_xml.should be_equivalent_to exp_xml_role
-    @doc.find_by_terms(:journal, :issue, :pages, :start).to_xml.should == exp_xml_start
+    expect(@doc.find_by_terms(:organization, :role).class).to eq Nokogiri::XML::NodeSet
+    expect(@doc.find_by_terms(:organization, :role).to_xml).to be_equivalent_to exp_xml_role
+    expect(@doc.find_by_terms(:journal, :issue, :pages, :start).to_xml).to eq exp_xml_start
   end
 
   it "find_by_terms() error" do
@@ -63,10 +58,8 @@ describe "Rspec tests for QUERYING_DOCUMENTS.textile" do
   end
 
   it "proxies" do
-    @term.xpath_for(:title).should ==
-      '//oxns:titleInfo/oxns:title'
-    @term.xpath_for(:journal_title)
-      '//oxns:relatedItem[@type="host"]/oxns:titleInfo/oxns:title'
+    expect(@term.xpath_for(:title)).to eq '//oxns:titleInfo/oxns:title'
+    expect(@term.xpath_for(:journal_title)).to eq'//oxns:relatedItem[@type="host"]/oxns:titleInfo/oxns:title'
   end
 
 end

data/spec/integration/rights_metadata_integration_example_spec.rb

@@ -66,10 +66,10 @@ describe "OM::XML::Accessors" do
   describe "update_properties" do
     it "should update the declared properties" do
       skip "nesting is too deep..."
-      @sample.retrieve(*[:edit_access, :machine, :person]).length.should == 0
-      @sample.update_properties([:edit_access, :machine, :person]=>"user id").should == {"edit_access_machine_person"=>{"-1"=>"user id"}}
-      @sample.retrieve(*[:edit_access, :machine, :person]).length.should == 1
-      @sample.retrieve(*[:edit_access, :machine, :person]).first.text.should == "user id"
+      expect(@sample.retrieve(*[:edit_access, :machine, :person]).length).to eq 0
+      expect(@sample.update_properties([:edit_access, :machine, :person]=>"user id")).to eq({"edit_access_machine_person"=>{"-1"=>"user id"}})
+      expect(@sample.retrieve(*[:edit_access, :machine, :person]).length).to eq  1
+      expect(@sample.retrieve(*[:edit_access, :machine, :person]).first.text).to eq "user id"
     end
   end
   

data/spec/integration/selective_querying_spec.rb

@@ -83,7 +83,7 @@ describe "Selecting nodes based on (a) position in hierarchy and (b) attributes"
       [ 'inner_note_a',     %w(                    i3a i4a) ],
       [ 'inner_note_not_a', %w(              i1 i2        ) ],
     ]
-    tests.each { |meth, exp| @doc.send(meth).should == exp }
+    tests.each { |meth, exp| expect(@doc.send(meth)).to eq exp }
   end
 
 end

data/spec/integration/serialization_spec.rb

@@ -35,16 +35,16 @@ EOF
     subject { datastream } 
     describe "reading  values" do
       it "should deserialize date" do
-        subject.my_date.should == [Date.parse('2012-10-30')]
+        expect(subject.my_date).to eq [Date.parse('2012-10-30')]
       end
       it "should deserialize time" do
-        subject.my_time.should == [DateTime.parse('2012-10-30T12:22:33Z')]
+        expect(subject.my_time).to eq [DateTime.parse('2012-10-30T12:22:33Z')]
       end
       it "should deserialize ints" do
-        subject.my_int.should == [7]
+        expect(subject.my_int).to eq [7]
       end
       it "should deserialize boolean" do
-        subject.active.should == [true]
+        expect(subject.active).to eq [true]
       end
     end
     describe "Writing to xml" do
@@ -52,7 +52,7 @@ EOF
         context "with a valid time" do
           subject { datastream.to_xml }
           before { datastream.my_time = [DateTime.parse('2011-01-30T03:45:15Z')] }
-          it { should be_equivalent_to '<?xml version="1.0"?>
+          it { is_expected.to be_equivalent_to '<?xml version="1.0"?>
            <outer outerId="hypatia:outer" type="outer type">
              <my_date>2012-10-30</my_date>
              <my_time>2011-01-30T03:45:15Z</my_time>
@@ -77,7 +77,7 @@ EOF
         context "with a valid date" do
 
           before { datastream.my_date = [Date.parse('2012-09-22')] }
-          it { should be_equivalent_to '<?xml version="1.0"?>
+          it { is_expected.to be_equivalent_to '<?xml version="1.0"?>
            <outer outerId="hypatia:outer" type="outer type">
              <my_date>2012-09-22</my_date>
              <my_time>2012-10-30T12:22:33Z</my_time>
@@ -89,7 +89,7 @@ EOF
 
       it "should serialize ints" do
         subject.my_int = [9]
-        subject.to_xml.should be_equivalent_to '<?xml version="1.0"?>
+        expect(subject.to_xml).to be_equivalent_to '<?xml version="1.0"?>
          <outer outerId="hypatia:outer" type="outer type">
            <my_date>2012-10-30</my_date>
            <my_time>2012-10-30T12:22:33Z</my_time>
@@ -99,7 +99,7 @@ EOF
       end
       it "should serialize boolean" do
         subject.active = [false]
-        subject.to_xml.should be_equivalent_to '<?xml version="1.0"?>
+        expect(subject.to_xml).to be_equivalent_to '<?xml version="1.0"?>
          <outer outerId="hypatia:outer" type="outer type">
            <my_date>2012-10-30</my_date>
            <my_time>2012-10-30T12:22:33Z</my_time>
@@ -122,19 +122,19 @@ EOF
     end
     describe "reading  values" do
       it "should deserialize date" do
-        subject.my_date.should == [nil]
+        expect(subject.my_date).to eq [nil]
       end
       it "should deserialize ints" do
-        subject.my_int.should == [nil]
+        expect(subject.my_int).to eq [nil]
       end
       it "should deserialize bools" do
-        subject.active.should == [false]
+        expect(subject.active).to eq [false]
       end
     end
     describe "Writing to xml" do
       it "should serialize date" do
         subject.my_date = [Date.parse('2012-09-22')]
-        subject.to_xml.should be_equivalent_to '<?xml version="1.0"?>
+        expect(subject.to_xml).to be_equivalent_to '<?xml version="1.0"?>
          <outer outerId="hypatia:outer" type="outer type">
            <my_date>2012-09-22</my_date>
            <my_int></my_int>
@@ -143,7 +143,7 @@ EOF
       end
       it "should serialize ints" do
         subject.my_int = [9]
-        subject.to_xml.should be_equivalent_to '<?xml version="1.0"?>
+        expect(subject.to_xml).to be_equivalent_to '<?xml version="1.0"?>
          <outer outerId="hypatia:outer" type="outer type">
            <my_date></my_date>
            <my_int>9</my_int>
@@ -152,7 +152,7 @@ EOF
       end
       it "should serialize booleans" do
         subject.active = [true]
-        subject.to_xml.should be_equivalent_to '<?xml version="1.0"?>
+        expect(subject.to_xml).to be_equivalent_to '<?xml version="1.0"?>
          <outer outerId="hypatia:outer" type="outer type">
            <my_date></my_date>
            <my_int></my_int>
@@ -163,7 +163,7 @@ EOF
         subject.my_int = [nil]
         subject.my_date = [nil]
         subject.active = [nil]
-        subject.to_xml.should be_equivalent_to '<?xml version="1.0"?>
+        expect(subject.to_xml).to be_equivalent_to '<?xml version="1.0"?>
          <outer outerId="hypatia:outer" type="outer type">
          </outer>'
       end

data/spec/integration/set_reentrant_terminology_spec.rb

@@ -21,7 +21,7 @@ describe "calling set_terminology more than once" do
     end
 
     it "can get foo" do
-      subject.foo.should == ['fooval']
+      expect(subject.foo).to eq ['fooval']
     end
 
     it "cannot get bar" do
@@ -51,7 +51,7 @@ describe "calling set_terminology more than once" do
     end
 
     it "can now get bar" do
-      subject.bar.should == ['barval']
+      expect(subject.bar).to eq ['barval']
     end
 
   end
@@ -80,11 +80,11 @@ describe "calling set_terminology more than once" do
     end
 
     it "can get foo" do
-      subject.foo.should == ['fooval']
+      expect(subject.foo).to eq ['fooval']
     end
 
     it "can get bar" do
-      subject.bar.should == ['barval']
+      expect(subject.bar).to eq ['barval']
     end
 
   end
@@ -122,11 +122,11 @@ describe "calling set_terminology more than once" do
     end
 
     it "can get foo" do
-      subject.foo.should == ['fooval']
+      expect(subject.foo).to eq ['fooval']
     end
 
     it "can get bar" do
-      subject.bar.should == ['barval']
+      expect(subject.bar).to eq ['barval']
     end
 
   end

data/spec/integration/subclass_terminology_spec.rb

@@ -31,12 +31,12 @@ describe "Inherited terminology" do
 
       it "should inherit terminology" do
         subject.foo = "Test value"
-        subject.foo.should == ["Test value"]
+        expect(subject.foo).to eq ["Test value"]
       end
 
       it "should have extended terminology" do
         subject.bar = "Test value"
-        subject.bar.should == ["Test value"]
+        expect(subject.bar).to eq ["Test value"]
       end
     end
 
@@ -48,7 +48,7 @@ describe "Inherited terminology" do
 
       it "should have terminology" do
         subject.foo = "Test value"
-        subject.foo.should == ["Test value"]
+        expect(subject.foo).to eq ["Test value"]
       end
 
       it "should not have extended terminology" do
@@ -99,14 +99,14 @@ describe "Inherited terminology" do
 
       it "should inherit templates" do
         subject.add_child_node subject.ng_xml.root, :creator, 'Test author', 'Primary' 
-        subject.ng_xml.xpath('//pbcoreCreator/creatorRole[@source="PBCore creatorRole"]').text.should == "Primary"
+        expect(subject.ng_xml.xpath('//pbcoreCreator/creatorRole[@source="PBCore creatorRole"]').text).to eq "Primary"
       end
 
       it "should inherit but not extend its parent's templates" do
-        OtherConcreteTerminology.template_registry.should have_node_type(:creator)
-        OtherConcreteTerminology.template_registry.should have_node_type(:foo)
-        AbstractTerminology.template_registry.should_not have_node_type(:foo)
-        ConcreteTerminology.template_registry.should_not have_node_type(:foo)
+        expect(OtherConcreteTerminology.template_registry).to have_node_type(:creator)
+        expect(OtherConcreteTerminology.template_registry).to have_node_type(:foo)
+        expect(AbstractTerminology.template_registry).not_to have_node_type(:foo)
+        expect(ConcreteTerminology.template_registry).not_to have_node_type(:foo)
       end
     end
   end

data/spec/integration/xpathy_stuff_spec.rb

@@ -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
 
 
@@ -121,14 +121,14 @@ describe "an example of xpath-y stuff, also using :proxy and :ref and namespaces
 
     it "should have the terms :author_given and :author_family to get the author name" do
       skip "This doesn't seem to work?"
-      subject.author_given.should include("Mary")
-      subject.author_family.should include("Pickral")
+      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
       skip "This doesn't seem to work?"
-      subject.advisor_given.should include("David")
-      subject.advisor_family.should include("Small")
+      expect(subject.advisor_given).to include("David")
+      expect(subject.advisor_family).to include("Small")
     end
 
   end
@@ -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/unit/container_spec.rb

@@ -1,80 +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
-    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.should_receive(:parse).and_return("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.should_receive(:parse).and_return("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.should_receive(:to_xml).and_return("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 = double("new node")
-      doc.root.should_receive(:add_child).with(subject.ng_xml.root).and_return(mock_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 = double("new node")
-      mock_new_node.stub(:to_xml).and_return("foo")
-      
+      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.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)
+      skip "Test not fully implemented"
+      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)
+      # expect(subject.to_xml(doc)).to be_equivalent_to
+      # expect(subject.to_xml(el )).to be_equivalent_to
     end
   end
-  
+
 end