active-fedora 8.7.0 → 9.0.0.beta1

data/spec/integration/attached_files_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+describe ActiveFedora::AttachedFiles do
+  describe "serializing datastreams" do
+    before do
+      class TestingMetadataSerializing < ActiveFedora::Base
+        has_metadata "nokogiri_autocreate_on", autocreate: true, type: ActiveFedora::OmDatastream
+        has_metadata "nokogiri_autocreate_off", autocreate: false, type: ActiveFedora::OmDatastream
+      end
+    end
+
+    after do
+      Object.send(:remove_const, :TestingMetadataSerializing)
+    end
+
+    subject { TestingMetadataSerializing.new }
+
+    it "should work" do
+      subject.save(:validate => false)
+      expect(subject.nokogiri_autocreate_on).to_not be_new_record
+      expect(subject.nokogiri_autocreate_off).to be_new_record
+    end
+  end
+
+  describe "#has_file_datastream" do
+    before do
+      class HasFile < ActiveFedora::Base
+        has_file_datastream "file_ds"
+        has_file_datastream "file_ds2", autocreate: false
+      end
+    end
+
+    after do
+      has_file.delete
+      Object.send(:remove_const, :HasFile)
+    end
+
+    let(:has_file) { HasFile.create("test:ds_versionable_has_file") }
+
+    it "should create datastreams from the spec on new objects" do
+      has_file.file_ds.content = "blah blah blah"
+      expect(has_file.file_ds).to be_changed
+      expect(has_file.file_ds2).to_not be_changed # no autocreate
+      expect(has_file.file_ds2).to be_new_record
+      has_file.save
+      has_file.reload
+      expect(has_file.file_ds).to_not be_changed
+      expect(has_file.file_ds2).to_not be_changed # no autocreate
+      expect(has_file.file_ds2).to be_new_record
+    end
+  end
+
+  describe "Datastreams synched together" do
+    before do
+      class DSTest < ActiveFedora::Base
+        def load_attached_files
+          super
+          unless attached_files.keys.include? :test_ds
+            add_file_datastream("XXX", dsid: 'test_ds', mime_type: 'text/html')
+          end
+        end
+      end
+    end
+
+    let(:file) { DSTest.create }
+    let(:ds) { file.test_ds }
+
+    subject { ds.content }
+
+    after do
+      Object.send(:remove_const, :DSTest)
+    end
+
+    it { should == 'XXX'}
+
+    context "After updating" do
+      before do
+        ds.content = "Foobar"
+        file.save!
+      end
+
+      it "Should update datastream" do
+        expect(DSTest.find(file.id).attached_files['test_ds'].content).to eq 'Foobar'
+        expect(DSTest.find(file.id).test_ds.content).to eq 'Foobar'
+      end
+    end
+
+  end
+
+  describe "an instance of ActiveFedora::Base" do
+    let(:obj) { ActiveFedora::Base.new }
+
+    describe ".attached_files" do
+      subject { obj.attached_files }
+      it "should return a Hash of datastreams from fedora" do
+        expect(subject).to be_a_kind_of(ActiveFedora::FilesHash)
+        expect(subject).to be_empty
+      end
+
+      it "should initialize the datastream pointers with @new_object=false" do
+        subject.each_value do |ds|
+          expect(ds).to_not be_new
+        end
+      end
+    end
+
+    describe ".metadata_streams" do
+      let(:mds1) { ActiveFedora::SimpleDatastream.new }
+      let(:mds2) { ActiveFedora::QualifiedDublinCoreDatastream.new }
+      let(:fds) { ActiveFedora::File.new }
+      before do
+        fds = ActiveFedora::File.new
+        obj.attach_file(mds1, 'md1')
+        obj.attach_file(mds2, 'qdc')
+        obj.attach_file(fds, 'fds')
+      end
+
+      it "should return all of the datastreams from the object that are kinds of OmDatastream " do
+        expect(obj.metadata_streams).to match_array [mds1, mds2]
+      end
+    end
+
+    describe '.add_file_datastream' do
+      before do
+        f = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino_jpg_no_file_ext" ))
+        obj.add_file_datastream(f, mime_type: "image/jpeg")
+        obj.save
+      end
+
+      it "should set the correct mime_type if :mime_type is passed in and path does not contain correct extension" do
+        expect(obj.reload.attached_files["DS1"].mime_type).to eq "image/jpeg"
+      end
+    end
+
+    describe '.attach_file' do
+      let(:ds) { ActiveFedora::File.new }
+
+      it "should be able to add datastreams" do
+        expect(obj.attach_file(ds, 'DS1')).to eq 'DS1'
+      end
+
+      it "adding and saving should add the datastream to the datastreams array" do
+        ds.content = fixture('dino.jpg').read
+        expect(obj.attached_files).to_not have_key(:DS1)
+        obj.attach_file(ds, 'DS1')
+        obj.save
+        expect(obj.attached_files).to have_key(:DS1)
+      end
+
+    end
+
+    describe "retrieving datastream content" do
+      let(:obj) { ActiveFedora::Base.create }
+      after { obj.destroy }
+
+      let(:ds) { ActiveFedora::File.new(obj.uri+'/DS1').tap {|ds| ds.content = "foo"; ds.save } }
+
+      it "should retrieve blobs that match the saved blobs" do
+        obj.attach_file(ds, 'DS1')
+        expect(obj.reload.attached_files["DS1"].content).to eq "foo"
+      end
+    end
+  end
+end

data/spec/integration/attributes_spec.rb

@@ -2,32 +2,93 @@ require 'spec_helper'
 
 describe "delegating attributes" do
   before :all do
+    class PropertiesDatastream < ActiveFedora::OmDatastream
+      set_terminology do |t|
+        t.root(path: "fields")
+        t.depositor index_as: [:symbol, :stored_searchable]
+      end
+    end
     class TitledObject < ActiveFedora::Base
       has_metadata 'foo', type: ActiveFedora::SimpleDatastream do |m|
         m.field "title", :string
       end
       has_attributes :title, datastream: 'foo', multiple: false
     end
+    class RdfObject < ActiveFedora::Base
+      contains 'foo', class_name: 'PropertiesDatastream'
+      has_attributes :depositor, datastream: :foo, multiple: false
+      property :resource_type, predicate: ::RDF::DC.type do |index|
+        index.as :stored_searchable, :facetable
+      end
+    end
   end
   after :all do
     Object.send(:remove_const, :TitledObject)
+    Object.send(:remove_const, :RdfObject)
+    Object.send(:remove_const, :PropertiesDatastream)
   end
 
-  describe "save" do
-    subject do
-      obj = TitledObject.create 
-      obj.title = "Hydra for Dummies"
-      obj.save
-      obj
+  context "with a simple datastream" do
+    describe "save" do
+      subject do
+        obj = TitledObject.create
+        obj.title = "Hydra for Dummies"
+        obj.save
+        obj
+      end
+      it "should keep a list of changes after a successful save" do
+        expect(subject.previous_changes).to_not be_empty
+        expect(subject.previous_changes.keys).to include("title")
+      end
+      it "should clean out changes" do
+        expect(subject).to_not be_title_changed
+        expect(subject.changes).to be_empty
+      end
     end
-    it "should keep a list of changes after a successful save" do
-      expect(subject.previous_changes).to_not be_empty
-      expect(subject.previous_changes.keys).to include("title")
+  end
+
+  context "with an rdf property" do
+
+    subject { RdfObject.create }
+
+    describe "getting attributes" do
+
+      before do
+        subject.depositor = "foo"
+        subject.resource_type = "bar"
+        subject.save
+      end
+
+      specify "using strings for keys" do
+        expect(subject["depositor"]).to eql("foo")
+        expect(subject["resource_type"]).to eql(["bar"])
+      end
+      specify "using symbols for keys" do
+        expect(subject[:depositor]).to eql("foo")
+        expect(subject[:resource_type]).to eql(["bar"])
+      end
+
     end
-    it "should clean out changes" do
-      expect(subject).to_not be_title_changed
-      expect(subject.changes).to be_empty
+
+    describe "setting attributes" do
+      
+      after do
+        expect(subject.depositor).to eql("foo")
+        expect(subject.resource_type).to eql(["bar"])
+      end
+      specify "using strings for keys" do
+        subject["depositor"] = "foo"
+        subject["resource_type"] = "bar"
+        subject.save
+      end
+      specify "using symbols for keys" do
+        subject[:depositor] = "foo"
+        subject[:resource_type] = "bar"
+        subject.save
+      end
+
     end
+
   end
 end
 

data/spec/integration/autosave_association_spec.rb

@@ -14,9 +14,9 @@ describe ActiveFedora::Base do
 
   context '#changed_for_autosave?' do
     before(:each) do
-      allow(subject).to receive(:new_record?).and_return(false)
-      allow(subject).to receive(:changed?).and_return(false)
-      allow(subject).to receive(:marked_for_destruction?).and_return(false)
+      expect(subject).to receive(:new_record?).and_return(false)
+      expect(subject).to receive(:changed?).and_return(false)
+      expect(subject).to receive(:marked_for_destruction?).and_return(false)
     end
     it {
       expect { subject.changed_for_autosave? }.to_not raise_error

data/spec/integration/base_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
 describe "A base object with metadata" do
-  before :all do
+  before :each do
     class MockAFBaseRelationship < ActiveFedora::Base
-      has_metadata 'foo', type: Hydra::ModsArticleDatastream 
+      has_metadata 'foo', type: Hydra::ModsArticleDatastream
     end
   end
-  after :all do
+  after :each do
     Object.send(:remove_const, :MockAFBaseRelationship)
   end
   describe "a new document" do
@@ -16,31 +16,20 @@ describe "A base object with metadata" do
       @obj.foo.person = "bob"
       @obj.save
     end
+
     it "should save the datastream." do
-      obj = ActiveFedora::Base.find(@obj.pid)
-      expect(obj.foo).not_to be_new
-      expect(obj.foo.person).to eq(['bob'])
+      obj = ActiveFedora::Base.find(@obj.id)
+      expect(obj.foo).to_not be_new_record
+      expect(obj.foo.person).to eq ['bob']
       person_field = ActiveFedora::SolrService.solr_name('foo__person', type: :string)
-      solr_result = ActiveFedora::SolrService.query("{!raw f=id}#{@obj.pid}", :fl=>"id #{person_field}").first
-      expect(solr_result).to eq("id"=>@obj.pid, person_field =>['bob'])
-    end
-  end
-
-  describe "setting object state" do
-    it "should store it" do
-      obj = MockAFBaseRelationship.create
-      obj.state='D'
-      obj.save!
-      obj.reload
-      expect(obj.state).to eq('D')
+      solr_result = ActiveFedora::SolrService.query("{!raw f=id}#{@obj.id}", :fl=>"id #{person_field}").first
+      expect(solr_result).to eq("id"=>@obj.id, person_field =>['bob'])
     end
   end
 
   describe "that already exists in the repo" do
     before do
       @release = MockAFBaseRelationship.create()
-      @release.add_relationship(:is_governed_by, 'info:fedora/test:catalog-fixture')
-      @release.add_relationship(:is_part_of, 'info:fedora/test:777')
       @release.foo.person = "test foo content"
       @release.save
     end
@@ -50,56 +39,18 @@ describe "A base object with metadata" do
         @release.save!
       end
       it "should save the datastream." do
-        expect(MockAFBaseRelationship.find(@release.pid).foo.person).to eq(['frank'])
+        expect(MockAFBaseRelationship.find(@release.id).foo.person).to eq ['frank']
         person_field = ActiveFedora::SolrService.solr_name('foo__person', type: :string)
-        expect(ActiveFedora::SolrService.query("id:#{@release.pid.gsub(":", "\\:")}", :fl=>"id #{person_field}").first).to eq({"id"=>@release.pid, person_field =>['frank']})
-      end
-    end
-    describe "clone_into a new object" do
-      before do
-        begin
-          new_object = MockAFBaseRelationship.find('test:999')
-          new_object.delete
-        rescue ActiveFedora::ObjectNotFoundError
-        end
-        
-        new_object = MockAFBaseRelationship.create(:pid => 'test:999')
-        @release.clone_into(new_object)
-        @new_object = MockAFBaseRelationship.find('test:999')
-      end
-      it "should have all the assertions" do
-        expect(@new_object.rels_ext.content).to be_equivalent_to '<rdf:RDF xmlns:ns1="info:fedora/fedora-system:def/model#" xmlns:ns2="info:fedora/fedora-system:def/relations-external#" xmlns:ns0="http://projecthydra.org/ns/relations#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
-         <rdf:Description rdf:about="info:fedora/test:999">
-           <ns0:isGovernedBy rdf:resource="info:fedora/test:catalog-fixture"/>
-           <ns1:hasModel rdf:resource="info:fedora/afmodel:MockAFBaseRelationship"/>
-           <ns2:isPartOf rdf:resource="info:fedora/test:777"/>
-
-         </rdf:Description>
-       </rdf:RDF>'
-      end
-      it "should have the other datastreams too" do
-        expect(@new_object.datastreams.keys).to include "foo"
-        expect(@new_object.foo.content).to be_equivalent_to @release.foo.content
+        expect(ActiveFedora::SolrService.query("id:\"#{@release.id}\"", :fl=>"id #{person_field}").first).to eq("id"=>@release.id, person_field =>['frank'])
       end
     end
-    describe "clone" do
-      before do
-        @new_object = @release.clone
+    describe "when trying to create it again" do
+      it "should raise an error" do
+        expect { MockAFBaseRelationship.create(id: @release.id) }.to raise_error(ActiveFedora::IllegalOperation)
+        @release.reload
+        expect(@release.foo.person).to include('test foo content')
       end
-      it "should have all the assertions" do
-        expect(@new_object.rels_ext.content).to be_equivalent_to '<rdf:RDF xmlns:ns1="info:fedora/fedora-system:def/model#" xmlns:ns2="info:fedora/fedora-system:def/relations-external#" xmlns:ns0="http://projecthydra.org/ns/relations#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
-         <rdf:Description rdf:about="info:fedora/'+ @new_object.pid+'">
-           <ns0:isGovernedBy rdf:resource="info:fedora/test:catalog-fixture"/>
-           <ns1:hasModel rdf:resource="info:fedora/afmodel:MockAFBaseRelationship"/>
-           <ns2:isPartOf rdf:resource="info:fedora/test:777"/>
 
-         </rdf:Description>
-       </rdf:RDF>'
-      end
-      it "should have the other datastreams too" do
-        expect(@new_object.datastreams.keys).to include "foo"
-        expect(@new_object.foo.content).to be_equivalent_to @release.foo.content
-      end
     end
   end
 
@@ -109,7 +60,7 @@ describe "A base object with metadata" do
       @object.foo.person = 'bob'
       @object.save
 
-      @object2 = @object.class.find(@object.pid)
+      @object2 = @object.class.find(@object.id)
 
       @object2.foo.person = 'dave'
       @object2.save
@@ -117,7 +68,7 @@ describe "A base object with metadata" do
 
     it 'should requery Fedora' do
       @object.reload
-      expect(@object.foo.person).to eq(['dave'])
+      expect(@object.foo.person).to eq ['dave']
     end
 
     it 'should raise an error if not persisted' do
@@ -127,318 +78,73 @@ describe "A base object with metadata" do
   end
 end
 
-describe "Datastreams synched together" do
-  before do
-    class DSTest < ActiveFedora::Base
-      def load_datastreams
-        super
-        unless self.datastreams.keys.include? 'test_ds'
-         add_file_datastream("XXX",:dsid=>'test_ds', :mimeType=>'text/html')
-        end
-      end
-    end
-  end
-  it "Should update datastream" do
-    @nc = DSTest.new
-    @nc.save
-    expect(@nc.test_ds.content).to eq('XXX')
-    ds  = @nc.datastreams['test_ds']
-    ds.content = "Foobar"
-    @nc.save
-    expect(DSTest.find(@nc.pid).datastreams['test_ds'].content).to eq('Foobar')
-    expect(DSTest.find(@nc.pid).test_ds.content).to eq('Foobar')
-  end
-
-end
-
-
-
-
 describe ActiveFedora::Base do
-  before :all do
-    class MockAFBaseRelationship < ActiveFedora::Base
-    end
-
-    class MockAFBaseFromSolr < ActiveFedora::Base
-      has_metadata :name => "properties", :type => ActiveFedora::SimpleDatastream 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"
+  describe "a saved object" do
+    before do
+      class Book < ActiveFedora::Base
+        property :title, predicate: ::RDF::DC.title
       end
     end
-  end
-  
-  before(:all) do
-    ActiveFedora::SolrService.register(ActiveFedora.solr_config[:url])
-  end
 
-  after :all do
-    Object.send(:remove_const, :MockAFBaseRelationship)
-  end
-  
-  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
-    begin
-    @test_object4.delete
-    rescue
-    end
-    begin
-    @test_object5.delete
-    rescue
-    end
-  end
-  
-  describe ".initialize" do
-    it "calling constructor should create a new Fedora Object" do    
-      expect(@test_object.errors).to be_blank
-      expect(@test_object.pid).not_to be_nil
-    end
-  end
-  
-  describe "#save" do
-    before(:each) do
-      @test_object2 = ActiveFedora::Base.new
+    after do
+      Object.send(:remove_const, :Book)
     end
+    let!(:obj) { Book.create }
 
-    after(:each) do
-      @test_object2.delete
-    end
-    
-    it "passing namespace to constructor with no pid should generate a pid with the supplied namespace" do
-      @test_object2 = ActiveFedora::Base.new({:namespace=>"randomNamespace"})
-      # will be nil if match failed, otherwise will equal pid
-      @test_object2.save
-      expect(@test_object2.pid.match('randomNamespace:\d+').to_a.first).to eq(@test_object2.pid)
-    end
+    after { obj.destroy unless obj.destroyed? }
 
-    it "should set the CMA hasModel relationship in the Rels-EXT" do 
-      @test_object2.save
-      rexml = REXML::Document.new(@test_object2.datastreams["RELS-EXT"].content)
-      # Purpose: confirm that the isMemberOf entries exist and have real RDF in them
-      expect(rexml.root.elements["rdf:Description/ns0:hasModel"].attributes["rdf:resource"]).to eq('info:fedora/afmodel:ActiveFedora_Base')
+    describe "errors" do
+      subject { obj.errors }
+      it { should be_empty }
     end
-    it "should merge attributes from fedora into attributes hash" do
-      @test_object2.save
-      inner_object = @test_object2.inner_object
-      expect(inner_object.pid).to eq(@test_object2.pid)
-      expect(inner_object).to respond_to(:lastModifiedDate)
-    end
-
-    it 'when the object is updated, it also updates modification time field in solr' do
-      @test_object2.save
-
-      # Make sure the modification time changes by at least 1 second
-      sleep 1
-
-      @test_object2.state = 'I' 
-      @test_object2.save
-      @test_object2.reload
-
-      pid = @test_object2.pid.sub(':', '\:')
-      solr_doc = ActiveFedora::SolrService.query("id:#{pid}")
 
-      new_time_fedora = Time.parse(@test_object2.modified_date).to_i
-      new_time_solr = Time.parse(solr_doc.first['system_modified_dtsi']).to_i
-      expect(new_time_solr).to eq(new_time_fedora)
+    describe "id" do
+      subject { obj.id }
+      it { should_not be_nil }
     end
-  end
-  
-  describe ".datastreams" do
-    it "should return a Hash of datastreams from fedora" do
-      datastreams = @test_object.datastreams
-      expect(datastreams).to be_a_kind_of(ActiveFedora::DatastreamHash) 
-      datastreams.each_value do |ds| 
-        expect(ds).to be_a_kind_of(ActiveFedora::Datastream)
+
+    context "when updated with changes after one second" do
+      before do
+        obj.title = ['sample']
+        sleep 1
       end
-      expect(@test_object.datastreams["DC"]).to be_an_instance_of(ActiveFedora::Datastream)
-      expect(datastreams["DC"]).not_to be_nil
-      expect(datastreams["DC"]).to be_an_instance_of(ActiveFedora::Datastream)       
-    end
-    it "should initialize the datastream pointers with @new_object=false" do
-      datastreams = @test_object.datastreams
-      datastreams.each_value do |ds| 
-        expect(ds).not_to be_new
+
+      it 'updates the modification time field in solr' do
+        expect { obj.save }.to change {
+          ActiveFedora::SolrService.query("id:\"#{obj.id}\"").first['system_modified_dtsi']
+        }
       end
     end
-  end
-  
-  describe ".metadata_streams" do
-    it "should return all of the datastreams from the object that are kinds of OmDatastream " do
-      mds1 = ActiveFedora::SimpleDatastream.new(@test_object.inner_object, "md1")
-      mds2 = ActiveFedora::QualifiedDublinCoreDatastream.new(@test_object.inner_object, "qdc")
-      fds = ActiveFedora::Datastream.new(@test_object.inner_object, "fds")
-      @test_object.add_datastream(mds1)
-      @test_object.add_datastream(mds2)
-      @test_object.add_datastream(fds)      
-      
-      result = @test_object.metadata_streams
-      expect(result.length).to eq(2)
-      expect(result).to include(mds1)
-      expect(result).to include(mds2)
-    end
-  end
-  
-  describe '.rels_ext' do
-    it "should retrieve RelsExtDatastream object via rels_ext method" do
-      expect(@test_object.rels_ext).to be_instance_of(ActiveFedora::RelsExtDatastream)
-    end
-    
-    it 'should create the RELS-EXT datastream if it doesnt exist' do
-      test_object = ActiveFedora::Base.new
-      #test_object.datastreams["RELS-EXT"].should == nil
-      test_object.rels_ext
-      expect(test_object.datastreams["RELS-EXT"]).not_to eq(nil)
-      expect(test_object.datastreams["RELS-EXT"].class).to eq(ActiveFedora::RelsExtDatastream)
-    end
-  end
 
-  describe '.add_relationship' do
-    it "should update the RELS-EXT datastream and relationships should end up in Fedora when the object is saved" do
-      @test_object.add_relationship(:is_member_of, "info:fedora/demo:5")
-      @test_object.add_relationship(:is_member_of, "info:fedora/demo:10")
-      @test_object.add_relationship(:conforms_to, "info:fedora/afmodel:OralHistory")
-      @test_object.save
-      rexml = REXML::Document.new(@test_object.datastreams["RELS-EXT"].content)
-      # Purpose: confirm that the isMemberOf entries exist and have real RDF in them
-      expect(rexml.root.attributes["xmlns:ns1"]).to eq('info:fedora/fedora-system:def/relations-external#')
-      expect(rexml.root.elements["rdf:Description/ns1:isMemberOf[@rdf:resource='info:fedora/demo:5']"]).not_to be_nil
-      expect(rexml.root.elements["rdf:Description/ns1:isMemberOf[@rdf:resource='info:fedora/demo:10']"]).not_to be_nil
+    describe "#create_date" do
+      subject { obj.create_date }
+      it { should_not be_nil }
     end
-  end
-
-  describe '.add_file_datastream' do
 
-   it "should set the correct mimeType if :mime_type, :mimeType, or :content_type passed in and path does not contain correct extension" do
-     f = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino_jpg_no_file_ext" ))
-     @test_object.add_file_datastream(f)
-     @test_object.save
-     test_obj = ActiveFedora::Base.find(@test_object.pid)
-     #check case where nothing passed in does not have correct mime type
-     expect(test_obj.datastreams["DS1"].mimeType).to eq("application/octet-stream")
-     @test_object2 = ActiveFedora::Base.new
-     f = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino_jpg_no_file_ext" ))
-     @test_object2.add_file_datastream(f,{:mimeType=>"image/jpeg"})
-     @test_object2.save
-     test_obj = ActiveFedora::Base.find(@test_object2.pid)
-     expect(test_obj.datastreams["DS1"].mimeType).to eq("image/jpeg")
-     @test_object3 = ActiveFedora::Base.new
-     f = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino_jpg_no_file_ext" ))
-     @test_object3.add_file_datastream(f,{:mime_type=>"image/jpeg"})
-     @test_object3.save
-     test_obj = ActiveFedora::Base.find(@test_object3.pid)
-     expect(test_obj.datastreams["DS1"].mimeType).to eq("image/jpeg")
-     @test_object4 = ActiveFedora::Base.new
-     f = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino_jpg_no_file_ext" ))
-     @test_object4.add_file_datastream(f,{:content_type=>"image/jpeg"})
-     @test_object4.save
-     test_obj = ActiveFedora::Base.find(@test_object4.pid)
-     expect(test_obj.datastreams["DS1"].mimeType).to eq("image/jpeg")
-   end
-  end
-  
-  describe '.add_datastream' do
-  
-    it "should be able to add datastreams" do
-      ds = ActiveFedora::Datastream.new(@test_object.inner_object, 'DS1')
-      expect(@test_object.add_datastream(ds)).to be_truthy
-    end
-      
-    it "adding and saving should add the datastream to the datastreams array" do
-      ds = ActiveFedora::Datastream.new(@test_object.inner_object, 'DS1') 
-      ds.content = fixture('dino.jpg').read
-      expect(@test_object.datastreams).not_to have_key("DS1")
-      @test_object.add_datastream(ds)
-      ds.save
-      expect(@test_object.datastreams).to have_key("DS1")
-    end
-    
-  end
-  
-  it "should retrieve blobs that match the saved blobs" do
-    ds = ActiveFedora::Datastream.new(@test_object.inner_object, 'DS1')
-    ds.content = "foo"
-    new_ds = ds.save
-    @test_object.add_datastream(new_ds)
-    expect(@test_object.class.find(@test_object.pid).datastreams["DS1"].content).to eq(new_ds.content)
-  end
-  
-  describe ".create_date" do 
-    it "should return W3C date" do 
-      expect(@test_object.create_date).not_to be_nil
+    describe "#modified_date" do
+      subject { obj.modified_date }
+      it { should_not be_nil }
     end
-  end
-  
-  describe ".modified_date" do 
-    it "should return nil before saving and a W3C date after saving" do       
-      expect(@test_object.modified_date).not_to be_nil
-    end  
-  end
-  
-  describe "delete" do
-    
-    it "should delete the object from Fedora and Solr" do
-      @test_object.save
-      expect(ActiveFedora::Base.find_with_conditions(:id=>@test_object.pid).first["id"]).to eq(@test_object.pid)
-      pid = @test_object.pid # store so we can access it after deletion
-      @test_object.delete
-      expect(ActiveFedora::Base.find_with_conditions(:id=>pid)).to be_empty
-    end
-  end
 
-  describe '#remove_relationship' do
-    it 'should remove a relationship from an object after a save' do
-      @test_object2 = ActiveFedora::Base.new
-      @test_object2.save
-      @test_object.add_relationship(:has_part,@test_object2)
-      @test_object.save
-      @pid = @test_object.pid
-      begin
-        @test_object = ActiveFedora::Base.find(@pid)
-      rescue => e
-        puts "#{e.message}\n#{e.backtrace}"
-        raise e
+    describe "delete" do
+      it "should delete the object from Fedora and Solr" do
+        expect {
+          obj.delete
+        }.to change { ActiveFedora::Base.exists?(obj.id) }.from(true).to(false)
       end
-      expect(@test_object.object_relations[:has_part]).to include @test_object2.internal_uri
-      @test_object.remove_relationship(:has_part,@test_object2)
-      @test_object.save
-      @test_object = ActiveFedora::Base.find(@pid)
-      expect(@test_object.object_relations[:has_part]).to be_empty
     end
   end
-
   
+
   describe "#exists?" do
     let(:obj) { ActiveFedora::Base.create } 
     it "should return true for objects that exist" do
       expect(ActiveFedora::Base.exists?(obj)).to be true
     end
-    it "should return true for pids that exist" do
-      expect(ActiveFedora::Base.exists?(obj.pid)).to be true
+    it "should return true for ids that exist" do
+      expect(ActiveFedora::Base.exists?(obj.id)).to be true
     end
-    it "should return false for pids that don't exist" do
+    it "should return false for ids that don't exist" do
       expect(ActiveFedora::Base.exists?('test:missing_object')).to be false
     end
     it "should return false for nil" do