active-fedora 8.7.0 → 9.0.0.beta1

data/spec/integration/load_from_solr_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-
-describe "Loading from solr" do
-  before do
-    class MyRdfDatastream < ActiveFedora::NtriplesRDFDatastream
-      property :title, predicate: RDF::DC.title do |index|
-        index.as :stored_searchable, :facetable
-      end
-      property :date_uploaded, predicate: RDF::DC.dateSubmitted do |index|
-        index.type :date
-        index.as :stored_searchable, :sortable
-      end
-      property :date_modified, predicate: RDF::DC.date do |index|
-        index.type :date
-        index.as :stored_sortable
-      end
-      property :identifier, predicate: RDF::DC.identifier do |index|
-        index.type :integer
-        index.as :stored_searchable, :sortable
-      end
-      property :part, predicate: RDF::DC.hasPart
-      property :based_near, predicate: RDF::FOAF.based_near
-      property :related_url, predicate: RDF::RDFS.seeAlso
-    end
-    class MyOmDatastream < ActiveFedora::OmDatastream
-      set_terminology do |t|
-        t.root(path: "animals")
-        t.duck(index_as: :stored_searchable)
-      end
-    end
-    class RdfTest < ActiveFedora::Base 
-      has_metadata 'rdf', type: MyRdfDatastream
-      has_metadata 'om', type: MyOmDatastream
-      has_attributes :based_near, :related_url, :part, :date_uploaded, datastream: 'rdf', multiple: true
-      has_attributes :date_modified, datastream: 'rdf', multiple: false
-      has_attributes :title, :identifier, datastream: 'rdf', multiple: false
-      has_attributes :duck, datastream: 'om', multiple: false
-    end
-  end
-
-  let!(:original) { RdfTest.create!(title: "PLAN 9 FROM OUTER SPACE",
-                                    date_uploaded: [Date.parse('1959-01-01')],
-                                    date_modified: Date.parse('1999-01-01'),
-                                    duck: "quack",
-                                   identifier: 12345) }
-
-  after do
-    original.destroy
-    Object.send(:remove_const, :RdfTest)
-    Object.send(:remove_const, :MyRdfDatastream)
-    Object.send(:remove_const, :MyOmDatastream)
-  end
-
-  it "should be able to get indexed properties without loading from fedora" do
-    expect(RdfTest.connection_for_pid('1')).not_to receive(:datastream_dissemination)
-    obj = RdfTest.load_instance_from_solr original.pid
-    expect(obj.title).to eq "PLAN 9 FROM OUTER SPACE"
-    expect(obj.date_uploaded).to eq [Date.parse('1959-01-01')]
-    expect(obj.date_modified).to eq Date.parse('1999-01-01')
-    expect(obj.identifier).to eq 12345
-    expect{obj.part}.to raise_error KeyError, "Tried to fetch `part' from solr, but it isn't indexed."
-    expect(ActiveFedora::Base.logger).to receive(:info).with "Couldn't get duck out of solr, because the datastream 'MyOmDatastream' doesn't respond to 'primary_solr_name'. Trying another way."
-    expect(obj.duck).to eq 'quack'
-  end
-
-end

data/spec/integration/rels_ext_datastream_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-require 'active_fedora'
-require "rexml/document"
-
-
-describe ActiveFedora::RelsExtDatastream do
-  
-  before(:all) do
-    @sample_relationships_hash = Hash.new(:is_member_of => ["info:fedora/demo:5", "info:fedora/demo:10"])
-    @sample_xml_string = <<-EOS
-    <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
-      <rdf:Description rdf:about="info:fedora/changeme:475">
-        <isMemberOf xmlns="info:fedora/fedora-system:def/relations-external#" rdf:resource="info:fedora/demo:5"></isMemberOf>
-        <isMemberOf xmlns="info:fedora/fedora-system:def/relations-external#" rdf:resource="info:fedora/demo:10"></isMemberOf>
-      </rdf:Description>
-    </rdf:RDF>
-    EOS
-  
-    @sample_xml = REXML::Document.new(@sample_xml_string)
-  end
-  
-  before(:each) do
-    @test_object = ActiveFedora::Base.new
-    @test_datastream = ActiveFedora::RelsExtDatastream.new(@test_object.inner_object, 'RELS-EXT')
-    @test_datastream.model = @test_object
-    @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
-    begin
-    @test_object4.delete
-    rescue
-    end
-    begin
-    @test_object5.delete
-    rescue
-    end
-  end
-  
-  
-  describe '#serialize!' do
-    
-    it "should generate new rdf/xml as the datastream content" do
-      @test_object.add_datastream(@test_datastream)
-      @test_object.add_relationship(:is_member_of, "info:fedora/demo:5")
-      @test_object.add_relationship(:is_member_of, "info:fedora/demo:10")
-      rexml1 = REXML::Document.new(@test_datastream.to_rels_ext())
-      @test_datastream.serialize!
-      rexml2 = REXML::Document.new(@test_object.datastreams["RELS-EXT"].content)
-      expect(rexml1.root.elements["rdf:Description"].inspect).to eql(rexml2.root.elements["rdf:Description"].inspect)
-    end
-  
-  end
-  
-  it "should load relationships from fedora into parent object" do
-    class SpecNode; include ActiveFedora::SemanticNode; end
-    ActiveFedora::Predicates.predicate_mappings[ActiveFedora::Predicates.default_predicate_namespace].each_key do |p| 
-      @test_object.add_relationship(p, "info:fedora/demo:#{rand(100)}")
-    end
-    @test_object.save
-    # make sure that _something_ was actually added to the object's relationships hash
-    expect(@test_object.ids_for_outbound(:is_member_of).size).to eq(1)
-    new_rels = ActiveFedora::Base.find(@test_object.pid).relationships
-    # This stopped working, need to push an issue into the rdf library. (when dumping ntriples, the order of assertions changed)
-    #new_rels.should == @test_object.relationships
-    expect(new_rels.dump(:rdfxml)).to eq(@test_object.relationships.dump(:rdfxml))
-  end
-
-end

data/spec/support/mock_fedora.rb

@@ -1,44 +0,0 @@
-def mock_client
-  return @mock_client if @mock_client
-  @mock_client = double("client")
-  @getter = double("getter")
-  allow(@getter).to receive(:get).and_return('')
-  allow(@mock_client).to receive(:[]).with("describe?xml=true").and_return('')
-  @mock_client 
-end
-  
-def stub_get(pid, datastreams=nil, record_exists=false)
-  pid.gsub!(/:/, '%3A')
-  if record_exists
-    allow(mock_client).to receive(:[]).with("objects/#{pid}?format=xml").and_return(double('get getter', :get=>'foobar'))
-  else
-    allow(mock_client).to receive(:[]).with("objects/#{pid}?format=xml").and_raise(RestClient::ResourceNotFound)
-  end
-  allow(mock_client).to receive(:[]).with("objects/#{pid}/datastreams?format=xml").and_return(@getter)
-  datastreams ||= ['someData', 'withText', 'withText2', 'RELS-EXT']
-  datastreams.each do |dsid|
-    allow(mock_client).to receive(:[]).with("objects/#{pid}/datastreams/#{dsid}?format=xml").and_return(@getter)
-  end
-end
-
-def stub_ingest(pid=nil)
-  n = pid ? pid.gsub(/:/, '%3A') : nil
-  expect(mock_client).to receive(:[]).with("objects/#{n || 'new'}").and_return(double("ingester", :post=>pid))
-end
-
-def stub_add_ds(pid, dsids)
-  pid.gsub!(/:/, '%3A')
-  dsids.each do |dsid|
-    client = allow(mock_client).to receive(:[]) do |params|
-      /objects\/#{pid}\/datastreams\/#{dsid}/.match(params)
-    end
-    client.and_return(double("ds_adder", :post=>pid, :get=>''))
-  end
-end
-
-def stub_get_content(pid, dsids)
-  pid.gsub!(/:/, '%3A')
-  dsids.each do |dsid|
-    allow(mock_client).to receive(:[]) { |params| /objects\/#{pid}\/datastreams\/#{dsid}\/content/.match(params)}.and_return(double("content_accessor", :post=>pid, :get=>''))
-  end
-end

data/spec/unit/content_model_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::ContentModel do
-  
-  before(:all) do
-    class BaseModel < ActiveFedora::Base
-    end
-    
-    class SampleModel < BaseModel
-    end
-
-    class GenericContent < ActiveFedora::Base
-    end
-    
-    module Sample
-      class NamespacedModel < ActiveFedora::Base
-      end
-    end
-  end
-  
-  describe '.best_model_for' do
-    it 'should be nil if no relationships' do
-      mock_object = BaseModel.new
-      expect(mock_object).to receive(:relationships).with(:has_model).and_return([])
-      expect(ActiveFedora::ContentModel.best_model_for(mock_object)).to be_nil
-    end
-
-    it 'should be based on inheritance hierarchy' do
-      mock_object = ActiveFedora::Base.new
-      expect(mock_object).to receive(:relationships).with(:has_model).and_return(["info:fedora/fedora-system:ServiceDefinition-3.0", 'info:fedora/afmodel:SampleModel', 'info:fedora/afmodel:BaseModel'])
-      expect(ActiveFedora::ContentModel.best_model_for(mock_object)).to eq SampleModel
-    end
-
-    it 'should find the deepest descendant of the on inheritance hierarchy' do
-      mock_object = BaseModel.new
-      expect(mock_object).to receive(:relationships).with(:has_model).and_return(["info:fedora/fedora-system:ServiceDefinition-3.0", 'info:fedora/afmodel:SampleModel', 'info:fedora/afmodel:BaseModel'])
-      expect(ActiveFedora::ContentModel.best_model_for(mock_object)).to eq SampleModel
-    end
-  end
-  
-  describe "models_asserted_by" do
-    it "should return an array of all of the content models asserted by the given object" do
-      mock_object = double("ActiveFedora Object")
-      expect(mock_object).to receive(:relationships).with(:has_model).and_return(["info:fedora/fedora-system:ServiceDefinition-3.0", "info:fedora/afmodel:SampleModel", "info:fedora/afmodel:NonDefinedModel"])
-      expect(ActiveFedora::ContentModel.models_asserted_by(mock_object)).to eq(["info:fedora/fedora-system:ServiceDefinition-3.0", "info:fedora/afmodel:SampleModel", "info:fedora/afmodel:NonDefinedModel"])
-    end
-    it "should return an empty array if the object doesn't have a RELS-EXT datastream" do
-      mock_object = double("ActiveFedora Object")
-      expect(mock_object).to receive(:relationships).with(:has_model).and_return([])
-      expect(ActiveFedora::ContentModel.models_asserted_by(mock_object)).to eq([])
-    end
-  end
-  
-  describe "known_models_asserted_by" do
-    it "should figure out the applicable models to load" do
-      mock_object = double("ActiveFedora Object")
-      expect(mock_object).to receive(:relationships).with(:has_model).and_return(["info:fedora/fedora-system:ServiceDefinition-3.0", "info:fedora/afmodel:SampleModel", "info:fedora/afmodel:NonDefinedModel"])
-      expect(ActiveFedora::ContentModel.known_models_for(mock_object)).to eq([SampleModel])
-    end
-    it "should support namespaced models" do
-      mock_object = double("ActiveFedora Object")
-      expect(mock_object).to receive(:relationships).with(:has_model).and_return(["info:fedora/afmodel:Sample_NamespacedModel"])
-      expect(ActiveFedora::ContentModel.known_models_for(mock_object)).to eq([Sample::NamespacedModel])
-    end
-    it "should default to using ActiveFedora::Base as the model" do
-      mock_object = double("ActiveFedora Object")
-      expect(mock_object).to receive(:relationships).with(:has_model).and_return(["info:fedora/afmodel:NonDefinedModel"])
-      expect(ActiveFedora::ContentModel.known_models_for(mock_object)).to eq([ActiveFedora::Base])
-    end
-    it "should still work even if the object doesn't have a RELS-EXT datastream" do
-      mock_object = double("ActiveFedora Object")
-      expect(mock_object).to receive(:relationships).with(:has_model).and_return([])
-      expect(ActiveFedora::ContentModel.known_models_for(mock_object)).to eq([ActiveFedora::Base])
-    end
-  end
-  
-  describe "uri_to_model_class" do
-    it "should return an ActiveFedora Model class corresponding to the given uri if a valid model can be found" do
-      expect(ActiveFedora::ContentModel.uri_to_model_class("info:fedora/afmodel:SampleModel")).to eq(SampleModel)
-      expect(ActiveFedora::ContentModel.uri_to_model_class("info:fedora/afmodel:NonDefinedModel")).to eq(false)
-      expect(ActiveFedora::ContentModel.uri_to_model_class("info:fedora/afmodel:String")).to eq(false)
-      expect(ActiveFedora::ContentModel.uri_to_model_class("info:fedora/hydra-cModel:genericContent")).to eq(GenericContent)
-    end
-  end
-
-end

data/spec/unit/datastream_collections_spec.rb

@@ -1,420 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::DatastreamCollections do
-  describe '.has_datastream' do
-    before(:all) do
-      
-      class MockHasDatastream < ActiveFedora::Base
-        include ActiveFedora::DatastreamCollections
-        has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
-        has_datastream :name=>"EAD", :type=>ActiveFedora::Datastream, :mimeType=>"application/xml", :controlGroup=>'M' 
-        has_datastream :name=>"external", :type=>ActiveFedora::Datastream, :controlGroup=>'E'
-      end
-    end
-    
-    it 'should cache a definition of named datastream and create helper methods to add/remove/access them' do
-      @test_object2 = MockHasDatastream.new
-      #prefix should default to name in caps if not specified in has_datastream call
-      expect(@test_object2.named_datastreams_desc).to eq({"thumbnail"=>{:name=>"thumbnail",:prefix => "THUMB", 
-                                                                    :type=>"ActiveFedora::Datastream", :mimeType=>"image/jpeg", 
-                                                                    :controlGroup=>'M'},
-                                                      "EAD"=>       {:name=>"EAD", :prefix=>"EAD",
-                                                                    :type=>"ActiveFedora::Datastream", :mimeType=>"application/xml", 
-                                                                    :controlGroup=>'M' },
-                                                      "external"=>  {:name=>"external", :prefix=>"EXTERNAL",
-                                                                    :type=>"ActiveFedora::Datastream", :controlGroup=>'E' }})
-      expect(@test_object2).to respond_to(:thumbnail_append)
-      expect(@test_object2).to respond_to(:thumbnail_file_append)
-      expect(@test_object2).to respond_to(:thumbnail)
-      expect(@test_object2).to respond_to(:thumbnail_ids)
-      expect(@test_object2).to respond_to(:ead_append)
-      expect(@test_object2).to respond_to(:ead_file_append)
-      expect(@test_object2).to respond_to(:EAD)
-      expect(@test_object2).to respond_to(:EAD_ids)
-      expect(@test_object2).to respond_to(:external)
-      expect(@test_object2).to respond_to(:external_ids)
-    end
-  end
-  describe '#datastream_names' do
-    before(:all) do
-      class MockDatastreamNames < ActiveFedora::Base
-        include ActiveFedora::DatastreamCollections
-        has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
-        has_datastream :name=>"EAD", :type=>ActiveFedora::Datastream, :mimeType=>"application/xml", :controlGroup=>'M' 
-      end
-    end
-    
-    it 'should return a set of datastream names defined by has_datastream' do
-      @test_object2 = MockDatastreamNames.new
-      expect(@test_object2.datastream_names).to include("thumbnail","EAD")
-    end
-  end
-  
-  describe '#add_named_datastream' do
-    before(:all) do
-      class MockAddNamedDatastream < ActiveFedora::Base
-        include ActiveFedora::DatastreamCollections
-        has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
-        has_datastream :name=>"high", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M' 
-        has_datastream :name=>"anymime", :type=>ActiveFedora::Datastream, :controlGroup=>'M' 
-        has_datastream :name=>"external", :type=>ActiveFedora::Datastream, :controlGroup=>'E'
-      end
-    end
-    before do
-
-      @test_object2 = MockAddNamedDatastream.new
-      @f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"))
-      @f2 = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ))
-      allow(@f).to receive(:content_type).and_return("image/jpeg")
-      allow(@f2).to receive(:original_filename).and_return("dino.jpg")
-    end
-      
-    it 'cannot add a datastream with name that does not exist' do
-      expect { @test_object2.add_named_datastream("thumb",{:content_type=>"image/jpeg",:blob=>f}) }.to raise_error
-    end
-
-    it "should accept a file blob" do
-      @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg",:blob=>@f})
-    end
-
-    it "should accept a file handle" do
-      @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg",:file=>@f})
-    end
-
-    it "should  allow access to file content" do
-      @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg",:file=>@f})
-      @test_object2.save!
-      @test_object2.thumbnail[0].content
-    end
-
-    it "should raise an error if neither a blob nor file is set" do
-      expect { @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg"}) }.to raise_error
-    end
-
-    it "should use the given label for the dsLabel" do
-      @test_object2.add_named_datastream("high",{:content_type=>"image/jpeg",:blob=>@f2, :label=>"my_image"})
-      expect(@test_object2.high.first.dsLabel).to eq("my_image")
-    end
-
-    it "should fallback on using the file name" do
-      @test_object2.add_named_datastream("high",{:content_type=>"image/jpeg",:blob=>@f2})
-      expect(@test_object2.high.first.dsLabel).to eq("dino.jpg")
-    end 
-
-    it "should check the file for a content type" do
-      expect(@f).to receive(:content_type).and_return("image/jpeg")
-      @test_object2.add_named_datastream("thumbnail",{:file=>@f})
-    end
-
-    it "should raise an error if no content type is avialable" do
-      expect { @test_object2.add_named_datastream("thumbnail",{:file=>@f2}) }.to raise_error
-    end
-
-    it "should encsure mimetype and content type match" do
-      allow(@f).to receive(:content_type).and_return("image/tiff")
-      expect { @test_object2.add_named_datastream("thumbnail",{:file=>f}) }.to raise_error
-    end
-      
-    it "should allow any mime type" do
-      #check for if any mime type allowed
-      @test_object2.add_named_datastream("anymime",{:file=>@f})
-      #check datastream created is of type ActiveFedora::Datastream
-      expect(@test_object2.anymime.first.class).to eq(ActiveFedora::Datastream)
-    end
-
-    it "should cgecj that a dsid forms to the prefix" do
-      #if dsid supplied check that conforms to prefix
-      allow(@f).to receive(:content_type).and_return("image/jpeg")
-      expect { @test_object2.add_named_datastream("thumbnail",{:file=>@f,:dsid=>"DS1"}) }.to raise_error
-    end
-
-    it "should have the right properties" do
-      @test_object2.add_named_datastream("high",{:content_type=>"image/jpeg",:blob=>@f2})
-      #if prefix not set check uses name in CAPS and dsid uses prefix
-      #@test_object2.high.first.attributes[:prefix].should == "HIGH"
-      @test_object2.high.first.dsid.match(/HIGH[0-9]/)
-      #check datastreams added with other right properties
-      expect(@test_object2.high.first.controlGroup).to eq("M")
-    end
-
-    it "should work with external datastreams" do
-      
-      #check external datastream
-      @test_object2.add_named_datastream("external",{:dsLocation=>"http://myreasource.com"})
-      #check dslocation goes to dslabel
-      expect(@test_object2.external.first.dsLabel).to eq("http://myreasource.com")
-      #check datastreams added to fedora (may want to stub this at first)
-    end
-  end
-  
-  describe '#add_named_file_datastream' do
-    before do
-      class MockDS < ActiveFedora::Datastream; end
-      class MockAddNamedFileDatastream < ActiveFedora::Base
-        include ActiveFedora::DatastreamCollections
-        has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>MockDS, :mimeType=>"image/jpeg", :controlGroup=>'M'
-        has_datastream :name=>"high", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M' 
-        has_datastream :name=>"anymime", :type=>ActiveFedora::Datastream, :controlGroup=>'M' 
-      end
-    end
-    
-    it 'should add a datastream as controlGroup M with blob set to file' do
-      @test_object2 = MockAddNamedFileDatastream.new
-      f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"))
-      #these normally supplied in multi-part post request
-      allow(f).to receive(:original_filename).and_return("minivan.jpg")
-      allow(f).to receive(:content_type).and_return("image/jpeg")
-      @test_object2.add_named_file_datastream("thumbnail",f)
-      thumb = @test_object2.thumbnail.first
-      expect(thumb.class).to eq(MockDS)
-      expect(thumb.mimeType).to eq("image/jpeg")
-      expect(thumb.dsid).to eq("THUMB1")
-      expect(thumb.controlGroup).to eq("M")
-      expect(thumb.dsLabel).to eq("minivan.jpg")
-      #thumb.name.should == "thumbnail"
-        # :prefix=>"THUMB", :content_type=>"image/jpeg", :dsid=>"THUMB1", :dsID=>"THUMB1", 
-        # :pid=>@test_object2.pid, :mimeType=>"image/jpeg", :controlGroup=>"M", :dsLabel=>"minivan.jpg", :name=>"thumbnail"}
-      
-    end
-  end
-
-  describe '#update_named_datastream' do
-    before do
-      class MockUpdateNamedDatastream < ActiveFedora::Base
-        include ActiveFedora::DatastreamCollections
-        has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
-      end
-    end
-    
-    it 'should update a datastream and not increment the dsid' do
-      @test_object2 = MockUpdateNamedDatastream.new
-      f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"))
-      f2 = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ))
-      allow(f).to receive(:content_type).and_return("image/jpeg")
-      allow(f).to receive(:original_filename).and_return("minivan.jpg")
-      allow(f2).to receive(:content_type).and_return("image/jpeg")
-      allow(f2).to receive(:original_filename).and_return("dino.jpg")
-      #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  
-      expect(@test_object2.thumbnail.size).to eq(1)
-      @test_object2.thumbnail_ids == ["THUMB1"]
-      thumb1 = @test_object2.thumbnail.first
-      expect(thumb1.dsid).to eq('THUMB1')
-      expect(thumb1.pid).to eq(@test_object2.pid)
-      expect(thumb1.dsLabel).to eq('minivan.jpg')
-      f.rewind
-      @test_object2.update_named_datastream("thumbnail",{:file=>f2,:dsid=>"THUMB1"})
-      expect(@test_object2.thumbnail.size).to eq(1)
-      @test_object2.thumbnail_ids == ["THUMB1"]
-      # @test_object2.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"}
-      thumb1 = @test_object2.thumbnail.first
-      expect(thumb1.dsid).to eq('THUMB1')
-      expect(thumb1.pid).to eq(@test_object2.pid)
-      expect(thumb1.dsLabel).to eq('dino.jpg')
-    end
-  end
-  describe '#named_datastreams_desc' do
-      
-    before do
-      class MockNamedDatastreamsDesc < ActiveFedora::Base
-        include ActiveFedora::DatastreamCollections
-        has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
-      end
-    end
-    
-    it 'should intialize a value to an empty hash and then not modify afterward' do
-      @test_object2 = MockNamedDatastreamsDesc.new
-      expect(@test_object2.named_datastreams_desc).to eq({"thumbnail"=>{:name=>"thumbnail",:prefix => "THUMB", 
-                                                                    :type=>"ActiveFedora::Datastream", :mimeType=>"image/jpeg", 
-                                                                    :controlGroup=>'M'}})
-    end
-  end
-
-  describe '#is_named_datastream?' do
-    before do
-      class MockIsNamedDatastream < ActiveFedora::Base
-        include ActiveFedora::DatastreamCollections
-        has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
-      end
-    end
-    
-    it 'should return true if a named datastream exists in model' do
-      @test_object2 = MockIsNamedDatastream.new
-      expect(@test_object2.is_named_datastream?("thumbnail")).to eq(true)
-      expect(@test_object2.is_named_datastream?("thumb")).to eq(false)
-    end
-  end
-  
-  
-  describe '#named_datastreams' do
-    before do
-      class MockNamedDatastreams < ActiveFedora::Base
-        include ActiveFedora::DatastreamCollections
-        has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
-        has_datastream :name=>"high", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M' 
-        has_datastream :name=>"external", :type=>ActiveFedora::Datastream, :controlGroup=>'E' 
-      end
-    end
-    
-    it 'should return a hash of datastream names to arrays of datastreams' do
-      @test_object2 = MockNamedDatastreams.new
-      f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg" ))
-      allow(f).to receive(:content_type).and_return("image/jpeg")
-      allow(f).to receive(:original_filename).and_return("minivan.jpg")
-      f2 = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ))
-      allow(f2).to receive(:content_type).and_return("image/jpeg")
-      allow(f2).to receive(:original_filename).and_return("dino.jpg")
-      @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
-      expect(datastreams.keys.include?("thumbnail")).to eq(true)
-      expect(datastreams.keys.include?("external")).to eq(true)
-      expect(datastreams.keys.include?("high")).to eq(true)
-      expect(datastreams.keys.size).to eq(3)
-      expect(datastreams["thumbnail"].size).to eq(1)
-      expect(datastreams["thumbnail"].first.dsid).to eq('THUMB1')
-      expect(datastreams["thumbnail"].first.dsLabel).to eq('minivan.jpg')
-      expect(datastreams["thumbnail"].first.controlGroup).to eq("M")
-
-      expect(datastreams["external"].size).to eq(1)
-      expect(datastreams["external"].first.dsid).to eq("EXTERNAL1")
-      expect(datastreams["external"].first.dsLocation).to eq("http://myresource.com")
-      expect(datastreams["external"].first.controlGroup).to eq("E")
-
-      expect(datastreams["high"].size).to eq(1)
-      expect(datastreams["high"].first.dsLabel).to eq('dino.jpg')
-      expect(datastreams["high"].first.controlGroup).to eq("M")
-      expect(datastreams["high"].first.dsid).to eq("HIGH1")
-    end
-  end
-  
-  
-    
-  describe '#named_datastreams_ids' do
-    before do
-      class MockNamedDatastreamsIds < ActiveFedora::Base
-        include ActiveFedora::DatastreamCollections
-        has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
-        has_datastream :name=>"high", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M' 
-        has_datastream :name=>"external", :type=>ActiveFedora::Datastream, :controlGroup=>'E' 
-      end
-    end
-    
-    it 'should provide a hash of datastreams names to array of datastream ids' do
-      @test_object2 = MockNamedDatastreamsIds.new
-      f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg" ))
-      allow(f).to receive(:content_type).and_return("image/jpeg")
-      allow(f).to receive(:original_filename).and_return("minivan.jpg")
-      f2 = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ))
-      allow(f2).to receive(:content_type).and_return("image/jpeg")
-      allow(f2).to receive(:original_filename).and_return("dino.jpg")
-      @test_object2.thumbnail_file_append(f)
-      @test_object2.high_file_append(f2)
-      @test_object2.external_append({:dsLocation=>"http://myresource.com"})
-      expect(@test_object2.named_datastreams_ids).to eq({"thumbnail"=>["THUMB1"],"high"=>["HIGH1"],"external"=>["EXTERNAL1"]})
-    end
-  end
-  
-    
-  describe '#create_named_datastream_finders' do
-    before do
-      class MockCreateNamedDatastreamFinder < ActiveFedora::Base
-        include ActiveFedora::DatastreamCollections
-        has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
-        has_datastream :name=>"high", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M' 
-      end
-    end
-    
-    it 'should create helper methods to get named datastreams or dsids' do
-      @test_object2 = MockCreateNamedDatastreamFinder.new
-      expect(@test_object2).to respond_to(:thumbnail)
-      expect(@test_object2).to respond_to(:thumbnail_ids)  
-      expect(@test_object2).to respond_to(:high)
-      expect(@test_object2).to respond_to(:high_ids)
-      f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"))
-      f2 = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ))
-      allow(f2).to receive(:original_filename).and_return("dino.jpg")
-      allow(f).to receive(:content_type).and_return("image/jpeg")
-      @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg",:blob=>f, :label=>"testDS"})
-      @test_object2.add_named_datastream("high",{:content_type=>"image/jpeg",:blob=>f2})
-      @test_object2.add_named_datastream("high",{:content_type=>"image/jpeg",:blob=>f2})
-      t2_thumb1 = @test_object2.thumbnail.first
-      expect(t2_thumb1.mimeType).to eq("image/jpeg")
-      expect(t2_thumb1.controlGroup).to eq("M")
-      expect(t2_thumb1.dsLabel).to eq("testDS")
-      expect(t2_thumb1.pid).to eq(@test_object2.pid) 
-      expect(t2_thumb1.dsid).to eq("THUMB1")
-      # :type=>"ActiveFedora::Datastream", 
-      # :prefix=>"THUMB", :content_type=>"image/jpeg", :dsid=>"THUMB1", :dsID=>"THUMB1", 
-      # :pid=>@test_object2.pid, :mimeType=>"image/jpeg", :controlGroup=>"M", :dsLabel=>"testDS", :name=>"thumbnail", :label=>"testDS"}
-      expect(@test_object2.thumbnail_ids).to eq(["THUMB1"])
-      @test_object2.high_ids.include?("HIGH1") == true
-      @test_object2.high_ids.include?("HIGH2") == true
-      expect(@test_object2.high_ids.size).to eq(2)
-      #just check returning datastream object at this point
-      expect(@test_object2.high.first.class).to eq(ActiveFedora::Datastream)
-    end
-  end
-    
-  describe '#create_named_datastream_update_methods' do
-    before do
-      class MockCreateNamedDatastreamUpdateMethods < ActiveFedora::Base
-        include ActiveFedora::DatastreamCollections
-        has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
-        has_datastream :name=>"EAD", :type=>ActiveFedora::Datastream, :mimeType=>"application/xml", :controlGroup=>'M' 
-        has_datastream :name=>"external", :type=>ActiveFedora::Datastream, :controlGroup=>'E' 
-      end
-    end
-    
-    it 'should create append method for each has_datastream entry' do
-      @test_object2 = MockCreateNamedDatastreamUpdateMethods.new
-      @test_object3 = MockCreateNamedDatastreamUpdateMethods.new
-      expect(@test_object2).to respond_to(:thumbnail_append)
-      expect(@test_object2).to respond_to(:ead_append)
-      f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"))
-      allow(f).to receive(:content_type).and_return("image/jpeg")
-      allow(f).to receive(:original_filename).and_return("minivan.jpg")
-      @test_object2.thumbnail_file_append(f)
-      t2_thumb1 = @test_object2.thumbnail.first
-      expect(t2_thumb1.mimeType).to eq("image/jpeg")
-      expect(t2_thumb1.dsLabel).to eq("minivan.jpg")
-      expect(t2_thumb1.pid).to eq(@test_object2.pid) 
-      expect(t2_thumb1.dsid).to eq("THUMB1")
-      @test_object3.thumbnail_append({:file=>f})
-      t3_thumb1 = @test_object3.thumbnail.first
-      expect(t3_thumb1.mimeType).to eq("image/jpeg")
-      expect(t3_thumb1.dsLabel).to eq("minivan.jpg")
-      expect(t3_thumb1.pid).to eq(@test_object3.pid) 
-      expect(t3_thumb1.dsid).to eq("THUMB1")
-      @test_object3.external_append({:dsLocation=>"http://myresource.com"})
-      t3_external1 = @test_object3.external.first
-      expect(t3_external1.dsLabel).to eq("http://myresource.com")
-      expect(t3_external1.dsLocation).to eq("http://myresource.com")
-      expect(t3_external1.pid).to eq(@test_object3.pid) 
-      expect(t3_external1.dsid).to eq("EXTERNAL1")
-      t3_external1.controlGroup == 'E'
-    end
-  end
-end