active-fedora 6.7.8 → 6.8.0

data/spec/integration/relation_delegation_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 describe ActiveFedora::Model do
-  
-  before(:all) do 
+
+  before(:all) do
     module ModelIntegrationSpec
       class Basic < ActiveFedora::Base
-        has_metadata :name => "properties", :type => ActiveFedora::SimpleDatastream do |m|
-          m.field "foo", :string
-          m.field "bar", :string
-          m.field "baz", :string
+        has_metadata :name => 'properties', :type => ActiveFedora::SimpleDatastream do |m|
+          m.field 'foo', :string
+          m.field 'bar', :string
+          m.field 'baz', :string
         end
 
         delegate_to :properties, [:foo, :bar, :baz], multiple: true
@@ -18,50 +18,48 @@ describe ActiveFedora::Model do
           doc[ActiveFedora::SolrService.solr_name('foo', :sortable)] = doc[ActiveFedora::SolrService.solr_name('foo', type: :string)]
           doc
         end
-      
+
       end
     end
 
   end
-  
+
   after(:all) do
     Object.send(:remove_const, :ModelIntegrationSpec)
   end
 
 
-  describe "with multiple objects" do
-    let!(:instance1){ ModelIntegrationSpec::Basic.create!(:foo=>'Beta', :bar=>'Chips')}
-    let!(:instance2){ ModelIntegrationSpec::Basic.create!(:foo=>'Alpha', :bar=>'Peanuts')}
-    let!(:instance3){ ModelIntegrationSpec::Basic.create!(:foo=>'Sigma', :bar=>'Peanuts')}
+  describe 'with multiple objects' do
+    let!(:instance1){ ModelIntegrationSpec::Basic.create!(:foo => 'Beta', :bar => 'Chips')}
+    let!(:instance2){ ModelIntegrationSpec::Basic.create!(:foo => 'Alpha', :bar => 'Peanuts')}
+    let!(:instance3){ ModelIntegrationSpec::Basic.create!(:foo => 'Sigma', :bar => 'Peanuts')}
 
     after { ModelIntegrationSpec::Basic.delete_all }
 
     subject { ModelIntegrationSpec::Basic.where(bar: 'Peanuts') }
 
-    it "should map" do
-      subject.map(&:id).should == [instance2.id, instance3.id]
+    it 'should map' do
+      expect(subject.map(&:id)).to eq([instance2.id, instance3.id])
     end
 
-    it "should collect" do
-      subject.collect(&:id).should == [instance2.id, instance3.id]
+    it 'should collect' do
+      expect(subject.collect(&:id)).to eq([instance2.id, instance3.id])
     end
 
-    it "should have each" do
+    it 'should have each' do
       t = double
-      t.should_receive(:foo).twice
+      expect(t).to receive(:foo).twice
       subject.each { t.foo }
     end
 
-    it "should have all?" do
-      expect(subject.all? { |t| t.foo == ['Alpha']}).to be_false
-      expect(subject.all? { |t| t.bar == ['Peanuts']}).to be_true
+    it 'should have all?' do
+      expect(subject.all? { |t| t.foo == ['Alpha']}).to be_falsey
+      expect(subject.all? { |t| t.bar == ['Peanuts']}).to be_truthy
     end
 
-    it "should have include?" do
-      expect(subject.include?(instance1)).to be_false
-      expect(subject.include?(instance2)).to be_true
+    it 'should have include?' do
+      expect(subject.include?(instance1)).to be_falsey
+      expect(subject.include?(instance2)).to be_truthy
     end
   end
 end
-
-

data/spec/integration/rels_ext_datastream_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 require 'active_fedora'
-require "rexml/document"
+require 'rexml/document'
 
 
 describe ActiveFedora::RelsExtDatastream do
-  
+
   before(:all) do
-    @sample_relationships_hash = Hash.new(:is_member_of => ["info:fedora/demo:5", "info:fedora/demo:10"])
+    @sample_relationships_hash = Hash.new(:is_member_of => ['info:fedora/demo:5', 'info:fedora/demo:10'])
     @sample_xml_string = <<-EOS
     <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
       <rdf:Description rdf:about="info:fedora/changeme:475">
@@ -16,17 +16,17 @@ describe ActiveFedora::RelsExtDatastream do
       </rdf:Description>
     </rdf:RDF>
     EOS
-  
+
     @sample_xml = REXML::Document.new(@sample_xml_string)
   end
-  
+
   before(:each) do
     @test_object = ActiveFedora::Base.new
     @test_datastream = ActiveFedora::RelsExtDatastream.new(@test_object.inner_object, 'RELS-EXT')
     @test_datastream.model = @test_object
     @test_object.save
   end
-  
+
   after(:each) do
     begin
     @test_object.delete
@@ -49,34 +49,34 @@ describe ActiveFedora::RelsExtDatastream do
     rescue
     end
   end
-  
-  
+
+
   describe '#serialize!' do
-    
-    it "should generate new rdf/xml as the datastream content" do
+
+    it 'should generate new rdf/xml as the datastream content' do
       @test_object.add_datastream(@test_datastream)
-      @test_object.add_relationship(:is_member_of, "info:fedora/demo:5")
-      @test_object.add_relationship(:is_member_of, "info:fedora/demo:10")
+      @test_object.add_relationship(:is_member_of, 'info:fedora/demo:5')
+      @test_object.add_relationship(:is_member_of, 'info:fedora/demo:10')
       rexml1 = REXML::Document.new(@test_datastream.to_rels_ext())
       @test_datastream.serialize!
-      rexml2 = REXML::Document.new(@test_object.datastreams["RELS-EXT"].content)
-      rexml1.root.elements["rdf:Description"].inspect.should eql(rexml2.root.elements["rdf:Description"].inspect)
+      rexml2 = REXML::Document.new(@test_object.datastreams['RELS-EXT'].content)
+      expect(rexml1.root.elements['rdf:Description'].inspect).to eql(rexml2.root.elements['rdf:Description'].inspect)
     end
-  
+
   end
-  
-  it "should load relationships from fedora into parent object" do
+
+  it 'should load relationships from fedora into parent object' do
     class SpecNode; include ActiveFedora::SemanticNode; end
-    ActiveFedora::Predicates.predicate_mappings[ActiveFedora::Predicates.default_predicate_namespace].each_key do |p| 
+    ActiveFedora::Predicates.predicate_mappings[ActiveFedora::Predicates.default_predicate_namespace].each_key do |p|
       @test_object.add_relationship(p, "info:fedora/demo:#{rand(100)}")
     end
     @test_object.save
     # make sure that _something_ was actually added to the object's relationships hash
-    @test_object.ids_for_outbound(:is_member_of).size.should == 1
+    expect(@test_object.ids_for_outbound(:is_member_of).size).to eq(1)
     new_rels = ActiveFedora::Base.find(@test_object.pid).relationships
     # This stopped working, need to push an issue into the rdf library. (when dumping ntriples, the order of assertions changed)
     #new_rels.should == @test_object.relationships
-    new_rels.dump(:rdfxml).should == @test_object.relationships.dump(:rdfxml)
+    expect(new_rels.dump(:rdfxml)).to eq(@test_object.relationships.dump(:rdfxml))
   end
 
 end

data/spec/integration/scoped_query_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
-describe "scoped queries" do
-  
-  before(:each) do 
+describe 'scoped queries' do
+
+  before(:each) do
     module ModelIntegrationSpec
       class Basic < ActiveFedora::Base
-        has_metadata :name => "properties", :type => ActiveFedora::SimpleDatastream do |m|
-          m.field "foo", :string
-          m.field "bar", :string
-          m.field "baz", :string
+        has_metadata :name => 'properties', :type => ActiveFedora::SimpleDatastream do |m|
+          m.field 'foo', :string
+          m.field 'bar', :string
+          m.field 'baz', :string
         end
 
         delegate_to :properties, [:foo, :bar, :baz], multiple: true
@@ -18,81 +18,80 @@ describe "scoped queries" do
           doc[ActiveFedora::SolrService.solr_name('foo', :sortable)] = doc[ActiveFedora::SolrService.solr_name('foo', type: :string)]
           doc
         end
-      
+
       end
     end
 
   end
-  
+
   after(:each) do
     Object.send(:remove_const, :ModelIntegrationSpec)
   end
 
 
-  describe "When there is one object in the store" do
+  describe 'When there is one object in the store' do
     let!(:test_instance) { ModelIntegrationSpec::Basic.create!()}
 
     after do
       test_instance.delete
     end
-    
-    describe ".all" do
-      it "should return an array of instances of the calling Class" do
+
+    describe '.all' do
+      it 'should return an array of instances of the calling Class' do
         result = ModelIntegrationSpec::Basic.all
-        result.should be_instance_of(Array)
+        expect(result).to be_instance_of(Array)
         # this test is meaningless if the array length is zero
-        result.length.should > 0
+        expect(result.length).to be > 0
         result.each do |obj|
-          obj.class.should == ModelIntegrationSpec::Basic
+          expect(obj.class).to eq(ModelIntegrationSpec::Basic)
         end
       end
     end
 
-    describe ".first" do
-      it "should return one instance of the calling class" do
-        ModelIntegrationSpec::Basic.first.should == test_instance
+    describe '.first' do
+      it 'should return one instance of the calling class' do
+        expect(ModelIntegrationSpec::Basic.first).to eq(test_instance)
       end
     end
   end
 
-  describe "with multiple objects" do
-    let!(:test_instance1) { ModelIntegrationSpec::Basic.create!(:foo=>'Beta', :bar=>'Chips')}
-    let!(:test_instance2) { ModelIntegrationSpec::Basic.create!(:foo=>'Alpha', :bar=>'Peanuts')}
-    let!(:test_instance3) { ModelIntegrationSpec::Basic.create!(:foo=>'Sigma', :bar=>'Peanuts')}
+  describe 'with multiple objects' do
+    let!(:test_instance1) { ModelIntegrationSpec::Basic.create!(:foo => 'Beta', :bar => 'Chips')}
+    let!(:test_instance2) { ModelIntegrationSpec::Basic.create!(:foo => 'Alpha', :bar => 'Peanuts')}
+    let!(:test_instance3) { ModelIntegrationSpec::Basic.create!(:foo => 'Sigma', :bar => 'Peanuts')}
 
     after do
       test_instance1.delete
       test_instance2.delete
       test_instance3.delete
     end
-    it "should query" do
-      ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('foo', type: :string)=> 'Beta').should == [test_instance1]
-      ModelIntegrationSpec::Basic.where('foo' => 'Beta').should == [test_instance1]
+    it 'should query' do
+      expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('foo', type: :string) => 'Beta')).to eq([test_instance1])
+      expect(ModelIntegrationSpec::Basic.where('foo' => 'Beta')).to eq([test_instance1])
     end
-    it "should order" do
-      ModelIntegrationSpec::Basic.order(ActiveFedora::SolrService.solr_name('foo', :sortable) + ' asc').should == [test_instance2, test_instance1, test_instance3]
+    it 'should order' do
+      expect(ModelIntegrationSpec::Basic.order(ActiveFedora::SolrService.solr_name('foo', :sortable) + ' asc')).to eq([test_instance2, test_instance1, test_instance3])
     end
-    it "should limit" do
-      ModelIntegrationSpec::Basic.limit(1).should == [test_instance1]
+    it 'should limit' do
+      expect(ModelIntegrationSpec::Basic.limit(1)).to eq([test_instance1])
     end
 
-    it "should chain queries" do
-      ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').order(ActiveFedora::SolrService.solr_name('foo', :sortable) + ' asc').limit(1).should == [test_instance2]
+    it 'should chain queries' do
+      expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').order(ActiveFedora::SolrService.solr_name('foo', :sortable) + ' asc').limit(1)).to eq([test_instance2])
     end
 
-    it "should chain count" do
-      ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').count.should == 2 
+    it 'should chain count' do
+      expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').count).to eq(2)
     end
 
     describe "when one of the objects in solr isn't in fedora" do
-      it "should log an error" do
-        ModelIntegrationSpec::Basic.should_receive(:find_one).with(test_instance1.pid, nil).and_call_original
-        ModelIntegrationSpec::Basic.should_receive(:find_one).with(test_instance2.pid, nil).and_raise(ActiveFedora::ObjectNotFoundError)
-        ModelIntegrationSpec::Basic.should_receive(:find_one).with(test_instance3.pid, nil).and_call_original
-        ActiveFedora::Relation.logger.should_receive(:error).with("When trying to find_each #{test_instance2.pid}, encountered an ObjectNotFoundError. Solr may be out of sync with Fedora")
-        ModelIntegrationSpec::Basic.all.should == [test_instance1, test_instance3]
+      it 'should log an error' do
+        expect(ModelIntegrationSpec::Basic).to receive(:find_one).with(test_instance1.pid, nil).and_call_original
+        expect(ModelIntegrationSpec::Basic).to receive(:find_one).with(test_instance2.pid, nil).and_raise(ActiveFedora::ObjectNotFoundError)
+        expect(ModelIntegrationSpec::Basic).to receive(:find_one).with(test_instance3.pid, nil).and_call_original
+        expect(ActiveFedora::Relation.logger).to receive(:error).with("When trying to find_each #{test_instance2.pid}, encountered an ObjectNotFoundError. Solr may be out of sync with Fedora")
+        expect(ModelIntegrationSpec::Basic.all).to eq([test_instance1, test_instance3])
       end
     end
   end
 end
-

data/spec/integration/solr_instance_loader_spec.rb

@@ -22,14 +22,14 @@ describe ActiveFedora::SolrInstanceLoader do
       end
     end
     describe 'with matching solr document' do
-      let(:solr_doc) { ActiveFedora::Base.find_with_conditions(:id=>pid).first }
+      let(:solr_doc) { ActiveFedora::Base.find_with_conditions(:id => pid).first }
       it 'it casts the SOLR document and casts into an AF::Base object' do
         expect(subject.object).to eq(active_fedora_object)
       end
     end
     describe 'with a mismatching solr document' do
       let(:mismatching_pid) { @test_object2.pid }
-      let(:solr_doc) { ActiveFedora::Base.find_with_conditions(:id=>mismatching_pid).first }
+      let(:solr_doc) { ActiveFedora::Base.find_with_conditions(:id => mismatching_pid).first }
       it 'it raise ObjectNotFoundError' do
         expect {
           subject
@@ -47,7 +47,7 @@ describe ActiveFedora::SolrInstanceLoader do
       end
     end
     describe 'with matching solr document' do
-      let(:solr_doc) { ActiveFedora::Base.find_with_conditions(:id=>pid).first }
+      let(:solr_doc) { ActiveFedora::Base.find_with_conditions(:id => pid).first }
       it 'it raise ObjectNotFoundError' do
         expect {
           subject.object
@@ -56,7 +56,7 @@ describe ActiveFedora::SolrInstanceLoader do
     end
     describe 'with a mismatching solr document' do
       let(:mismatching_pid) { @test_object2.pid }
-      let(:solr_doc) { ActiveFedora::Base.find_with_conditions(:id=>mismatching_pid).first }
+      let(:solr_doc) { ActiveFedora::Base.find_with_conditions(:id => mismatching_pid).first }
       it 'it raise ObjectNotFoundError' do
         expect {
           subject

data/spec/integration/solr_service_spec.rb

@@ -3,23 +3,23 @@ require 'spec_helper'
 require 'active_fedora'
 
 describe ActiveFedora::SolrService do
-  describe "#reify_solr_results" do
+  describe '#reify_solr_results' do
     before(:all) do
       class FooObject < ActiveFedora::Base
         def self.pid_namespace
-          "foo"
+          'foo'
         end
-  
-        has_metadata :name => "descMetadata", :type => ActiveFedora::QualifiedDublinCoreDatastream
+
+        has_metadata :name => 'descMetadata', :type => ActiveFedora::QualifiedDublinCoreDatastream
       end
       @test_object = ActiveFedora::Base.new
       @test_object.label = 'test_object'
       @foo_object = FooObject.new
       @foo_object.label = 'foo_object'
-      attributes = {"language"=>{0=>"Italian"},
-                    "creator"=>{0=>"Linguist, A."},
-                    "geography"=>{0=>"Italy"},
-                    "title"=>{0=>"Italian and Spanish: A Comparison of Common Phrases"}}
+      attributes = {'language' => {0 => 'Italian'},
+                    'creator' => {0 => 'Linguist, A.'},
+                    'geography' => {0 => 'Italy'},
+                    'title' => {0 => 'Italian and Spanish: A Comparison of Common Phrases'}}
       @foo_object.descMetadata.update_indexed_attributes(attributes)
       @test_object.save
       @foo_object.save
@@ -35,78 +35,78 @@ describe ActiveFedora::SolrService do
       @foo_object.delete
       Object.send(:remove_const, :FooObject)
     end
-    it "should return an array of objects that are of the class stored in active_fedora_model_s" do
+    it 'should return an array of objects that are of the class stored in active_fedora_model_s' do
       query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@test_object.pid)} OR id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
       solr_result = ActiveFedora::SolrService.query(query)
       result = ActiveFedora::SolrService.reify_solr_results(solr_result)
-      result.length.should == 2
+      expect(result.length).to eq(2)
       result.each do |r|
-        (r.class == ActiveFedora::Base || r.class == FooObject).should be_true
+        expect(r.class == ActiveFedora::Base || r.class == FooObject).to be_truthy
       end
     end
-    
+
     it 'should load objects from solr data if a :load_from_solr option is passed in' do
       query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@test_object.pid)} OR id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
       solr_result = ActiveFedora::SolrService.query(query)
-      result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
-      result.length.should == 2
+      result = ActiveFedora::SolrService.reify_solr_results(solr_result, {:load_from_solr => true})
+      expect(result.length).to eq(2)
       result.each do |r|
-        r.inner_object.should be_a(ActiveFedora::SolrDigitalObject)
-        [ActiveFedora::Base, FooObject].should include(r.class)
-        ['test_object','foo_object'].should include(r.label)
-        @test_object.inner_object.profile.should == @profiles['test']
-        @foo_object.inner_object.profile.should == @profiles['foo']
-        @foo_object.datastreams['descMetadata'].profile.should == @profiles['foo_descMetadata']
-        @foo_object.datastreams['descMetadata'].content.should be_equivalent_to(@foo_content)
+        expect(r.inner_object).to be_a(ActiveFedora::SolrDigitalObject)
+        expect([ActiveFedora::Base, FooObject]).to include(r.class)
+        expect(['test_object', 'foo_object']).to include(r.label)
+        expect(@test_object.inner_object.profile).to eq(@profiles['test'])
+        expect(@foo_object.inner_object.profile).to eq(@profiles['foo'])
+        expect(@foo_object.datastreams['descMetadata'].profile).to eq(@profiles['foo_descMetadata'])
+        expect(@foo_object.datastreams['descMetadata'].content).to be_equivalent_to(@foo_content)
       end
     end
-    
+
     it 'should instantiate all datastreams in the solr doc, even ones undeclared by the class' do
-      obj = ActiveFedora::Base.load_instance_from_solr @foo_object.pid 
-      obj.datastreams.keys.should include('descMetadata')
+      obj = ActiveFedora::Base.load_instance_from_solr @foo_object.pid
+      expect(obj.datastreams.keys).to include('descMetadata')
     end
-    
+
     it 'should #reify a lightweight object as a new instance' do
       query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
       solr_result = ActiveFedora::SolrService.query(query)
-      result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
+      result = ActiveFedora::SolrService.reify_solr_results(solr_result, {:load_from_solr => true})
       solr_foo = result.first
       real_foo = solr_foo.reify
-      solr_foo.inner_object.should be_a(ActiveFedora::SolrDigitalObject)
-      real_foo.inner_object.should be_a(ActiveFedora::DigitalObject)
-      solr_foo.label.should == 'foo_object'
-      real_foo.label.should == 'foo_object'
+      expect(solr_foo.inner_object).to be_a(ActiveFedora::SolrDigitalObject)
+      expect(real_foo.inner_object).to be_a(ActiveFedora::DigitalObject)
+      expect(solr_foo.label).to eq('foo_object')
+      expect(real_foo.label).to eq('foo_object')
     end
-    
+
     it 'should #reify! a lightweight object within the same instance' do
       query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
       solr_result = ActiveFedora::SolrService.query(query)
-      result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
+      result = ActiveFedora::SolrService.reify_solr_results(solr_result, {:load_from_solr => true})
       solr_foo = result.first
-      solr_foo.inner_object.should be_a(ActiveFedora::SolrDigitalObject)
+      expect(solr_foo.inner_object).to be_a(ActiveFedora::SolrDigitalObject)
       solr_foo.reify!
-      solr_foo.inner_object.should be_a(ActiveFedora::DigitalObject)
-      solr_foo.label.should == 'foo_object'
+      expect(solr_foo.inner_object).to be_a(ActiveFedora::DigitalObject)
+      expect(solr_foo.label).to eq('foo_object')
     end
-    
+
     it 'should raise an exception when attempting to reify a first-class object' do
       query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
       solr_result = ActiveFedora::SolrService.query(query)
-      result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
+      result = ActiveFedora::SolrService.reify_solr_results(solr_result, {:load_from_solr => true})
       solr_foo = result.first
-      lambda {solr_foo.reify}.should_not raise_exception
-      lambda {solr_foo.reify!}.should_not raise_exception
-      lambda {solr_foo.reify!}.should raise_exception(/already a full/)
-      lambda {solr_foo.reify}.should raise_exception(/already a full/)
+      expect {solr_foo.reify}.not_to raise_exception
+      expect {solr_foo.reify!}.not_to raise_exception
+      expect {solr_foo.reify!}.to raise_exception(/already a full/)
+      expect {solr_foo.reify}.to raise_exception(/already a full/)
     end
-  
+
     it 'should call load_instance_from_solr if :load_from_solr option passed in' do
       query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@test_object.pid)} OR id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
       solr_result = ActiveFedora::SolrService.query(query)
-      ActiveFedora::Base.should_receive(:load_instance_from_solr).once
-      FooObject.should_receive(:load_instance_from_solr).once
-      result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
+      expect(ActiveFedora::Base).to receive(:load_instance_from_solr).once
+      expect(FooObject).to receive(:load_instance_from_solr).once
+      result = ActiveFedora::SolrService.reify_solr_results(solr_result, {:load_from_solr => true})
     end
-    
+
   end
 end