active-fedora 8.2.1 → 8.2.2

data/spec/unit/builder/has_and_belongs_to_many_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe ActiveFedora::Associations::Builder::HasAndBelongsToMany do
   describe "valid_options" do
     subject { ActiveFedora::Associations::Builder::HasAndBelongsToMany.valid_options }
-    it { should eq [:class_name, :property, :before_add, :after_add, :before_remove, :after_remove, 
+    it { is_expected.to eq [:class_name, :property, :before_add, :after_add, :before_remove, :after_remove, 
                     :inverse_of, :solr_page_size, :autosave] }
   end
 end

data/spec/unit/callback_spec.rb

@@ -30,22 +30,22 @@ describe ActiveFedora::Base do
   end
 
   it "Should have after_initialize, before_save,after_save, before_create, after_create, after_update, before_update, before_destroy" do
-    CallbackStub.any_instance.should_receive(:a_init)
-    CallbackStub.any_instance.should_receive :b_create
-    CallbackStub.any_instance.should_receive :a_create
-    CallbackStub.any_instance.should_receive(:b_save)
-    CallbackStub.any_instance.should_receive(:a_save)
+    expect_any_instance_of(CallbackStub).to receive(:a_init)
+    expect_any_instance_of(CallbackStub).to receive :b_create
+    expect_any_instance_of(CallbackStub).to receive :a_create
+    expect_any_instance_of(CallbackStub).to receive(:b_save)
+    expect_any_instance_of(CallbackStub).to receive(:a_save)
     cb = CallbackStub.new :pid => 'test:123'
     cb.save
 end
  it "Should have after_initialize, before_save,after_save, before_create, after_create, after_update, before_update, before_destroy" do
-    CallbackStub.any_instance.should_receive(:a_init)
-    CallbackStub.any_instance.should_receive(:b_save)
-    CallbackStub.any_instance.should_receive(:a_save)
-    CallbackStub.any_instance.should_receive(:a_find)
-    CallbackStub.any_instance.should_receive(:b_update)
-    CallbackStub.any_instance.should_receive(:a_update)
-    CallbackStub.any_instance.should_receive(:do_stuff)
+    expect_any_instance_of(CallbackStub).to receive(:a_init)
+    expect_any_instance_of(CallbackStub).to receive(:b_save)
+    expect_any_instance_of(CallbackStub).to receive(:a_save)
+    expect_any_instance_of(CallbackStub).to receive(:a_find)
+    expect_any_instance_of(CallbackStub).to receive(:b_update)
+    expect_any_instance_of(CallbackStub).to receive(:a_update)
+    expect_any_instance_of(CallbackStub).to receive(:do_stuff)
 
     cb2 = CallbackStub.find('test:123')
     cb2.save

data/spec/unit/code_configurator_spec.rb

@@ -38,14 +38,14 @@ describe ActiveFedora::FileConfigurator do
   end
 
   it "should initialize from code" do
-    Psych.should_receive(:load).never
-    File.should_receive(:exists?).never
-    File.should_receive(:read).never
-    File.should_receive(:open).never
+    expect(Psych).to receive(:load).never
+    expect(File).to receive(:exists?).never
+    expect(File).to receive(:read).never
+    expect(File).to receive(:open).never
     ActiveFedora.init(@config_params)
-    ActiveFedora.fedora_config.credentials.should == @config_params[:fedora_config]
-    ActiveFedora.solr_config.should == @config_params[:solr_config]
-    ActiveFedora::Predicates.predicate_mappings['info:fedora/fedora-system:def/relations-external#'].length.should == 1
+    expect(ActiveFedora.fedora_config.credentials).to eq(@config_params[:fedora_config])
+    expect(ActiveFedora.solr_config).to eq(@config_params[:solr_config])
+    expect(ActiveFedora::Predicates.predicate_mappings['info:fedora/fedora-system:def/relations-external#'].length).to eq(1)
   end
   
 end

data/spec/unit/config_spec.rb

@@ -5,7 +5,7 @@ describe ActiveFedora::Config do
     conf = Psych.load(File.read('spec/fixtures/rails_root/config/fedora.yml'))['test']
     subject { ActiveFedora::Config.new(conf) }
     its(:credentials) { should == {:url => 'http://testhost.com:8983/fedora', :user=> 'fedoraAdmin', :password=> 'fedoraAdmin'}}
-    it { should_not be_sharded }
+    it { is_expected.not_to be_sharded }
   end
   describe "with several fedora shards" do
     conf = Psych.load(File.read('spec/fixtures/sharded_fedora.yml'))['test']
@@ -13,7 +13,7 @@ describe ActiveFedora::Config do
     its(:credentials) { should == [{:url => 'http://127.0.0.1:8983/fedora1', :user=> 'fedoraAdmin', :password=> 'fedoraAdmin'},
                               {:url => 'http://127.0.0.1:8983/fedora2', :user=> 'fedoraAdmin', :password=> 'fedoraAdmin'},
                               {:url => 'http://127.0.0.1:8983/fedora3', :user=> 'fedoraAdmin', :password=> 'fedoraAdmin'}]}
-    it { should be_sharded }
+    it { is_expected.to be_sharded }
   end
 
 end

data/spec/unit/content_model_spec.rb

@@ -21,19 +21,19 @@ describe ActiveFedora::ContentModel do
   describe '.best_model_for' do
     it 'should be nil if no relationships' do
       mock_object = BaseModel.new
-      mock_object.should_receive(:relationships).with(:has_model).and_return([])
+      expect(mock_object).to receive(:relationships).with(:has_model).and_return([])
       expect(ActiveFedora::ContentModel.best_model_for(mock_object)).to be_nil
     end
 
     it 'should be based on inheritance hierarchy' do
       mock_object = ActiveFedora::Base.new
-      mock_object.should_receive(:relationships).with(:has_model).and_return(["info:fedora/fedora-system:ServiceDefinition-3.0", 'info:fedora/afmodel:SampleModel', 'info:fedora/afmodel:BaseModel'])
+      expect(mock_object).to receive(:relationships).with(:has_model).and_return(["info:fedora/fedora-system:ServiceDefinition-3.0", 'info:fedora/afmodel:SampleModel', 'info:fedora/afmodel:BaseModel'])
       expect(ActiveFedora::ContentModel.best_model_for(mock_object)).to eq SampleModel
     end
 
     it 'should find the deepest descendant of the on inheritance hierarchy' do
       mock_object = BaseModel.new
-      mock_object.should_receive(:relationships).with(:has_model).and_return(["info:fedora/fedora-system:ServiceDefinition-3.0", 'info:fedora/afmodel:SampleModel', 'info:fedora/afmodel:BaseModel'])
+      expect(mock_object).to receive(:relationships).with(:has_model).and_return(["info:fedora/fedora-system:ServiceDefinition-3.0", 'info:fedora/afmodel:SampleModel', 'info:fedora/afmodel:BaseModel'])
       expect(ActiveFedora::ContentModel.best_model_for(mock_object)).to eq SampleModel
     end
   end
@@ -41,46 +41,45 @@ describe ActiveFedora::ContentModel do
   describe "models_asserted_by" do
     it "should return an array of all of the content models asserted by the given object" do
       mock_object = double("ActiveFedora Object")
-      mock_object.should_receive(:relationships).with(:has_model).and_return(["info:fedora/fedora-system:ServiceDefinition-3.0", "info:fedora/afmodel:SampleModel", "info:fedora/afmodel:NonDefinedModel"])
-      ActiveFedora::ContentModel.models_asserted_by(mock_object).should == ["info:fedora/fedora-system:ServiceDefinition-3.0", "info:fedora/afmodel:SampleModel", "info:fedora/afmodel:NonDefinedModel"]
+      expect(mock_object).to receive(:relationships).with(:has_model).and_return(["info:fedora/fedora-system:ServiceDefinition-3.0", "info:fedora/afmodel:SampleModel", "info:fedora/afmodel:NonDefinedModel"])
+      expect(ActiveFedora::ContentModel.models_asserted_by(mock_object)).to eq(["info:fedora/fedora-system:ServiceDefinition-3.0", "info:fedora/afmodel:SampleModel", "info:fedora/afmodel:NonDefinedModel"])
     end
     it "should return an empty array if the object doesn't have a RELS-EXT datastream" do
       mock_object = double("ActiveFedora Object")
-      mock_object.should_receive(:relationships).with(:has_model).and_return([])
-      ActiveFedora::ContentModel.models_asserted_by(mock_object).should == []
+      expect(mock_object).to receive(:relationships).with(:has_model).and_return([])
+      expect(ActiveFedora::ContentModel.models_asserted_by(mock_object)).to eq([])
     end
   end
   
   describe "known_models_asserted_by" do
     it "should figure out the applicable models to load" do
       mock_object = double("ActiveFedora Object")
-      mock_object.should_receive(:relationships).with(:has_model).and_return(["info:fedora/fedora-system:ServiceDefinition-3.0", "info:fedora/afmodel:SampleModel", "info:fedora/afmodel:NonDefinedModel"])
-      ActiveFedora::ContentModel.known_models_for(mock_object).should == [SampleModel]
+      expect(mock_object).to receive(:relationships).with(:has_model).and_return(["info:fedora/fedora-system:ServiceDefinition-3.0", "info:fedora/afmodel:SampleModel", "info:fedora/afmodel:NonDefinedModel"])
+      expect(ActiveFedora::ContentModel.known_models_for(mock_object)).to eq([SampleModel])
     end
     it "should support namespaced models" do
-      pending "This is harder than it looks."
       mock_object = double("ActiveFedora Object")
-      mock_object.should_receive(:relationships).with(:has_model).and_return(["info:fedora/afmodel:Sample_NamespacedModel"])
-      ActiveFedora::ContentModel.known_models_for(mock_object).should == [Sample::NamespacedModel]
+      expect(mock_object).to receive(:relationships).with(:has_model).and_return(["info:fedora/afmodel:Sample_NamespacedModel"])
+      expect(ActiveFedora::ContentModel.known_models_for(mock_object)).to eq([Sample::NamespacedModel])
     end
     it "should default to using ActiveFedora::Base as the model" do
       mock_object = double("ActiveFedora Object")
-      mock_object.should_receive(:relationships).with(:has_model).and_return(["info:fedora/afmodel:NonDefinedModel"])
-      ActiveFedora::ContentModel.known_models_for(mock_object).should == [ActiveFedora::Base]
+      expect(mock_object).to receive(:relationships).with(:has_model).and_return(["info:fedora/afmodel:NonDefinedModel"])
+      expect(ActiveFedora::ContentModel.known_models_for(mock_object)).to eq([ActiveFedora::Base])
     end
     it "should still work even if the object doesn't have a RELS-EXT datastream" do
       mock_object = double("ActiveFedora Object")
-      mock_object.should_receive(:relationships).with(:has_model).and_return([])
-      ActiveFedora::ContentModel.known_models_for(mock_object).should == [ActiveFedora::Base]
+      expect(mock_object).to receive(:relationships).with(:has_model).and_return([])
+      expect(ActiveFedora::ContentModel.known_models_for(mock_object)).to eq([ActiveFedora::Base])
     end
   end
   
   describe "uri_to_model_class" do
     it "should return an ActiveFedora Model class corresponding to the given uri if a valid model can be found" do
-      ActiveFedora::ContentModel.uri_to_model_class("info:fedora/afmodel:SampleModel").should == SampleModel
-      ActiveFedora::ContentModel.uri_to_model_class("info:fedora/afmodel:NonDefinedModel").should == false
-      ActiveFedora::ContentModel.uri_to_model_class("info:fedora/afmodel:String").should == false
-      ActiveFedora::ContentModel.uri_to_model_class("info:fedora/hydra-cModel:genericContent").should == GenericContent
+      expect(ActiveFedora::ContentModel.uri_to_model_class("info:fedora/afmodel:SampleModel")).to eq(SampleModel)
+      expect(ActiveFedora::ContentModel.uri_to_model_class("info:fedora/afmodel:NonDefinedModel")).to eq(false)
+      expect(ActiveFedora::ContentModel.uri_to_model_class("info:fedora/afmodel:String")).to eq(false)
+      expect(ActiveFedora::ContentModel.uri_to_model_class("info:fedora/hydra-cModel:genericContent")).to eq(GenericContent)
     end
   end
 

data/spec/unit/core_spec.rb

@@ -68,7 +68,7 @@ describe ActiveFedora::Base do
     it "should access associations" do
       f = Book.find(subject.id)
       f.freeze
-      f.library_id.should_not be_nil
+      expect(f.library_id).not_to be_nil
 
     end
   end

data/spec/unit/datastream_collections_spec.rb

@@ -15,24 +15,24 @@ describe ActiveFedora::DatastreamCollections do
     it 'should cache a definition of named datastream and create helper methods to add/remove/access them' do
       @test_object2 = MockHasDatastream.new
       #prefix should default to name in caps if not specified in has_datastream call
-      @test_object2.named_datastreams_desc.should == {"thumbnail"=>{:name=>"thumbnail",:prefix => "THUMB", 
+      expect(@test_object2.named_datastreams_desc).to eq({"thumbnail"=>{:name=>"thumbnail",:prefix => "THUMB", 
                                                                     :type=>"ActiveFedora::Datastream", :mimeType=>"image/jpeg", 
                                                                     :controlGroup=>'M'},
                                                       "EAD"=>       {:name=>"EAD", :prefix=>"EAD",
                                                                     :type=>"ActiveFedora::Datastream", :mimeType=>"application/xml", 
                                                                     :controlGroup=>'M' },
                                                       "external"=>  {:name=>"external", :prefix=>"EXTERNAL",
-                                                                    :type=>"ActiveFedora::Datastream", :controlGroup=>'E' }}
-      @test_object2.should respond_to(:thumbnail_append)
-      @test_object2.should respond_to(:thumbnail_file_append)
-      @test_object2.should respond_to(:thumbnail)
-      @test_object2.should respond_to(:thumbnail_ids)
-      @test_object2.should respond_to(:ead_append)
-      @test_object2.should respond_to(:ead_file_append)
-      @test_object2.should respond_to(:EAD)
-      @test_object2.should respond_to(:EAD_ids)
-      @test_object2.should respond_to(:external)
-      @test_object2.should respond_to(:external_ids)
+                                                                    :type=>"ActiveFedora::Datastream", :controlGroup=>'E' }})
+      expect(@test_object2).to respond_to(:thumbnail_append)
+      expect(@test_object2).to respond_to(:thumbnail_file_append)
+      expect(@test_object2).to respond_to(:thumbnail)
+      expect(@test_object2).to respond_to(:thumbnail_ids)
+      expect(@test_object2).to respond_to(:ead_append)
+      expect(@test_object2).to respond_to(:ead_file_append)
+      expect(@test_object2).to respond_to(:EAD)
+      expect(@test_object2).to respond_to(:EAD_ids)
+      expect(@test_object2).to respond_to(:external)
+      expect(@test_object2).to respond_to(:external_ids)
     end
   end
   describe '#datastream_names' do
@@ -46,7 +46,7 @@ describe ActiveFedora::DatastreamCollections do
     
     it 'should return a set of datastream names defined by has_datastream' do
       @test_object2 = MockDatastreamNames.new
-      @test_object2.datastream_names.should include("thumbnail","EAD")
+      expect(@test_object2.datastream_names).to include("thumbnail","EAD")
     end
   end
   
@@ -65,8 +65,8 @@ describe ActiveFedora::DatastreamCollections do
       @test_object2 = MockAddNamedDatastream.new
       @f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"))
       @f2 = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ))
-      @f.stub(:content_type).and_return("image/jpeg")
-      @f2.stub(:original_filename).and_return("dino.jpg")
+      allow(@f).to receive(:content_type).and_return("image/jpeg")
+      allow(@f2).to receive(:original_filename).and_return("dino.jpg")
     end
       
     it 'cannot add a datastream with name that does not exist' do
@@ -93,16 +93,16 @@ describe ActiveFedora::DatastreamCollections do
 
     it "should use the given label for the dsLabel" do
       @test_object2.add_named_datastream("high",{:content_type=>"image/jpeg",:blob=>@f2, :label=>"my_image"})
-      @test_object2.high.first.dsLabel.should == "my_image"
+      expect(@test_object2.high.first.dsLabel).to eq("my_image")
     end
 
     it "should fallback on using the file name" do
       @test_object2.add_named_datastream("high",{:content_type=>"image/jpeg",:blob=>@f2})
-      @test_object2.high.first.dsLabel.should == "dino.jpg"
+      expect(@test_object2.high.first.dsLabel).to eq("dino.jpg")
     end 
 
     it "should check the file for a content type" do
-      @f.should_receive(:content_type).and_return("image/jpeg")
+      expect(@f).to receive(:content_type).and_return("image/jpeg")
       @test_object2.add_named_datastream("thumbnail",{:file=>@f})
     end
 
@@ -111,7 +111,7 @@ describe ActiveFedora::DatastreamCollections do
     end
 
     it "should encsure mimetype and content type match" do
-      @f.stub(:content_type).and_return("image/tiff")
+      allow(@f).to receive(:content_type).and_return("image/tiff")
       expect { @test_object2.add_named_datastream("thumbnail",{:file=>f}) }.to raise_error
     end
       
@@ -119,12 +119,12 @@ describe ActiveFedora::DatastreamCollections do
       #check for if any mime type allowed
       @test_object2.add_named_datastream("anymime",{:file=>@f})
       #check datastream created is of type ActiveFedora::Datastream
-      @test_object2.anymime.first.class.should == ActiveFedora::Datastream
+      expect(@test_object2.anymime.first.class).to eq(ActiveFedora::Datastream)
     end
 
     it "should cgecj that a dsid forms to the prefix" do
       #if dsid supplied check that conforms to prefix
-      @f.stub(:content_type).and_return("image/jpeg")
+      allow(@f).to receive(:content_type).and_return("image/jpeg")
       expect { @test_object2.add_named_datastream("thumbnail",{:file=>@f,:dsid=>"DS1"}) }.to raise_error
     end
 
@@ -134,7 +134,7 @@ describe ActiveFedora::DatastreamCollections do
       #@test_object2.high.first.attributes[:prefix].should == "HIGH"
       @test_object2.high.first.dsid.match(/HIGH[0-9]/)
       #check datastreams added with other right properties
-      @test_object2.high.first.controlGroup.should == "M"
+      expect(@test_object2.high.first.controlGroup).to eq("M")
     end
 
     it "should work with external datastreams" do
@@ -142,7 +142,7 @@ describe ActiveFedora::DatastreamCollections do
       #check external datastream
       @test_object2.add_named_datastream("external",{:dsLocation=>"http://myreasource.com"})
       #check dslocation goes to dslabel
-      @test_object2.external.first.dsLabel.should == "http://myreasource.com"
+      expect(@test_object2.external.first.dsLabel).to eq("http://myreasource.com")
       #check datastreams added to fedora (may want to stub this at first)
     end
   end
@@ -162,15 +162,15 @@ describe ActiveFedora::DatastreamCollections do
       @test_object2 = MockAddNamedFileDatastream.new
       f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"))
       #these normally supplied in multi-part post request
-      f.stub(:original_filename).and_return("minivan.jpg")
-      f.stub(:content_type).and_return("image/jpeg")
+      allow(f).to receive(:original_filename).and_return("minivan.jpg")
+      allow(f).to receive(:content_type).and_return("image/jpeg")
       @test_object2.add_named_file_datastream("thumbnail",f)
       thumb = @test_object2.thumbnail.first
-      thumb.class.should == MockDS
-      thumb.mimeType.should == "image/jpeg"
-      thumb.dsid.should == "THUMB1"
-      thumb.controlGroup.should == "M"
-      thumb.dsLabel.should == "minivan.jpg"
+      expect(thumb.class).to eq(MockDS)
+      expect(thumb.mimeType).to eq("image/jpeg")
+      expect(thumb.dsid).to eq("THUMB1")
+      expect(thumb.controlGroup).to eq("M")
+      expect(thumb.dsLabel).to eq("minivan.jpg")
       #thumb.name.should == "thumbnail"
         # :prefix=>"THUMB", :content_type=>"image/jpeg", :dsid=>"THUMB1", :dsID=>"THUMB1", 
         # :pid=>@test_object2.pid, :mimeType=>"image/jpeg", :controlGroup=>"M", :dsLabel=>"minivan.jpg", :name=>"thumbnail"}
@@ -190,10 +190,10 @@ describe ActiveFedora::DatastreamCollections do
       @test_object2 = MockUpdateNamedDatastream.new
       f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"))
       f2 = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ))
-      f.stub(:content_type).and_return("image/jpeg")
-      f.stub(:original_filename).and_return("minivan.jpg")
-      f2.stub(:content_type).and_return("image/jpeg")
-      f2.stub(:original_filename).and_return("dino.jpg")
+      allow(f).to receive(:content_type).and_return("image/jpeg")
+      allow(f).to receive(:original_filename).and_return("minivan.jpg")
+      allow(f2).to receive(:content_type).and_return("image/jpeg")
+      allow(f2).to receive(:original_filename).and_return("dino.jpg")
       #check raise exception if dsid not supplied
       @test_object2.add_named_datastream("thumbnail",{:file=>f})
       had_exception = false
@@ -212,15 +212,15 @@ describe ActiveFedora::DatastreamCollections do
       end
       raise "Failed to raise exception if dsid does not exist" unless had_exception  
       #check datastream is updated in place without new dsid  
-      @test_object2.thumbnail.size.should == 1
+      expect(@test_object2.thumbnail.size).to eq(1)
       @test_object2.thumbnail_ids == ["THUMB1"]
       thumb1 = @test_object2.thumbnail.first
-      thumb1.dsid.should == 'THUMB1'
-      thumb1.pid.should == @test_object2.pid
-      thumb1.dsLabel.should == 'minivan.jpg'
+      expect(thumb1.dsid).to eq('THUMB1')
+      expect(thumb1.pid).to eq(@test_object2.pid)
+      expect(thumb1.dsLabel).to eq('minivan.jpg')
       f.rewind
       @test_object2.update_named_datastream("thumbnail",{:file=>f2,:dsid=>"THUMB1"})
-      @test_object2.thumbnail.size.should == 1
+      expect(@test_object2.thumbnail.size).to eq(1)
       @test_object2.thumbnail_ids == ["THUMB1"]
       # @test_object2.thumbnail.first.attributes.should == {:type=>"ActiveFedora::Datastream",
       #                                                     :content_type=>"image/jpeg", 
@@ -229,9 +229,9 @@ describe ActiveFedora::DatastreamCollections do
       #                                                     :pid=>@test_object2.pid, :dsID=>"THUMB1", 
       #                                                     :name=>"thumbnail", :dsLabel=>"dino.jpg"}
       thumb1 = @test_object2.thumbnail.first
-      thumb1.dsid.should == 'THUMB1'
-      thumb1.pid.should == @test_object2.pid
-      thumb1.dsLabel.should == 'dino.jpg'
+      expect(thumb1.dsid).to eq('THUMB1')
+      expect(thumb1.pid).to eq(@test_object2.pid)
+      expect(thumb1.dsLabel).to eq('dino.jpg')
     end
   end
   describe '#named_datastreams_desc' do
@@ -245,9 +245,9 @@ describe ActiveFedora::DatastreamCollections do
     
     it 'should intialize a value to an empty hash and then not modify afterward' do
       @test_object2 = MockNamedDatastreamsDesc.new
-      @test_object2.named_datastreams_desc.should == {"thumbnail"=>{:name=>"thumbnail",:prefix => "THUMB", 
+      expect(@test_object2.named_datastreams_desc).to eq({"thumbnail"=>{:name=>"thumbnail",:prefix => "THUMB", 
                                                                     :type=>"ActiveFedora::Datastream", :mimeType=>"image/jpeg", 
-                                                                    :controlGroup=>'M'}}
+                                                                    :controlGroup=>'M'}})
     end
   end
 
@@ -261,8 +261,8 @@ describe ActiveFedora::DatastreamCollections do
     
     it 'should return true if a named datastream exists in model' do
       @test_object2 = MockIsNamedDatastream.new
-      @test_object2.is_named_datastream?("thumbnail").should == true
-      @test_object2.is_named_datastream?("thumb").should == false
+      expect(@test_object2.is_named_datastream?("thumbnail")).to eq(true)
+      expect(@test_object2.is_named_datastream?("thumb")).to eq(false)
     end
   end
   
@@ -280,33 +280,33 @@ describe ActiveFedora::DatastreamCollections do
     it 'should return a hash of datastream names to arrays of datastreams' do
       @test_object2 = MockNamedDatastreams.new
       f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg" ))
-      f.stub(:content_type).and_return("image/jpeg")
-      f.stub(:original_filename).and_return("minivan.jpg")
+      allow(f).to receive(:content_type).and_return("image/jpeg")
+      allow(f).to receive(:original_filename).and_return("minivan.jpg")
       f2 = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ))
-      f2.stub(:content_type).and_return("image/jpeg")
-      f2.stub(:original_filename).and_return("dino.jpg")
+      allow(f2).to receive(:content_type).and_return("image/jpeg")
+      allow(f2).to receive(:original_filename).and_return("dino.jpg")
       @test_object2.thumbnail_file_append(f)
       @test_object2.high_file_append(f2)
       @test_object2.external_append({:dsLocation=>"http://myresource.com"})
       datastreams = @test_object2.named_datastreams
-      datastreams.keys.include?("thumbnail").should == true
-      datastreams.keys.include?("external").should == true
-      datastreams.keys.include?("high").should == true
-      datastreams.keys.size.should == 3
-      datastreams["thumbnail"].size.should == 1
-      datastreams["thumbnail"].first.dsid.should == 'THUMB1'
-      datastreams["thumbnail"].first.dsLabel.should == 'minivan.jpg'
-      datastreams["thumbnail"].first.controlGroup.should == "M"
+      expect(datastreams.keys.include?("thumbnail")).to eq(true)
+      expect(datastreams.keys.include?("external")).to eq(true)
+      expect(datastreams.keys.include?("high")).to eq(true)
+      expect(datastreams.keys.size).to eq(3)
+      expect(datastreams["thumbnail"].size).to eq(1)
+      expect(datastreams["thumbnail"].first.dsid).to eq('THUMB1')
+      expect(datastreams["thumbnail"].first.dsLabel).to eq('minivan.jpg')
+      expect(datastreams["thumbnail"].first.controlGroup).to eq("M")
 
-      datastreams["external"].size.should == 1
-      datastreams["external"].first.dsid.should == "EXTERNAL1"
-      datastreams["external"].first.dsLocation.should == "http://myresource.com"
-      datastreams["external"].first.controlGroup.should == "E"
+      expect(datastreams["external"].size).to eq(1)
+      expect(datastreams["external"].first.dsid).to eq("EXTERNAL1")
+      expect(datastreams["external"].first.dsLocation).to eq("http://myresource.com")
+      expect(datastreams["external"].first.controlGroup).to eq("E")
 
-      datastreams["high"].size.should == 1
-      datastreams["high"].first.dsLabel.should == 'dino.jpg'
-      datastreams["high"].first.controlGroup.should == "M"
-      datastreams["high"].first.dsid.should == "HIGH1"
+      expect(datastreams["high"].size).to eq(1)
+      expect(datastreams["high"].first.dsLabel).to eq('dino.jpg')
+      expect(datastreams["high"].first.controlGroup).to eq("M")
+      expect(datastreams["high"].first.dsid).to eq("HIGH1")
     end
   end
   
@@ -325,15 +325,15 @@ describe ActiveFedora::DatastreamCollections do
     it 'should provide a hash of datastreams names to array of datastream ids' do
       @test_object2 = MockNamedDatastreamsIds.new
       f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg" ))
-      f.stub(:content_type).and_return("image/jpeg")
-      f.stub(:original_filename).and_return("minivan.jpg")
+      allow(f).to receive(:content_type).and_return("image/jpeg")
+      allow(f).to receive(:original_filename).and_return("minivan.jpg")
       f2 = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ))
-      f2.stub(:content_type).and_return("image/jpeg")
-      f2.stub(:original_filename).and_return("dino.jpg")
+      allow(f2).to receive(:content_type).and_return("image/jpeg")
+      allow(f2).to receive(:original_filename).and_return("dino.jpg")
       @test_object2.thumbnail_file_append(f)
       @test_object2.high_file_append(f2)
       @test_object2.external_append({:dsLocation=>"http://myresource.com"})
-      @test_object2.named_datastreams_ids.should == {"thumbnail"=>["THUMB1"],"high"=>["HIGH1"],"external"=>["EXTERNAL1"]}
+      expect(@test_object2.named_datastreams_ids).to eq({"thumbnail"=>["THUMB1"],"high"=>["HIGH1"],"external"=>["EXTERNAL1"]})
     end
   end
   
@@ -349,32 +349,32 @@ describe ActiveFedora::DatastreamCollections do
     
     it 'should create helper methods to get named datastreams or dsids' do
       @test_object2 = MockCreateNamedDatastreamFinder.new
-      @test_object2.should respond_to(:thumbnail)
-      @test_object2.should respond_to(:thumbnail_ids)  
-      @test_object2.should respond_to(:high)
-      @test_object2.should respond_to(:high_ids)
+      expect(@test_object2).to respond_to(:thumbnail)
+      expect(@test_object2).to respond_to(:thumbnail_ids)  
+      expect(@test_object2).to respond_to(:high)
+      expect(@test_object2).to respond_to(:high_ids)
       f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"))
       f2 = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ))
-      f2.stub(:original_filename).and_return("dino.jpg")
-      f.stub(:content_type).and_return("image/jpeg")
+      allow(f2).to receive(:original_filename).and_return("dino.jpg")
+      allow(f).to receive(:content_type).and_return("image/jpeg")
       @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg",:blob=>f, :label=>"testDS"})
       @test_object2.add_named_datastream("high",{:content_type=>"image/jpeg",:blob=>f2})
       @test_object2.add_named_datastream("high",{:content_type=>"image/jpeg",:blob=>f2})
       t2_thumb1 = @test_object2.thumbnail.first
-      t2_thumb1.mimeType.should == "image/jpeg"
-      t2_thumb1.controlGroup.should == "M"
-      t2_thumb1.dsLabel.should == "testDS"
-      t2_thumb1.pid.should == @test_object2.pid 
-      t2_thumb1.dsid.should == "THUMB1"
+      expect(t2_thumb1.mimeType).to eq("image/jpeg")
+      expect(t2_thumb1.controlGroup).to eq("M")
+      expect(t2_thumb1.dsLabel).to eq("testDS")
+      expect(t2_thumb1.pid).to eq(@test_object2.pid) 
+      expect(t2_thumb1.dsid).to eq("THUMB1")
       # :type=>"ActiveFedora::Datastream", 
       # :prefix=>"THUMB", :content_type=>"image/jpeg", :dsid=>"THUMB1", :dsID=>"THUMB1", 
       # :pid=>@test_object2.pid, :mimeType=>"image/jpeg", :controlGroup=>"M", :dsLabel=>"testDS", :name=>"thumbnail", :label=>"testDS"}
-      @test_object2.thumbnail_ids.should == ["THUMB1"]
+      expect(@test_object2.thumbnail_ids).to eq(["THUMB1"])
       @test_object2.high_ids.include?("HIGH1") == true
       @test_object2.high_ids.include?("HIGH2") == true
-      @test_object2.high_ids.size.should == 2
+      expect(@test_object2.high_ids.size).to eq(2)
       #just check returning datastream object at this point
-      @test_object2.high.first.class.should == ActiveFedora::Datastream
+      expect(@test_object2.high.first.class).to eq(ActiveFedora::Datastream)
     end
   end
     
@@ -391,29 +391,29 @@ describe ActiveFedora::DatastreamCollections do
     it 'should create append method for each has_datastream entry' do
       @test_object2 = MockCreateNamedDatastreamUpdateMethods.new
       @test_object3 = MockCreateNamedDatastreamUpdateMethods.new
-      @test_object2.should respond_to(:thumbnail_append)
-      @test_object2.should respond_to(:ead_append)
+      expect(@test_object2).to respond_to(:thumbnail_append)
+      expect(@test_object2).to respond_to(:ead_append)
       f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"))
-      f.stub(:content_type).and_return("image/jpeg")
-      f.stub(:original_filename).and_return("minivan.jpg")
+      allow(f).to receive(:content_type).and_return("image/jpeg")
+      allow(f).to receive(:original_filename).and_return("minivan.jpg")
       @test_object2.thumbnail_file_append(f)
       t2_thumb1 = @test_object2.thumbnail.first
-      t2_thumb1.mimeType.should == "image/jpeg"
-      t2_thumb1.dsLabel.should == "minivan.jpg"
-      t2_thumb1.pid.should == @test_object2.pid 
-      t2_thumb1.dsid.should == "THUMB1"
+      expect(t2_thumb1.mimeType).to eq("image/jpeg")
+      expect(t2_thumb1.dsLabel).to eq("minivan.jpg")
+      expect(t2_thumb1.pid).to eq(@test_object2.pid) 
+      expect(t2_thumb1.dsid).to eq("THUMB1")
       @test_object3.thumbnail_append({:file=>f})
       t3_thumb1 = @test_object3.thumbnail.first
-      t3_thumb1.mimeType.should == "image/jpeg"
-      t3_thumb1.dsLabel.should == "minivan.jpg"
-      t3_thumb1.pid.should == @test_object3.pid 
-      t3_thumb1.dsid.should == "THUMB1"
+      expect(t3_thumb1.mimeType).to eq("image/jpeg")
+      expect(t3_thumb1.dsLabel).to eq("minivan.jpg")
+      expect(t3_thumb1.pid).to eq(@test_object3.pid) 
+      expect(t3_thumb1.dsid).to eq("THUMB1")
       @test_object3.external_append({:dsLocation=>"http://myresource.com"})
       t3_external1 = @test_object3.external.first
-      t3_external1.dsLabel.should == "http://myresource.com"
-      t3_external1.dsLocation.should == "http://myresource.com"
-      t3_external1.pid.should == @test_object3.pid 
-      t3_external1.dsid.should == "EXTERNAL1"
+      expect(t3_external1.dsLabel).to eq("http://myresource.com")
+      expect(t3_external1.dsLocation).to eq("http://myresource.com")
+      expect(t3_external1.pid).to eq(@test_object3.pid) 
+      expect(t3_external1.dsid).to eq("EXTERNAL1")
       t3_external1.controlGroup == 'E'
     end
   end