active-fedora 1.1.13 → 1.2.0

data/spec/integration/metadata_datastream_helper_spec.rb

@@ -0,0 +1,103 @@
+require File.join( File.dirname(__FILE__), "../spec_helper" )
+
+require 'active_fedora'
+require "rexml/document"
+require 'ftools'
+
+class MockMetaHelperSolr < ActiveFedora::Base
+  has_metadata :name => "properties", :type => ActiveFedora::MetadataDatastream do |m|
+    m.field "holding_id", :string
+  end
+  
+  has_metadata :name => "descMetadata", :type => ActiveFedora::QualifiedDublinCoreDatastream do |m|
+    m.field "created", :date, :xml_node => "created"
+    m.field "language", :string, :xml_node => "language"
+    m.field "creator", :string, :xml_node => "creator"
+    # Created remaining fields
+    m.field "geography", :string, :xml_node => "geography"
+    m.field "title", :string, :xml_node => "title"
+  end
+end
+
+describe ActiveFedora::MetadataDatastreamHelper do
+  
+  before(:each) do
+    @test_object = ActiveFedora::Base.new
+    @test_object.save
+  end
+  
+  after(:each) do
+    begin
+    @test_object.delete
+    rescue
+    end
+    begin
+    @test_object2.delete
+    rescue
+    end
+    begin
+    @test_object3.delete
+    rescue
+    end
+  end
+  
+  describe '#from_solr' do
+    it 'should return an object with the appropriate metadata fields filled in' do
+      @test_object = MockMetaHelperSolr.new
+      @test_object.new_object = true
+      attributes = {"holding_id"=>{0=>"Holding 1"},
+                    "language"=>{0=>"Italian"},
+                    "creator"=>{0=>"Linguist, A."},
+                    "geography"=>{0=>"Italy"},
+                    "title"=>{0=>"Italian and Spanish: A Comparison of Common Phrases"}}
+      @test_object.update_indexed_attributes(attributes)
+      @test_object.save
+      
+      @test_object2 = MockMetaHelperSolr.new
+      @test_object2.new_object = true
+      attributes = {"holding_id"=>{0=>"Holding 2"},
+                    "language"=>{0=>"Spanish;Latin"},
+                    "creator"=>{0=>"Linguist, A."},
+                    "geography"=>{0=>"Spain"},
+                    "title"=>{0=>"A study of the evolution of Spanish from Latin"}}
+      @test_object2.update_indexed_attributes(attributes)
+      @test_object2.save      
+
+      @test_object3 = MockMetaHelperSolr.new
+      @test_object3.new_object = true
+      attributes = {"holding_id"=>{0=>"Holding 3"},
+                    "language"=>{0=>"Spanish;Latin"},
+                    "creator"=>{0=>"Linguist, A."},
+                    "geography"=>{0=>"Spain"},
+                    "title"=>{0=>"An obscure look into early nomadic tribes of Spain"}}
+      @test_object3.update_indexed_attributes(attributes)
+      @test_object3.save
+      
+      #from_solr gets called indirectly
+      test_from_solr_object = MockMetaHelperSolr.load_instance_from_solr(@test_object.pid)
+      test_from_solr_object2 = MockMetaHelperSolr.load_instance_from_solr(@test_object2.pid)
+      test_from_solr_object3 = MockMetaHelperSolr.load_instance_from_solr(@test_object3.pid)
+      
+      test_from_solr_object.fields[:language][:values].should == ["Italian"]
+      test_from_solr_object.fields[:creator][:values].should == ["Linguist, A."]
+      test_from_solr_object.fields[:geography][:values].should == ["Italy"]
+      test_from_solr_object.fields[:title][:values].should == ["Italian and Spanish: A Comparison of Common Phrases"]
+      test_from_solr_object.fields[:holding_id][:values].should == ["Holding 1"]
+      
+      test_from_solr_object2.fields[:language][:values].should == ["Spanish;Latin"]
+      test_from_solr_object2.fields[:creator][:values].should == ["Linguist, A."]
+      test_from_solr_object2.fields[:geography][:values].should == ["Spain"]
+      test_from_solr_object2.fields[:title][:values].should == ["A study of the evolution of Spanish from Latin"]
+      test_from_solr_object2.fields[:holding_id][:values].should == ["Holding 2"]
+      
+      test_from_solr_object3.fields[:language][:values].should == ["Spanish;Latin"]
+      test_from_solr_object3.fields[:creator][:values].should == ["Linguist, A."]
+      test_from_solr_object3.fields[:geography][:values].should == ["Spain"]
+      test_from_solr_object3.fields[:title][:values].should == ["An obscure look into early nomadic tribes of Spain"]
+      test_from_solr_object3.fields[:holding_id][:values].should == ["Holding 3"]
+      
+      
+    end
+  end
+  
+end

data/spec/integration/model_spec.rb

@@ -13,30 +13,31 @@ describe ActiveFedora::Model do
   
   
   before(:each) do 
-    module SpecModel
+    module ModelIntegrationSpec
       
       class Basic < ActiveFedora::Base
-        #include ActiveFedora::Model
+        include ActiveFedora::Model
       end
       
     end
-    @test_instance = SpecModel::Basic.new
+
+    @test_instance = ModelIntegrationSpec::Basic.new
     @test_instance.save
     
   end
   
   after(:each) do
     @test_instance.delete
-    Object.send(:remove_const, :SpecModel)
+    Object.send(:remove_const, :ModelIntegrationSpec)
   end
   
   describe '#find' do
     it "should return an array of instances of the calling Class" do
       pending
-      result = SpecModel::Basic.find(:all)
+      result = ModelIntegrationSpec::Basic.find(:all)
       result.should be_instance_of(Array)
       result.each do |obj|
-        obj.class.should == SpecModel::Basic
+        obj.class.should == ModelIntegrationSpec::Basic
       end
     end
   end
@@ -44,9 +45,9 @@ describe ActiveFedora::Model do
   describe '#find_model' do
     
     it "should return an object of the given Model whose inner object is nil" do
-      #result = SpecModel::Basic.find_model(@test_instance.pid, SpecModel::Basic)
-      result = Fedora::Repository.instance.find_model(@test_instance.pid, SpecModel::Basic)
-      result.class.should == SpecModel::Basic
+      #result = ModelIntegrationSpec::Basic.find_model(@test_instance.pid, ModelIntegrationSpec::Basic)
+      result = Fedora::Repository.instance.find_model(@test_instance.pid, ModelIntegrationSpec::Basic)
+      result.class.should == ModelIntegrationSpec::Basic
       result.inner_object.new_object?.should be_false
     end
   end

data/spec/integration/rels_ext_datastream_spec.rb

@@ -4,6 +4,13 @@ require 'active_fedora'
 require "rexml/document"
 require 'ftools'
 
+class MockAFRelsSolr < ActiveFedora::Base
+  has_relationship "testing", :has_part, :type=>MockAFRelsSolr
+  has_relationship "testing2", :has_member, :type=>MockAFRelsSolr
+  has_relationship "testing_inbound", :has_part, :type=>MockAFRelsSolr, :inbound=>true
+  has_relationship "testing_inbound2", :has_member, :type=>MockAFRelsSolr, :inbound=>true
+end
+
 describe ActiveFedora::RelsExtDatastream do
   
   before(:all) do
@@ -29,7 +36,26 @@ describe ActiveFedora::RelsExtDatastream do
   end
   
   after(:each) do
+    begin
     @test_object.delete
+    rescue
+    end
+    begin
+    @test_object2.delete
+    rescue
+    end
+    begin
+    @test_object3.delete
+    rescue
+    end
+    begin
+    @test_object4.delete
+    rescue
+    end
+    begin
+    @test_object5.delete
+    rescue
+    end
   end
   
   
@@ -64,4 +90,63 @@ describe ActiveFedora::RelsExtDatastream do
     @test_object.relationships[:self].should have_key(:is_member_of)
     ActiveFedora::Base.load_instance(@test_object.pid).relationships.should == @test_object.relationships
   end
+  
+  describe '#from_solr' do
+    
+    it "should respond_to from_solr" do
+      @test_datastream.respond_to?(:from_solr).should be_true
+    end
+    
+    it 'should populate the relationships hash based on data in solr only for any possible fedora predicates' do
+      @test_object2 = MockAFRelsSolr.new
+      @test_object2.new_object = true
+      @test_object2.save
+      @test_object3 = MockAFRelsSolr.new
+      @test_object3.new_object = true
+      @test_object3.save
+      @test_object4 = MockAFRelsSolr.new
+      @test_object4.new_object = true
+      @test_object4.save
+      @test_object5 = MockAFRelsSolr.new
+      @test_object5.new_object = true
+      @test_object5.save
+      #append to named relationship 'testing'
+      @test_object2.testing_append(@test_object3)
+      @test_object2.testing2_append(@test_object4)
+      @test_object5.testing_append(@test_object2)
+      @test_object5.testing2_append(@test_object3)
+      @test_object2.save
+      @test_object5.save
+      r2 = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:dummy, :object=>@test_object2)
+      r3 = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:dummy, :object=>@test_object3)
+      r4 = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:dummy, :object=>@test_object4)
+      r5 = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:dummy, :object=>@test_object5)
+      model_rel = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:dummy, :object=>ActiveFedora::ContentModel.pid_from_ruby_class(MockAFRelsSolr))
+      #check inbound correct, testing goes to :has_part and testing2 goes to :has_member
+      #get solr doc for @test_object2
+      solr_doc = MockAFRelsSolr.find_by_solr(@test_object2.pid).hits.first
+      test_from_solr_object2 = MockAFRelsSolr.new
+      test_from_solr_object2.rels_ext.from_solr(solr_doc)
+      solr_doc = MockAFRelsSolr.find_by_solr(@test_object3.pid).hits.first
+      test_from_solr_object3 = MockAFRelsSolr.new
+      test_from_solr_object3.rels_ext.from_solr(solr_doc)
+      solr_doc = MockAFRelsSolr.find_by_solr(@test_object4.pid).hits.first
+      test_from_solr_object4 = MockAFRelsSolr.new
+      test_from_solr_object4.rels_ext.from_solr(solr_doc)
+      solr_doc = MockAFRelsSolr.find_by_solr(@test_object5.pid).hits.first
+      test_from_solr_object5 = MockAFRelsSolr.new
+      test_from_solr_object5.rels_ext.from_solr(solr_doc)
+      
+      test_from_solr_object2.relationships.should == {:self=>{:has_part=>[r3.object],:has_member=>[r4.object],:has_model=>[model_rel.object]}}
+      test_from_solr_object2.named_relationships.should == {:self=>{"testing"=>[r3.object],"testing2"=>[r4.object]}}
+      test_from_solr_object3.relationships.should == {:self=>{:has_model=>[model_rel.object]}}
+      test_from_solr_object3.named_relationships.should == {:self=>{"testing"=>[],"testing2"=>[]}}
+      test_from_solr_object4.relationships.should == {:self=>{:has_model=>[model_rel.object]}}
+      test_from_solr_object4.named_relationships.should == {:self=>{"testing"=>[],"testing2"=>[]}}
+      test_from_solr_object5.relationships.should == {:self=>{:has_model=>[model_rel.object],
+                                                             :has_part=>[r2.object],
+                                                             :has_member=>[r3.object]}}
+      test_from_solr_object5.named_relationships.should == {:self=>{"testing"=>[r2.object],"testing2"=>[r3.object]}}
+    end
+  end
 end

data/spec/integration/semantic_node_spec.rb

@@ -90,6 +90,5 @@ describe ActiveFedora::SemanticNode do
         id.should satisfy {|id| id == @container1.pid || @container2.pid}
       end  
     end
-  end
-  
+  end  
 end

data/spec/integration/solr_service_spec.rb

@@ -6,9 +6,27 @@ describe ActiveFedora::SolrService do
   describe "#reify_solr_results" do
     before(:all) do
       class FooObject < ActiveFedora::Base
+        has_metadata :name => "properties", :type => ActiveFedora::MetadataDatastream do |m|
+          m.field "holding_id", :string
+        end
+  
+        has_metadata :name => "descMetadata", :type => ActiveFedora::QualifiedDublinCoreDatastream do |m|
+          m.field "created", :date, :xml_node => "created"
+          m.field "language", :string, :xml_node => "language"
+          m.field "creator", :string, :xml_node => "creator"
+          # Created remaining fields
+          m.field "geography", :string, :xml_node => "geography"
+          m.field "title", :string, :xml_node => "title"
+        end
       end
       @test_object = ActiveFedora::Base.new
       @foo_object = FooObject.new
+      attributes = {"holding_id"=>{0=>"Holding 1"},
+                    "language"=>{0=>"Italian"},
+                    "creator"=>{0=>"Linguist, A."},
+                    "geography"=>{0=>"Italy"},
+                    "title"=>{0=>"Italian and Spanish: A Comparison of Common Phrases"}}
+      @foo_object.update_indexed_attributes(attributes)
       @test_object.save
       @foo_object.save
     end
@@ -26,5 +44,23 @@ describe ActiveFedora::SolrService do
       end
     end
     
+    it 'should load objects from solr data if a :load_from_solr option is passed in' do
+      query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@test_object.pid)} OR id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
+      solr_result = ActiveFedora::SolrService.instance.conn.query(query)
+      result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
+      result.length.should == 2
+      result.each do |r|
+        (r.class == ActiveFedora::Base || r.class == FooObject).should be_true
+      end
+    end
+    
+    it 'should call load_instance_from_solr if :load_from_solr option passed in' do
+      query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@test_object.pid)} OR id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
+      solr_result = ActiveFedora::SolrService.instance.conn.query(query)
+      ActiveFedora::Base.expects(:load_instance_from_solr).times(1)
+      FooObject.expects(:load_instance_from_solr).times(1)
+      result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
+    end
+    
   end
 end

data/spec/unit/base_file_management_spec.rb

@@ -1,5 +1,4 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-require "active_fedora"
 
 # Some tentative extensions to ActiveFedora::Base
 

data/spec/unit/base_named_datastream_spec.rb

@@ -0,0 +1,580 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require "active_fedora"
+
+# Some tentative extensions to ActiveFedora::Base
+
+describe ActiveFedora::Base do
+  
+  def increment_pid
+    @@last_pid += 1    
+  end
+  
+  before(:each) do
+    Fedora::Repository.instance.stubs(:nextid).returns(increment_pid)
+    @test_object = ActiveFedora::Base.new
+    @test_object.new_object = true
+  end
+
+  after(:each) do
+    begin
+    @test_object.delete
+    rescue
+    end
+  
+    begin
+    @test_object2.delete
+    rescue
+    end
+    
+    begin
+    @test_object3.delete
+    rescue
+    end
+  end
+  
+  it 'should provide #datastream_names' do
+    @test_object.should respond_to(:datastream_names)
+  end
+  
+  describe '#datastream_names' do
+    class MockDatastreamNames < ActiveFedora::Base
+      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
+    
+    it 'should return an array of datastream names defined by has_datastream' do
+      Fedora::Repository.instance.stubs(:nextid).returns(increment_pid)
+      @test_object2 = MockDatastreamNames.new
+      @test_object2.datastream_names.should == ["thumbnail","EAD"]
+    end
+  end
+  
+  it 'should provide #add_named_datastream' do
+    @test_object.should respond_to(:add_named_datastream)
+  end
+  
+  describe '#add_named_datastream' do
+    class MockAddNamedDatastream < ActiveFedora::Base
+      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
+      
+    it 'should add a named datastream to a fedora object' do
+      Fedora::Repository.instance.stubs(:nextid).returns(increment_pid)
+      @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" ))
+      f2.stubs(:original_filename).returns("dino.jpg")
+      f.stubs(:content_type).returns("image/jpeg")
+      #check cannot add a datastream with name that does not exist
+      had_exception = false
+      begin  
+        @test_object2.add_named_datastream("thumb",{:content_type=>"image/jpeg",:blob=>f})
+      rescue
+        had_exception = true
+      end
+      raise "Did not raise exception with datastream name that does not exist" unless had_exception 
+      #check that either blob or file opt must be set
+      had_exception = false
+      begin  
+        @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg"})
+      rescue
+        had_exception = true
+      end
+      raise "Did not raise exception with blob not set" unless had_exception 
+      
+      @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg",:blob=>f})
+      @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg",:file=>f})
+      #check dslabel set from either opt[label] or opt[blob].original_file_name
+      @test_object2.add_named_datastream("high",{:content_type=>"image/jpeg",:blob=>f2, :label=>"my_image"})
+      @test_object2.high.first.attributes[:dsLabel].should == "my_image"
+      @test_object2.add_named_datastream("high",{:content_type=>"image/jpeg",:blob=>f2})
+      @test_object2.high.first.attributes[:dsLabel].should == "dino.jpg"
+      #check opt[content_type] must be set or opt[blob] responds to content_type, already checking if content_type option set above
+      f.expects(:content_type).returns("image/jpeg")
+      @test_object2.add_named_datastream("thumbnail",{:file=>f})
+      had_exception = false
+      begin
+        @test_object2.add_named_datastream("thumbnail",{:file=>f2})
+      rescue
+        had_exception = true
+      end
+      raise "Did not raise exception if content_type not set" unless had_exception
+      #check mimetype and content type must match if mimetype is specified (if not specified can be anything)
+      f.stubs(:content_type).returns("image/tiff")
+      had_exception = false
+      begin
+        @test_object2.add_named_datastream("thumbnail",{:file=>f})
+      rescue
+        had_exception = true
+      end
+      raise "Did not raise exception on content type and mime type mismatch" unless had_exception
+      
+      #check for if any mime type allowed
+      @test_object2.add_named_datastream("anymime",{:file=>f})
+      #check datastream created is of type ActiveFedora::Datastream
+      @test_object2.anymime.first.class.should == ActiveFedora::Datastream
+      #if dsid supplied check that conforms to prefix
+      f.stubs(:content_type).returns("image/jpeg")
+      had_exception = false
+      begin
+        @test_object2.add_named_datastream("thumbnail",{:file=>f,:dsid=>"DS1"})
+      rescue
+        had_exception = true
+      end
+      raise "Did not raise exception with dsid that does not conform to prefix" unless had_exception
+      #if prefix not set check uses name in CAPS and dsid uses prefix
+      @test_object2.high.first.attributes[:prefix].should == "HIGH"
+      @test_object2.high.first.dsid.match(/HIGH[0-9]/)
+      #check datastreams added with other right properties
+      @test_object2.high.first.attributes[:controlGroup].should == "M"
+      @test_object2.high.first.attributes[:type].should == "ActiveFedora::Datastream"
+      
+      #check external datastream
+      @test_object2.add_named_datastream("external",{:dsLocation=>"http://myreasource.com"})
+      #check dslocation goes to dslabel
+      @test_object2.external.first.attributes[:dsLabel].should == "http://myreasource.com"
+      #check datastreams added to fedora (may want to stub this at first)
+      
+    end
+  end
+  
+  it 'should provide #add_named_file_datastream' do
+    @test_object.should respond_to(:add_named_file_datastream)
+  end
+  
+  describe '#add_named_file_datastream' do
+    class MockAddNamedFileDatastream < ActiveFedora::Base
+      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
+    
+    it 'should add a datastream as controlGroup M with blob set to file' do
+      Fedora::Repository.instance.stubs(:nextid).returns(increment_pid)
+      @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")
+      @test_object2.add_named_file_datastream("thumbnail",f)
+      @test_object2.thumbnail.first.attributes.should == {:type=>"ActiveFedora::Datastream", 
+        :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
+  
+  it 'should provide #update_named_datastream' do
+    @test_object.should respond_to(:update_named_datastream)
+  end
+  
+  describe '#update_named_datastream' do
+    class MockUpdateNamedDatastream < ActiveFedora::Base
+      has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
+    end
+    
+    it 'should update a datastream and not increment the dsid' do
+      Fedora::Repository.instance.stubs(:nextid).returns(increment_pid)
+      @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")
+      #check raise exception if dsid not supplied
+      @test_object2.add_named_datastream("thumbnail",{:file=>f})
+      had_exception = false
+      begin
+        @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 exception if dsid does not exist
+      had_exception = false
+      begin
+        @test_object2.update_named_datastream("thumbnail",{:file=>f,:dsid=>"THUMB100"})
+      rescue
+        had_exception = true
+      end
+      raise "Failed to raise exception if dsid does not exist" unless had_exception  
+      #check datastream is updated in place without new dsid  
+      @test_object2.thumbnail.size.should == 1
+      @test_object2.thumbnail_ids == ["THUMB1"]
+      @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", 
+                                                          :name=>"thumbnail", :dsLabel=>"minivan.jpg"}
+      @test_object2.thumbnail.first.blob.should == f
+      @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", 
+                                                          :name=>"thumbnail", :dsLabel=>"dino.jpg"}
+      @test_object2.thumbnail.first.blob.should == f2
+    end
+  end
+  
+  it 'should provide #create_datastream' do
+    @test_object.should respond_to(:create_datastream)
+  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",{:blob=>f})
+      ds.class.should == ActiveFedora::Datastream
+      ds.blob.should == f
+    end
+  end
+  
+  it 'should provide #is_named_datastream?' do
+    @test_object.should respond_to(:is_named_datastream?)
+  end
+  
+  describe '#is_named_datastream?' do
+    class MockIsNamedDatastream < ActiveFedora::Base
+      has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
+    end
+    
+    it 'should return true if a named datastream exists in model' do
+      Fedora::Repository.instance.stubs(:nextid).returns(increment_pid)
+      @test_object2 = MockIsNamedDatastream.new
+      @test_object2.is_named_datastream?("thumbnail").should == true
+      @test_object2.is_named_datastream?("thumb").should == false
+    end
+  end
+  
+  it 'should provide #named_datastreams' do
+    @test_object.should respond_to(:named_datastreams)
+  end
+  
+  describe '#named_datastreams' do
+    class MockNamedDatastreams < ActiveFedora::Base
+      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
+    
+    it 'should return a hash of datastream names to arrays of datastreams' do
+      Fedora::Repository.instance.stubs(:nextid).returns(increment_pid)
+      @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")
+      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")
+      @test_object2.thumbnail_file_append(f)
+      @test_object2.high_file_append(f2)
+      @test_object2.external_append({:dsLocation=>"http://myresource.com"})
+      datastreams = @test_object2.named_datastreams
+      datastreams.keys.include?("thumbnail").should == true
+      datastreams.keys.include?("external").should == true
+      datastreams.keys.include?("high").should == true
+      datastreams.keys.size.should == 3
+      datastreams["thumbnail"].size.should == 1
+      datastreams["thumbnail"].first.class.should == ActiveFedora::Datastream
+      datastreams["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", 
+                                                           :name=>"thumbnail", :dsLabel=>"minivan.jpg"}
+      datastreams["thumbnail"].first.blob.should == f
+      datastreams["external"].size.should == 1
+      datastreams["external"].first.class.should == ActiveFedora::Datastream
+      datastreams["external"].first.attributes.should == {:type=>"ActiveFedora::Datastream", 
+                                                           :prefix=>"EXTERNAL", 
+                                                           :controlGroup=>"E", 
+                                                           :dsid=>"EXTERNAL1", 
+                                                           :pid=>@test_object2.pid, 
+                                                           :dsID=>"EXTERNAL1",
+                                                           :dsLocation=>"http://myresource.com",
+                                                           :name=>"external", :dsLabel=>"http://myresource.com"}
+      datastreams["external"].first.blob.should == nil
+      datastreams["high"].size.should == 1
+      datastreams["high"].first.class.should == ActiveFedora::Datastream
+      datastreams["high"].first.attributes.should == {:type=>"ActiveFedora::Datastream", 
+                                                           :content_type=>"image/jpeg", 
+                                                           :prefix=>"HIGH", 
+                                                           :mimeType=>"image/jpeg", 
+                                                           :controlGroup=>"M", 
+                                                           :dsid=>"HIGH1", 
+                                                           :pid=>@test_object2.pid, 
+                                                           :dsID=>"HIGH1", 
+                                                           :name=>"high", :dsLabel=>"dino.jpg"}
+      datastreams["high"].first.blob.should == f2
+    end
+  end
+  
+  it 'should provide #named_datastreams_attributes' do
+    @test_object.should respond_to(:named_datastreams_attributes)
+  end
+  
+  describe '#named_datastreams_attributes' do
+    class MockNamedDatastreamsAttributes < ActiveFedora::Base
+      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
+    
+    it 'should return a hash of datastream names to hash of dsid to attribute hashes' do
+      Fedora::Repository.instance.stubs(:nextid).returns(increment_pid)
+      @test_object2 = MockNamedDatastreamsAttributes.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")
+      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")
+      @test_object2.thumbnail_file_append(f)
+      @test_object2.high_file_append(f2)
+      @test_object2.external_append({:dsLocation=>"http://myresource.com"})
+      datastreams_attr = @test_object2.named_datastreams_attributes
+      datastreams_attr.keys.include?("thumbnail").should == true
+      datastreams_attr.keys.include?("external").should == true
+      datastreams_attr.keys.include?("high").should == true
+      datastreams_attr.keys.size.should == 3
+      datastreams_attr["thumbnail"].size.should == 1
+      datastreams_attr["thumbnail"]["THUMB1"].should == {:type=>"ActiveFedora::Datastream", 
+                                                :content_type=>"image/jpeg", 
+                                                :prefix=>"THUMB", 
+                                                :mimeType=>"image/jpeg", 
+                                                :controlGroup=>"M", 
+                                                :dsid=>"THUMB1", 
+                                                :pid=>@test_object2.pid, 
+                                                :dsID=>"THUMB1", 
+                                                :name=>"thumbnail", :dsLabel=>"minivan.jpg"}
+      datastreams_attr["external"].size.should == 1
+      datastreams_attr["external"]["EXTERNAL1"].should == {:type=>"ActiveFedora::Datastream", 
+                                                    :prefix=>"EXTERNAL", 
+                                                    :controlGroup=>"E", 
+                                                    :dsid=>"EXTERNAL1", 
+                                                    :pid=>@test_object2.pid, 
+                                                    :dsID=>"EXTERNAL1",
+                                                    :dsLocation=>"http://myresource.com",
+                                                    :name=>"external", :dsLabel=>"http://myresource.com"}
+      datastreams_attr["high"].size.should == 1
+      datastreams_attr["high"]["HIGH1"].should == {:type=>"ActiveFedora::Datastream", 
+                                                :content_type=>"image/jpeg", 
+                                                :prefix=>"HIGH", 
+                                                :mimeType=>"image/jpeg", 
+                                                :controlGroup=>"M", 
+                                                :dsid=>"HIGH1", 
+                                                :pid=>@test_object2.pid, 
+                                                :dsID=>"HIGH1", 
+                                                :name=>"high", :dsLabel=>"dino.jpg"}
+    end
+  end
+  
+  it 'should provide #named_datastreams_ids' do
+    @test_object.should respond_to(:named_datastreams_ids)
+  end
+  
+  describe '#named_datastreams_ids' do
+    class MockNamedDatastreamsIds < ActiveFedora::Base
+      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
+    
+    it 'should provide a hash of datastreams names to array of datastream ids' do
+      Fedora::Repository.instance.stubs(:nextid).returns(increment_pid)
+      @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")
+      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")
+      @test_object2.thumbnail_file_append(f)
+      @test_object2.high_file_append(f2)
+      @test_object2.external_append({:dsLocation=>"http://myresource.com"})
+      @test_object2.named_datastreams_ids.should == {"thumbnail"=>["THUMB1"],"high"=>["HIGH1"],"external"=>["EXTERNAL1"]}
+    end
+  end
+  
+  it 'should provide #datastreams_attributes' do
+    @test_object.should respond_to(:datastreams_attributes)
+  end
+  
+  describe '#datastreams_attributes' do
+    class MockDatastreamsAttributes < ActiveFedora::Base
+      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
+    
+    it 'should return a hash of datastream ids to an attribute hash' do
+      Fedora::Repository.instance.stubs(:nextid).returns(increment_pid)
+      @test_object2 = MockDatastreamsAttributes.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")
+      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")
+      @test_object2.thumbnail_file_append(f)
+      @test_object2.high_file_append(f2)
+      @test_object2.external_append({:dsLocation=>"http://myresource.com"})
+      datastreams_attr = @test_object2.datastreams_attributes
+      datastreams_attr.should == {"THUMB1"=>{:type=>"ActiveFedora::Datastream", 
+                                                :content_type=>"image/jpeg", 
+                                                :prefix=>"THUMB", 
+                                                :mimeType=>"image/jpeg", 
+                                                :controlGroup=>"M", 
+                                                :dsid=>"THUMB1", 
+                                                :pid=>@test_object2.pid, 
+                                                :dsID=>"THUMB1", 
+                                                :name=>"thumbnail", :dsLabel=>"minivan.jpg"},
+                                   "EXTERNAL1"=>{:type=>"ActiveFedora::Datastream", 
+                                                    :prefix=>"EXTERNAL", 
+                                                    :controlGroup=>"E", 
+                                                    :dsid=>"EXTERNAL1", 
+                                                    :pid=>@test_object2.pid, 
+                                                    :dsID=>"EXTERNAL1",
+                                                    :dsLocation=>"http://myresource.com",
+                                                    :name=>"external", :dsLabel=>"http://myresource.com"},
+                                    "HIGH1"=>{:type=>"ActiveFedora::Datastream", 
+                                                :content_type=>"image/jpeg", 
+                                                :prefix=>"HIGH", 
+                                                :mimeType=>"image/jpeg", 
+                                                :controlGroup=>"M", 
+                                                :dsid=>"HIGH1", 
+                                                :pid=>@test_object2.pid, 
+                                                :dsID=>"HIGH1", 
+                                                :name=>"high", :dsLabel=>"dino.jpg"}}
+    end
+  end
+  
+  #
+  # Class level methods
+  #
+  describe '#named_datastreams_desc' do
+      
+    class MockNamedDatastreamsDesc < ActiveFedora::Base
+      has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
+    end
+    
+    it 'should intialize a value to an empty hash and then not modify afterward' do
+      @test_object.named_datastreams_desc.should == {}
+      Fedora::Repository.instance.stubs(:nextid).returns(increment_pid)
+      @test_object2 = MockNamedDatastreamsDesc.new
+      @test_object2.named_datastreams_desc.should == {"thumbnail"=>{:name=>"thumbnail",:prefix => "THUMB", 
+                                                                    :type=>"ActiveFedora::Datastream", :mimeType=>"image/jpeg", 
+                                                                    :controlGroup=>'M'}}
+    end
+  end
+    
+  describe '#create_named_datastream_finders' do
+    class MockCreateNamedDatastreamFinder < ActiveFedora::Base
+      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
+    
+    it 'should create helper methods to get named datastreams or dsids' do
+      Fedora::Repository.instance.stubs(:nextid).returns(increment_pid)
+      @test_object2 = MockCreateNamedDatastreamFinder.new
+      @test_object2.should respond_to(:thumbnail)
+      @test_object2.should respond_to(:thumbnail_ids)  
+      @test_object2.should respond_to(:high)
+      @test_object2.should respond_to(:high_ids)
+      f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"))
+      f2 = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ))
+      f2.stubs(:original_filename).returns("dino.jpg")
+      f.stubs(:content_type).returns("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.thumbnail.first.attributes.should == {:type=>"ActiveFedora::Datastream", 
+      :prefix=>"THUMB", :content_type=>"image/jpeg", :dsid=>"THUMB1", :dsID=>"THUMB1", 
+      :pid=>@test_object2.pid, :mimeType=>"image/jpeg", :controlGroup=>"M", :dsLabel=>"testDS", :name=>"thumbnail", :label=>"testDS"}
+      @test_object2.thumbnail_ids.should == ["THUMB1"]
+      @test_object2.high_ids.include?("HIGH1") == true
+      @test_object2.high_ids.include?("HIGH2") == true
+      @test_object2.high_ids.size.should == 2
+      #just check returning datastream object at this point
+      @test_object2.high.first.class.should == ActiveFedora::Datastream
+    end
+  end
+    
+  describe '#create_named_datastream_update_methods' do
+    class MockCreateNamedDatastreamUpdateMethods < ActiveFedora::Base
+      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
+    
+    it 'should create append method for each has_datastream entry' do
+      Fedora::Repository.instance.stubs(:nextid).returns(increment_pid)
+      @test_object2 = MockCreateNamedDatastreamUpdateMethods.new
+      Fedora::Repository.instance.stubs(:nextid).returns(increment_pid)
+      @test_object3 = MockCreateNamedDatastreamUpdateMethods.new
+      @test_object2.should respond_to(:thumbnail_append)
+      @test_object2.should respond_to(:ead_append)
+      f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"))
+      f.stubs(:content_type).returns("image/jpeg")
+      f.stubs(:original_filename).returns("minivan.jpg")
+      @test_object2.thumbnail_file_append(f)
+      @test_object2.thumbnail.first.attributes.should == {:type=>"ActiveFedora::Datastream", 
+      :prefix=>"THUMB", :content_type=>"image/jpeg", :dsid=>"THUMB1", :dsID=>"THUMB1", 
+      :pid=>@test_object2.pid, :mimeType=>"image/jpeg", :controlGroup=>"M", :dsLabel=>"minivan.jpg", :name=>"thumbnail"}
+      @test_object3.thumbnail_append({:file=>f})
+      @test_object3.thumbnail.first.attributes.should == {:type=>"ActiveFedora::Datastream", 
+      :prefix=>"THUMB", :content_type=>"image/jpeg", :dsid=>"THUMB1", :dsID=>"THUMB1", 
+      :pid=>@test_object3.pid, :mimeType=>"image/jpeg", :controlGroup=>"M", :dsLabel=>"minivan.jpg", :name=>"thumbnail"}
+      @test_object3.external_append({:dsLocation=>"http://myresource.com"})
+      @test_object3.external.first.attributes.should == {:type=>"ActiveFedora::Datastream", 
+      :prefix=>"EXTERNAL", :dsid=>"EXTERNAL1", :dsID=>"EXTERNAL1", 
+      :pid=>@test_object3.pid, :controlGroup=>"E", :dsLabel=>"http://myresource.com", :dsLocation=>"http://myresource.com", :name=>"external"}
+    end
+  end
+    
+  describe '#has_datastream' do
+    class MockHasDatastream < ActiveFedora::Base
+      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
+    
+    it 'should cache a definition of named datastream and create helper methods to add/remove/access them' do
+      Fedora::Repository.instance.stubs(:nextid).returns(increment_pid)
+      @test_object2 = MockHasDatastream.new
+      #prefix should default to name in caps if not specified in has_datastream call
+      @test_object2.named_datastreams_desc.should == {"thumbnail"=>{:name=>"thumbnail",:prefix => "THUMB", 
+                                                                    :type=>"ActiveFedora::Datastream", :mimeType=>"image/jpeg", 
+                                                                    :controlGroup=>'M'},
+                                                      "EAD"=>       {:name=>"EAD", :prefix=>"EAD",
+                                                                    :type=>"ActiveFedora::Datastream", :mimeType=>"application/xml", 
+                                                                    :controlGroup=>'M' },
+                                                      "external"=>  {:name=>"external", :prefix=>"EXTERNAL",
+                                                                    :type=>"ActiveFedora::Datastream", :controlGroup=>'E' }}
+      @test_object2.should respond_to(:thumbnail_append)
+      @test_object2.should respond_to(:thumbnail_file_append)
+      @test_object2.should respond_to(:thumbnail)
+      @test_object2.should respond_to(:thumbnail_ids)
+      @test_object2.should respond_to(:ead_append)
+      @test_object2.should respond_to(:ead_file_append)
+      @test_object2.should respond_to(:EAD)
+      @test_object2.should respond_to(:EAD_ids)
+      @test_object2.should respond_to(:external)
+      @test_object2.should respond_to(:external_ids)
+    end
+  end
+end