active-fedora 5.1.0 → 5.2.0

data/spec/unit/callback_spec.rb

@@ -31,19 +31,24 @@ describe ActiveFedora::Base do
   end
 
   it "Should have after_initialize, before_save,after_save, before_create, after_create, after_update, before_update, before_destroy" do
-    CallbackStub.any_instance.expects(:a_init).twice
-    CallbackStub.any_instance.expects :b_create
-    CallbackStub.any_instance.expects :a_create
-    CallbackStub.any_instance.expects(:b_save).twice
-    CallbackStub.any_instance.expects(:a_save).twice
-    CallbackStub.any_instance.expects(:a_find)
-    CallbackStub.any_instance.expects(:b_update)
-    CallbackStub.any_instance.expects(:a_update)
-    CallbackStub.any_instance.expects(:do_stuff)
-    cb = CallbackStub.new
+    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
+    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(cb.pid)
+    cb2 = CallbackStub.find('test:123')
     cb2.save
 
     cb2.destroy

data/spec/unit/code_configurator_spec.rb

@@ -38,10 +38,10 @@ describe ActiveFedora::FileConfigurator do
   end
 
   it "should initialize from code" do
-    YAML.expects(:load).never
-    File.expects(:exists?).never
-    File.expects(:read).never
-    File.expects(:open).never
+    YAML.should_receive(:load).never
+    File.should_receive(:exists?).never
+    File.should_receive(:read).never
+    File.should_receive(:open).never
     ActiveFedora.init(@config_params)
     ActiveFedora.fedora_config.credentials.should == @config_params[:fedora_config]
     ActiveFedora.solr_config.should == @config_params[:solr_config]

data/spec/unit/content_model_spec.rb

@@ -20,8 +20,8 @@ describe ActiveFedora::ContentModel do
   
   before(:each) do
     stub_get('__nextid__')
-    ActiveFedora::Base.stubs(:assign_pid).returns("__nextid__")
-    Rubydora::Repository.any_instance.stubs(:client).returns(@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
   
@@ -54,12 +54,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.expects(:relationships).with(:has_model).returns(["info:fedora/fedora-system:ServiceDefinition-3.0", "info:fedora/afmodel:SampleModel", "info:fedora/afmodel:NonDefinedModel"])
+      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.expects(:relationships).with(:has_model).returns([])
+      mock_object.should_receive(:relationships).with(:has_model).and_return([])
       ActiveFedora::ContentModel.models_asserted_by(mock_object).should == []
     end
   end
@@ -67,23 +67,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.expects(:relationships).with(:has_model).returns(["info:fedora/fedora-system:ServiceDefinition-3.0", "info:fedora/afmodel:SampleModel", "info:fedora/afmodel:NonDefinedModel"])
+      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.expects(:relationships).with(:has_model).returns(["info:fedora/afmodel:Sample_NamespacedModel"])
+      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.expects(:relationships).with(:has_model).returns(["info:fedora/afmodel:NonDefinedModel"])
+      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.expects(:relationships).with(:has_model).returns([])
+      mock_object.should_receive(:relationships).with(:has_model).and_return([])
       ActiveFedora::ContentModel.known_models_for(mock_object).should == [ActiveFedora::Base]
     end
   end

data/spec/unit/datastream_collections_spec.rb

@@ -65,8 +65,8 @@ describe ActiveFedora::DatastreamCollections do
       @test_object2 = MockAddNamedDatastream.new
       @f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"))
       @f2 = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ))
-      @f.stubs(:content_type).returns("image/jpeg")
-      @f2.stubs(:original_filename).returns("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
@@ -96,7 +96,7 @@ describe ActiveFedora::DatastreamCollections do
     end 
 
     it "should check the file for a content type" do
-      @f.expects(:content_type).returns("image/jpeg")
+      @f.should_receive(:content_type).and_return("image/jpeg")
       @test_object2.add_named_datastream("thumbnail",{:file=>@f})
     end
 
@@ -105,7 +105,7 @@ describe ActiveFedora::DatastreamCollections do
     end
 
     it "should encsure mimetype and content type match" do
-      @f.stubs(:content_type).returns("image/tiff")
+      @f.stub(:content_type).and_return("image/tiff")
       expect { @test_object2.add_named_datastream("thumbnail",{:file=>f}) }.to raise_error
     end
       
@@ -118,7 +118,7 @@ describe ActiveFedora::DatastreamCollections do
 
     it "should cgecj that a dsid forms to the prefix" do
       #if dsid supplied check that conforms to prefix
-      @f.stubs(:content_type).returns("image/jpeg")
+      @f.stub(:content_type).and_return("image/jpeg")
       expect { @test_object2.add_named_datastream("thumbnail",{:file=>@f,:dsid=>"DS1"}) }.to raise_error
     end
 
@@ -155,8 +155,8 @@ describe ActiveFedora::DatastreamCollections do
       @test_object2 = MockAddNamedFileDatastream.new
       f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"))
       #these normally supplied in multi-part post request
-      f.stubs(:original_filename).returns("minivan.jpg")
-      f.stubs(:content_type).returns("image/jpeg")
+      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
       thumb.class.should == ActiveFedora::Datastream
@@ -183,10 +183,10 @@ describe ActiveFedora::DatastreamCollections do
       @test_object2 = MockUpdateNamedDatastream.new
       f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"))
       f2 = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ))
-      f.stubs(:content_type).returns("image/jpeg")
-      f.stubs(:original_filename).returns("minivan.jpg")
-      f2.stubs(:content_type).returns("image/jpeg")
-      f2.stubs(:original_filename).returns("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})
       had_exception = false
@@ -273,11 +273,11 @@ describe ActiveFedora::DatastreamCollections do
     it 'should return a hash of datastream names to arrays of datastreams' do
       @test_object2 = MockNamedDatastreams.new
       f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg" ))
-      f.stubs(:content_type).returns("image/jpeg")
-      f.stubs(:original_filename).returns("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.stubs(:content_type).returns("image/jpeg")
-      f2.stubs(:original_filename).returns("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"})
@@ -319,11 +319,11 @@ describe ActiveFedora::DatastreamCollections do
     it 'should provide a hash of datastreams names to array of datastream ids' do
       @test_object2 = MockNamedDatastreamsIds.new
       f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg" ))
-      f.stubs(:content_type).returns("image/jpeg")
-      f.stubs(:original_filename).returns("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.stubs(:content_type).returns("image/jpeg")
-      f2.stubs(:original_filename).returns("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"})
@@ -349,8 +349,8 @@ describe ActiveFedora::DatastreamCollections do
       @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.stubs(:original_filename).returns("dino.jpg")
-      f.stubs(:content_type).returns("image/jpeg")
+      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})
@@ -388,8 +388,8 @@ describe ActiveFedora::DatastreamCollections do
       @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.stubs(:content_type).returns("image/jpeg")
-      f.stubs(:original_filename).returns("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
       t2_thumb1.mimeType.should == "image/jpeg"

data/spec/unit/datastream_spec.rb

@@ -14,7 +14,7 @@ describe ActiveFedora::Datastream do
   its(:metadata?) { should be_false}
 
   it "should escape dots in  to_param" do
-    @test_datastream.stubs(:dsid).returns('foo.bar')
+    @test_datastream.stub(:dsid).and_return('foo.bar')
     @test_datastream.to_param.should == 'foo%2ebar'
   end
   
@@ -64,10 +64,10 @@ describe ActiveFedora::Datastream do
   describe '#save' do
     it "should set changed" do
       mock_repo = mock('repository')
-      mock_repo.stubs(:config).returns({})
-      mock_repo.stubs(:add_datastream).with(:versionable => true, :pid => @test_object.pid, :dsid => 'abcd', :controlGroup => 'M', :dsState => 'A', :content => 'hi there')
-      mock_repo.expects(:datastream).with(:dsid => 'abcd', :pid => @test_object.pid).returns('').at_least_once
-      @test_object.inner_object.stubs(:repository).returns(mock_repo)
+      mock_repo.stub(:config).and_return({})
+      mock_repo.stub(:add_datastream).with(:versionable => true, :pid => @test_object.pid, :dsid => 'abcd', :controlGroup => 'M', :dsState => 'A', :content => 'hi there')
+      mock_repo.stub(:datastream).with(:dsid => 'abcd', :pid => @test_object.pid).and_return('')
+      @test_object.inner_object.stub(:repository).and_return(mock_repo)
       @test_datastream.save
       @test_datastream.should_not be_changed
     end
@@ -122,8 +122,8 @@ describe ActiveFedora::Datastream do
       EOS
 
       mock_repo = mock('repository', :config=>{})
-      @test_object.inner_object.stubs(:repository).returns(mock_repo)
-      mock_repo.expects(:datastream).with(:dsid => 'abcd', :pid => @test_object.pid).returns(ds_profile)
+      @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
     end
 

data/spec/unit/datastreams_spec.rb

@@ -1,358 +1,243 @@
 require 'spec_helper'
 
 describe ActiveFedora::Datastreams do
-  before do
-    @test_object = ActiveFedora::Base.new
-  end
-
-  it "should respond_to has_metadata" do
-    ActiveFedora::Base.respond_to?(:has_metadata).should be_true
-  end
+  subject { ActiveFedora::Base.new }
 
-  describe ".metadata_streams" do
-    it "should return all of the datastreams from the object that are kinds of SimpleDatastreams " do
-      mock_mds1 = mock("metadata ds1")
-      mock_mds2 = mock("metadata ds2")
-      mock_fds = mock("file ds")
-      mock_fds.expects(:metadata?).returns(false)
-      mock_ngds = mock("nokogiri ds")
-      mock_ngds.expects(:metadata?).returns(true)
-      
-      [mock_mds1,mock_mds2].each do |ds|
-        ds.expects(:metadata?).returns(true)
+  describe '.has_metadata' do
+    before do
+      class FooHistory < ActiveFedora::Base
+         has_metadata :name => 'dsid'
+         has_metadata :name => 'complex_ds', :versionable => true, :autocreate => true, :type => 'Z', :label => 'My Label', :control_group => 'Z'
       end
-      
-      @test_object.expects(:datastreams).returns({:foo => mock_mds1, :bar => mock_mds2, :baz => mock_fds, :bork=>mock_ngds})
-      
-      result = @test_object.metadata_streams
-      result.length.should == 3
-      result.should include(mock_mds1)
-      result.should include(mock_mds2)
-      result.should include(mock_ngds)
+    end
+
+    it "should have a ds_specs entry" do
+      FooHistory.ds_specs.should have_key('dsid')
+    end
+
+    it "should have reasonable defaults" do
+      FooHistory.ds_specs['dsid'].should include(:autocreate => false)
+    end
+
+    it "should let you override defaults" do
+      FooHistory.ds_specs['complex_ds'].should include(:versionable => true, :autocreate => true, :type => 'Z', :label => 'My Label', :control_group => 'Z')
     end
   end
 
-  describe "datastream_from_spec" do
-    it "should accept versionable" do
-      ds = @test_object.datastream_from_spec({:type=>ActiveFedora::Datastream, :versionable=>false}, 'test')
-      ds.versionable.should be_false
-      ds = @test_object.datastream_from_spec({:type=>ActiveFedora::Datastream, :versionable=>true}, 'test')
-      ds.versionable.should be_true
+  describe '.has_file_datastream' do
+    before do
+      class FooHistory < ActiveFedora::Base
+         has_file_datastream :name => 'dsid'
+      end
     end
-    it "should default versionable to true" do
-      ds = @test_object.datastream_from_spec({:type=>ActiveFedora::Datastream}, 'test') 
-      ds.versionable.should be_true
+
+    it "should have reasonable defaults" do
+      FooHistory.ds_specs['dsid'].should include(:type => ActiveFedora::Datastream, :label => 'File Datastream', :control_group => 'M')
     end
+  end
+
+  describe "#serialize_datastreams" do
+    it "should touch each datastream" do
+      m1 = mock()
+      m2 = mock()
 
+      m1.should_receive(:serialize!)
+      m2.should_receive(:serialize!)
+       subject.stub(:datastreams => { :m1 => m1, :m2 => m2})
+       subject.serialize_datastreams
+    end
   end
 
-  describe "has_metadata" do
-    @@last_pid = 0
-    def increment_pid
-      @@last_pid += 1    
+  describe "#add_disseminator_location_to_datastreams" do
+    it "should infer dsLocations for E datastreams without hitting Fedora" do
+      
+      mock_specs = {:e => { :disseminator => 'xyz' }}
+      mock_ds = mock(: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})
+      mock_ds.should_receive(:dsLocation=).with("http://localhost/objects/test:1/methods/xyz")
+      subject.add_disseminator_location_to_datastreams
     end
+  end
 
+  describe "#corresponding_datastream_name" do
     before(:each) do
-      @this_pid = increment_pid.to_s
-      stub_get(@this_pid)
-      Rubydora::Repository.any_instance.stubs(:client).returns(@mock_client)
-      ActiveFedora::Base.stubs(:assign_pid).returns(@this_pid)
-      #ActiveFedora::RubydoraConnection.instance.stubs(:nextid).returns(@this_pid)
+      subject.stub(:datastreams => { 'abc' => mock(), 'a_b_c' => mock(), 'a-b' => mock()})
     end
 
-    describe "updates the spec" do
-      before do
-        class FooHistory < ActiveFedora::Base
-        end
-      end
-      after do
-        Object.send(:remove_const, :FooHistory)
-      end
-      subject { FooHistory}
-      it "should update the ds_spec" do
-        FooHistory.ds_specs.keys.should == ['RELS-EXT']
-        FooHistory.has_metadata :type=>ActiveFedora::Datastream, :name=>'new_ds'
-        FooHistory.ds_specs.keys.should include 'new_ds'
-      end
-      it "should be able to set a type" do
-        FooHistory.has_metadata :type=>ActiveFedora::Datastream, :name=>'new_ds', :control_group=>'R'
-        FooHistory.ds_specs['new_ds'][:control_group].should == 'R'
-      end
-      it "should be able to set versionable to false" do
-        FooHistory.has_metadata :type=>ActiveFedora::Datastream, :name=>'new_ds', :versionable=>false
-        FooHistory.has_file_datastream :type=>ActiveFedora::Datastream, :name=>'newer_ds', :versionable=>false
-        FooHistory.ds_specs['new_ds'][:versionable].should be_false
-        FooHistory.ds_specs['newer_ds'][:versionable].should be_false
-      end
-      it "should be able to set versionable to true" do
-        FooHistory.has_metadata :type=>ActiveFedora::Datastream, :name=>'new_ds', :versionable=>true
-        FooHistory.ds_specs['new_ds'][:versionable].should be_true
-      end
-      it "should not set versionable if it's not supplied" do
-        FooHistory.has_metadata :type=>ActiveFedora::Datastream, :name=>'new_ds'
-        FooHistory.ds_specs['new_ds'].keys.should_not include :versionable
-      end
-      
+    it "should use the name, if it exists" do
+      subject.corresponding_datastream_name('abc').should == 'abc'
     end
 
-    describe "creates datastreams" do
-      before(:each) do
-        class FooHistory < ActiveFedora::Base
-          has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"someData", :autocreate => true do |m|
-            m.field "fubar", :string
-            m.field "swank", :text
-          end
-          has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"withText2", :label=>"withLabel", :autocreate => true do |m|
-            m.field "fubar", :text
-          end 
-          
-          has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"no_autocreate", :autocreate => false, :label=>"withLabel" do |m|
-            m.field "fubar", :text
-          end 
-        end
-        stub_ingest(@this_pid)
-        stub_add_ds(@this_pid, ['RELS-EXT', 'someData', 'withText', 'withText2','no_autocreate'])
-
-        @n = FooHistory.new()
-        FooHistory.stubs(:assign_pid).returns(@this_pid)
-        @n.datastreams['RELS-EXT'].expects(:changed?).returns(true).at_least_once
-        @n.expects(:update_index)
-      end
+    it "should hash-erize underscores" do
+      subject.corresponding_datastream_name('a_b').should == 'a-b'
+    end
 
-      after do
-        Object.send(:remove_const, :FooHistory)
-      end
+    it "should return nil if nothing matches" do
+      subject.corresponding_datastream_name('xyz').should be_nil
+    end
+  end
+ 
+  describe "#datastreams" do
+    it "should return the datastream hash proxy" do
+      subject.stub(:load_datastreams)
+      subject.datastreams.should be_a_kind_of(ActiveFedora::DatastreamHash)
+    end
+  end
 
-      it "should respect autocreate => false" do
-        @n.datastreams['no_autocreate'].expects(:save).never
-        @n.save
-      end
+  describe "#configure_datastream" 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'))
+    end
 
-      it "should default to autocreating datastreams" do
-        @n.datastreams['someData'].expects(:save).once
-        @n.save
-      end
+    it "should be ok if there is no ds spec" do
+      mock_dsspec = mock()
+      subject.stub(:ds_specs => {})
+      subject.configure_datastream(mock(:dsid => 'abc'))
+    end
 
-      it "should create specified datastreams with specified fields" do
-        @n.save
-        @n.datastreams["someData"].should_not be_nil
-        @n.datastreams["someData"].fubar='bar'
-        @n.datastreams["someData"].fubar.should == ['bar']
-        @n.datastreams["withText2"].dsLabel.should == "withLabel"
-      end
+    it "should configure RelsExtDatastream" do
+      mock_dsspec = { :type => ActiveFedora::RelsExtDatastream }
+      subject.stub(:ds_specs => {'abc' => mock_dsspec})
+
+      ds = mock(:dsid => 'abc')
+      ds.should_receive(:model=).with(subject)
+
+      subject.configure_datastream(ds)
     end
 
+    it "should run a Proc" do
+      ds = mock(:dsid => 'abc')
+      @count = 0
+      mock_dsspec = { :block => lambda { |x| @count += 1 } }
+      subject.stub(:ds_specs => {'abc' => mock_dsspec})
 
-    it "should create specified datastreams with appropriate control group" do
-      ActiveFedora.stubs(:config_for_environment).returns(:url=>'sub_url')
-      stub_ingest(@this_pid)
-      stub_add_ds(@this_pid, ['RELS-EXT', 'DC', 'rightsMetadata', 'properties', 'descMetadata', 'UKETD_DC'])
-      stub_get(@this_pid, ['RELS-EXT', 'DC', 'rightsMetadata', 'properties', 'descMetadata', 'UKETD_DC'])
-      class UketdObject < ActiveFedora::Base
-        has_metadata :name => "rightsMetadata", :label=>"Rights metadata", :type => ActiveFedora::NokogiriDatastream 
-        
-        # Uses the Hydra MODS Article profile for tracking most of the descriptive metadata
-        # TODO: define terminology for ETD
-        has_metadata :name => "descMetadata", :label=>"MODS metadata", :control_group=>"M", :type => ActiveFedora::NokogiriDatastream
 
-        has_metadata :name => "UKETD_DC", :label=>"UKETD_DC metadata", :control_group => "E", :disseminator=>"hull-sDef:uketdObject/getUKETDMetadata", :type => ActiveFedora::NokogiriDatastream
+      expect {
+      subject.configure_datastream(ds)
+      }.to change { @count }.by(1)
+    end
+  end
 
-        has_metadata :name => "DC", :type => ActiveFedora::NokogiriDatastream, :label=>"DC admin metadata"
+  describe "#datastream_from_spec" do
+    it "should fetch the rubydora datastream" do
+      subject.inner_object.should_receive(:datastream_object_for).with('dsid', {})
+      subject.datastream_from_spec({}, 'dsid')
+    end
+  end
 
-        # A place to put extra metadata values
-        has_metadata :name => "properties", :label=>"Workflow properties", :type => ActiveFedora::SimpleDatastream do |m|
-          m.field 'collection', :string
-          m.field 'depositor', :string
-        end
+  describe "#load_datastreams" do
+    it "should load and configure persisted datastreams and should add any datastreams left over in the ds specs" do
+      pending
+    end
+  end
 
-      end
-      @n = UketdObject.new()
-      UketdObject.stubs(:assign_pid).returns(@this_pid)
-      @n.save
-      @n.datastreams["DC"].controlGroup.should eql("X")
-      @n.datastreams["rightsMetadata"].controlGroup.should eql("X")
-      @n.datastreams["properties"].controlGroup.should eql("X")
-      @n.datastreams["descMetadata"].controlGroup.should eql("M")
-      @n.datastreams["UKETD_DC"].controlGroup.should eql("E")
-      @n.datastreams["UKETD_DC"].dsLocation.should == "sub_url/objects/#{@this_pid}/methods/hull-sDef:uketdObject/getUKETDMetadata"
-    end
-
-
-    context ":control_group => 'E'" do
-      before do
-        stub_get(@this_pid)
-        stub_add_ds(@this_pid, ['RELS-EXT', 'externalDisseminator', 'externalUrl'])
-      end
+  describe "#add_datastream" do
+    it "should add the datastream to the object" do
+      ds = mock(:dsid => 'Abc')
+      subject.add_datastream(ds)
+      subject.datastreams['Abc'].should == ds
+    end
 
-      after :each do
-        # clean up test class
-        Object.send(:remove_const, :MoreFooHistory)
-      end
-      
-      it "should allow :control_group => 'E' with a :url option" do
-        class MoreFooHistory < ActiveFedora::Base
-          has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"externalDisseminator",:control_group => "E", :url => "http://exampl.com/mypic.jpg"
-        end
-        stub_ingest(@this_pid)
-        @n = MoreFooHistory.new
-        MoreFooHistory.stubs(:assign_pid).returns(@this_pid)
-        @n.save
-        @n.datastreams['externalDisseminator'].dsLocation.should == "http://exampl.com/mypic.jpg"
-      end
-      
-      describe "control_group E without a url" do
-        before do
-          class MoreFooHistory < ActiveFedora::Base
-            has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"externalDisseminator",:control_group => "E"
-          end
-          stub_ingest(@this_pid)
-          @n = MoreFooHistory.new
-          MoreFooHistory.stubs(:assign_pid).returns(@this_pid)
-        end
-        it "should allow :control_group => 'E' without a :url option" do
-          @n.datastreams['externalDisseminator'].dsLocation.present?.should == false
-          @n.save
-        end
-        
-        it "should fail validation if a :url is not added before save" do
-          @n.datastreams['externalDisseminator'].validate_content_present.should == false
-          @n.save
-        end
-        
-        it "should pass validation if a :url is added before save" do
-          @n.datastreams['externalDisseminator'].dsLocation = "http://exampl.com/mypic.jpg"
-          @n.datastreams['externalDisseminator'].validate_content_present.should == true
-          @n.save
-        end
-      end
+    it "should mint a dsid" do
+      ds = ActiveFedora::Datastream.new
+      subject.add_datastream(ds).should == 'DS1'
     end
+  end
 
-    context ":control_group => 'R'" do
-      before do
-        stub_get(@this_pid)
-        stub_add_ds(@this_pid, ['RELS-EXT', 'externalDisseminator' ])
-      end
-      
-      after :each do
-        Object.send(:remove_const, :MoreFooHistory)
-      end
-      
-      it "should allow :control_group => 'R' with a :url option" do
-        stub_ingest(@this_pid)
-        class MoreFooHistory < ActiveFedora::Base
-          has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"externalDisseminator",:control_group => "R", :url => "http://exampl.com/mypic.jpg"
-        end
-        @n = MoreFooHistory.new
-        MoreFooHistory.stubs(:assign_pid).returns(@this_pid)
-        @n.save
-      end
-    
-      describe "control_group R without url" do
-        before do
-          class MoreFooHistory < ActiveFedora::Base
-            has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"externalDisseminator",:control_group => "R"
-          end
-          MoreFooHistory.stubs(:assign_pid).returns(@this_pid)
-          stub_ingest(@this_pid)
-          @n = MoreFooHistory.new
-        end
-        it "should allow :control_group => 'R' without a :url option" do
-          @n.datastreams['externalDisseminator'].dsLocation.present?.should == false
-          @n.save
-        end
-      
-        it "should fail validation if a :url is not added before save" do
-          @n.datastreams['externalDisseminator'].validate_content_present.should == false
-          @n.save
-        end
-      
-        it "should pass validation if a :url is added before save" do
-          @n.datastreams['externalDisseminator'].dsLocation = "http://exampl.com/mypic.jpg"
-          @n.datastreams['externalDisseminator'].validate_content_present.should == true
-          @n.save
-        end
-      end
+  describe "#metadata_streams" do
+    it "should only be metadata datastreams" do
+      ds1 = mock(:metadata? => true)
+      ds2 = mock(:metadata? => true)
+      ds3 = mock(:metadata? => true)
+      relsextds = ActiveFedora::RelsExtDatastream.new
+      file_ds = mock(: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)
+      subject.metadata_streams.should_not include(file_ds)
     end
   end
 
-  describe "#create_datastream" do
-    it 'should create a datastream object using the type of object supplied in the string (does reflection)' do
-      f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"))
-      f.stubs(:content_type).returns("image/jpeg")
-      f.stubs(:original_filename).returns("minivan.jpg")
-      ds = @test_object.create_datastream("ActiveFedora::Datastream", 'NAME', {:blob=>f})
-      ds.class.should == ActiveFedora::Datastream
-      ds.dsLabel.should == "minivan.jpg"
-      ds.mimeType.should == "image/jpeg"
-    end
-    it 'should create a datastream object from a string' do
-      ds = @test_object.create_datastream("ActiveFedora::Datastream", 'NAME', {:blob=>"My file data"})
-      ds.class.should == ActiveFedora::Datastream
-      ds.dsLabel.should == nil
-      ds.mimeType.should == "application/octet-stream"
-    end
-
-    it 'should not set dsLocation if dsLocation is nil' do
-      ActiveFedora::Datastream.any_instance.expects(:dsLocation=).never
-      ds = @test_object.create_datastream("ActiveFedora::Datastream", 'NAME', {:dsLocation=>nil})
-    end
-
-    it 'should set attributes passed in onto the datastream' do
-      ds = @test_object.create_datastream("ActiveFedora::Datastream", 'NAME', {:dsLocation=>"a1", :mimeType=>'image/png', :controlGroup=>'X', :dsLabel=>'My Label', :checksumType=>'SHA-1'})
-      ds.location.should == 'a1'
-      ds.mimeType.should == 'image/png'
-      ds.controlGroup.should == 'X'
-      ds.label.should == 'My Label'
-      ds.checksumType.should == 'SHA-1'
+  describe "#generate_dsid" do
+    it "should create an autoincrementing dsid" do
+      subject.generate_dsid('FOO').should == 'FOO1'
+    end
+
+    it "should start from the highest existin dsid" do
+      subject.stub(:datastreams => {'FOO56' => mock()})
+      subject.generate_dsid('FOO').should == 'FOO57'
     end
   end
 
-  describe ".has_file_datastream" do
-    before do
-      class FileDS < ActiveFedora::Datastream; end
-      class FooHistory < ActiveFedora::Base
-        has_file_datastream
-        has_file_datastream :name=>"second", :label=>"Second file", :type=>FileDS, :control_group=>'X'
-      end
+  describe "#dc" do
+    it "should be the DC datastream" do
+      m = mock
+      subject.stub(:datastreams => { 'DC' => m})
+      subject.dc.should == m
     end
-    after do
-      Object.send(:remove_const, :FooHistory)
-      Object.send(:remove_const, :FileDS)
+  end
+
+
+  describe "#relsext" do
+    it "should be the RELS-EXT datastream" do
+      m = mock
+      subject.stub(:datastreams => { 'RELS-EXT' => m})
+      subject.rels_ext.should == m
     end
-    it "Should add a line in ds_spec" do
-      FooHistory.ds_specs['content'][:type].should == ActiveFedora::Datastream
-      FooHistory.ds_specs['content'][:label].should == "File Datastream"
-      FooHistory.ds_specs['content'][:control_group].should == "M"
-      FooHistory.ds_specs['second'][:type].should == FileDS
-      FooHistory.ds_specs['second'][:label].should == "Second file"
-      FooHistory.ds_specs['second'][:control_group].should == "X"
+
+    it "should make one up otherwise" do
+      subject.stub(:datastreams => {})
+
+      subject.rels_ext.should be_a_kind_of(ActiveFedora::RelsExtDatastream)
     end
   end
 
   describe "#add_file_datastream" do
-    before do
-      @mock_file = mock('file')
+    # tested elsewhere :/
+  end 
+
+  describe "#create_datastream" do
+    it "should mint a DSID" do
+      ds = subject.create_datastream(ActiveFedora::Datastream, nil, {})
+      ds.dsid.should == 'DS1'
     end
-    it "should pass prefix" do
-      stub_add_ds(@test_object.pid, ['content1'])
-      @test_object.add_file_datastream(@mock_file, :prefix=>'content' )
-      @test_object.datastreams.keys.should include 'content1'
+
+    it "should raise an argument error if the supplied dsid is nonsense" do
+      expect { subject.create_datastream(ActiveFedora::Datastream, 0) }.to raise_error(ArgumentError)
     end
-    it "should pass dsid" do
-      stub_add_ds(@test_object.pid, ['MY_DSID'])
-      @test_object.add_file_datastream(@mock_file, :dsid=>'MY_DSID')
-      @test_object.datastreams.keys.should include 'MY_DSID'
+
+    it "should try to get a mime type from the blob" do
+      mock_file = mock(:content_type => 'x-application/asdf')
+      ds = subject.create_datastream(ActiveFedora::Datastream, nil, {:blob => mock_file})
+      ds.mimeType.should == 'x-application/asdf'
     end
-    it "without dsid or prefix" do
-      stub_add_ds(@test_object.pid, ['DS1'])
-      @test_object.add_file_datastream(@mock_file, {} )
-      @test_object.datastreams.keys.should include 'DS1'
+
+    it "should provide a default mime type" do
+      mock_file = mock()
+      ds = subject.create_datastream(ActiveFedora::Datastream, nil, {:blob => mock_file})
+      ds.mimeType.should == 'application/octet-stream'
     end
-    it "Should pass checksum Type" do
-      stub_add_ds(@test_object.pid, ['DS1'])
-      @test_object.add_file_datastream(@mock_file, {:checksumType=>'MD5'} )
-      @test_object.datastreams['DS1'].checksumType.should == 'MD5'
+
+    it "should use the filename as a default label" do
+     mock_file = mock(:path => '/asdf/fdsa')
+      ds = subject.create_datastream(ActiveFedora::Datastream, nil, {:blob => mock_file})
+      ds.dsLabel.should == 'fdsa'
     end
   end
 
+  describe "#additional_attributes_for_external_and_redirect_control_groups" do
+    before(:all) do
+      @behavior = ActiveFedora::Datastreams.deprecation_behavior
+      ActiveFedora::Datastreams.deprecation_behavior = :silence
+    end
+  
+     after :all do
+      ActiveFedora::Datastreams.deprecation_behavior = @behavior
+    end
+
+  end
 end