active-fedora 6.7.8 → 6.8.0

data/spec/unit/callback_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 describe ActiveFedora::Base do
   before :all do
     class CallbackStub < ActiveFedora::Base
-      has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"someData" do |m|
-        m.field "fubar", :string
-        m.field "swank", :text
+      has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'someData' do |m|
+        m.field 'fubar', :string
+        m.field 'swank', :text
       end
-      delegate :fubar, :to=>'someData', multiple: true
-      delegate :swank, :to=>'someData', multiple: true
+      delegate :fubar, :to => 'someData', multiple: true
+      delegate :swank, :to => 'someData', multiple: true
 
       after_initialize :a_init
       before_save :b_save
@@ -30,23 +30,23 @@ describe ActiveFedora::Base do
     Object.send(:remove_const, :CallbackStub)
   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)
+  it 'Should have after_initialize, before_save,after_save, before_create, after_create, after_update, before_update, before_destroy' do
+    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)
+ it 'Should have after_initialize, before_save,after_save, before_create, after_create, after_update, before_update, before_destroy' do
+    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

@@ -2,34 +2,34 @@ require 'spec_helper'
 require 'config_helper'
 
 describe ActiveFedora::FileConfigurator do
-  
+
   before :all do
     class TestConfigurator
       attr_reader :fedora_config, :solr_config, :predicate_config
-      
+
       def init(options = {})
         @fedora_config = options[:fedora_config]
         @solr_config = options[:solr_config]
         @predicate_config = options[:predicate_config]
       end
     end
-    
+
     @config_params = {
       :fedora_config => { :url => 'http://codeconfig.example.edu/fedora/', :user => 'fedoraAdmin', :password => 'configurator', :cert_file => '/path/to/cert/file' },
       :solr_config => { :url => 'http://codeconfig.example.edu/solr/' },
-      :predicate_config => { 
+      :predicate_config => {
         :default_namespace => 'info:fedora/fedora-system:def/relations-external#',
         :predicate_mapping => {
-          'info:fedora/fedora-system:def/relations-external#' => { :has_part => 'hasPart' } 
+          'info:fedora/fedora-system:def/relations-external#' => { :has_part => 'hasPart' }
         }
       }
     }
   end
-  
+
   before :each do
     ActiveFedora.configurator = TestConfigurator.new
   end
-  
+
   after :all do
     unstub_rails
     # Restore to default fedora configs
@@ -37,15 +37,15 @@ describe ActiveFedora::FileConfigurator do
     restore_spec_configuration
   end
 
-  it "should initialize from code" do
-    YAMLAdaptor.should_receive(:load).never
-    File.should_receive(:exists?).never
-    File.should_receive(:read).never
-    File.should_receive(:open).never
+  it 'should initialize from code' do
+    expect(YAMLAdaptor).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
+
+end

data/spec/unit/config_spec.rb

@@ -1,19 +1,27 @@
 require 'spec_helper'
 
 describe ActiveFedora::Config do
-  describe "with a single fedora instance" do
+  describe 'with a single fedora instance' do
     conf = YAMLAdaptor.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 }
+
+    describe '#credentials' do
+      subject { super().credentials }
+      it { is_expected.to eq({:url => 'http://testhost.com:8983/fedora', :user => 'fedoraAdmin', :password => 'fedoraAdmin'})}
+    end
+    it { is_expected.not_to be_sharded }
   end
-  describe "with several fedora shards" do
+  describe 'with several fedora shards' do
     conf = YAMLAdaptor.load(File.read('spec/fixtures/sharded_fedora.yml'))['test']
     subject { ActiveFedora::Config.new(conf) }
-    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 }
+
+    describe '#credentials' do
+      subject { super().credentials }
+      it { is_expected.to eq([{: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'}])}
+    end
+    it { is_expected.to be_sharded }
   end
 
 end

data/spec/unit/content_model_spec.rb

@@ -1,99 +1,99 @@
 require 'spec_helper'
 
 describe ActiveFedora::ContentModel do
-  
+
   before(:all) do
     class BaseModel < ActiveFedora::Base
     end
-    
+
     class SampleModel < BaseModel
     end
 
     class GenericContent < ActiveFedora::Base
     end
-    
+
     module Sample
       class NamespacedModel < ActiveFedora::Base
       end
     end
   end
-  
+
   before(:each) do
     stub_get('__nextid__')
-    ActiveFedora::Base.stub(:assign_pid).and_return("__nextid__")
-    Rubydora::Repository.any_instance.stub(:client).and_return(@mock_client)
+    allow(ActiveFedora::Base).to receive(:assign_pid).and_return('__nextid__')
+    allow_any_instance_of(Rubydora::Repository).to receive(:client).and_return(@mock_client)
     @test_cmodel = ActiveFedora::ContentModel.new
   end
-  
-  it "should provide #new" do
-    ActiveFedora::ContentModel.should respond_to(:new)
+
+  it 'should provide #new' do
+    expect(ActiveFedora::ContentModel).to respond_to(:new)
   end
-  
-  describe "#new" do
-    it "should create a kind of ActiveFedora::Base object" do
-      @test_cmodel.should be_kind_of(ActiveFedora::Base)
+
+  describe '#new' do
+    it 'should create a kind of ActiveFedora::Base object' do
+      expect(@test_cmodel).to be_kind_of(ActiveFedora::Base)
     end
-    it "should set pid_suffix to empty string unless overriden in options hash" do
-      @test_cmodel.pid_suffix.should == ""
-      boo_model = ActiveFedora::ContentModel.new(:pid_suffix => "boo")
-      boo_model.pid_suffix.should == "boo"
+    it 'should set pid_suffix to empty string unless overriden in options hash' do
+      expect(@test_cmodel.pid_suffix).to eq('')
+      boo_model = ActiveFedora::ContentModel.new(:pid_suffix => 'boo')
+      expect(boo_model.pid_suffix).to eq('boo')
     end
-    it "should set namespace to cmodel unless overriden in options hash" do
-      @test_cmodel.namespace.should == "afmodel"
-      boo_model = ActiveFedora::ContentModel.new(:namespace => "boo")
-      boo_model.namespace.should == "boo"
+    it 'should set namespace to cmodel unless overriden in options hash' do
+      expect(@test_cmodel.namespace).to eq('afmodel')
+      boo_model = ActiveFedora::ContentModel.new(:namespace => 'boo')
+      expect(boo_model.namespace).to eq('boo')
     end
   end
-  
-  it "should provide @pid_suffix" do
-    @test_cmodel.should respond_to(:pid_suffix)
-    @test_cmodel.should respond_to(:pid_suffix=)
+
+  it 'should provide @pid_suffix' do
+    expect(@test_cmodel).to respond_to(:pid_suffix)
+    expect(@test_cmodel).to respond_to(:pid_suffix=)
   end
-  
-  
-  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"]
+
+
+  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')
+      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 == []
+      mock_object = double('ActiveFedora Object')
+      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]
+
+  describe 'known_models_asserted_by' do
+    it 'should figure out the applicable models to load' do
+      mock_object = double('ActiveFedora Object')
+      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]
+    it 'should support namespaced models' do
+      skip 'This is harder than it looks.'
+      mock_object = double('ActiveFedora Object')
+      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]
+    it 'should default to using ActiveFedora::Base as the model' do
+      mock_object = double('ActiveFedora Object')
+      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]
+      mock_object = double('ActiveFedora Object')
+      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
+
+  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
+      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/datastream_collections_spec.rb

@@ -3,177 +3,177 @@ require 'spec_helper'
 describe ActiveFedora::DatastreamCollections do
   describe '.has_datastream' do
     before(:all) do
-      
+
       class MockHasDatastream < ActiveFedora::Base
         include ActiveFedora::DatastreamCollections
-        has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
-        has_datastream :name=>"EAD", :type=>ActiveFedora::Datastream, :mimeType=>"application/xml", :controlGroup=>'M' 
-        has_datastream :name=>"external", :type=>ActiveFedora::Datastream, :controlGroup=>'E'
+        has_datastream :name => 'thumbnail', :prefix => 'THUMB', :type => ActiveFedora::Datastream, :mimeType => 'image/jpeg', :controlGroup => 'M'
+        has_datastream :name => 'EAD', :type => ActiveFedora::Datastream, :mimeType => 'application/xml', :controlGroup => 'M'
+        has_datastream :name => 'external', :type => ActiveFedora::Datastream, :controlGroup => 'E'
       end
     end
-    
+
     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", 
-                                                                    :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)
+      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' }})
+      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
     before(:all) do
       class MockDatastreamNames < ActiveFedora::Base
         include ActiveFedora::DatastreamCollections
-        has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
-        has_datastream :name=>"EAD", :type=>ActiveFedora::Datastream, :mimeType=>"application/xml", :controlGroup=>'M' 
+        has_datastream :name => 'thumbnail', :prefix => 'THUMB', :type => ActiveFedora::Datastream, :mimeType => 'image/jpeg', :controlGroup => 'M'
+        has_datastream :name => 'EAD', :type => ActiveFedora::Datastream, :mimeType => 'application/xml', :controlGroup => 'M'
       end
     end
-    
+
     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
-  
+
   describe '#add_named_datastream' do
     before(:all) do
       class MockAddNamedDatastream < ActiveFedora::Base
         include ActiveFedora::DatastreamCollections
-        has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
-        has_datastream :name=>"high", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M' 
-        has_datastream :name=>"anymime", :type=>ActiveFedora::Datastream, :controlGroup=>'M' 
-        has_datastream :name=>"external", :type=>ActiveFedora::Datastream, :controlGroup=>'E'
+        has_datastream :name => 'thumbnail', :prefix => 'THUMB', :type => ActiveFedora::Datastream, :mimeType => 'image/jpeg', :controlGroup => 'M'
+        has_datastream :name => 'high', :type => ActiveFedora::Datastream, :mimeType => 'image/jpeg', :controlGroup => 'M'
+        has_datastream :name => 'anymime', :type => ActiveFedora::Datastream, :controlGroup => 'M'
+        has_datastream :name => 'external', :type => ActiveFedora::Datastream, :controlGroup => 'E'
       end
     end
     before 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")
+      @f = File.new(File.join( File.dirname(__FILE__), '../fixtures/minivan.jpg'))
+      @f2 = File.new(File.join( File.dirname(__FILE__), '../fixtures/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
-      expect { @test_object2.add_named_datastream("thumb",{:content_type=>"image/jpeg",:blob=>f}) }.to raise_error
+      expect { @test_object2.add_named_datastream('thumb', {:content_type => 'image/jpeg', :blob => f}) }.to raise_error
     end
 
-    it "should accept a file blob" do
-      @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg",:blob=>@f})
+    it 'should accept a file blob' do
+      @test_object2.add_named_datastream('thumbnail', {:content_type => 'image/jpeg', :blob => @f})
     end
 
-    it "should accept a file handle" do
-      @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg",:file=>@f})
+    it 'should accept a file handle' do
+      @test_object2.add_named_datastream('thumbnail', {:content_type => 'image/jpeg', :file => @f})
     end
 
-    it "should  allow access to file content" do
-      @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg",:file=>@f})
+    it 'should  allow access to file content' do
+      @test_object2.add_named_datastream('thumbnail', {:content_type => 'image/jpeg', :file => @f})
       @test_object2.save!
       @test_object2.thumbnail[0].content
     end
 
-    it "should raise an error if neither a blob nor file is set" do
-      expect { @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg"}) }.to raise_error
+    it 'should raise an error if neither a blob nor file is set' do
+      expect { @test_object2.add_named_datastream('thumbnail', {:content_type => 'image/jpeg'}) }.to raise_error
     end
 
-    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"
+    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'})
+      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"
-    end 
+    it 'should fallback on using the file name' do
+      @test_object2.add_named_datastream('high', {:content_type => 'image/jpeg', :blob => @f2})
+      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")
-      @test_object2.add_named_datastream("thumbnail",{:file=>@f})
+    it 'should check the file for a content type' do
+      expect(@f).to receive(:content_type).and_return('image/jpeg')
+      @test_object2.add_named_datastream('thumbnail', {:file => @f})
     end
 
-    it "should raise an error if no content type is avialable" do
-      expect { @test_object2.add_named_datastream("thumbnail",{:file=>@f2}) }.to raise_error
+    it 'should raise an error if no content type is avialable' do
+      expect { @test_object2.add_named_datastream('thumbnail', {:file => @f2}) }.to raise_error
     end
 
-    it "should encsure mimetype and content type match" do
-      @f.stub(:content_type).and_return("image/tiff")
-      expect { @test_object2.add_named_datastream("thumbnail",{:file=>f}) }.to raise_error
+    it 'should encsure mimetype and content type match' do
+      allow(@f).to receive(:content_type).and_return('image/tiff')
+      expect { @test_object2.add_named_datastream('thumbnail', {:file => f}) }.to raise_error
     end
-      
-    it "should allow any mime type" do
+
+    it 'should allow any mime type' do
       #check for if any mime type allowed
-      @test_object2.add_named_datastream("anymime",{:file=>@f})
+      @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
+    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")
-      expect { @test_object2.add_named_datastream("thumbnail",{:file=>@f,:dsid=>"DS1"}) }.to raise_error
+      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
 
-    it "should have the right properties" do
-      @test_object2.add_named_datastream("high",{:content_type=>"image/jpeg",:blob=>@f2})
+    it 'should have the right properties' do
+      @test_object2.add_named_datastream('high', {:content_type => 'image/jpeg', :blob => @f2})
       #if prefix not set check uses name in CAPS and dsid uses prefix
       #@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
-      
+    it 'should work with external datastreams' do
+
       #check external datastream
-      @test_object2.add_named_datastream("external",{:dsLocation=>"http://myreasource.com"})
+      @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
-  
+
   describe '#add_named_file_datastream' do
     before do
       class MockAddNamedFileDatastream < ActiveFedora::Base
         include ActiveFedora::DatastreamCollections
-        has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
-        has_datastream :name=>"high", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M' 
-        has_datastream :name=>"anymime", :type=>ActiveFedora::Datastream, :controlGroup=>'M' 
+        has_datastream :name => 'thumbnail', :prefix => 'THUMB', :type => ActiveFedora::Datastream, :mimeType => 'image/jpeg', :controlGroup => 'M'
+        has_datastream :name => 'high', :type => ActiveFedora::Datastream, :mimeType => 'image/jpeg', :controlGroup => 'M'
+        has_datastream :name => 'anymime', :type => ActiveFedora::Datastream, :controlGroup => 'M'
       end
     end
-    
+
     it 'should add a datastream as controlGroup M with blob set to file' do
       @test_object2 = MockAddNamedFileDatastream.new
-      f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"))
+      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")
-      @test_object2.add_named_file_datastream("thumbnail",f)
+      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 == ActiveFedora::Datastream
-      thumb.mimeType.should == "image/jpeg"
-      thumb.dsid.should == "THUMB1"
-      thumb.controlGroup.should == "M"
-      thumb.dsLabel.should == "minivan.jpg"
+      expect(thumb.class).to eq(ActiveFedora::Datastream)
+      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", 
+        # :prefix=>"THUMB", :content_type=>"image/jpeg", :dsid=>"THUMB1", :dsID=>"THUMB1",
         # :pid=>@test_object2.pid, :mimeType=>"image/jpeg", :controlGroup=>"M", :dsLabel=>"minivan.jpg", :name=>"thumbnail"}
-      
+
     end
   end
 
@@ -181,72 +181,72 @@ describe ActiveFedora::DatastreamCollections do
     before do
       class MockUpdateNamedDatastream < ActiveFedora::Base
         include ActiveFedora::DatastreamCollections
-        has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
+        has_datastream :name => 'thumbnail', :prefix => 'THUMB', :type => ActiveFedora::Datastream, :mimeType => 'image/jpeg', :controlGroup => 'M'
       end
     end
-    
+
     it 'should update a datastream and not increment the dsid' 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")
+      f = File.new(File.join( File.dirname(__FILE__), '../fixtures/minivan.jpg'))
+      f2 = File.new(File.join( File.dirname(__FILE__), '../fixtures/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})
+      @test_object2.add_named_datastream('thumbnail', {:file => f})
       had_exception = false
       begin
-        @test_object2.update_named_datastream("thumbnail",{:file=>f})
+        @test_object2.update_named_datastream('thumbnail', {:file => f})
       rescue
         had_exception = true
       end
-      raise "Failed to raise exception if dsid not supplied" unless had_exception
+      raise 'Failed to raise exception if dsid not supplied' unless had_exception
       #raise exception if dsid does not exist
       had_exception = false
       begin
-        @test_object2.update_named_datastream("thumbnail",{:file=>f,:dsid=>"THUMB100"})
+        @test_object2.update_named_datastream('thumbnail', {:file => f, :dsid => 'THUMB100'})
       rescue
         had_exception = true
       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
-      @test_object2.thumbnail_ids == ["THUMB1"]
+      raise 'Failed to raise exception if dsid does not exist' unless had_exception
+      #check datastream is updated in place without new dsid
+      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
-      @test_object2.thumbnail_ids == ["THUMB1"]
+      @test_object2.update_named_datastream('thumbnail', {:file => f2, :dsid => 'THUMB1'})
+      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", 
-      #                                                     :prefix=>"THUMB", :mimeType=>"image/jpeg", 
-      #                                                     :controlGroup=>"M", :dsid=>"THUMB1", 
-      #                                                     :pid=>@test_object2.pid, :dsID=>"THUMB1", 
+      #                                                     :content_type=>"image/jpeg",
+      #                                                     :prefix=>"THUMB", :mimeType=>"image/jpeg",
+      #                                                     :controlGroup=>"M", :dsid=>"THUMB1",
+      #                                                     :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
-      
+
     before do
       class MockNamedDatastreamsDesc < ActiveFedora::Base
         include ActiveFedora::DatastreamCollections
-        has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
+        has_datastream :name => 'thumbnail', :prefix => 'THUMB', :type => ActiveFedora::Datastream, :mimeType => 'image/jpeg', :controlGroup => 'M'
       end
     end
-    
+
     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", 
-                                                                    :type=>"ActiveFedora::Datastream", :mimeType=>"image/jpeg", 
-                                                                    :controlGroup=>'M'}}
+      expect(@test_object2.named_datastreams_desc).to eq({'thumbnail' => {:name => 'thumbnail', :prefix => 'THUMB',
+                                                                    :type => 'ActiveFedora::Datastream', :mimeType => 'image/jpeg',
+                                                                    :controlGroup => 'M'}})
     end
   end
 
@@ -254,166 +254,166 @@ describe ActiveFedora::DatastreamCollections do
     before do
       class MockIsNamedDatastream < ActiveFedora::Base
         include ActiveFedora::DatastreamCollections
-        has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
+        has_datastream :name => 'thumbnail', :prefix => 'THUMB', :type => ActiveFedora::Datastream, :mimeType => 'image/jpeg', :controlGroup => 'M'
       end
     end
-    
+
     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
-  
-  
+
+
   describe '#named_datastreams' do
     before do
       class MockNamedDatastreams < ActiveFedora::Base
         include ActiveFedora::DatastreamCollections
-        has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
-        has_datastream :name=>"high", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M' 
-        has_datastream :name=>"external", :type=>ActiveFedora::Datastream, :controlGroup=>'E' 
+        has_datastream :name => 'thumbnail', :prefix => 'THUMB', :type => ActiveFedora::Datastream, :mimeType => 'image/jpeg', :controlGroup => 'M'
+        has_datastream :name => 'high', :type => ActiveFedora::Datastream, :mimeType => 'image/jpeg', :controlGroup => 'M'
+        has_datastream :name => 'external', :type => ActiveFedora::Datastream, :controlGroup => 'E'
       end
     end
-    
+
     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")
-      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")
+      f = File.new(File.join( File.dirname(__FILE__), '../fixtures/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' ))
+      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.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"
-
-      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"
-      datastreams["external"].first.content.should == "" 
-
-      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.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')
+
+      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')
+      expect(datastreams['external'].first.content).to eq('')
+
+      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
-  
-  
-    
+
+
+
   describe '#named_datastreams_ids' do
     before do
       class MockNamedDatastreamsIds < ActiveFedora::Base
         include ActiveFedora::DatastreamCollections
-        has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
-        has_datastream :name=>"high", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M' 
-        has_datastream :name=>"external", :type=>ActiveFedora::Datastream, :controlGroup=>'E' 
+        has_datastream :name => 'thumbnail', :prefix => 'THUMB', :type => ActiveFedora::Datastream, :mimeType => 'image/jpeg', :controlGroup => 'M'
+        has_datastream :name => 'high', :type => ActiveFedora::Datastream, :mimeType => 'image/jpeg', :controlGroup => 'M'
+        has_datastream :name => 'external', :type => ActiveFedora::Datastream, :controlGroup => 'E'
       end
     end
-    
+
     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")
-      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")
+      f = File.new(File.join( File.dirname(__FILE__), '../fixtures/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' ))
+      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"]}
+      @test_object2.external_append({:dsLocation => 'http://myresource.com'})
+      expect(@test_object2.named_datastreams_ids).to eq({'thumbnail' => ['THUMB1'], 'high' => ['HIGH1'], 'external' => ['EXTERNAL1']})
     end
   end
-  
-    
+
+
   describe '#create_named_datastream_finders' do
     before do
       class MockCreateNamedDatastreamFinder < ActiveFedora::Base
         include ActiveFedora::DatastreamCollections
-        has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
-        has_datastream :name=>"high", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M' 
+        has_datastream :name => 'thumbnail', :prefix => 'THUMB', :type => ActiveFedora::Datastream, :mimeType => 'image/jpeg', :controlGroup => 'M'
+        has_datastream :name => 'high', :type => ActiveFedora::Datastream, :mimeType => 'image/jpeg', :controlGroup => 'M'
       end
     end
-    
+
     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)
-      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")
-      @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})
+      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' ))
+      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"
-      # :type=>"ActiveFedora::Datastream", 
-      # :prefix=>"THUMB", :content_type=>"image/jpeg", :dsid=>"THUMB1", :dsID=>"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"]
-      @test_object2.high_ids.include?("HIGH1") == true
-      @test_object2.high_ids.include?("HIGH2") == true
-      @test_object2.high_ids.size.should == 2
+      expect(@test_object2.thumbnail_ids).to eq(['THUMB1'])
+      @test_object2.high_ids.include?('HIGH1') == true
+      @test_object2.high_ids.include?('HIGH2') == true
+      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
-    
+
   describe '#create_named_datastream_update_methods' do
     before do
       class MockCreateNamedDatastreamUpdateMethods < ActiveFedora::Base
         include ActiveFedora::DatastreamCollections
-        has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
-        has_datastream :name=>"EAD", :type=>ActiveFedora::Datastream, :mimeType=>"application/xml", :controlGroup=>'M' 
-        has_datastream :name=>"external", :type=>ActiveFedora::Datastream, :controlGroup=>'E' 
+        has_datastream :name => 'thumbnail', :prefix => 'THUMB', :type => ActiveFedora::Datastream, :mimeType => 'image/jpeg', :controlGroup => 'M'
+        has_datastream :name => 'EAD', :type => ActiveFedora::Datastream, :mimeType => 'application/xml', :controlGroup => 'M'
+        has_datastream :name => 'external', :type => ActiveFedora::Datastream, :controlGroup => 'E'
       end
     end
-    
+
     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)
-      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")
+      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'))
+      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"
-      @test_object3.thumbnail_append({:file=>f})
+      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"
-      @test_object3.external_append({:dsLocation=>"http://myresource.com"})
+      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