active-fedora 3.1.6 → 3.2.0.pre1

data/spec/integration/datastream_collections_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+describe ActiveFedora::DatastreamCollections do
+  before(:all) do
+    ActiveSupport::Deprecation.expects(:warn).with("Deprecation: DatastreamCollections will not be included by default in the next version.   To use has_datastream add 'include ActiveFedora::DatastreamCollections' to your model")
+    class MockAFBaseDatastream < 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
+  end
+
+  #
+  # Named datastream specs
+  #
+  describe '#add_named_datastream' do
+    it 'should add a datastream with the given name to the object in fedora' do
+      @test_object2 = MockAFBaseDatastream.new
+#      @test_object2.new_object = true
+      f = File.open(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"), 'rb')
+      f2 = File.open(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ), 'rb')
+      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})
+      ds = @test_object2.thumbnail.first
+      ds2 = @test_object2.high.first
+      @test_object2.save
+      @test_object2 = MockAFBaseDatastream.load_instance(@test_object2.pid)
+      @test_object2.named_datastreams.keys.size.should == 2
+      @test_object2.named_datastreams.keys.include?("thumbnail").should == true
+      @test_object2.named_datastreams.keys.include?("high").should == true
+      @test_object2.named_datastreams["thumbnail"].size.should == 1
+      @test_object2.named_datastreams["high"].size.should == 1
+      t2_thumb1 = @test_object2.named_datastreams["thumbnail"].first
+      t2_thumb1.dsid.should == ds.dsid
+      t2_thumb1.mimeType.should == ds.mimeType
+      t2_thumb1.pid.should == ds.pid
+      t2_thumb1.dsLabel.should == ds.dsLabel
+      t2_thumb1.controlGroup.should == ds.controlGroup
+      t2_high1 = @test_object2.named_datastreams["high"].first
+      t2_high1.dsid.should == ds2.dsid
+      t2_high1.mimeType.should == ds2.mimeType
+      t2_high1.pid.should == ds2.pid
+      t2_high1.dsLabel.should == ds2.dsLabel
+      t2_high1.controlGroup.should == ds2.controlGroup
+    end
+  end
+  
+  describe '#add_named_file_datastream' do
+    it 'should add a file datastream with the given name to the object in fedora' do
+      @test_object2 = MockAFBaseDatastream.new
+#      @test_object2.new_object = true
+      f = File.open(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"), 'rb')
+      f.stubs(:content_type).returns("image/jpeg")
+      @test_object2.add_named_file_datastream("thumbnail",f)
+      ds = @test_object2.thumbnail.first
+      @test_object2.save
+      @test_object2 = MockAFBaseDatastream.load_instance(@test_object2.pid)
+      @test_object2.named_datastreams["thumbnail"].size.should == 1
+      t2_thumb1 = @test_object2.named_datastreams["thumbnail"].first
+      t2_thumb1.dsid.should == "THUMB1"
+      t2_thumb1.mimeType.should == "image/jpeg"
+      t2_thumb1.pid.should == @test_object2.pid
+      t2_thumb1.dsLabel.should == "minivan.jpg"
+      t2_thumb1.controlGroup.should == "M"
+
+# .attributes.should == {"label"=>ds.label,"dsid"=>ds.dsid,
+#                                                                                  "mimeType"=>ds.attributes[:mimeType],
+#                                                                                  :controlGroup=>ds.attributes[:controlGroup],
+#                                                                                  :pid=>ds.pid, :dsID=>ds.dsid, :dsLabel=>ds.attributes[:dsLabel]}
+    end
+  end
+  
+  describe '#update_named_datastream' do
+    it 'should update a named datastream to have a new file' do
+      @test_object2 = MockAFBaseDatastream.new
+      f = File.open(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"), 'rb')
+      minivan = f.read
+      f.rewind
+      f2 = File.open(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ), 'rb')
+      dino = f2.read
+      f2.rewind
+      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})
+      @test_object2.save
+      @test_object2 = MockAFBaseDatastream.load_instance(@test_object2.pid)
+      
+      @test_object2.thumbnail.size.should == 1
+      @test_object2.thumbnail_ids == ["THUMB1"]
+      ds = @test_object2.thumbnail.first
+      ds.dsid.should == "THUMB1"
+      ds.mimeType.should == "image/jpeg"
+      ds.pid.should == @test_object2.pid
+      ds.dsLabel.should == "minivan.jpg"
+      ds.controlGroup.should == "M"
+
+      ds.content.should == minivan 
+      @test_object2.update_named_datastream("thumbnail",{:file=>f2,:dsid=>"THUMB1"})
+      @test_object2.save
+      @test_object2 = MockAFBaseDatastream.load_instance(@test_object2.pid)
+      @test_object2.thumbnail.size.should == 1
+      @test_object2.thumbnail_ids == ["THUMB1"]
+      ds2 = @test_object2.thumbnail.first
+      ds2.dsid.should == "THUMB1"
+      ds2.mimeType.should == "image/jpeg"
+      ds2.pid.should == @test_object2.pid
+      ds2.dsLabel.should == "dino.jpg"
+      ds2.controlGroup.should == "M"
+      (ds2.content == dino).should be_true
+    end
+  end
+  
+  describe '#named_datastreams_ids' do
+    it 'should return a hash of datastream name to an array of dsids' do
+      @test_object2 = MockAFBaseDatastream.new
+#      @test_object2.new_object = true
+      f = File.open(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"), 'rb')
+      f2 = File.open(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ), 'rb')
+      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("thumbnail",{:content_type=>"image/jpeg",:blob=>f2})
+      @test_object2.save
+      @test_object2 = MockAFBaseDatastream.load_instance(@test_object2.pid)
+      @test_object2.named_datastreams_ids.should == {"high"=>[], "thumbnail"=>["THUMB1", "THUMB2"]}
+    end
+  end
+
+  
+
+end

data/spec/integration/rels_ext_datastream_spec.rb

@@ -31,8 +31,6 @@ describe ActiveFedora::RelsExtDatastream do
     @test_datastream = ActiveFedora::RelsExtDatastream.new(@test_object.inner_object, 'RELS-EXT')
     @test_datastream.model = @test_object
     @test_object.save
-    @test_relationships = [ActiveFedora::Relationship.new(:subject => :self, :predicate => :is_member_of, :object => "info:fedora/demo:5"), 
-                              ActiveFedora::Relationship.new(:subject => :self, :predicate => :is_member_of, :object => "info:fedora/demo:10")]
   end
   
   after(:each) do
@@ -63,9 +61,8 @@ describe ActiveFedora::RelsExtDatastream do
     
     it "should generate new rdf/xml as the datastream content" do
       @test_object.add_datastream(@test_datastream)
-      @test_relationships.each do |rel|
-        @test_object.add_relationship(rel.predicate, rel.object)
-      end
+      @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)
@@ -76,7 +73,7 @@ describe ActiveFedora::RelsExtDatastream do
   
   it "should load relationships from fedora into parent object" do
     class SpecNode; include ActiveFedora::SemanticNode; end
-    SpecNode.predicate_mappings[SpecNode.default_predicate_namespace].each_key do |p| 
+    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
@@ -113,11 +110,7 @@ describe ActiveFedora::RelsExtDatastream do
       @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))
+      model_rel = 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
@@ -133,35 +126,21 @@ describe ActiveFedora::RelsExtDatastream do
       test_from_solr_object5 = MockAFRelsSolr.new
       test_from_solr_object5.rels_ext.from_solr(solr_doc)
       
-      stmt = test_from_solr_object2.build_statement(test_from_solr_object2.internal_uri, :has_part, r3.object)
-      test_from_solr_object2.relationships.has_statement?(stmt).should be_true
-      stmt = test_from_solr_object2.build_statement(test_from_solr_object2.internal_uri, :has_member, r4.object)
-      test_from_solr_object2.relationships.has_statement?(stmt).should be_true
-      stmt = test_from_solr_object2.build_statement(test_from_solr_object2.internal_uri, :has_model, model_rel.object)
-      test_from_solr_object2.relationships.has_statement?(stmt).should be_true
+      test_from_solr_object2.object_relations[:has_part].should include @test_object3.internal_uri
+      test_from_solr_object2.object_relations[:has_member].should include @test_object4.internal_uri
+      test_from_solr_object2.object_relations[:has_model].should include model_rel
 
-#      test_from_solr_object2.relationships.should == {:self=>{:has_part=>[r3.object],:has_member=>[r4.object],:has_model=>[model_rel.object]}}
-      test_from_solr_object2.relationships_by_name.should == {:self=>{"testing"=>[r3.object],"testing2"=>[r4.object], "collection_members"=>[], "part_of"=>[], "parts_outbound"=>[r3.object]}}
-      #test_from_solr_object3.relationships.should == {:self=>{:has_model=>[model_rel.object]}}
-      stmt = test_from_solr_object3.build_statement(test_from_solr_object3.internal_uri, :has_model, model_rel.object)
-      test_from_solr_object3.relationships.has_statement?(stmt).should be_true
+      test_from_solr_object2.relationships_by_name.should == {:self=>{"testing"=>[@test_object3.internal_uri],"testing2"=>[@test_object4.internal_uri], "collection_members"=>[], "part_of"=>[], "parts_outbound"=>[@test_object3.internal_uri]}}
+      test_from_solr_object3.object_relations[:has_model].should include model_rel
       test_from_solr_object3.relationships_by_name.should == {:self=>{"testing2"=>[], "collection_members"=>[], "part_of"=>[], "testing"=>[], "parts_outbound"=>[]}}
-      #test_from_solr_object4.relationships.should == {:self=>{:has_model=>[model_rel.object]}}
-      stmt = test_from_solr_object4.build_statement(test_from_solr_object4.internal_uri, :has_model, model_rel.object)
-      test_from_solr_object4.relationships.has_statement?(stmt).should be_true
+      test_from_solr_object4.object_relations[:has_model].should include model_rel
       test_from_solr_object4.relationships_by_name.should == {:self=>{"testing2"=>[], "collection_members"=>[], "part_of"=>[], "testing"=>[], "parts_outbound"=>[]}}
 
-      stmt = test_from_solr_object5.build_statement(test_from_solr_object5.internal_uri, :has_model, model_rel.object)
-      test_from_solr_object5.relationships.has_statement?(stmt).should be_true
-      stmt = test_from_solr_object5.build_statement(test_from_solr_object5.internal_uri, :has_part, r2.object)
-      test_from_solr_object5.relationships.has_statement?(stmt).should be_true
-      stmt = test_from_solr_object5.build_statement(test_from_solr_object5.internal_uri, :has_member, r3.object)
-      test_from_solr_object5.relationships.has_statement?(stmt).should be_true
+      test_from_solr_object5.object_relations[:has_model].should include model_rel
+      test_from_solr_object5.object_relations[:has_part].should include @test_object2.internal_uri
+      test_from_solr_object5.object_relations[:has_member].should include @test_object3.internal_uri
 
-      # test_from_solr_object5.relationships.should == {:self=>{:has_model=>[model_rel.object],
-      #                                                        :has_part=>[r2.object],
-      #                                                        :has_member=>[r3.object]}}
-      test_from_solr_object5.relationships_by_name.should == {:self=>{"testing2"=>[r3.object], "collection_members"=>[], "part_of"=>[], "testing"=>[r2.object], "parts_outbound"=>[r2.object]}} 
+      test_from_solr_object5.relationships_by_name.should == {:self=>{"testing2"=>[@test_object3.internal_uri], "collection_members"=>[], "part_of"=>[], "testing"=>[@test_object2.internal_uri], "parts_outbound"=>[@test_object2.internal_uri]}} 
     end
   end
 end

data/spec/integration/semantic_node_spec.rb

@@ -150,9 +150,8 @@ describe ActiveFedora::SemanticNode do
     it "should create useable finders" do
       spec_node = SNSpecNode.new
       spec_node.collection_members.should == []
-      rel = ActiveFedora::Relationship.new(:subject => :self, :predicate => :has_collection_member, :object => @test_object.pid)  
       
-      spec_node.add_relationship(rel.predicate, rel.object)
+      spec_node.add_relationship(:has_collection_member, @test_object.pid)
       collection_members = spec_node.collection_members
       collection_members.length.should == 1
       collection_members.first.pid.should == @test_object.pid
@@ -449,16 +448,13 @@ describe ActiveFedora::SemanticNode do
 
     it 'should automatically update the relationships_by_name if relationships has changed (no refresh of relationships_by_name hash unless relationships hash has changed' do
       @test_object2 = MockSemNamedRelationships.new
-      r = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_model,:object=>ActiveFedora::ContentModel.pid_from_ruby_class(MockSemNamedRelationships)}) 
-      @test_object2.add_relationship(r.predicate, r.object)
+      @test_object2.add_relationship(:has_model, ActiveFedora::ContentModel.pid_from_ruby_class(MockSemNamedRelationships))
       #should return expected named relationships
       @test_object2.relationships_by_name.should == {:self=>{"testing"=>[],"testing2"=>[], "collection_members"=>[], "part_of"=>[], "parts_outbound"=>[]}}
-      r3 = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_part,:object=>@test_object})
-      @test_object2.add_relationship(r3.predicate, r3.object)
-      @test_object2.relationships_by_name.should == {:self=>{"testing"=>[r3.object],"testing2"=>[], "collection_members"=>[], "part_of"=>[],  "parts_outbound"=>[r3.object]}}
-      r4 = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_member,:object=>"3"})
-      @test_object2.add_relationship(r4.predicate, r4.object)
-      @test_object2.relationships_by_name.should == {:self=>{"testing"=>[r3.object],"testing2"=>[r4.object], "collection_members"=>[], "part_of"=>[],  "parts_outbound"=>[r3.object]}}
+      @test_object2.add_relationship(:has_part, @test_object.internal_uri)
+      @test_object2.relationships_by_name.should == {:self=>{"testing"=>[@test_object.internal_uri],"testing2"=>[], "collection_members"=>[], "part_of"=>[],  "parts_outbound"=>[@test_object.internal_uri]}}
+      @test_object2.add_relationship(:has_member, "3", true)
+      @test_object2.relationships_by_name.should == {:self=>{"testing"=>[@test_object.internal_uri],"testing2"=>["3"], "collection_members"=>[], "part_of"=>[],  "parts_outbound"=>[@test_object.internal_uri]}}
     end
   end
 end

data/spec/unit/base_datastream_management_spec.rb

@@ -3,9 +3,6 @@ require 'spec_helper'
 describe ActiveFedora::Base do
   
   before(:each) do
-    stub_get('__nextid__')
-    ActiveFedora::RubydoraConnection.instance.expects(:nextid).returns("__nextid__")
-    Rubydora::Repository.any_instance.stubs(:client).returns(@mock_client)
     @test_object = ActiveFedora::Base.new
   end
   

data/spec/unit/base_extra_spec.rb

@@ -6,9 +6,9 @@ require 'active_fedora/metadata_datastream'
 describe ActiveFedora::Base do
   
   before(:each) do
-    stub_get('__nextid__')
-    ActiveFedora::RubydoraConnection.instance.expects(:nextid).returns("__nextid__")
-    Rubydora::Repository.any_instance.stubs(:client).returns(@mock_client)
+    # stub_get('__nextid__')
+    # ActiveFedora::RubydoraConnection.instance.expects(:nextid).returns("__nextid__")
+    # Rubydora::Repository.any_instance.stubs(:client).returns(@mock_client)
     @test_object = ActiveFedora::Base.new
   end
   
@@ -100,12 +100,8 @@ describe ActiveFedora::Base do
     end
     
     it "should delete object from repository and index" do
-      @test_object.stubs(:pid).returns("foo")
-      ActiveFedora::SolrService.instance.conn.expects(:delete).with("foo")      
-      #@test_object.inner_object.stubs(:delete)
-      mock_repository = mock('repo')
-      @test_object.inner_object.expects(:repository).returns(mock_repository)
-      mock_repository.expects :purge_object
+      ActiveFedora::SolrService.instance.conn.expects(:delete).with("__DO_NOT_USE__")      
+      @test_object.inner_object.stubs(:delete)
       @test_object.expects(:inbound_relationships).returns({})
       @test_object.delete
     end

data/spec/unit/base_spec.rb

@@ -17,6 +17,8 @@ class FooHistory < ActiveFedora::Base
     m.field "fubar", :text
   end 
 end
+class FooAdaptation < ActiveFedora::Base
+end
 
 @@last_pid = 0  
 
@@ -33,7 +35,6 @@ describe ActiveFedora::Base do
     ActiveFedora::RubydoraConnection.instance.stubs(:nextid).returns(@this_pid)
 
     @test_object = ActiveFedora::Base.new
-    @test_history = FooHistory.new
   end
 
   after(:each) do
@@ -47,14 +48,9 @@ describe ActiveFedora::Base do
   describe '#new' do
     it "should create a new inner object" do
       Rubydora::DigitalObject.any_instance.expects(:save).never
-      #@mock_repo.expects(:datastreams).with(:pid => "test:1").returns("")
-      @mock_client.stubs(:[]).with("objects/test%3A1/datastreams?format=xml").returns(@getter)
-      ['someData', 'withText', 'withText2', 'RELS-EXT'].each do |dsid|
-        @mock_client.stubs(:[]).with {|params| /objects\/test%3A1\/datastreams\/#{dsid}/.match(params)}.returns(@getter)
-#        @mock_client.stubs(:[]).with {|params| /objects\/test%3A1\/datastreams\/#{dsid}\/content/.match(params)}.returns(stub(:post=>'test:1'))
-      end
+      stub_get_content(@this_pid, ['RELS-EXT', 'someData', 'withText2', 'withText'])
 
-      result = ActiveFedora::Base.new(:pid=>"test:1")  
+      result = ActiveFedora::Base.new(:pid=>@this_pid)  
       result.inner_object.should be_kind_of(Rubydora::DigitalObject)    
     end
 
@@ -62,7 +58,7 @@ describe ActiveFedora::Base do
       # for doing AFObject.new(params[:foo]) when nothing is in params[:foo]
       Rubydora::DigitalObject.any_instance.expects(:save).never
       result = ActiveFedora::Base.new(nil)  
-      result.inner_object.should be_kind_of(Rubydora::DigitalObject)    
+      result.inner_object.should be_kind_of(ActiveFedora::UnsavedDigitalObject)    
     end
 
   end
@@ -241,6 +237,9 @@ describe ActiveFedora::Base do
 
 
   describe ".datastreams" do
+    before do
+      @test_history = FooHistory.new
+    end
     it "should create dynamic accessors" do
       @test_history.withText.should == @test_history.datastreams['withText']
     end
@@ -320,7 +319,7 @@ describe ActiveFedora::Base do
   describe '#add_relationship' do
     it 'should call #add_relationship on the rels_ext datastream' do
       @test_object.add_relationship("predicate", "info:fedora/object")
-      pred = @test_object.class.vocabularies["info:fedora/fedora-system:def/relations-external#"]["predicate"] 
+      pred = ActiveFedora::Predicates.vocabularies["info:fedora/fedora-system:def/relations-external#"]["predicate"] 
       @test_object.relationships.should have_statement(RDF::Statement.new(RDF::URI.new(@test_object.internal_uri), pred, RDF::URI.new("info:fedora/object")))
     end
 
@@ -328,11 +327,8 @@ describe ActiveFedora::Base do
       mock_ds = mock("Rels-Ext")
       mock_ds.expects(:dirty=).with(true).times(2)
       @test_object.datastreams["RELS-EXT"] = mock_ds
-      test_relationships = [ActiveFedora::Relationship.new(:subject => :self, :predicate => :is_member_of, :object => "info:fedora/demo:5"), 
-        ActiveFedora::Relationship.new(:subject => :self, :predicate => :is_member_of, :object => "info:fedora/demo:10")]
-      test_relationships.each do |rel|
-        @test_object.add_relationship(rel.predicate, rel.object)
-      end
+      @test_object.add_relationship(:is_member_of, "info:fedora/demo:5")
+      @test_object.add_relationship(:is_member_of, "info:fedora/demo:10")
     end
     
     it 'should add a relationship to an object only if it does not exist already' do
@@ -342,7 +338,6 @@ describe ActiveFedora::Base do
 
       @test_object3 = ActiveFedora::Base.new
       @test_object.add_relationship(:has_part,@test_object3)
-      r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:dummy, :object=>@test_object3)
       @test_object.ids_for_outbound(:has_part).should == [@test_object3.pid]
       #try adding again and make sure not there twice
       @test_object.add_relationship(:has_part,@test_object3)
@@ -364,11 +359,11 @@ describe ActiveFedora::Base do
       next_pid = increment_pid.to_s
       ActiveFedora::RubydoraConnection.instance.stubs(:nextid).returns(next_pid)
       stub_get(next_pid)
-      @test_object3 = ActiveFedora::Base.new
+      @test_object3 = ActiveFedora::Base.new(:pid=>next_pid)
       next_pid = increment_pid.to_s
       ActiveFedora::RubydoraConnection.instance.stubs(:nextid).returns(next_pid)
       stub_get(next_pid)
-      @test_object4 = ActiveFedora::Base.new
+      @test_object4 = ActiveFedora::Base.new(:pid=>next_pid)
       @test_object.add_relationship(:has_part,@test_object3)
       @test_object.add_relationship(:has_part,@test_object4)
       #check both are there
@@ -426,8 +421,8 @@ describe ActiveFedora::Base do
     end
     
     it "should call .save on any datastreams that are dirty" do
-      stub_ingest(@test_object.pid)
-      stub_add_ds(@test_object.pid, ['withText2', 'withText', 'RELS-EXT'])
+      stub_ingest(@this_pid)
+      stub_add_ds(@this_pid, ['withText2', 'withText', 'RELS-EXT'])
       to = FooHistory.new
       to.expects(:update_index)
 
@@ -438,8 +433,8 @@ describe ActiveFedora::Base do
       to.save
     end
     it "should call .save on any datastreams that are new" do
-      stub_ingest(@test_object.pid)
-      stub_add_ds(@test_object.pid, ['RELS-EXT'])
+      stub_ingest(@this_pid)
+      stub_add_ds(@this_pid, ['RELS-EXT'])
       ds = ActiveFedora::Datastream.new(@test_object.inner_object, 'ds_to_add')
       ds.content = "DS CONTENT"
       @test_object.add_datastream(ds)
@@ -450,7 +445,7 @@ describe ActiveFedora::Base do
       @test_object.save
     end
     it "should not call .save on any datastreams that are not dirty" do
-      stub_ingest(@test_object.pid)
+      stub_ingest(@this_pid)
       @test_object = FooHistory.new
       @test_object.expects(:update_index)
       @test_object.expects(:refresh)
@@ -465,9 +460,8 @@ describe ActiveFedora::Base do
       @test_object.save
     end
     it "should update solr index with all metadata if any MetadataDatastreams have changed" do
-#      rels_ds.expects(:new?).returns(false).twice
-      stub_ingest(@test_object.pid)
-      stub_add_ds(@test_object.pid, ['ds1', 'RELS-EXT'])
+      stub_ingest(@this_pid)
+      stub_add_ds(@this_pid, ['ds1', 'RELS-EXT'])
 
       dirty_ds = ActiveFedora::MetadataDatastream.new(@test_object.inner_object, 'ds1')
       rels_ds = ActiveFedora::RelsExtDatastream.new(@test_object.inner_object, 'RELS-EXT')
@@ -495,20 +489,20 @@ describe ActiveFedora::Base do
       @test_object.save
     end
     it "should update solr index if relationships have changed" do
-      @mock_repo.expects(:ingest).with(:pid => @test_object.pid)
-      @test_object.inner_object.expects(:repository).returns(@mock_repo).at_least_once
-      @test_object.inner_object.expects(:new?).returns(true).twice
+      stub_ingest(@this_pid)
 
       rels_ext = ActiveFedora::RelsExtDatastream.new(@test_object.inner_object, 'RELS-EXT')
       rels_ext.model = @test_object
-      rels_ext.expects(:changed?).returns(true).twice  
+      rels_ext.expects(:changed?).returns(true).twice
       rels_ext.expects(:save).returns(true)
       rels_ext.expects(:serialize!)
-      clean_ds = mock("ds2")
+      clean_ds = mock("ds2", :digital_object=)
       clean_ds.stubs(:dirty? => false, :changed? => false, :new? => false)
       clean_ds.expects(:serialize!)
-      @test_object.inner_object.stubs(:datastreams).returns({"RELS-EXT" => rels_ext, :clean_ds => clean_ds})
-      @test_object.stubs(:datastreams).returns({"RELS-EXT" => rels_ext, :clean_ds => clean_ds})
+      @test_object.datastreams["RELS-EXT"] = rels_ext
+      @test_object.datastreams[:clean_ds] = clean_ds
+#      @test_object.inner_object.stubs(:datastreams).returns({"RELS-EXT" => rels_ext, :clean_ds => clean_ds})
+#      @test_object.stubs(:datastreams).returns({"RELS-EXT" => rels_ext, :clean_ds => clean_ds})
       @test_object.instance_variable_set(:@new_object, false)
       @test_object.expects(:refresh)
       @test_object.expects(:update_index)
@@ -517,6 +511,24 @@ describe ActiveFedora::Base do
     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
+  end
+
   describe ".add_file_datastream" do
     before do
       @mock_file = mock('file')
@@ -541,6 +553,47 @@ describe ActiveFedora::Base do
     end
   end
 
+  describe ".adapt_to" do
+    before(:each) do
+      @mock_client.stubs(:[]).with("objects/monkey%3A99/datastreams?format=xml").returns(@getter)
+      @mock_client.stubs(:[]).with("objects/monkey%3A99/datastreams/MY_DSID?format=xml").returns(@getter)
+      @mock_client.stubs(:[]).with("objects/monkey%3A99/datastreams/RELS-EXT/content").returns(@getter)
+      @mock_client.stubs(:[]).with("objects/monkey%3A99/datastreams/MY_DSID/content").returns("XXX")
+      #Update record
+      @mock_client.stubs(:[]).with("objects/monkey%3A99").returns(stub('post', :post=>'monkey:99'))
+      #Update datastream
+      ['someData', 'withText', 'withText2', 'RELS-EXT'].each do |dsid|
+        @mock_client.stubs(:[]).with {|params| /objects\/monkey%3A99\/datastreams\/#{dsid}/.match(params)}.returns(stub('post', :post=>'monkey:99', :get=>''))
+      end
+      @mock_file = mock('file')
+    end
+    it "should return an adapted object of the requested type" do
+      @test_object = FooHistory.new(:pid=>"monkey:99")
+      @test_object.adapt_to(FooAdaptation).class.should == FooAdaptation
+    end
+    it "should not make an additional call to fedora to create the adapted object" do
+      @mock_client.stubs(:[]).with("objects/monkey%3A99/datastreams?format=xml").returns(@getter).once
+      @test_object = FooHistory.new(:pid=>"monkey:99")
+      adapted = @test_object.adapt_to(FooAdaptation)
+    end
+    it "should propagate new datastreams to the adapted object" do
+      @test_object = FooHistory.new(:pid=>"monkey:99")
+      @test_object.add_file_datastream("XXX", :dsid=>'MY_DSID')
+      adapted = @test_object.adapt_to(FooAdaptation)
+      adapted.datastreams.keys.should include 'MY_DSID'
+      adapted.datastreams['MY_DSID'].content.should == "XXX"
+      adapted.datastreams['MY_DSID'].changed?.should be_true
+    end
+    it "should propagate modified datastreams to the adapted object" do
+      @test_object = FooHistory.new(:pid=>"monkey:99")
+      @test_object.datastreams['someData'].content="YYY"
+      adapted = @test_object.adapt_to(FooAdaptation)
+      adapted.datastreams.keys.should include 'someData'
+      adapted.datastreams['someData'].content.should == "YYY"
+      adapted.datastreams['someData'].changed?.should be_true
+    end
+  end
+
   describe ".to_xml" do
     it "should provide .to_xml" do
       @test_object.should respond_to(:to_xml)
@@ -594,7 +647,9 @@ describe ActiveFedora::Base do
     end
     
     it "should add self.class as the :active_fedora_model" do
-      stub_get_content(@this_pid, ['someData', 'withText2', 'withText'])
+      stub_get(@this_pid)
+      stub_get_content(@this_pid, ['RELS-EXT', 'someData', 'withText2', 'withText'])
+      @test_history = FooHistory.new(:pid=>@this_pid)
       solr_doc = @test_history.to_solr
       solr_doc["active_fedora_model_s"].should eql("FooHistory")
     end
@@ -664,16 +719,10 @@ describe ActiveFedora::Base do
     end
   end
   
-  it "should get a pid but not save on init" do
+  it "should not save or get an pid on init" do
     Rubydora::DigitalObject.any_instance.expects(:save).never
-    ActiveFedora::RubydoraConnection.instance.stubs(:nextid).returns('mooshoo:24')
-    @mock_client.stubs(:[]).with("objects/mooshoo%3A24/datastreams?format=xml").returns(@getter)
-    ['someData', 'withText', 'withText2', 'RELS-EXT'].each do |dsid|
-      @mock_client.stubs(:[]).with {|params| /objects\/mooshoo%3A24\/datastreams\/#{dsid}/.match(params)}.returns(@getter)
-    end
+    ActiveFedora::RubydoraConnection.instance.expects(:nextid).never
     f = FooHistory.new
-    f.pid.should_not be_nil
-    f.pid.should == 'mooshoo:24'
   end
   it "should not clobber a pid if i'm creating!" do
     @mock_client.stubs(:[]).with("objects/numbnuts%3A1/datastreams?format=xml").returns(@getter)
@@ -746,10 +795,9 @@ describe ActiveFedora::Base do
     end
     it "should take a :datastreams argument" do 
       att= {"fubar"=>{"-1"=>"mork", "0"=>"york", "1"=>"mangle"}}
-      m = FooHistory.new
-      ['withText', 'someData', 'withText2'].each do |dsid|
-        @mock_client.stubs(:[]).with {|params| /objects\/#{@this_pid}\/datastreams\/#{dsid}\/content/.match(params)}.returns(stub('getter/setter', :get=>'', :post=>@this_pid))
-      end
+      stub_get(@this_pid)
+      stub_get_content(@this_pid, ['RELS-EXT', 'someData', 'withText2', 'withText'])
+      m = FooHistory.new(:pid=>@this_pid)
       m.update_indexed_attributes(att, :datastreams=>"withText")
       m.should_not be_nil
       m.datastreams['someData'].fubar_values.should == []
@@ -804,9 +852,8 @@ describe ActiveFedora::Base do
       #should return expected named relationships
       @test_object2.relationships_by_name
       @test_object2.relationships_by_name.should == {:self=>{"testing2"=>[], "collection_members"=>[], "part_of"=>[], "testing"=>[], "parts_outbound"=>[]}}
-      r = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:dummy,:object=>@test_object})
       @test_object2.add_relationship_by_name("testing",@test_object)
-      @test_object2.relationships_by_name.should == {:self=>{"testing"=>[r.object],"testing2"=>[],"part_of"=>[], "parts_outbound"=>[r.object], "collection_members"=>[]}}
+      @test_object2.relationships_by_name.should == {:self=>{"testing"=>[@test_object.internal_uri],"testing2"=>[],"part_of"=>[], "parts_outbound"=>[@test_object.internal_uri], "collection_members"=>[]}}
     end 
   end
 
@@ -825,13 +872,12 @@ describe ActiveFedora::Base do
       @test_object2.should respond_to(:testing_append)
       @test_object2.should respond_to(:testing_remove)
       #test executing each one to make sure code added is correct
-      r = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_model,:object=>ActiveFedora::ContentModel.pid_from_ruby_class(ActiveFedora::Base)})
-      @test_object.add_relationship(r.predicate,r.object)
-      @test_object2.add_relationship(r.predicate,r.object)
+      model_pid = ActiveFedora::ContentModel.pid_from_ruby_class(ActiveFedora::Base)
+      @test_object.add_relationship(:has_model,model_pid)
+      @test_object2.add_relationship(:has_model,model_pid)
       @test_object2.testing_append(@test_object)
       #create relationship to access generate_uri method for an object
-      r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:dummy, :object=>@test_object)
-      @test_object2.relationships_by_name.should == {:self=>{"testing"=>[r.object],"collection_members"=>[], "part_of"=>[r.object], "parts_outbound"=>[]}}
+      @test_object2.relationships_by_name.should == {:self=>{"testing"=>[@test_object.internal_uri],"collection_members"=>[], "part_of"=>[@test_object.internal_uri], "parts_outbound"=>[]}}
       @test_object2.testing_remove(@test_object)
       @test_object2.relationships_by_name.should == {:self=>{"testing"=>[],"collection_members"=>[], "part_of"=>[], "parts_outbound"=>[]}}
     end
@@ -841,10 +887,10 @@ describe ActiveFedora::Base do
     it "should serialize the relationships into a Hash" do
       graph = RDF::Graph.new
       subject = RDF::URI.new "info:fedora/test:sample_pid"
-      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:is_member_of),  RDF::URI.new('info:fedora/demo:10'))
-      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:is_part_of),  RDF::URI.new('info:fedora/demo:11'))
-      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:has_part),  RDF::URI.new('info:fedora/demo:12'))
-      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:conforms_to),  "AnInterface")
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:is_member_of),  RDF::URI.new('info:fedora/demo:10'))
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:is_part_of),  RDF::URI.new('info:fedora/demo:11'))
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:has_part),  RDF::URI.new('info:fedora/demo:12'))
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:conforms_to),  "AnInterface")
 
       @test_object.expects(:relationships).returns(graph)
       solr_doc = @test_object.solrize_relationships