active-fedora 6.7.8 → 6.8.0

data/spec/integration/om_datastream_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
-require "solrizer"
+require 'solrizer'
 
 describe ActiveFedora::OmDatastream do
-  
-  describe "a new instance with an inline datastream" do
-    before(:all) do 
+
+  describe 'a new instance with an inline datastream' do
+    before(:all) do
       class ModsArticle3 < ActiveFedora::Base
         # Uses the Hydra MODS Article profile for tracking most of the descriptive metadata
-        has_metadata "descMetadata", type: Hydra::ModsArticleDatastream, control_group: 'X', autocreate: true
+        has_metadata 'descMetadata', type: Hydra::ModsArticleDatastream, control_group: 'X', autocreate: true
       end
     end
 
@@ -25,38 +25,38 @@ describe ActiveFedora::OmDatastream do
       @obj.destroy
     end
 
-    it "should report being inline" do
-      @obj.descMetadata.should be_inline
+    it 'should report being inline' do
+      expect(@obj.descMetadata).to be_inline
     end
 
-    it "should not be changed when no fields have been set" do
-      @obj.descMetadata.should_not be_content_changed
+    it 'should not be changed when no fields have been set' do
+      expect(@obj.descMetadata).not_to be_content_changed
     end
-    it "should be changed when a field has been set" do
+    it 'should be changed when a field has been set' do
       @obj.descMetadata.title = 'Foobar'
-      @obj.descMetadata.should be_content_changed
+      expect(@obj.descMetadata).to be_content_changed
     end
-    describe "#changed?" do
-      it "should not be changed if the new xml matches the old xml" do
+    describe '#changed?' do
+      it 'should not be changed if the new xml matches the old xml' do
         @obj.descMetadata.content = @obj.descMetadata.content
-        @obj.descMetadata.should_not be_changed
+        expect(@obj.descMetadata).not_to be_changed
       end
 
-      it "should not be changed if there are minor differences in whitespace" do
-        @obj.descMetadata.content = "<a><b>1</b></a>"
+      it 'should not be changed if there are minor differences in whitespace' do
+        @obj.descMetadata.content = '<a><b>1</b></a>'
         @obj.save
-        @obj.descMetadata.should_not be_changed
+        expect(@obj.descMetadata).not_to be_changed
         @obj.descMetadata.content = "<a>\n<b>1</b>\n</a>"
-        @obj.descMetadata.should_not be_changed
+        expect(@obj.descMetadata).not_to be_changed
       end
     end
   end
 
-  describe "an instance that is a managed datastream" do
+  describe 'an instance that is a managed datastream' do
     before(:all) do
       class ModsArticle2 < ActiveFedora::Base
         # Uses the Hydra MODS Article profile for tracking most of the descriptive metadata
-        has_metadata "descMetadata", type: Hydra::ModsArticleDatastream, autocreate: true
+        has_metadata 'descMetadata', type: Hydra::ModsArticleDatastream, autocreate: true
       end
     end
 
@@ -74,28 +74,28 @@ describe ActiveFedora::OmDatastream do
       @obj.destroy
     end
 
-    it "should not report being inline" do
-      @obj.descMetadata.should be_managed
+    it 'should not report being inline' do
+      expect(@obj.descMetadata).to be_managed
     end
 
-    describe "#changed?" do
-      it "should not be changed if the new xml matches the old xml" do
+    describe '#changed?' do
+      it 'should not be changed if the new xml matches the old xml' do
         @obj.descMetadata.content = @obj.descMetadata.content
-        @obj.descMetadata.should_not be_changed
+        expect(@obj.descMetadata).not_to be_changed
       end
 
-      it "should be changed if there are minor differences in whitespace" do
-        @obj.descMetadata.content = "<a><b>1</b></a>"
+      it 'should be changed if there are minor differences in whitespace' do
+        @obj.descMetadata.content = '<a><b>1</b></a>'
         @obj.save
-        @obj.descMetadata.should_not be_changed
+        expect(@obj.descMetadata).not_to be_changed
         @obj.descMetadata.content = "<a>\n<b>1</b>\n</a>"
-        @obj.descMetadata.should be_changed
+        expect(@obj.descMetadata).to be_changed
       end
     end
 
-    describe "empty datastream content" do
-      it "should not break when there is empty datastream content" do
-        @obj.descMetadata.content = ""
+    describe 'empty datastream content' do
+      it 'should not break when there is empty datastream content' do
+        @obj.descMetadata.content = ''
         @obj.save
       end
     end
@@ -108,35 +108,35 @@ describe ActiveFedora::OmDatastream do
         @solr_obj = ActiveFedora::Base.load_instance_from_solr(@obj.pid)
       end
 
-      it "should return the same values whether getting from solr or Fedora" do
-        @solr_obj.datastreams["descMetadata"].term_values(:name,:role,:text).should == ["Creator","Contributor","Funder","Host"]
-        @solr_obj.datastreams["descMetadata"].term_values({:name=>0},:role,:text).should == ["Creator"]
-        @solr_obj.datastreams["descMetadata"].term_values({:name=>1},:role,:text).should == ["Contributor"]
-        @solr_obj.datastreams["descMetadata"].term_values({:name=>0},{:role=>0},:text).should == ["Creator"]
-        @solr_obj.datastreams["descMetadata"].term_values({:name=>1},{:role=>0},:text).should == ["Contributor"]
-        @solr_obj.datastreams["descMetadata"].term_values({:name=>1},{:role=>1},:text).should == []
-        ar = @solr_obj.datastreams["descMetadata"].term_values(:name,{:role=>0},:text)
-        ar.length.should == 4
-        ar.include?("Creator").should == true
-        ar.include?("Contributor").should == true
-        ar.include?("Funder").should == true
-        ar.include?("Host").should == true
-
-        @obj.datastreams["descMetadata"].term_values(:name,:role,:text).should == ["Creator","Contributor","Funder","Host"]
-        @obj.datastreams["descMetadata"].term_values({:name=>0},:role,:text).should == ["Creator"]
-        @obj.datastreams["descMetadata"].term_values({:name=>1},:role,:text).should == ["Contributor"]
-        @obj.datastreams["descMetadata"].term_values({:name=>0},{:role=>0},:text).should == ["Creator"]
-        @obj.datastreams["descMetadata"].term_values({:name=>1},{:role=>0},:text).should == ["Contributor"]
-        @obj.datastreams["descMetadata"].term_values({:name=>1},{:role=>1},:text).should == []
-        ar = @obj.datastreams["descMetadata"].term_values(:name,{:role=>0},:text)
-        ar.length.should == 4
-        ar.include?("Creator").should == true
-        ar.include?("Contributor").should == true
-        ar.include?("Funder").should == true
-        ar.include?("Host").should == true
+      it 'should return the same values whether getting from solr or Fedora' do
+        expect(@solr_obj.datastreams['descMetadata'].term_values(:name, :role, :text)).to eq(['Creator', 'Contributor', 'Funder', 'Host'])
+        expect(@solr_obj.datastreams['descMetadata'].term_values({:name => 0}, :role, :text)).to eq(['Creator'])
+        expect(@solr_obj.datastreams['descMetadata'].term_values({:name => 1}, :role, :text)).to eq(['Contributor'])
+        expect(@solr_obj.datastreams['descMetadata'].term_values({:name => 0}, {:role => 0}, :text)).to eq(['Creator'])
+        expect(@solr_obj.datastreams['descMetadata'].term_values({:name => 1}, {:role => 0}, :text)).to eq(['Contributor'])
+        expect(@solr_obj.datastreams['descMetadata'].term_values({:name => 1}, {:role => 1}, :text)).to eq([])
+        ar = @solr_obj.datastreams['descMetadata'].term_values(:name, {:role => 0}, :text)
+        expect(ar.length).to eq(4)
+        expect(ar.include?('Creator')).to eq(true)
+        expect(ar.include?('Contributor')).to eq(true)
+        expect(ar.include?('Funder')).to eq(true)
+        expect(ar.include?('Host')).to eq(true)
+
+        expect(@obj.datastreams['descMetadata'].term_values(:name, :role, :text)).to eq(['Creator', 'Contributor', 'Funder', 'Host'])
+        expect(@obj.datastreams['descMetadata'].term_values({:name => 0}, :role, :text)).to eq(['Creator'])
+        expect(@obj.datastreams['descMetadata'].term_values({:name => 1}, :role, :text)).to eq(['Contributor'])
+        expect(@obj.datastreams['descMetadata'].term_values({:name => 0}, {:role => 0}, :text)).to eq(['Creator'])
+        expect(@obj.datastreams['descMetadata'].term_values({:name => 1}, {:role => 0}, :text)).to eq(['Contributor'])
+        expect(@obj.datastreams['descMetadata'].term_values({:name => 1}, {:role => 1}, :text)).to eq([])
+        ar = @obj.datastreams['descMetadata'].term_values(:name, {:role => 0}, :text)
+        expect(ar.length).to eq(4)
+        expect(ar.include?('Creator')).to eq(true)
+        expect(ar.include?('Contributor')).to eq(true)
+        expect(ar.include?('Funder')).to eq(true)
+        expect(ar.include?('Host')).to eq(true)
       end
     end
-    
+
     describe '.update_values' do
       before do
         @obj.descMetadata.content = File.read(fixture('mods_articles/mods_article1.xml'))
@@ -144,24 +144,24 @@ describe ActiveFedora::OmDatastream do
         @obj.reload
       end
 
-      it "should not be dirty after .update_values is saved" do
-        @obj.datastreams["descMetadata"].update_values([{:name=>0},{:role=>0},:text] =>"Funder")
-        @obj.datastreams["descMetadata"].should be_changed
+      it 'should not be dirty after .update_values is saved' do
+        @obj.datastreams['descMetadata'].update_values([{:name => 0}, {:role => 0}, :text] => 'Funder')
+        expect(@obj.datastreams['descMetadata']).to be_changed
         @obj.save
-        @obj.datastreams["descMetadata"].should_not be_changed
-        @obj.datastreams["descMetadata"].term_values({:name=>0},{:role=>0},:text).should == ["Funder"]
-      end    
+        expect(@obj.datastreams['descMetadata']).not_to be_changed
+        expect(@obj.datastreams['descMetadata'].term_values({:name => 0}, {:role => 0}, :text)).to eq(['Funder'])
+      end
     end
 
 
-    describe ".to_solr" do
+    describe '.to_solr' do
       before do
         @obj.descMetadata.journal.issue.publication_date = Date.parse('2012-11-02')
         @obj.save!
         @obj.reload
       end
       it "should solrize terms with :type=>'date' to *_dt solr terms" do
-        @obj.to_solr[ActiveFedora::SolrService.solr_name('journal_issue_publication_date', type: :date)].should == ['2012-11-02T00:00:00Z']
+        expect(@obj.to_solr[ActiveFedora::SolrService.solr_name('journal_issue_publication_date', type: :date)]).to eq(['2012-11-02T00:00:00Z'])
       end
     end
   end

data/spec/integration/persistence_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe "persisting objects" do
+describe 'persisting objects' do
   before :all do
     class MockAFBaseRelationship < ActiveFedora::Base
-      has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"foo" do |m|
-        m.field "name", :string
+      has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'foo' do |m|
+        m.field 'name', :string
       end
       delegate :name, to: 'foo', multiple: false
       validates :name, presence: true
@@ -14,9 +14,9 @@ describe "persisting objects" do
     Object.send(:remove_const, :MockAFBaseRelationship)
   end
 
-  describe "#create!" do
-    it "should validate" do
-      lambda { MockAFBaseRelationship.create!}.should raise_error ActiveFedora::RecordInvalid, "Validation failed: Name can't be blank"
+  describe '#create!' do
+    it 'should validate' do
+      expect { MockAFBaseRelationship.create!}.to raise_error ActiveFedora::RecordInvalid, "Validation failed: Name can't be blank"
     end
   end
 end

data/spec/integration/rdf_nested_attributes_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe "Nesting attribute behavior of RDFDatastream" do
-  describe ".attributes=" do
-    describe "complex properties" do
-      before do 
-        class DummyMADS < RDF::Vocabulary("http://www.loc.gov/mads/rdf/v1#")
+describe 'Nesting attribute behavior of RDFDatastream' do
+  describe '.attributes=' do
+    describe 'complex properties' do
+      before do
+        class DummyMADS < RDF::Vocabulary('http://www.loc.gov/mads/rdf/v1#')
           # componentList and Types of components
           property :componentList
           property :Topic
@@ -12,8 +12,8 @@ describe "Nesting attribute behavior of RDFDatastream" do
           property :PersonalName
           property :CorporateName
           property :ComplexSubject
-          
-          
+
+
           # elementList and elementList values
           property :elementList
           property :elementValue
@@ -26,8 +26,8 @@ describe "Nesting attribute behavior of RDFDatastream" do
 
         class ComplexRDFDatastream < ActiveFedora::NtriplesRDFDatastream
           map_predicates do |map|
-            map.topic(in: DummyMADS, to: "Topic", class_name:"Topic")
-            map.personalName(in: DummyMADS, to: "PersonalName", class_name:"PersonalName")
+            map.topic(in: DummyMADS, to: 'Topic', class_name: 'Topic')
+            map.personalName(in: DummyMADS, to: 'PersonalName', class_name: 'PersonalName')
             map.title(in: RDF::DC)
           end
 
@@ -36,15 +36,15 @@ describe "Nesting attribute behavior of RDFDatastream" do
           class Topic
             include ActiveFedora::RdfObject
             map_predicates do |map|
-              map.elementList(in: DummyMADS, class_name:"ComplexRDFDatastream::ElementList")
+              map.elementList(in: DummyMADS, class_name: 'ComplexRDFDatastream::ElementList')
             end
             accepts_nested_attributes_for :elementList
           end
           class PersonalName
             include ActiveFedora::RdfObject
             map_predicates do |map|
-              map.elementList(in: DummyMADS, to: "elementList", class_name:"ComplexRDFDatastream::ElementList")
-              map.extraProperty(in: DummyMADS, to: "elementValue", class_name:"ComplexRDFDatastream::Topic")
+              map.elementList(in: DummyMADS, to: 'elementList', class_name: 'ComplexRDFDatastream::ElementList')
+              map.extraProperty(in: DummyMADS, to: 'elementValue', class_name: 'ComplexRDFDatastream::Topic')
             end
             accepts_nested_attributes_for :elementList, :extraProperty
           end
@@ -52,11 +52,11 @@ describe "Nesting attribute behavior of RDFDatastream" do
             include ActiveFedora::RdfList
             rdf_type DummyMADS.elementList
             map_predicates do |map|
-              map.topicElement(in: DummyMADS, to: "TopicElement", :class_name => "MadsTopicElement")
-              map.temporalElement(in: DummyMADS, to: "TemporalElement")
-              map.fullNameElement(in: DummyMADS, to: "FullNameElement")
-              map.dateNameElement(in: DummyMADS, to: "DateNameElement")
-              map.nameElement(in: DummyMADS, to: "NameElement")
+              map.topicElement(in: DummyMADS, to: 'TopicElement', :class_name => 'MadsTopicElement')
+              map.temporalElement(in: DummyMADS, to: 'TemporalElement')
+              map.fullNameElement(in: DummyMADS, to: 'FullNameElement')
+              map.dateNameElement(in: DummyMADS, to: 'DateNameElement')
+              map.nameElement(in: DummyMADS, to: 'NameElement')
               map.elementValue(in: DummyMADS)
             end
             accepts_nested_attributes_for :topicElement
@@ -74,58 +74,58 @@ describe "Nesting attribute behavior of RDFDatastream" do
         Object.send(:remove_const, :ComplexRDFDatastream)
         Object.send(:remove_const, :DummyMADS)
       end
-      subject { ComplexRDFDatastream.new(double('inner object', :pid=>'foo', :new_record? =>true), 'descMetadata') }
-      let(:params) do 
-        { myResource: 
+      subject { ComplexRDFDatastream.new(double('inner object', :pid => 'foo', :new_record? => true), 'descMetadata') }
+      let(:params) do
+        { myResource:
           {
             topic_attributes: {
               '0' =>
               {
                 elementList_attributes: [{
-                  topicElement_attributes: [{elementValue:"Cosmology"}]
+                  topicElement_attributes: [{elementValue: 'Cosmology'}]
                   }]
               },
               '1' =>
               {
                 elementList_attributes: [{
-                  topicElement_attributes: {'0' => {elementValue:"Quantum Behavior"}}
+                  topicElement_attributes: {'0' => {elementValue: 'Quantum Behavior'}}
                 }]
               }
             },
             personalName_attributes: [
-              { 
+              {
                 elementList_attributes: [{
-                  fullNameElement: "Jefferson, Thomas",
-                  dateNameElement: "1743-1826"                  
+                  fullNameElement: 'Jefferson, Thomas',
+                  dateNameElement: '1743-1826'
                 }]
-              } 
+              }
               #, "Hemings, Sally"
-            ],
+            ]
           }
         }
       end
 
-      describe "on lists" do
-        subject { ComplexRDFDatastream::PersonalName.new(RDF::Graph.new) } 
-        it "should accept a hash" do
-          subject.elementList_attributes =  [{ topicElement_attributes: {'0' => { elementValue:"Quantum Behavior" }, '1' => { elementValue:"Wave Function" }}}]
-          subject.elementList.first[0].elementValue.should == ["Quantum Behavior"]
-          subject.elementList.first[1].elementValue.should == ["Wave Function"]
+      describe 'on lists' do
+        subject { ComplexRDFDatastream::PersonalName.new(RDF::Graph.new) }
+        it 'should accept a hash' do
+          subject.elementList_attributes =  [{ topicElement_attributes: {'0' => { elementValue: 'Quantum Behavior' }, '1' => { elementValue: 'Wave Function' }}}]
+          expect(subject.elementList.first[0].elementValue).to eq(['Quantum Behavior'])
+          expect(subject.elementList.first[1].elementValue).to eq(['Wave Function'])
 
         end
-        it "should accept an array" do
-          subject.elementList_attributes =  [{ topicElement_attributes: [{ elementValue:"Quantum Behavior" }, { elementValue:"Wave Function" }]}]
-          subject.elementList.first[0].elementValue.should == ["Quantum Behavior"]
-          subject.elementList.first[1].elementValue.should == ["Wave Function"]
+        it 'should accept an array' do
+          subject.elementList_attributes =  [{ topicElement_attributes: [{ elementValue: 'Quantum Behavior' }, { elementValue: 'Wave Function' }]}]
+          expect(subject.elementList.first[0].elementValue).to eq(['Quantum Behavior'])
+          expect(subject.elementList.first[1].elementValue).to eq(['Wave Function'])
         end
       end
 
-      it "should create nested objects" do
+      it 'should create nested objects' do
           # Replace the graph's contents with the Hash
           subject.attributes = params[:myResource]
 
           # Here's how this would happen if we didn't have attributes=
-          # personal_name = subject.personalName.build 
+          # personal_name = subject.personalName.build
           # elem_list = personal_name.elementList.build
           # elem_list.fullNameElement = "Jefferson, Thomas"
           # elem_list.dateNameElement = "1743-1826"
@@ -133,35 +133,35 @@ describe "Nesting attribute behavior of RDFDatastream" do
           # elem_list = topic.elementList.build
           # elem_list.fullNameElement = 'Cosmology'
 
-          subject.topic[0].elementList.first[0].elementValue.should == ["Cosmology"]
-          subject.topic[1].elementList.first[0].elementValue.should == ["Quantum Behavior"]
-          subject.personalName.first.elementList.first.fullNameElement.should == ["Jefferson, Thomas"]
-          subject.personalName.first.elementList.first.dateNameElement.should == ["1743-1826"]
+          expect(subject.topic[0].elementList.first[0].elementValue).to eq(['Cosmology'])
+          expect(subject.topic[1].elementList.first[0].elementValue).to eq(['Quantum Behavior'])
+          expect(subject.personalName.first.elementList.first.fullNameElement).to eq(['Jefferson, Thomas'])
+          expect(subject.personalName.first.elementList.first.dateNameElement).to eq(['1743-1826'])
       end
     end
 
-    describe "with an existing object" do
-      before(:each) do 
+    describe 'with an existing object' do
+      before(:each) do
         class SpecDatastream < ActiveFedora::NtriplesRDFDatastream
           map_predicates do |map|
-            map.parts(:in=> RDF::DC, :to=>'hasPart', :class_name=>'Component')
+            map.parts(:in => RDF::DC, :to => 'hasPart', :class_name => 'Component')
           end
           accepts_nested_attributes_for :parts, allow_destroy: true
 
           class Component
             include ActiveFedora::RdfObject
             map_predicates do |map|
-              map.label(:in=> RDF::DC, :to=>'title')
+              map.label(:in => RDF::DC, :to => 'title')
             end
           end
         end
 
       end
-      
+
       after(:each) do
         Object.send(:remove_const, :SpecDatastream)
       end
-      subject { SpecDatastream.new(double('inner object', :pid=>'foo', :new_record? =>true), 'descMetadata') }
+      subject { SpecDatastream.new(double('inner object', :pid => 'foo', :new_record? => true), 'descMetadata') }
       before do
         subject.attributes = { parts_attributes: [
                                   {label: 'Alternator'},
@@ -172,16 +172,16 @@ describe "Nesting attribute behavior of RDFDatastream" do
       let (:replace_object_id) { subject.parts[1].rdf_subject.to_s }
       let (:remove_object_id) { subject.parts[3].rdf_subject.to_s }
 
-      it "should update nested objects" do
-        subject.parts_attributes= [{id: replace_object_id, label: "Universal Joint"}, {label:"Oil Pump"}, {id: remove_object_id, _destroy: '1', label: "bar1 uno"}]
+      it 'should update nested objects' do
+        subject.parts_attributes = [{id: replace_object_id, label: 'Universal Joint'}, {label: 'Oil Pump'}, {id: remove_object_id, _destroy: '1', label: 'bar1 uno'}]
 
-        subject.parts.map{|p| p.label.first}.should == ['Alternator', 'Universal Joint', 'Transmission', 'Oil Pump']
+        expect(subject.parts.map{|p| p.label.first}).to eq(['Alternator', 'Universal Joint', 'Transmission', 'Oil Pump'])
 
       end
-      it "create a new object when the id is provided" do
-       subject.parts_attributes= [{id: 'http://example.com/part#1', label: "Universal Joint"}]
-       subject.parts.last.rdf_subject.should == 'http://example.com/part#1'
+      it 'create a new object when the id is provided' do
+       subject.parts_attributes = [{id: 'http://example.com/part#1', label: 'Universal Joint'}]
+       expect(subject.parts.last.rdf_subject).to eq('http://example.com/part#1')
       end
-    end    
+    end
   end
 end