active-fedora 6.8.0 → 7.0.0.pre1

data/spec/unit/callback_spec.rb

@@ -3,12 +3,11 @@ 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
+      has_attributes :fubar, :swank, datastream: 'someData', multiple: true
 
       after_initialize :a_init
       before_save :b_save
@@ -30,23 +29,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
-    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)
+  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)
     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
-    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)
+ 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)
 
     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
-    expect(YAMLAdaptor).to receive(:load).never
-    expect(File).to receive(:exists?).never
-    expect(File).to receive(:read).never
-    expect(File).to receive(:open).never
+  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
     ActiveFedora.init(@config_params)
-    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)
+    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
   end
-
-end
+  
+end

data/spec/unit/config_spec.rb

@@ -1,27 +1,19 @@
 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) }
-
-    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 }
+    its(:credentials) { should == {:url => 'http://testhost.com:8983/fedora', :user=> 'fedoraAdmin', :password=> 'fedoraAdmin'}}
+    it { should_not 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) }
-
-    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 }
+    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 }
   end
 
 end

data/spec/unit/content_model_spec.rb

@@ -1,99 +1,118 @@
 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__')
-    allow(ActiveFedora::Base).to receive(:assign_pid).and_return('__nextid__')
-    allow_any_instance_of(Rubydora::Repository).to receive(:client).and_return(@mock_client)
+    ActiveFedora::Base.stub(:assign_pid).and_return("__nextid__")
+    Rubydora::Repository.any_instance.stub(:client).and_return(@mock_client)
     @test_cmodel = ActiveFedora::ContentModel.new
   end
-
-  it 'should provide #new' do
-    expect(ActiveFedora::ContentModel).to respond_to(:new)
+  
+  it "should provide #new" do
+    ActiveFedora::ContentModel.should respond_to(:new)
   end
-
-  describe '#new' do
-    it 'should create a kind of ActiveFedora::Base object' do
-      expect(@test_cmodel).to be_kind_of(ActiveFedora::Base)
+  
+  describe "#new" do
+    it "should create a kind of ActiveFedora::Base object" do
+      @test_cmodel.should be_kind_of(ActiveFedora::Base)
     end
-    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')
+    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"
     end
-    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')
+    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"
     end
   end
-
-  it 'should provide @pid_suffix' do
-    expect(@test_cmodel).to respond_to(:pid_suffix)
-    expect(@test_cmodel).to respond_to(:pid_suffix=)
+  
+  it "should provide @pid_suffix" do
+    @test_cmodel.should respond_to(:pid_suffix)
+    @test_cmodel.should respond_to(:pid_suffix=)
   end
+  
+  describe '.best_model_for' do
+    it 'should be the input model if no relationships' do
+      mock_object = BaseModel.new
+      mock_object.should_receive(:relationships).with(:has_model).and_return([])
+      expect(ActiveFedora::ContentModel.best_model_for(mock_object)).to eq BaseModel
+    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(ActiveFedora::ContentModel.best_model_for(mock_object)).to eq SampleModel
+    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')
-      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'])
+    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(ActiveFedora::ContentModel.best_model_for(mock_object)).to eq SampleModel
+    end
+  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"]
     end
     it "should return an empty array if the object doesn't have a RELS-EXT datastream" do
-      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([])
+      mock_object = double("ActiveFedora Object")
+      mock_object.should_receive(:relationships).with(:has_model).and_return([])
+      ActiveFedora::ContentModel.models_asserted_by(mock_object).should == []
     end
   end
-
-  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
-      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')
-      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])
+  
+  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]
+    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]
+    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]
     end
     it "should still work even if the object doesn't have a RELS-EXT datastream" do
-      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])
+      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]
     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
-      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)
+  
+  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
     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
-      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)
+      @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)
     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
-      expect(@test_object2.datastream_names).to include('thumbnail', 'EAD')
+      @test_object2.datastream_names.should 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' ))
-      allow(@f).to receive(:content_type).and_return('image/jpeg')
-      allow(@f2).to receive(: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" ))
+      @f.stub(:content_type).and_return("image/jpeg")
+      @f2.stub(: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'})
-      expect(@test_object2.high.first.dsLabel).to eq('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"})
+      @test_object2.high.first.dsLabel.should == "my_image"
     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 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 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})
+    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})
     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
-      allow(@f).to receive(: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
+      @f.stub(: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
-      expect(@test_object2.anymime.first.class).to eq(ActiveFedora::Datastream)
+      @test_object2.anymime.first.class.should == 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
-      allow(@f).to receive(:content_type).and_return('image/jpeg')
-      expect { @test_object2.add_named_datastream('thumbnail', {:file => @f, :dsid => 'DS1'}) }.to raise_error
+      @f.stub(: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
-      expect(@test_object2.high.first.controlGroup).to eq('M')
+      @test_object2.high.first.controlGroup.should == "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
-      expect(@test_object2.external.first.dsLabel).to eq('http://myreasource.com')
+      @test_object2.external.first.dsLabel.should == "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
-      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)
+      f.stub(:original_filename).and_return("minivan.jpg")
+      f.stub(:content_type).and_return("image/jpeg")
+      @test_object2.add_named_file_datastream("thumbnail",f)
       thumb = @test_object2.thumbnail.first
-      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.class.should == ActiveFedora::Datastream
+      thumb.mimeType.should == "image/jpeg"
+      thumb.dsid.should == "THUMB1"
+      thumb.controlGroup.should == "M"
+      thumb.dsLabel.should == "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' ))
-      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')
+      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")
       #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
-      expect(@test_object2.thumbnail.size).to eq(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  
+      @test_object2.thumbnail.size.should == 1
+      @test_object2.thumbnail_ids == ["THUMB1"]
       thumb1 = @test_object2.thumbnail.first
-      expect(thumb1.dsid).to eq('THUMB1')
-      expect(thumb1.pid).to eq(@test_object2.pid)
-      expect(thumb1.dsLabel).to eq('minivan.jpg')
+      thumb1.dsid.should == 'THUMB1'
+      thumb1.pid.should == @test_object2.pid
+      thumb1.dsLabel.should == 'minivan.jpg'
       f.rewind
-      @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.update_named_datastream("thumbnail",{:file=>f2,:dsid=>"THUMB1"})
+      @test_object2.thumbnail.size.should == 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
-      expect(thumb1.dsid).to eq('THUMB1')
-      expect(thumb1.pid).to eq(@test_object2.pid)
-      expect(thumb1.dsLabel).to eq('dino.jpg')
+      thumb1.dsid.should == 'THUMB1'
+      thumb1.pid.should == @test_object2.pid
+      thumb1.dsLabel.should == '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
-      expect(@test_object2.named_datastreams_desc).to eq({'thumbnail' => {:name => 'thumbnail', :prefix => 'THUMB',
-                                                                    :type => 'ActiveFedora::Datastream', :mimeType => 'image/jpeg',
-                                                                    :controlGroup => 'M'}})
+      @test_object2.named_datastreams_desc.should == {"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
-      expect(@test_object2.is_named_datastream?('thumbnail')).to eq(true)
-      expect(@test_object2.is_named_datastream?('thumb')).to eq(false)
+      @test_object2.is_named_datastream?("thumbnail").should == true
+      @test_object2.is_named_datastream?("thumb").should == 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' ))
-      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')
+      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")
       @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
-      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')
+      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"
     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' ))
-      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')
+      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")
       @test_object2.thumbnail_file_append(f)
       @test_object2.high_file_append(f2)
-      @test_object2.external_append({:dsLocation => 'http://myresource.com'})
-      expect(@test_object2.named_datastreams_ids).to eq({'thumbnail' => ['THUMB1'], 'high' => ['HIGH1'], 'external' => ['EXTERNAL1']})
+      @test_object2.external_append({:dsLocation=>"http://myresource.com"})
+      @test_object2.named_datastreams_ids.should == {"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
-      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})
+      @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})
       t2_thumb1 = @test_object2.thumbnail.first
-      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",
+      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", 
       # :pid=>@test_object2.pid, :mimeType=>"image/jpeg", :controlGroup=>"M", :dsLabel=>"testDS", :name=>"thumbnail", :label=>"testDS"}
-      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)
+      @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
       #just check returning datastream object at this point
-      expect(@test_object2.high.first.class).to eq(ActiveFedora::Datastream)
+      @test_object2.high.first.class.should == 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
-      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.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")
       @test_object2.thumbnail_file_append(f)
       t2_thumb1 = @test_object2.thumbnail.first
-      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})
+      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})
       t3_thumb1 = @test_object3.thumbnail.first
-      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_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"})
       t3_external1 = @test_object3.external.first
-      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.dsLabel.should == "http://myresource.com"
+      t3_external1.dsLocation.should == "http://myresource.com"
+      t3_external1.pid.should == @test_object3.pid 
+      t3_external1.dsid.should == "EXTERNAL1"
       t3_external1.controlGroup == 'E'
     end
   end