active-fedora 6.4.2 → 6.4.3

data/spec/integration/rdf_nested_attributes_spec.rb

@@ -66,7 +66,7 @@ describe "Nesting attribute behavior of RDFDatastream" do
         Object.send(:remove_const, :ComplexRDFDatastream)
         Object.send(:remove_const, :DummyMADS)
       end
-      subject { ComplexRDFDatastream.new(stub('inner object', :pid=>'foo', :new? =>true), 'descMetadata') }
+      subject { ComplexRDFDatastream.new(double('inner object', :pid=>'foo', :new? =>true), 'descMetadata') }
       let(:params) do 
         { myResource: 
           {
@@ -138,7 +138,7 @@ describe "Nesting attribute behavior of RDFDatastream" do
       after(:each) do
         Object.send(:remove_const, :SpecDatastream)
       end
-      subject { SpecDatastream.new(stub('inner object', :pid=>'foo', :new? =>true), 'descMetadata') }
+      subject { SpecDatastream.new(double('inner object', :pid=>'foo', :new? =>true), 'descMetadata') }
       before do
         subject.attributes = { parts_attributes: [
                                   {label: 'Alternator'},

data/spec/integration/solr_instance_loader_spec.rb

@@ -3,6 +3,11 @@ require 'spec_helper'
 require 'active_fedora'
 
 describe ActiveFedora::SolrInstanceLoader do
+  before(:all) do
+    @test_object = ActiveFedora::Base.create
+    @test_object2 = ActiveFedora::Base.create
+  end
+
   let(:context) { ActiveFedora::Base }
   let(:pid) { nil }
   let(:solr_doc) { nil }
@@ -10,7 +15,7 @@ describe ActiveFedora::SolrInstanceLoader do
   subject { ActiveFedora::SolrInstanceLoader.new(context, pid, solr_doc) }
 
   describe 'existing pid' do
-    let(:pid) { 'test:fixture_mods_article1' }
+    let(:pid) { @test_object.pid }
     describe 'without a solr document' do
       it 'it finds the SOLR document and casts into an AF::Base object' do
         expect(subject.object).to eq(active_fedora_object)
@@ -23,7 +28,7 @@ describe ActiveFedora::SolrInstanceLoader do
       end
     end
     describe 'with a mismatching solr document' do
-      let(:mismatching_pid) { 'test:fixture_mods_article2' }
+      let(:mismatching_pid) { @test_object2.pid }
       let(:solr_doc) { ActiveFedora::Base.find_with_conditions(:id=>mismatching_pid).first }
       it 'it raise ObjectNotFoundError' do
         expect {
@@ -33,7 +38,7 @@ describe ActiveFedora::SolrInstanceLoader do
     end
   end
   describe 'missing pid' do
-    let(:pid) { 'test:fixture_mods_article8675309' }
+    let(:pid) { 'test:missing_pid' }
     describe 'without a solr document' do
       it 'it raise ObjectNotFoundError' do
         expect {
@@ -50,7 +55,7 @@ describe ActiveFedora::SolrInstanceLoader do
       end
     end
     describe 'with a mismatching solr document' do
-      let(:mismatching_pid) { 'test:fixture_mods_article2' }
+      let(:mismatching_pid) { @test_object2.pid }
       let(:solr_doc) { ActiveFedora::Base.find_with_conditions(:id=>mismatching_pid).first }
       it 'it raise ObjectNotFoundError' do
         expect {

data/spec/integration/solr_service_spec.rb

@@ -9,9 +9,6 @@ describe ActiveFedora::SolrService do
         def self.pid_namespace
           "foo"
         end
-        has_metadata :name => "properties", :type => ActiveFedora::SimpleDatastream do |m|
-          m.field "holding_id", :string
-        end
   
         has_metadata :name => "descMetadata", :type => ActiveFedora::QualifiedDublinCoreDatastream
       end
@@ -19,8 +16,7 @@ describe ActiveFedora::SolrService do
       @test_object.label = 'test_object'
       @foo_object = FooObject.new
       @foo_object.label = 'foo_object'
-      attributes = {"holding_id"=>{0=>"Holding 1"},
-                    "language"=>{0=>"Italian"},
+      attributes = {"language"=>{0=>"Italian"},
                     "creator"=>{0=>"Linguist, A."},
                     "geography"=>{0=>"Italy"},
                     "title"=>{0=>"Italian and Spanish: A Comparison of Common Phrases"}}
@@ -30,7 +26,6 @@ describe ActiveFedora::SolrService do
       @profiles = {
         'test' => @test_object.inner_object.profile,
         'foo' => @foo_object.inner_object.profile,
-        'foo_properties' => @foo_object.datastreams['properties'].profile,
         'foo_descMetadata' => @foo_object.datastreams['descMetadata'].profile
       }
       @foo_content = @foo_object.datastreams['descMetadata'].content
@@ -61,14 +56,13 @@ describe ActiveFedora::SolrService do
         ['test_object','foo_object'].should include(r.label)
         @test_object.inner_object.profile.should == @profiles['test']
         @foo_object.inner_object.profile.should == @profiles['foo']
-        @foo_object.datastreams['properties'].profile.should == @profiles['foo_properties']
         @foo_object.datastreams['descMetadata'].profile.should == @profiles['foo_descMetadata']
         @foo_object.datastreams['descMetadata'].content.should be_equivalent_to(@foo_content)
       end
     end
     
     it 'should instantiate all datastreams in the solr doc, even ones undeclared by the class' do
-      obj = ActiveFedora::Base.load_instance_from_solr "test:fixture_mods_article1"
+      obj = ActiveFedora::Base.load_instance_from_solr @foo_object.pid 
       obj.datastreams.keys.should include('descMetadata')
     end
     

data/spec/support/mock_fedora.rb

@@ -1,7 +1,7 @@
 def mock_client
   return @mock_client if @mock_client
-  @mock_client = mock("client")
-  @getter = mock("getter")
+  @mock_client = double("client")
+  @getter = double("getter")
   @getter.stub(:get).and_return('')
   @mock_client.stub(:[]).with("describe?xml=true").and_return('')
   @mock_client 
@@ -10,7 +10,7 @@ end
 def stub_get(pid, datastreams=nil, record_exists=false)
   pid.gsub!(/:/, '%3A')
   if record_exists
-    mock_client.stub(:[]).with("objects/#{pid}?format=xml").and_return(stub('get getter', :get=>'foobar'))
+    mock_client.stub(:[]).with("objects/#{pid}?format=xml").and_return(double('get getter', :get=>'foobar'))
   else
     mock_client.stub(:[]).with("objects/#{pid}?format=xml").and_raise(RestClient::ResourceNotFound)
   end
@@ -23,7 +23,7 @@ end
 
 def stub_ingest(pid=nil)
   n = pid ? pid.gsub(/:/, '%3A') : nil
-  mock_client.should_receive(:[]).with("objects/#{n || 'new'}").and_return(stub("ingester", :post=>pid))
+  mock_client.should_receive(:[]).with("objects/#{n || 'new'}").and_return(double("ingester", :post=>pid))
 end
 
 def stub_add_ds(pid, dsids)
@@ -32,14 +32,14 @@ def stub_add_ds(pid, dsids)
     client = mock_client.stub(:[]).with do |params|
       /objects\/#{pid}\/datastreams\/#{dsid}/.match(params)
     end
-    client.and_return(stub("ds_adder", :post=>pid, :get=>''))
+    client.and_return(double("ds_adder", :post=>pid, :get=>''))
   end
 end
 
 def stub_get_content(pid, dsids)
   pid.gsub!(/:/, '%3A')
   dsids.each do |dsid|
-    mock_client.stub(:[]).with { |params| /objects\/#{pid}\/datastreams\/#{dsid}\/content/.match(params)}.and_return(stub("content_accessor", :post=>pid, :get=>''))
+    mock_client.stub(:[]).with { |params| /objects\/#{pid}\/datastreams\/#{dsid}\/content/.match(params)}.and_return(double("content_accessor", :post=>pid, :get=>''))
   end
 end
 

data/spec/unit/active_fedora_spec.rb

@@ -104,11 +104,22 @@ describe ActiveFedora do
   end
   
   describe "#class_from_string" do
+    before do
+      module ParentClass
+        class SiblingClass
+        end
+        class OtherSiblingClass
+        end
+      end
+    end
     it "should return class constants based on strings" do
       ActiveFedora.class_from_string("Om").should == Om
       ActiveFedora.class_from_string("ActiveFedora::RdfNode::TermProxy").should == ActiveFedora::RdfNode::TermProxy
       ActiveFedora.class_from_string("TermProxy", ActiveFedora::RdfNode).should == ActiveFedora::RdfNode::TermProxy
-      
+    end
+
+    it "should find sibling classes" do
+      ActiveFedora.class_from_string("SiblingClass", ParentClass::OtherSiblingClass).should == ParentClass::SiblingClass
     end
   end
 end

data/spec/unit/base_extra_spec.rb

@@ -8,19 +8,19 @@ describe ActiveFedora::Base do
 
   describe ".update_index" do
     before do
-      mock_conn = mock("SolrConnection")
+      mock_conn = double("SolrConnection")
       mock_conn.should_receive(:add)
       mock_conn.should_receive(:commit)
-      mock_ss = mock("SolrService")
+      mock_ss = double("SolrService")
       mock_ss.stub(:conn).and_return(mock_conn)
       ActiveFedora::SolrService.stub(:instance).and_return(mock_ss)
     end
     
     it "should call .to_solr on all SimpleDatastreams AND RelsExtDatastreams and pass the resulting document to solr" do
       # Actually uses self.to_solr internally to gather solr info from all metadata datastreams
-      mock1 = mock("ds1", :to_solr => {})
-      mock2 = mock("ds2", :to_solr => {})
-      mock3 = mock("RELS-EXT", :to_solr => {})
+      mock1 = double("ds1", :to_solr => {})
+      mock2 = double("ds2", :to_solr => {})
+      mock3 = double("RELS-EXT", :to_solr => {})
       
       mock_datastreams = {:ds1 => mock1, :ds2 => mock2, :rels_ext => mock3}
       mock1.should_receive(:solrize_profile).and_return({})
@@ -33,9 +33,9 @@ describe ActiveFedora::Base do
 
     it "should call .to_solr on all RDFDatastreams and pass the resulting document to solr" do
       # Actually uses self.to_solr internally to gather solr info from all metadata datastreams
-      mock1 = mock("ds1", :to_solr => {})
-      mock2 = mock("ds2", :to_solr => {})
-      mock3 = mock("RELS-EXT", :to_solr => {})
+      mock1 = double("ds1", :to_solr => {})
+      mock2 = double("ds2", :to_solr => {})
+      mock3 = double("RELS-EXT", :to_solr => {})
       
       mock_datastreams = {:ds1 => mock1, :ds2 => mock2, :rels_ext => mock3}
       mock1.should_receive(:solrize_profile).and_return({})
@@ -59,10 +59,10 @@ describe ActiveFedora::Base do
     
     it "should delete object from repository and index" do
       @test_object.inner_object.stub(:delete)
-      mock_conn = mock("SolrConnection")
+      mock_conn = double("SolrConnection")
       mock_conn.should_receive(:delete_by_id).with("__DO_NOT_USE__") 
       mock_conn.should_receive(:commit)
-      mock_ss = mock("SolrService")
+      mock_ss = double("SolrService")
       mock_ss.stub(:conn).and_return(mock_conn)
       ActiveFedora::SolrService.stub(:instance).and_return(mock_ss)
       @test_object.delete

data/spec/unit/base_spec.rb

@@ -28,8 +28,8 @@ describe ActiveFedora::Base do
         it "should use fedora to generate pids" do
           # TODO: This juggling of Fedora credentials & establishing connections should be handled by an establish_fedora_connection method, 
           # possibly wrap it all into a fedora_connection method - MZ 06-05-2012
-          stubfedora = mock("Fedora")
-          stubfedora.should_receive(:connection).and_return(mock("Connection", :mint =>"sample:newpid"))
+          stubfedora = double("Fedora")
+          stubfedora.should_receive(:connection).and_return(double("Connection", :mint =>"sample:newpid"))
           # Should use ActiveFedora.config.credentials as a single hash rather than an array of shards
           ActiveFedora::RubydoraConnection.should_receive(:new).with(ActiveFedora.config.credentials).and_return(stubfedora)
           ActiveFedora::Base.assign_pid(ActiveFedora::Base.new.inner_object)
@@ -49,9 +49,9 @@ describe ActiveFedora::Base do
       end
       describe "assign_pid" do
         it "should always use the first shard to generate pids" do
-          stubhard1 = mock("Shard")
-          stubhard2 = mock("Shard")
-          stubhard1.should_receive(:connection).and_return(mock("Connection", :mint =>"sample:newpid"))
+          stubhard1 = double("Shard")
+          stubhard2 = double("Shard")
+          stubhard1.should_receive(:connection).and_return(double("Connection", :mint =>"sample:newpid"))
           stubhard2.should_receive(:connection).never
           ActiveFedora::Base.fedora_connection = {0 => stubhard1, 1 => stubhard2}
           ActiveFedora::Base.assign_pid(ActiveFedora::Base.new.inner_object)
@@ -84,8 +84,8 @@ describe ActiveFedora::Base do
   describe "reindex_everything" do
     it "should call update_index on every object" do
        Rubydora::Repository.any_instance.should_receive(:search).
-            and_yield(stub(pid:'XXX')).and_yield(stub(pid:'YYY')).and_yield(stub(pid:'ZZZ'))
-       mock_update = stub(:mock_obj)
+            and_yield(double(pid:'XXX')).and_yield(double(pid:'YYY')).and_yield(double(pid:'ZZZ'))
+       mock_update = double(:mock_obj)
        mock_update.should_receive(:update_index).exactly(3).times
        ActiveFedora::Base.should_receive(:find).with('XXX', :cast=>true).and_return(mock_update)
        ActiveFedora::Base.should_receive(:find).with('YYY', :cast=>true).and_return(mock_update)
@@ -212,12 +212,12 @@ describe ActiveFedora::Base do
         @test_history.withText.should == @test_history.datastreams['withText']
       end
       it "dynamic accessors should convert dashes to underscores" do
-        ds = stub('datastream', :dsid=>'eac-cpf')
+        ds = double('datastream', :dsid=>'eac-cpf')
         @test_history.add_datastream(ds)
         @test_history.eac_cpf.should == ds
       end
       it "dynamic accessors should not convert datastreams named with underscore" do
-        ds = stub('datastream', :dsid=>'foo_bar')
+        ds = double('datastream', :dsid=>'foo_bar')
         @test_history.add_datastream(ds)
         @test_history.foo_bar.should == ds
       end
@@ -259,7 +259,7 @@ describe ActiveFedora::Base do
       end
 
       it "should update the RELS-EXT datastream and set the datastream as dirty when relationships are added" do
-        mock_ds = mock("Rels-Ext")
+        mock_ds = double("Rels-Ext")
         mock_ds.stub(:content_will_change!)
         @test_object.datastreams["RELS-EXT"] = mock_ds
         @test_object.add_relationship(:is_member_of, "info:fedora/demo:5")
@@ -347,7 +347,7 @@ describe ActiveFedora::Base do
 
     describe "#create" do
       it "should build a new record and save it" do
-        obj = mock()
+        obj = double()
         obj.should_receive(:save)
         FooHistory.should_receive(:new).and_return(obj)
         @hist = FooHistory.create(:fubar=>'ta', :swank=>'da')
@@ -436,9 +436,9 @@ describe ActiveFedora::Base do
       end
 
       it "should call .to_solr on all SimpleDatastreams and OmDatastreams, passing the resulting document to solr" do
-        mock1 = mock("ds1", :to_solr => {})
-        mock2 = mock("ds2", :to_solr => {})
-        ngds = mock("ngds", :to_solr => {})
+        mock1 = double("ds1", :to_solr => {})
+        mock2 = double("ds2", :to_solr => {})
+        ngds = double("ngds", :to_solr => {})
         ngds.should_receive(:solrize_profile)
         mock1.should_receive(:solrize_profile)
         mock2.should_receive(:solrize_profile)
@@ -448,7 +448,7 @@ describe ActiveFedora::Base do
         @test_object.to_solr
       end
       it "should call .to_solr on all RDFDatastreams, passing the resulting document to solr" do
-        mock = mock("ds1", :to_solr => {})
+        mock = double("ds1", :to_solr => {})
         mock.should_receive(:solrize_profile)
         
         @test_object.should_receive(:datastreams).twice.and_return({:ds1 => mock})
@@ -484,7 +484,7 @@ describe ActiveFedora::Base do
     
     describe "get_values_from_datastream" do
       it "should look up the named datastream and call get_values with the given pointer/field_name" do
-        mock_ds = mock("Datastream", :get_values=>["value1", "value2"])
+        mock_ds = double("Datastream", :get_values=>["value1", "value2"])
         @test_object.stub(:datastreams).and_return({"ds1"=>mock_ds})
         @test_object.get_values_from_datastream("ds1", "--my xpath--").should == ["value1", "value2"]
       end
@@ -492,8 +492,8 @@ describe ActiveFedora::Base do
     
     describe "update_datastream_attributes" do
       it "should look up any datastreams specified as keys in the given hash and call update_attributes on the datastream" do
-        mock_desc_metadata = mock("descMetadata")
-        mock_properties = mock("properties")
+        mock_desc_metadata = double("descMetadata")
+        mock_properties = double("properties")
         mock_ds_hash = {'descMetadata'=>mock_desc_metadata, 'properties'=>mock_properties}
         
         ds_values_hash = {

data/spec/unit/content_model_spec.rb

@@ -53,12 +53,12 @@ describe ActiveFedora::ContentModel do
   
   describe "models_asserted_by" do
     it "should return an array of all of the content models asserted by the given object" do
-      mock_object = mock("ActiveFedora Object")
+      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 = mock("ActiveFedora Object")
+      mock_object = double("ActiveFedora Object")
       mock_object.should_receive(:relationships).with(:has_model).and_return([])
       ActiveFedora::ContentModel.models_asserted_by(mock_object).should == []
     end
@@ -66,23 +66,23 @@ describe ActiveFedora::ContentModel do
   
   describe "known_models_asserted_by" do
     it "should figure out the applicable models to load" do
-      mock_object = mock("ActiveFedora Object")
+      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 = mock("ActiveFedora Object")
+      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 = mock("ActiveFedora Object")
+      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 = mock("ActiveFedora Object")
+      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

data/spec/unit/datastream_spec.rb

@@ -99,7 +99,7 @@ describe ActiveFedora::Datastream do
          </datastreamProfile>"
       EOS
 
-      mock_repo = mock('repository', :config=>{})
+      mock_repo = double('repository', :config=>{})
       @test_object.inner_object.stub(:repository).and_return(mock_repo)
       mock_repo.should_receive(:datastream).with(:dsid => 'abcd', :pid => @test_object.pid).and_return(ds_profile)
       @test_datastream.size.should == 9999

data/spec/unit/datastreams_spec.rb

@@ -40,8 +40,8 @@ describe ActiveFedora::Datastreams do
 
   describe "#serialize_datastreams" do
     it "should touch each datastream" do
-      m1 = mock()
-      m2 = mock()
+      m1 = double()
+      m2 = double()
 
       m1.should_receive(:serialize!)
       m2.should_receive(:serialize!)
@@ -54,7 +54,7 @@ describe ActiveFedora::Datastreams do
     it "should infer dsLocations for E datastreams without hitting Fedora" do
       
       mock_specs = {:e => { :disseminator => 'xyz' }}
-      mock_ds = mock(:controlGroup => 'E')
+      mock_ds = double(:controlGroup => 'E')
       ActiveFedora::Base.stub(:ds_specs => mock_specs)
       ActiveFedora.stub(:config_for_environment => { :url => 'http://localhost'})
       subject.stub(:pid => 'test:1', :datastreams => {:e => mock_ds})
@@ -65,7 +65,7 @@ describe ActiveFedora::Datastreams do
 
   describe "#corresponding_datastream_name" do
     before(:each) do
-      subject.stub(:datastreams => { 'abc' => mock(), 'a_b_c' => mock(), 'a-b' => mock()})
+      subject.stub(:datastreams => { 'abc' => double(), 'a_b_c' => double(), 'a-b' => double()})
     end
 
     it "should use the name, if it exists" do
@@ -92,27 +92,27 @@ describe ActiveFedora::Datastreams do
     it "should look up the ds_spec" do
       mock_dsspec = { :type => nil }
       subject.stub(:ds_specs => {'abc' => mock_dsspec})
-      subject.configure_datastream(mock(:dsid => 'abc'))
+      subject.configure_datastream(double(:dsid => 'abc'))
     end
 
     it "should be ok if there is no ds spec" do
-      mock_dsspec = mock()
+      mock_dsspec = double()
       subject.stub(:ds_specs => {})
-      subject.configure_datastream(mock(:dsid => 'abc'))
+      subject.configure_datastream(double(:dsid => 'abc'))
     end
 
     it "should configure RelsExtDatastream" do
       mock_dsspec = { :type => ActiveFedora::RelsExtDatastream }
       subject.stub(:ds_specs => {'abc' => mock_dsspec})
 
-      ds = mock(:dsid => 'abc')
+      ds = double(:dsid => 'abc')
       ds.should_receive(:model=).with(subject)
 
       subject.configure_datastream(ds)
     end
 
     it "should run a Proc" do
-      ds = mock(:dsid => 'abc')
+      ds = double(:dsid => 'abc')
       @count = 0
       mock_dsspec = { :block => lambda { |x| @count += 1 } }
       subject.stub(:ds_specs => {'abc' => mock_dsspec})
@@ -139,7 +139,7 @@ describe ActiveFedora::Datastreams do
 
   describe "#add_datastream" do
     it "should add the datastream to the object" do
-      ds = mock(:dsid => 'Abc')
+      ds = double(:dsid => 'Abc')
       subject.add_datastream(ds)
       subject.datastreams['Abc'].should == ds
     end
@@ -152,11 +152,11 @@ describe ActiveFedora::Datastreams do
 
   describe "#metadata_streams" do
     it "should only be metadata datastreams" do
-      ds1 = mock(:metadata? => true)
-      ds2 = mock(:metadata? => true)
-      ds3 = mock(:metadata? => true)
+      ds1 = double(:metadata? => true)
+      ds2 = double(:metadata? => true)
+      ds3 = double(:metadata? => true)
       relsextds = ActiveFedora::RelsExtDatastream.new
-      file_ds = mock(:metadata? => false)
+      file_ds = double(:metadata? => false)
       subject.stub(:datastreams => {:a => ds1, :b => ds2, :c => ds3, :d => relsextds, :e => file_ds})
       subject.metadata_streams.should include(ds1, ds2, ds3)
       subject.metadata_streams.should_not include(relsextds)
@@ -170,14 +170,14 @@ describe ActiveFedora::Datastreams do
     end
 
     it "should start from the highest existin dsid" do
-      subject.stub(:datastreams => {'FOO56' => mock()})
+      subject.stub(:datastreams => {'FOO56' => double()})
       subject.generate_dsid('FOO').should == 'FOO57'
     end
   end
 
   describe "#relsext" do
     it "should be the RELS-EXT datastream" do
-      m = mock
+      m = double
       subject.stub(:datastreams => { 'RELS-EXT' => m})
       subject.rels_ext.should == m
     end
@@ -204,19 +204,19 @@ describe ActiveFedora::Datastreams do
     end
 
     it "should try to get a mime type from the blob" do
-      mock_file = mock(:content_type => 'x-application/asdf')
+      mock_file = double(:content_type => 'x-application/asdf')
       ds = subject.create_datastream(ActiveFedora::Datastream, nil, {:blob => mock_file})
       ds.mimeType.should == 'x-application/asdf'
     end
 
     it "should provide a default mime type" do
-      mock_file = mock()
+      mock_file = double()
       ds = subject.create_datastream(ActiveFedora::Datastream, nil, {:blob => mock_file})
       ds.mimeType.should == 'application/octet-stream'
     end
 
     it "should use the filename as a default label" do
-     mock_file = mock(:path => '/asdf/fdsa')
+     mock_file = double(:path => '/asdf/fdsa')
       ds = subject.create_datastream(ActiveFedora::Datastream, nil, {:blob => mock_file})
       ds.dsLabel.should == 'fdsa'
     end