active-fedora 8.2.1 → 8.2.2

data/spec/integration/delete_all_spec.rb

@@ -31,8 +31,8 @@ describe ActiveFedora::Base do
   describe ".destroy_all" do
     it "should remove both and run callbacks" do 
       SpecModel::Basic.destroy_all
-      SpecModel::Basic.count.should == 0 
-      SpecModel::Basic.callback_counter.should == 2
+      expect(SpecModel::Basic.count).to eq(0) 
+      expect(SpecModel::Basic.callback_counter).to eq(2)
     end
 
     describe "when a model is missing" do
@@ -48,7 +48,7 @@ describe ActiveFedora::Base do
       it "should be able to skip a missing model" do 
         expect(ActiveFedora::Base.logger).to receive(:error).with("Although #{pid} was found in Solr, it doesn't seem to exist in Fedora. The index is out of synch.")
         SpecModel::Basic.destroy_all
-        SpecModel::Basic.count.should == 1 
+        expect(SpecModel::Basic.count).to eq(1) 
       end
     end
   end
@@ -56,8 +56,8 @@ describe ActiveFedora::Base do
   describe ".delete_all" do
     it "should remove both and not run callbacks" do 
       SpecModel::Basic.delete_all
-      SpecModel::Basic.count.should == 0
-      SpecModel::Basic.callback_counter.should == 0
+      expect(SpecModel::Basic.count).to eq(0)
+      expect(SpecModel::Basic.callback_counter).to eq(0)
     end
   end
 end

data/spec/integration/fedora_solr_sync_spec.rb

@@ -23,6 +23,6 @@ describe "fedora_solr_sync_issues" do
   it "should not go into an infinite loop" do
     subject.inner_object.delete
     parent.reload
-    parent.things.should == []
+    expect(parent.things).to eq([])
   end
 end

data/spec/integration/full_featured_model_spec.rb

@@ -108,16 +108,16 @@ describe ActiveFedora::Base do
   end
   
   it "should be an instance of ActiveFedora::Base" do
-    @test_history.should be_kind_of(ActiveFedora::Base)
+    expect(@test_history).to be_kind_of(ActiveFedora::Base)
   end
   
 
   it "should create proxies to all the datastreams" do
     properties_ds = @test_history.datastreams["properties"]
     dublin_core_ds = @test_history.datastreams["dublin_core"]
-    @test_history.properties.should be properties_ds    
-    @test_history.should respond_to(:properties)
-    OralHistory.new.should respond_to(:properties)
+    expect(@test_history.properties).to be properties_ds    
+    expect(@test_history).to respond_to(:properties)
+    expect(OralHistory.new).to respond_to(:properties)
   end 
 
     
@@ -142,12 +142,12 @@ describe ActiveFedora::Base do
     @properties_sample_values.each_pair do |field, value|
       next if field == :hard_copy_availability #FIXME HYDRA-824
       next if field == :location #FIXME HYDRA-825 
-      (@solr_result[ActiveFedora::SolrService.solr_name(field, type: :string)] || @solr_result[ActiveFedora::SolrService.solr_name(field, type: :date)]).should == [::Solrizer::Extractor.format_node_value(value)] 
+      expect(@solr_result[ActiveFedora::SolrService.solr_name(field, type: :string)] || @solr_result[ActiveFedora::SolrService.solr_name(field, type: :date)]).to eq([::Solrizer::Extractor.format_node_value(value)]) 
     end
     
     @dublin_core_sample_values.each_pair do |field, value|
       next if [:format, :type].include?(field)  #format and type are methods declared on Object
-      dublin_core_ds.send("#{field.to_s}").should == [value]
+      expect(dublin_core_ds.send("#{field.to_s}")).to eq([value])
     end    
   end
   
@@ -158,19 +158,19 @@ describe ActiveFedora::Base do
     dublin_core_ds.subject = "My Subject Heading"
     dc_xml = REXML::Document.new(dublin_core_ds.to_xml)
     
-    dc_xml.root.elements["dcterms:subject"].text.should == "My Subject Heading"
+    expect(dc_xml.root.elements["dcterms:subject"].text).to eq("My Subject Heading")
     
   end
   
   it "should support #find_with_conditions" do
     solr_result = OralHistory.find_with_conditions({})
-    solr_result.should_not be_nil
+    expect(solr_result).not_to be_nil
   end
   
   describe '#new' do
     it "should support custom pids" do
       oh = OralHistory.new(:pid=>"uuid:blah-blah-blah")
-      oh.pid.should == "uuid:blah-blah-blah"
+      expect(oh.pid).to eq("uuid:blah-blah-blah")
     end
   end
   

data/spec/integration/has_and_belongs_to_many_associations_spec.rb

@@ -36,14 +36,14 @@ describe ActiveFedora::Base do
       end
       it "habtm should set and remove relationships bidirectionally" do
         @book.topics << @topic1
-        @book.topics.should == [@topic1]
-        @topic1.books.should == [@book]
-        @topic1.reload.books.should == [@book]
+        expect(@book.topics).to eq([@topic1])
+        expect(@topic1.books).to eq([@book])
+        expect(@topic1.reload.books).to eq([@book])
 
         @book.topics.delete(@topic1)
         #@topic1.books.delete(@book)
-        @book.topics.should == []
-        @topic1.books.should == []
+        expect(@book.topics).to eq([])
+        expect(@topic1.books).to eq([])
       end
       it "Should allow for more than 10 items" do
 
@@ -51,16 +51,16 @@ describe ActiveFedora::Base do
           @book.topics << Topic.create
         end
         @book.save
-        @book.topics.count.should == 12
+        expect(@book.topics.count).to eq(12)
         book2 = Book.find(@book.pid)
-        book2.topics.count.should == 12
+        expect(book2.topics.count).to eq(12)
       end
 
       it "Should find inherited objects along with base objects" do
         @book.topics << @topic1
         @special_book.topics << @topic1
-        @topic1.books.should == [@book, @special_book]
-        @topic1.reload.books.should == [@book, @special_book]
+        expect(@topic1.books).to eq([@book, @special_book])
+        expect(@topic1.reload.books).to eq([@book, @special_book])
       end
 
       it "Should cast found books to the correct cmodel" do
@@ -83,20 +83,20 @@ describe ActiveFedora::Base do
       end
       it "should set relationships bidirectionally" do
         @book.topics << @topic1
-        @book.topics.should == [@topic1]
-        @book.relationships(:has_topic).should == [@topic1.internal_uri]
-        @topic1.relationships(:has_topic).should == []
-        @topic1.relationships(:is_topic_of).should == [@book.internal_uri]
-        Topic.find(@topic1.pid).books.should == [@book] #Can't have saved it because @book isn't saved yet.
+        expect(@book.topics).to eq([@topic1])
+        expect(@book.relationships(:has_topic)).to eq([@topic1.internal_uri])
+        expect(@topic1.relationships(:has_topic)).to eq([])
+        expect(@topic1.relationships(:is_topic_of)).to eq([@book.internal_uri])
+        expect(Topic.find(@topic1.pid).books).to eq([@book]) #Can't have saved it because @book isn't saved yet.
       end
       it "should save new child objects" do
         @book.topics << Topic.new
-        @book.topics.first.pid.should_not be_nil
+        expect(@book.topics.first.pid).not_to be_nil
       end
       it "should clear out the old associtions" do
         @book.topics = [@topic1]
         @book.topics = [@topic2]
-        @book.topic_ids.should == [@topic2.pid]
+        expect(@book.topic_ids).to eq([@topic2.pid])
       end
       after do
         @book.delete
@@ -135,27 +135,27 @@ describe ActiveFedora::Base do
       end
 
       it "should have a collection" do
-        book.relationships(:is_member_of_collection).should == [collection.internal_uri]
-        book.collections.should == [collection]
+        expect(book.relationships(:is_member_of_collection)).to eq([collection.internal_uri])
+        expect(book.collections).to eq([collection])
       end
       it "habtm should not set foreign relationships if :inverse_of is not specified" do
-         collection.relationships(:is_member_of_collection).should == []
+         expect(collection.relationships(:is_member_of_collection)).to eq([])
       end
       it "should load the collections" do
         reloaded = Book.find(book.pid)
-        reloaded.collections.should == [collection]
+        expect(reloaded.collections).to eq([collection])
       end
 
       describe "#empty?" do
         subject { book.collections }
-        its(:empty?) { should be_false }
+        its(:empty?) { is_expected.to be_falsey }
       end
     end
 
     context "when a book isn't in a collection" do 
       describe "#empty?" do
         subject { book.collections }
-        its(:empty?) { should be_true }
+        its(:empty?) { should be_truthy }
       end
     end
   end
@@ -191,23 +191,23 @@ describe ActiveFedora::Base do
       end
 
       it "delete should cause the entries to be removed from RELS-EXT, but not destroy the original record" do
-        book.collections.should == [collection1, collection2]
+        expect(book.collections).to eq([collection1, collection2])
         book.collections.delete(collection1)
-        book.collections.should == [collection2]
+        expect(book.collections).to eq([collection2])
         book.save!
         book.reload
-        book.collections.should == [collection2]
-        expect {Collection.find(collection1.pid)}.to_not be_nil
+        expect(book.collections).to eq([collection2])
+        expect(Collection.find(collection1.pid)).to_not be_nil
       end
 
       it "destroy should cause the entries to be removed from RELS-EXT, but not destroy the original record" do
-        book.collections.should == [collection1, collection2]
+        expect(book.collections).to eq([collection1, collection2])
         book.collections.destroy(collection1)
-        book.collections.should == [collection2]
+        expect(book.collections).to eq([collection2])
         book.save!
         book.reload
-        book.collections.should == [collection2]
-        expect {Collection.find(collection1.pid)}.to_not be_nil
+        expect(book.collections).to eq([collection2])
+        expect(Collection.find(collection1.pid)).to_not be_nil
       end
     end
 
@@ -240,25 +240,25 @@ describe ActiveFedora::Base do
       end
 
       it "destroy should cause the before_remove and after_remove callback to be triggered" do
-        book.should_receive(:foo).with(collection)
-        book.should_receive(:bar).with(collection)
+        expect(book).to receive(:foo).with(collection)
+        expect(book).to receive(:bar).with(collection)
         book.collections.destroy(collection)
       end
 
       it "delete should cause the before_remove and after_remove callback to be triggered" do
-        book.should_receive(:foo).with(collection)
-        book.should_receive(:bar).with(collection)
+        expect(book).to receive(:foo).with(collection)
+        expect(book).to receive(:bar).with(collection)
         book.collections.delete(collection)
       end
 
       it "should not remove if an exception is thrown in before_remove" do
-        book.should_receive(:foo).with(collection).and_raise
-        book.should_not_receive(:bar)
+        expect(book).to receive(:foo).with(collection).and_raise
+        expect(book).not_to receive(:bar)
         begin
           book.collections.delete(collection)
         rescue RuntimeError
         end
-        book.collections.should == [collection]
+        expect(book.collections).to eq([collection])
       end
     end
 
@@ -287,25 +287,25 @@ describe ActiveFedora::Base do
       end
 
       it "shift should cause the before_add and after_add callback to be triggered" do
-        book.should_receive(:foo).with(collection)
-        book.should_receive(:bar).with(collection)
+        expect(book).to receive(:foo).with(collection)
+        expect(book).to receive(:bar).with(collection)
         book.collections << collection
       end
 
       it "assignment should cause the before_add and after_add callback to be triggered" do
-        book.should_receive(:foo).with(collection)
-        book.should_receive(:bar).with(collection)
+        expect(book).to receive(:foo).with(collection)
+        expect(book).to receive(:bar).with(collection)
         book.collections = [collection]
       end
 
       it "should not add if an exception is thrown in before_add" do
-        book.should_receive(:foo).with(collection).and_raise
-        book.should_not_receive(:bar)
+        expect(book).to receive(:foo).with(collection).and_raise
+        expect(book).not_to receive(:bar)
         begin
           book.collections << collection
         rescue RuntimeError
         end
-        book.collections.should == []
+        expect(book.collections).to eq([])
       end
     end
 
@@ -341,7 +341,7 @@ describe "Autosave" do
 
     it "should save dependent records" do
       component.reload
-      component.items.first.title.should == 'my title'
+      expect(component.items.first.title).to eq('my title')
     end
   end
   describe "From the has_many side" do
@@ -349,9 +349,8 @@ describe "Autosave" do
 
     it "should save dependent records" do
       item.reload
-      item.components.first.description.should == 'my description'
+      expect(item.components.first.description).to eq('my description')
     end
   end
 
 end
-

data/spec/integration/has_many_associations_spec.rb

@@ -21,7 +21,7 @@ describe "Collection members" do
         expect(library.books).not_to be_loaded
         expect(library.books.size).to eq(0)
         expect(library.books).to be_loaded
-        expect(library.books.any?).to be_false
+        expect(library.books.any?).to be_falsey
       end
     end
   end
@@ -41,9 +41,9 @@ describe "Collection members" do
     end
 
     it "should cache the results" do
-      expect(library.books.loaded?).to be_false
+      expect(library.books.loaded?).to be_falsey
       expect(library.books).to eq [book]
-      expect(library.books.loaded?).to be_true
+      expect(library.books.loaded?).to be_truthy
     end
     it "should load from solr" do
       expect(library.books.load_from_solr.map {|r| r["id"]}).to eq([book.pid])
@@ -52,9 +52,9 @@ describe "Collection members" do
       expect(library.books.load_from_solr(rows: 0).size).to eq(0)
     end
     it "should respond to #any?" do
-      expect(library.books.any?).to be_true
-      expect(library.books.any? {|book| book.library == nil}).to be_false
-      expect(library.books.any? {|book| book.library == library}).to be_true
+      expect(library.books.any?).to be_truthy
+      expect(library.books.any? {|book| book.library == nil}).to be_falsey
+      expect(library.books.any? {|book| book.library == library}).to be_truthy
     end
   end
 end
@@ -84,7 +84,7 @@ describe "After save callbacks" do
   let(:book) { Book.new(library: library) }
   it "should have the relationship available in after_save" do
     book.save!
-    book.library_books.should include book
+    expect(book.library_books).to include book
   end
 end
 
@@ -115,8 +115,8 @@ describe "When two or more relationships share the same property" do
 
   it "Should only return relationships of the correct class" do
     @book.reload
-    @book.people.should == [@person1, @person2]
-    @book.collections.should == []
+    expect(@book.people).to eq([@person1, @person2])
+    expect(@book.collections).to eq([])
   end
 end
 
@@ -150,7 +150,7 @@ describe "When relationship is restricted to AF::Base" do
     end
     it "Should not restrict relationships " do
       @book.reload
-      @book.attachments.should == [@image, @pdf]
+      expect(@book.attachments).to eq([@image, @pdf])
     end
   end
 
@@ -168,7 +168,7 @@ describe "When relationship is restricted to AF::Base" do
     it "Should not restrict relationships " do
       email.attachment_ids = [image.id, pdf.id]
       email.reload
-      email.attachments.should == [image, pdf]
+      expect(email.attachments).to eq([image, pdf])
     end
   end
 end
@@ -194,12 +194,12 @@ describe "Deleting a dependent relationship" do
   it "should remove relationships" do
     component.item = item
     component.save!
-    item.components.should == [component]
+    expect(item.components).to eq([component])
     item.components.delete(component)
     item.reload
     component.reload
-    component.relationships(:is_part_of).should == []
-    item.components.should == []
+    expect(component.relationships(:is_part_of)).to eq([])
+    expect(item.components).to eq([])
   end
 
   it "should remove the relationships that point at that object" do
@@ -207,7 +207,7 @@ describe "Deleting a dependent relationship" do
     component.save!
     item.delete
     component.reload
-    component.relationships(:is_part_of).should == []
+    expect(component.relationships(:is_part_of)).to eq([])
   end
 
   it "should only try to delete objects that exist in the datastore (not cached objects)" do
@@ -254,7 +254,7 @@ describe "Autosave" do
 
     it "should save dependent records" do
       component.reload
-      component.item.title.should == 'my title'
+      expect(component.item.title).to eq('my title')
     end
   end
   describe "From the has_many side" do
@@ -262,7 +262,7 @@ describe "Autosave" do
 
     it "should save dependent records" do
       item.reload
-      item.components.first.description.should == 'my description'
+      expect(item.components.first.description).to eq('my description')
     end
   end
 

data/spec/integration/json_serialization_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe "Objects should be serialized to JSON" do
   it "should have json results" do
-    ActiveFedora::Base.new.to_json.should == "{\"id\":null}"
+    expect(ActiveFedora::Base.new.to_json).to eq("{\"id\":null}")
   end
 
   describe "with a more interesting model" do
@@ -20,7 +20,7 @@ describe "Objects should be serialized to JSON" do
       Object.send(:remove_const, :Foo)
     end
     subject { Foo.new(foo: ["baz"], bar: 'quix') }
-    before { subject.stub(pid: 'test:123') }
+    before { allow(subject).to receive_messages(pid: 'test:123') }
     it "should have to_json" do
       json = JSON.parse(subject.to_json)
       expect(json['id']).to eq "test:123"

data/spec/integration/load_from_solr_spec.rb

@@ -52,7 +52,7 @@ describe "Loading from solr" do
   end
 
   it "should be able to get indexed properties without loading from fedora" do
-    RdfTest.connection_for_pid('1').should_not_receive(:datastream_dissemination)
+    expect(RdfTest.connection_for_pid('1')).not_to receive(:datastream_dissemination)
     obj = RdfTest.load_instance_from_solr original.pid
     expect(obj.title).to eq "PLAN 9 FROM OUTER SPACE"
     expect(obj.date_uploaded).to eq [Date.parse('1959-01-01')]