active-fedora 6.7.8 → 6.8.0

data/spec/unit/rdf_datastream_spec.rb

@@ -2,12 +2,19 @@
 require 'spec_helper'
 
 describe ActiveFedora::RDFDatastream do
-  describe "a new instance" do
-    its(:metadata?) { should be_true}
-    its(:content_changed?) { should be_false}
+  describe 'a new instance' do
+    describe '#metadata?' do
+      subject { super().metadata? }
+      it { is_expected.to be_truthy}
+    end
+
+    describe '#content_changed?' do
+      subject { super().content_changed? }
+      it { is_expected.to be_falsey}
+    end
   end
   describe "an instance that exists in the datastore, but hasn't been loaded" do
-    before do 
+    before do
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
         map_predicates do |map|
           map.title(in: RDF::DC)
@@ -26,43 +33,43 @@ describe ActiveFedora::RDFDatastream do
       Object.send(:remove_const, :MyDatastream)
       Object.send(:remove_const, :MyObj)
     end
-    subject { @obj.reload.descMetadata } 
-    it "should not load the descMetadata datastream when calling content_changed?" do
-      @obj.inner_object.repository.should_not_receive(:datastream_dissemination).with(hash_including(:dsid=>'descMetadata'))
-      subject.should_not be_content_changed
+    subject { @obj.reload.descMetadata }
+    it 'should not load the descMetadata datastream when calling content_changed?' do
+      expect(@obj.inner_object.repository).not_to receive(:datastream_dissemination).with(hash_including(:dsid => 'descMetadata'))
+      expect(subject).not_to be_content_changed
     end
 
-    it "should allow asserting an empty string" do
+    it 'should allow asserting an empty string' do
       subject.title = ['']
-      subject.title.should == ['']
+      expect(subject.title).to eq([''])
     end
 
-    describe "when multivalue: false" do
-      it "should return single values" do
+    describe 'when multivalue: false' do
+      it 'should return single values' do
         subject.description = 'my description'
-        subject.description.should == 'my description'
+        expect(subject.description).to eq('my description')
       end
     end
 
-    it "should clear stuff" do
+    it 'should clear stuff' do
       subject.title = ['one', 'two', 'three']
       subject.title.clear
-      subject.graph.query([subject.rdf_subject,  RDF::DC.title, nil]).first.should be_nil
+      expect(subject.graph.query([subject.rdf_subject,  RDF::DC.title, nil]).first).to be_nil
     end
 
-    it "should have a list of fields" do
-      MyDatastream.fields.should == [:title, :description]
+    it 'should have a list of fields' do
+      expect(MyDatastream.fields).to eq([:title, :description])
     end
   end
 
-  describe "deserialize" do
-    it "should be able to handle non-utf-8 characters" do
+  describe 'deserialize' do
+    it 'should be able to handle non-utf-8 characters' do
       # see https://github.com/ruby-rdf/rdf/issues/142
       ds = ActiveFedora::NtriplesRDFDatastream.new
       data = "<info:fedora/scholarsphere:qv33rx50r> <http://purl.org/dc/terms/description> \"\\n\xE2\x80\x99 \" .\n".force_encoding('ASCII-8BIT')
-      
+
       result = ds.deserialize(data)
-      result.dump(:ntriples).should == "<info:fedora/scholarsphere:qv33rx50r> <http://purl.org/dc/terms/description> \"\\n’ \" .\n"
+      expect(result.dump(:ntriples)).to eq("<info:fedora/scholarsphere:qv33rx50r> <http://purl.org/dc/terms/description> \"\\n’ \" .\n")
     end
   end
 end

data/spec/unit/rdf_list_nested_attributes_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe ActiveFedora::RdfList do
   before :each do
-    class MADS < RDF::Vocabulary("http://www.loc.gov/mads/rdf/v1#")
+    class MADS < RDF::Vocabulary('http://www.loc.gov/mads/rdf/v1#')
       property :MADSScheme
       property :isMemberOfMADSScheme
       property :authoritativeLabel
@@ -18,22 +18,22 @@ describe ActiveFedora::RdfList do
       include ActiveFedora::RdfObject
       rdf_type MADS.TopicElement
       map_predicates do |map|
-        map.elementValue(:in=> MADS)
+        map.elementValue(:in => MADS)
       end
     end
     class TemporalElement
       include ActiveFedora::RdfObject
       rdf_type MADS.TemporalElement
       map_predicates do |map|
-        map.elementValue(:in=> MADS)
+        map.elementValue(:in => MADS)
       end
     end
     class ElementList
       include ActiveFedora::RdfList
-      
+
       map_predicates do |map|
-        map.topicElement(:in=> MADS, :to =>"TopicElement", :class_name => "TopicElement")
-        map.temporalElement(:in=> MADS, :to =>"TemporalElement", :class_name => "TemporalElement")
+        map.topicElement(:in => MADS, :to => 'TopicElement', :class_name => 'TopicElement')
+        map.temporalElement(:in => MADS, :to => 'TemporalElement', :class_name => 'TemporalElement')
       end
       accepts_nested_attributes_for :topicElement, :temporalElement
     end
@@ -44,7 +44,7 @@ describe ActiveFedora::RdfList do
       rdf_subject { |ds| RDF::URI.new(Rails.configuration.id_namespace + ds.pid)}
       map_predicates do |map|
         map.name(:in => MADS, :to => 'authoritativeLabel')
-        map.elementList(:in => MADS, :class_name=>'ElementList')
+        map.elementList(:in => MADS, :class_name => 'ElementList')
         map.externalAuthority(:in => MADS, :to => 'hasExactExternalAuthority')
       end
       accepts_nested_attributes_for :elementList
@@ -57,15 +57,15 @@ describe ActiveFedora::RdfList do
     Object.send(:remove_const, :TemporalElement)
     Object.send(:remove_const, :MADS)
   end
-  
-  describe "nested_attributes" do
-    it "should insert new nodes into RdfLists (rather than calling .build)" do
+
+  describe 'nested_attributes' do
+    it 'should insert new nodes into RdfLists (rather than calling .build)' do
       params = {
         topic: {
-          name: "Baseball",
-          externalAuthority: "http://id.loc.gov/authorities/subjects/sh85012026",
+          name: 'Baseball',
+          externalAuthority: 'http://id.loc.gov/authorities/subjects/sh85012026',
           elementList_attributes: [
-            topicElement_attributes: [{ elementValue: "Baseball" }, elementValue: "Football"],
+            topicElement_attributes: [{ elementValue: 'Baseball' }, elementValue: 'Football']
           ]
         }
       }
@@ -73,25 +73,25 @@ describe ActiveFedora::RdfList do
       topic = Topic.new(RDF::Graph.new)
       topic.attributes = params[:topic]
       # puts topic.graph.dump(:ntriples)
-      topic.elementList.first.size.should == 2
-      topic.elementList.first[0].should be_kind_of(TopicElement)
-      topic.elementList.first[0].elementValue.should == ["Baseball"]
-      topic.elementList.first[1].should be_kind_of(TopicElement)
-      topic.elementList.first[1].elementValue.should == ["Football"]
+      expect(topic.elementList.first.size).to eq(2)
+      expect(topic.elementList.first[0]).to be_kind_of(TopicElement)
+      expect(topic.elementList.first[0].elementValue).to eq(['Baseball'])
+      expect(topic.elementList.first[1]).to be_kind_of(TopicElement)
+      expect(topic.elementList.first[1].elementValue).to eq(['Football'])
 
       # only one rdf:rest rdf:nil
-      topic.graph.query([nil, RDF.rest, RDF.nil]).size.should == 1 
+      expect(topic.graph.query([nil, RDF.rest, RDF.nil]).size).to eq(1)
     end
-    it "should insert new nodes of varying types into RdfLists (rather than calling .build)" do
-      # It's Not clear what the syntax should be when an RDF list contains multiple types of sub-nodes.  
+    it 'should insert new nodes of varying types into RdfLists (rather than calling .build)' do
+      # It's Not clear what the syntax should be when an RDF list contains multiple types of sub-nodes.
       # This is a guess, which currently works.
       params = {
         topic: {
-          name: "Baseball",
-          externalAuthority: "http://id.loc.gov/authorities/subjects/sh85012026",
+          name: 'Baseball',
+          externalAuthority: 'http://id.loc.gov/authorities/subjects/sh85012026',
           elementList_attributes: [
-            topicElement_attributes: [{ elementValue: "Baseball" }, elementValue: "Football"],
-            temporalElement_attributes: [{elementValue: "1960"}, {elementValue:"Twentieth Century"}],
+            topicElement_attributes: [{ elementValue: 'Baseball' }, elementValue: 'Football'],
+            temporalElement_attributes: [{elementValue: '1960'}, {elementValue: 'Twentieth Century'}]
           ]
         }
       }
@@ -99,15 +99,15 @@ describe ActiveFedora::RdfList do
       topic = Topic.new(RDF::Graph.new)
       topic.attributes = params[:topic]
       # puts topic.graph.dump(:ntriples)
-      topic.elementList.first.size.should == 4
-      topic.elementList.first[0].should be_kind_of(TopicElement)
-      topic.elementList.first[0].elementValue.should == ["Baseball"]
-      topic.elementList.first[1].should be_kind_of(TopicElement)
-      topic.elementList.first[1].elementValue.should == ["Football"]
-      topic.elementList.first[2].should be_kind_of(TemporalElement)
-      topic.elementList.first[2].elementValue.should == ["1960"]
-      topic.elementList.first[3].should be_kind_of(TemporalElement)
-      topic.elementList.first[3].elementValue.should == ["Twentieth Century"]
+      expect(topic.elementList.first.size).to eq(4)
+      expect(topic.elementList.first[0]).to be_kind_of(TopicElement)
+      expect(topic.elementList.first[0].elementValue).to eq(['Baseball'])
+      expect(topic.elementList.first[1]).to be_kind_of(TopicElement)
+      expect(topic.elementList.first[1].elementValue).to eq(['Football'])
+      expect(topic.elementList.first[2]).to be_kind_of(TemporalElement)
+      expect(topic.elementList.first[2].elementValue).to eq(['1960'])
+      expect(topic.elementList.first[3]).to be_kind_of(TemporalElement)
+      expect(topic.elementList.first[3].elementValue).to eq(['Twentieth Century'])
     end
   end
 end

data/spec/unit/rdf_list_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe ActiveFedora::RdfList do
   before :each do
-    class MADS < RDF::Vocabulary("http://www.loc.gov/mads/rdf/v1#")
+    class MADS < RDF::Vocabulary('http://www.loc.gov/mads/rdf/v1#')
       property :complexSubject
       property :authoritativeLabel
       property :elementList
@@ -12,27 +12,27 @@ describe ActiveFedora::RdfList do
     end
     class DemoList < ActiveFedora::RdfxmlRDFDatastream
       map_predicates do |map|
-        map.elementList(:in => MADS, :to => 'elementList', :class_name=>'List')
-      end 
-      class List 
+        map.elementList(:in => MADS, :to => 'elementList', :class_name => 'List')
+      end
+      class List
         include ActiveFedora::RdfList
         map_predicates do |map|
-          map.topicElement(:in=> MADS, :to =>"TopicElement", :class_name => "TopicElement")
-          map.temporalElement(:in=> MADS, :to =>"TemporalElement", :class_name => "TemporalElement")
+          map.topicElement(:in => MADS, :to => 'TopicElement', :class_name => 'TopicElement')
+          map.temporalElement(:in => MADS, :to => 'TemporalElement', :class_name => 'TemporalElement')
         end
-          
+
         class TopicElement
           include ActiveFedora::RdfObject
           rdf_type MADS.TopicElement
-          map_predicates do |map|   
-            map.elementValue(:in=> MADS)
+          map_predicates do |map|
+            map.elementValue(:in => MADS)
           end
         end
         class TemporalElement
           include ActiveFedora::RdfObject
           rdf_type MADS.TemporalElement
-          map_predicates do |map|   
-            map.elementValue(:in=> MADS)
+          map_predicates do |map|
+            map.elementValue(:in => MADS)
           end
         end
       end
@@ -43,102 +43,91 @@ describe ActiveFedora::RdfList do
     Object.send(:remove_const, :MADS)
   end
 
-  describe "a new list" do
-    let (:ds) { DemoList.new(double('inner object', :pid=>'foo', :new_record? =>true), 'descMetadata')}
+  describe 'a new list' do
+    let (:ds) { DemoList.new(double('inner object', :pid => 'foo', :new_record? => true), 'descMetadata')}
     subject { ds.elementList.build}
 
-    it "should insert at the end" do
-      subject.should be_kind_of DemoList::List
-      subject.size.should == 0
+    it 'should insert at the end' do
+      expect(subject).to be_kind_of DemoList::List
+      expect(subject.size).to eq(0)
       subject[1] = DemoList::List::TopicElement.new(subject.graph)
-      subject.size.should == 2
+      expect(subject.size).to eq(2)
     end
 
-    it "should insert at the head" do
-      subject.should be_kind_of DemoList::List
-      subject.size.should == 0
+    it 'should insert at the head' do
+      expect(subject).to be_kind_of DemoList::List
+      expect(subject.size).to eq(0)
       subject[0] = DemoList::List::TopicElement.new(subject.graph)
-      subject.size.should == 1
+      expect(subject.size).to eq(1)
     end
 
-    describe "that has 4 elements" do
+    describe 'that has 4 elements' do
       before do
         subject[3] = DemoList::List::TopicElement.new(subject.graph)
-        subject.size.should == 4
+        expect(subject.size).to eq(4)
       end
-      it "should insert in the middle" do
+      it 'should insert in the middle' do
         subject[1] = DemoList::List::TopicElement.new(subject.graph)
-        subject.size.should == 4
+        expect(subject.size).to eq(4)
       end
     end
 
-    describe "return updated xml" do
-      it "should be built" do
-        subject[0] = RDF::URI.new "http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"
+    describe 'return updated xml' do
+      it 'should be built' do
+        subject[0] = RDF::URI.new 'http://library.ucsd.edu/ark:/20775/bbXXXXXXX6'
         subject[1] = DemoList::List::TopicElement.new(ds.graph)
-        subject[1].elementValue = "Relations with Mexican Americans"
-        subject[2] = RDF::URI.new "http://library.ucsd.edu/ark:/20775/bbXXXXXXX4"
+        subject[1].elementValue = 'Relations with Mexican Americans'
+        subject[2] = RDF::URI.new 'http://library.ucsd.edu/ark:/20775/bbXXXXXXX4'
         subject[3] = DemoList::List::TemporalElement.new(ds.graph)
         subject[3].elementValue = "20th century"
-        expected_xml =<<END
-  <rdf:RDF
-      xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:mads="http://www.loc.gov/mads/rdf/v1#">
-      
-        <rdf:Description rdf:about="info:fedora/foo">
-          <mads:elementList rdf:parseType="Collection">
-            <rdf:Description rdf:about="http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"/>
-            <mads:TopicElement>
-              <mads:elementValue>Relations with Mexican Americans</mads:elementValue>
-            </mads:TopicElement>
-            <rdf:Description rdf:about="http://library.ucsd.edu/ark:/20775/bbXXXXXXX4"/>
-            <mads:TemporalElement>
-              <mads:elementValue>20th century</mads:elementValue>
-            </mads:TemporalElement>
-          </mads:elementList>
-        </rdf:Description>
-      </rdf:RDF>
-END
-        ds.content.should be_equivalent_to expected_xml
+        doc = Nokogiri::XML(ds.content)
+        ns = {rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#", mads: "http://www.loc.gov/mads/rdf/v1#"}
+        expect(doc.xpath('/rdf:RDF/rdf:Description/@rdf:about', ns).map(&:value)).to eq ["info:fedora/foo"]
+        expect(doc.xpath('//rdf:Description/mads:elementList/@rdf:parseType', ns).map(&:value)).to eq ["Collection"]
+        expect(doc.xpath('//rdf:Description/mads:elementList/*[position() = 1]/@rdf:about', ns).map(&:value)).to eq ["http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"]
+        expect(doc.xpath('//rdf:Description/mads:elementList/*[position() = 2]/mads:elementValue', ns).map(&:text)).to eq ["Relations with Mexican Americans"]
+        expect(doc.xpath('//rdf:Description/mads:elementList/*[position() = 3]/@rdf:about', ns).map(&:value)).to eq ["http://library.ucsd.edu/ark:/20775/bbXXXXXXX4"]
+        expect(doc.xpath('//rdf:Description/mads:elementList/*[position() = 4]/mads:elementValue', ns).map(&:text)).to eq ["20th century"]
       end
     end
 
 
   end
 
-  describe "an empty list" do
-    subject { DemoList.new(double('inner object', :pid=>'foo', :new_record? =>true)).elementList.build } 
-    it "should have to_ary" do
-      subject.to_ary.should == []
+  describe 'an empty list' do
+    subject { DemoList.new(double('inner object', :pid => 'foo', :new_record? => true)).elementList.build }
+    it 'should have to_ary' do
+      expect(subject.to_ary).to eq([])
     end
   end
 
-  describe "a list that has a constructed element" do
-    let(:ds) { DemoList.new(double('inner object', :pid=>'foo', :new_record? =>true)) }
-    let(:list) { ds.elementList.build } 
+  describe 'a list that has a constructed element' do
+    let(:ds) { DemoList.new(double('inner object', :pid => 'foo', :new_record? => true)) }
+    let(:list) { ds.elementList.build }
     let!(:topic) { list.topicElement.build }
-    
-    it "should have to_ary" do
-      list.to_ary.size.should == 1
-      list.to_ary.first.class.should == DemoList::List::TopicElement
+
+    it 'should have to_ary' do
+      expect(list.to_ary.size).to eq(1)
+      expect(list.to_ary.first.class).to eq(DemoList::List::TopicElement)
     end
 
-    it "should be able to be cleared" do
+    it 'should be able to be cleared' do
       list.topicElement.build
       list.topicElement.build
       list.topicElement.build
-      list.size.should == 4
+      expect(list.size).to eq(4)
       list.clear
-      list.size.should == 0
+      expect(list.size).to eq(0)
     end
   end
 
-  describe "a list with content" do
+  describe 'a list with content' do
     subject do
-      subject = DemoList.new(double('inner object', :pid=>'foo', :new_record? =>true), 'descMetadata')
-      subject.content =<<END
+      subject = DemoList.new(double('inner object', :pid => 'foo', :new_record? => true), 'descMetadata')
+      subject.content = <<END
   <rdf:RDF
       xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:mads="http://www.loc.gov/mads/rdf/v1#">
-      
+
         <mads:ComplexSubject rdf:about="info:fedora/foo">
           <mads:elementList rdf:parseType="Collection">
             <rdf:Description rdf:about="http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"/>
@@ -156,60 +145,47 @@ END
 
       subject
     end
-    it "should have a subject" do
-      subject.rdf_subject.to_s.should == "info:fedora/foo"
+    it 'should have a subject' do
+      expect(subject.rdf_subject.to_s).to eq('info:fedora/foo')
     end
 
     let (:list) { subject.elementList.first }
 
-    it "should have fields" do
-      list.first.should == "http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"
-      list[1].should be_kind_of DemoList::List::TopicElement
-      list[1].elementValue.should == ["Relations with Mexican Americans"]
-      list[2].should == "http://library.ucsd.edu/ark:/20775/bbXXXXXXX4"
-      list[3].should be_kind_of DemoList::List::TemporalElement
-      list[3].elementValue.should == ["20th century"]
+    it 'should have fields' do
+      expect(list.first).to eq('http://library.ucsd.edu/ark:/20775/bbXXXXXXX6')
+      expect(list[1]).to be_kind_of DemoList::List::TopicElement
+      expect(list[1].elementValue).to eq(['Relations with Mexican Americans'])
+      expect(list[2]).to eq('http://library.ucsd.edu/ark:/20775/bbXXXXXXX4')
+      expect(list[3]).to be_kind_of DemoList::List::TemporalElement
+      expect(list[3].elementValue).to eq(['20th century'])
     end
 
-    it "should have each" do
+    it 'should have each' do
       foo = []
       list.each { |n| foo << n.class }
-      foo.should == [RDF::URI, DemoList::List::TopicElement, RDF::URI, DemoList::List::TemporalElement]
+      expect(foo).to eq([RDF::URI, DemoList::List::TopicElement, RDF::URI, DemoList::List::TemporalElement])
     end
 
-    it "should have to_ary" do
+    it 'should have to_ary' do
       ary = list.to_ary
-      ary.size.should == 4
-      ary[1].elementValue.should == ['Relations with Mexican Americans']
+      expect(ary.size).to eq(4)
+      expect(ary[1].elementValue).to eq(['Relations with Mexican Americans'])
     end
 
-    it "should have size" do
-      list.size.should == 4
+    it 'should have size' do
+      expect(list.size).to eq(4)
     end
 
     it "should update fields" do
       list[3].elementValue = ["1900s"]
-      expected_xml =<<END
-  <rdf:RDF
-      xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:mads="http://www.loc.gov/mads/rdf/v1#">
-      
-        <mads:ComplexSubject rdf:about="info:fedora/foo">
-          <mads:elementList rdf:parseType="Collection">
-            <rdf:Description rdf:about="http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"/>
-            <mads:TopicElement>
-              <mads:elementValue>Relations with Mexican Americans</mads:elementValue>
-            </mads:TopicElement>
-            <rdf:Description rdf:about="http://library.ucsd.edu/ark:/20775/bbXXXXXXX4"/>
-            <mads:TemporalElement>
-              <mads:elementValue>1900s</mads:elementValue>
-            </mads:TemporalElement>
-          </mads:elementList>
-        </mads:ComplexSubject>
-      </rdf:RDF>
-
-END
-      subject.content.should be_equivalent_to expected_xml
+      doc = Nokogiri::XML(subject.content)
+      ns = {rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#", mads: "http://www.loc.gov/mads/rdf/v1#"}
+      expect(doc.xpath('/rdf:RDF/mads:ComplexSubject/@rdf:about', ns).map(&:value)).to eq ["info:fedora/foo"]
+      expect(doc.xpath('//mads:ComplexSubject/mads:elementList/@rdf:parseType', ns).map(&:value)).to eq ["Collection"]
+      expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 1]/@rdf:about', ns).map(&:value)).to eq ["http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"]
+      expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 2]/mads:elementValue', ns).map(&:text)).to eq ["Relations with Mexican Americans"]
+      expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 3]/@rdf:about', ns).map(&:value)).to eq ["http://library.ucsd.edu/ark:/20775/bbXXXXXXX4"]
+      expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 4]/mads:elementValue', ns).map(&:text)).to eq ["1900s"]
     end
   end
 end
-