active-fedora 6.8.0 → 7.0.0.pre1

data/spec/integration/attributes_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe 'delegating attributes' do
+describe "delegating attributes" do
   before :all do
     class TitledObject < ActiveFedora::Base
       has_metadata 'foo', type: ActiveFedora::SimpleDatastream do |m|
-        m.field 'title', :string
+        m.field "title", :string
       end
       has_attributes :title, datastream: 'foo', multiple: false
     end
@@ -13,20 +13,21 @@ describe 'delegating attributes' do
     Object.send(:remove_const, :TitledObject)
   end
 
-  describe 'save' do
+  describe "save" do
     subject do
-      obj = TitledObject.create
-      obj.title = 'Hydra for Dummies'
+      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).not_to be_empty
-      expect(subject.previous_changes.keys).to include('title')
+    it "should keep a list of changes after a successful save" do
+      subject.previous_changes.should_not be_empty
+      subject.previous_changes.keys.should include("title")
     end
-    it 'should clean out changes' do
-      expect(subject.title_changed?).to be_falsey
-      expect(subject.changes).to be_empty
+    it "should clean out changes" do
+      subject.title_changed?.should be_false
+      subject.changes.should be_empty
     end
   end
 end
+

data/spec/integration/auditable_spec.rb

@@ -12,18 +12,18 @@ describe ActiveFedora::Auditable do
   after(:all) do
     @test_object.delete
   end
-  it 'should have the correct number of audit records' do
-    expect(@test_object.audit_trail.records.length).to eq(1)
+  it "should have the correct number of audit records" do
+    @test_object.audit_trail.records.length.should == 1
   end
-  it 'should return all the data from each audit record' do
+  it "should return all the data from each audit record" do
     record = @test_object.audit_trail.records.last
-    expect(record.id).to eq('AUDREC1')
-    expect(record.process_type).to eq('Fedora API-M')
-    expect(record.action).to eq('addDatastream')
-    expect(record.component_id).to eq('RELS-EXT')
-    expect(record.responsibility).to eq('fedoraAdmin')
-    expect(DateTime.parse(record.date)).to eq DateTime.parse(@test_object.modified_date)
-    expect(record.justification).to eq('')
+    record.id.should == "AUDREC1"
+    record.process_type.should == "Fedora API-M"
+    record.action.should == "addDatastream"
+    record.component_id.should == "RELS-EXT"
+    record.responsibility.should == "fedoraAdmin"
+    record.date.should == @test_object.modified_date
+    record.justification.should == ""
   end
-
+  
 end

data/spec/integration/autosave_association_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe ActiveFedora::Base do
+  before :all do
+    class MockAFBaseRelationship < ActiveFedora::Base
+      has_metadata :name=>'foo', :type=>Hydra::ModsArticleDatastream
+    end
+  end
+  after :all do
+    Object.send(:remove_const, :MockAFBaseRelationship)
+  end
+
+  subject { MockAFBaseRelationship.new }
+
+  context '#changed_for_autosave?' do
+    before(:each) do
+      subject.stub(:new_record?).and_return(false)
+      subject.stub(:changed?).and_return(false)
+      subject.stub(:marked_for_destruction?).and_return(false)
+    end
+    it {
+      expect { subject.changed_for_autosave? }.to_not raise_error
+    }
+  end
+end

data/spec/integration/base_spec.rb

@@ -1,73 +1,73 @@
 require 'spec_helper'
 
-describe 'A base object with metadata' do
+describe "A base object with metadata" do
   before :all do
     class MockAFBaseRelationship < ActiveFedora::Base
-      has_metadata :name => 'foo', :type => Hydra::ModsArticleDatastream
+      has_metadata :name=>'foo', :type=>Hydra::ModsArticleDatastream 
     end
   end
   after :all do
     Object.send(:remove_const, :MockAFBaseRelationship)
   end
-  describe 'a new document' do
+  describe "a new document" do
     before do
       @obj = MockAFBaseRelationship.new
 
-      @obj.foo.person = 'bob'
+      @obj.foo.person = "bob"
       @obj.save
     end
-    it 'should save the datastream.' do
-      obj = ActiveFedora::Base.find(@obj.pid, :cast => true)
-      expect(obj.foo).not_to be_new
-      expect(obj.foo.person).to eq(['bob'])
+    it "should save the datastream." do
+      obj = ActiveFedora::Base.find(@obj.pid)
+      obj.foo.should_not be_new
+      obj.foo.person.should == ['bob']
       person_field = ActiveFedora::SolrService.solr_name('person', type: :string)
-      expect(ActiveFedora::SolrService.query("{!raw f=id}#{@obj.pid}", :fl => "id #{person_field}").first).to eq({'id' => @obj.pid, person_field => ['bob']})
+      ActiveFedora::SolrService.query("{!raw f=id}#{@obj.pid}", :fl=>"id #{person_field}").first.should == {"id"=>@obj.pid, person_field =>['bob']}
     end
   end
 
-  describe 'setting object state' do
-    it 'should store it' do
+  describe "setting object state" do
+    it "should store it" do
       obj = MockAFBaseRelationship.create
-      obj.state = 'D'
+      obj.state='D'
       obj.save!
       obj.reload
-      expect(obj.state).to eq('D')
+      obj.state.should == 'D'
     end
   end
 
-  describe 'that already exists in the repo' do
+  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.foo.person = "test foo content"
       @release.save
     end
-    describe 'and has been changed' do
+    describe "and has been changed" do
       before do
         @release.foo.person = 'frank'
         @release.save!
       end
-      it 'should save the datastream.' do
-        expect(MockAFBaseRelationship.find(@release.pid).foo.person).to eq(['frank'])
+      it "should save the datastream." do
+        MockAFBaseRelationship.find(@release.pid).foo.person.should == ['frank']
         person_field = ActiveFedora::SolrService.solr_name('person', type: :string)
-        expect(ActiveFedora::SolrService.query("id:#{@release.pid.gsub(":", "\\:")}", :fl => "id #{person_field}").first).to eq({'id' => @release.pid, person_field => ['frank']})
+        ActiveFedora::SolrService.query("id:#{@release.pid.gsub(":", "\\:")}", :fl=>"id #{person_field}").first.should == {"id"=>@release.pid, person_field =>['frank']}
       end
     end
-    describe 'clone_into a new object' do
+    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#">
+      it "should have all the assertions" do
+        @new_object.rels_ext.content.should 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"/>
@@ -76,18 +76,18 @@ describe 'A base object with metadata' do
          </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
+      it "should have the other datastreams too" do
+        @new_object.datastreams.keys.should include "foo"
+        @new_object.foo.content.should be_equivalent_to @release.foo.content
       end
     end
-    describe 'clone' do
+    describe "clone" do
       before do
         @new_object = @release.clone
       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 + '">
+      it "should have all the assertions" do
+        @new_object.rels_ext.content.should 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"/>
@@ -95,9 +95,9 @@ describe 'A base object with metadata' do
          </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
+      it "should have the other datastreams too" do
+        @new_object.datastreams.keys.should include "foo"
+        @new_object.foo.content.should be_equivalent_to @release.foo.content
       end
     end
   end
@@ -115,12 +115,12 @@ describe 'A base object with metadata' do
     end
     it 'should requery Fedora' do
       @object.reload
-      expect(@object.foo.person).to eq(['dave'])
+      @object.foo.person.should == ['dave']
     end
     it 'should raise an error if not persisted' do
       @object = MockAFBaseRelationship.new
       # You will want this stub or else it will be really chatty in your STDERR
-      allow(@object.inner_object.logger).to receive(:error)
+      @object.inner_object.logger.stub(:error)
       expect {
         @object.reload
       }.to raise_error(ActiveFedora::ObjectNotFoundError)
@@ -128,26 +128,26 @@ describe 'A base object with metadata' do
   end
 end
 
-describe 'Datastreams synched together' do
+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')
+         add_file_datastream("XXX",:dsid=>'test_ds', :mimeType=>'text/html')
         end
       end
     end
   end
-  it 'Should update datastream' do
+  it "Should update datastream" do
     @nc = DSTest.new
     @nc.save
-    expect(@nc.test_ds.content).to eq('XXX')
+    @nc.test_ds.content.should == 'XXX'
     ds  = @nc.datastreams['test_ds']
-    ds.content = 'Foobar'
+    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')
+    DSTest.find(@nc.pid).datastreams['test_ds'].content.should == 'Foobar'
+    DSTest.find(@nc.pid).test_ds.content.should == 'Foobar'
   end
 
 end
@@ -161,21 +161,21 @@ describe ActiveFedora::Base do
     end
 
     class MockAFBaseFromSolr < ActiveFedora::Base
-      has_metadata :name => 'properties', :type => ActiveFedora::SimpleDatastream do |m|
-        m.field 'holding_id', :string
+      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'
+      
+      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'
+        m.field "geography", :string, :xml_node => "geography"
+        m.field "title", :string, :xml_node => "title"
       end
     end
   end
-
+  
   before(:all) do
     ActiveFedora::SolrService.register(ActiveFedora.solr_config[:url])
   end
@@ -183,12 +183,12 @@ describe ActiveFedora::Base do
   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
@@ -211,15 +211,15 @@ describe ActiveFedora::Base do
     rescue
     end
   end
-
-  describe '.initialize' do
-    it 'calling constructor should create a new Fedora Object' do
-      expect(@test_object.errors.size).to eq(0)
-      expect(@test_object.pid).not_to be_nil
+  
+  describe ".initialize" do
+    it "calling constructor should create a new Fedora Object" do    
+      @test_object.should have(0).errors
+      @test_object.pid.should_not be_nil
     end
   end
-
-  describe '#save' do
+  
+  describe "#save" do
     before(:each) do
       @test_object2 = ActiveFedora::Base.new
     end
@@ -227,167 +227,167 @@ describe ActiveFedora::Base do
     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'})
+    
+    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)
+      @test_object2.pid.match('randomNamespace:\d+').to_a.first.should == @test_object2.pid
     end
 
-    it 'should set the CMA hasModel relationship in the Rels-EXT' do
+    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)
+      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')
+      rexml.root.elements["rdf:Description/ns0:hasModel"].attributes["rdf:resource"].should == 'info:fedora/afmodel:ActiveFedora_Base'
     end
-    it 'should merge attributes from fedora into attributes hash' do
+    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)
+      inner_object.pid.should == @test_object2.pid
+      inner_object.should respond_to(:lastModifiedDate)
     end
   end
-
-  describe '.datastreams' do
-    it 'should return a Hash of datastreams from fedora' do
+  
+  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)
+      datastreams.should be_a_kind_of(Hash) 
+      datastreams.each_value do |ds| 
+        ds.should be_a_kind_of(ActiveFedora::Datastream)
       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)
+      @test_object.datastreams["DC"].should be_an_instance_of(ActiveFedora::Datastream)
+      datastreams["DC"].should_not be_nil
+      datastreams["DC"].should be_an_instance_of(ActiveFedora::Datastream)       
     end
-    it 'should initialize the datastream pointers with @new_object=false' do
+    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
+      datastreams.each_value do |ds| 
+        ds.should_not be_new
       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')
+  
+  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)
-
+      @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)
+      result.length.should == 2
+      result.should include(mds1)
+      result.should 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)
+    it "should retrieve RelsExtDatastream object via rels_ext method" do
+      @test_object.rels_ext.should 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.datastreams["RELS-EXT"].should == nil
       test_object.rels_ext
-      expect(test_object.datastreams['RELS-EXT']).not_to be_nil
-      expect(test_object.datastreams['RELS-EXT'].class).to eq(ActiveFedora::RelsExtDatastream)
+      test_object.datastreams["RELS-EXT"].should_not == nil
+      test_object.datastreams["RELS-EXT"].class.should == 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')
+    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)
+      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
+      rexml.root.attributes["xmlns:ns1"].should == 'info:fedora/fedora-system:def/relations-external#'
+      rexml.root.elements["rdf:Description/ns1:isMemberOf[@rdf:resource='info:fedora/demo:5']"].should_not be_nil
+      rexml.root.elements["rdf:Description/ns1:isMemberOf[@rdf:resource='info:fedora/demo:10']"].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' ))
+   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_obj.datastreams["DS1"].mimeType.should == "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'})
+     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_obj.datastreams["DS1"].mimeType.should == "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'})
+     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_obj.datastreams["DS1"].mimeType.should == "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'})
+     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')
+     test_obj.datastreams["DS1"].mimeType.should == "image/jpeg"
    end
   end
-
+  
   describe '.add_datastream' do
-
-    it 'should be able to add datastreams' 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
+      @test_object.add_datastream(ds).should be_true
     end
-
-    it 'adding and saving should add the datastream to the datastreams array' do
-      ds = ActiveFedora::Datastream.new(@test_object.inner_object, 'DS1')
+      
+    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.datastreams.should_not have_key("DS1")
       @test_object.add_datastream(ds)
       ds.save
-      expect(@test_object.datastreams).to have_key('DS1')
+      @test_object.datastreams.should have_key("DS1")
     end
-
+    
   end
-
-  it 'should retrieve blobs that match the saved blobs' do
+  
+  it "should retrieve blobs that match the saved blobs" do
     ds = ActiveFedora::Datastream.new(@test_object.inner_object, 'DS1')
-    ds.content = 'foo'
+    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)
+    @test_object.class.find(@test_object.pid).datastreams["DS1"].content.should == new_ds.content
   end
-
-  describe '.create_date' do
-    it 'should return W3C date' do
-      expect(@test_object.create_date).not_to be_nil
+  
+  describe ".create_date" do 
+    it "should return W3C date" do 
+      @test_object.create_date.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
+  
+  describe ".modified_date" do 
+    it "should return nil before saving and a W3C date after saving" do       
+      @test_object.modified_date.should_not be_nil
+    end  
   end
-
-  describe 'delete' do
-
-    it 'should delete the object from Fedora and Solr' do
+  
+  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)
+      ActiveFedora::Base.find_with_conditions(:id=>@test_object.pid).first["id"].should == @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
+      ActiveFedora::Base.find_with_conditions(:id=>pid).should be_empty
     end
   end
 
@@ -395,7 +395,7 @@ describe ActiveFedora::Base 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.add_relationship(:has_part,@test_object2)
       @test_object.save
       @pid = @test_object.pid
       begin
@@ -404,28 +404,28 @@ describe ActiveFedora::Base do
         puts "#{e.message}\n#{e.backtrace}"
         raise e
       end
-      expect(@test_object.object_relations[:has_part]).to include @test_object2.internal_uri
-      @test_object.remove_relationship(:has_part, @test_object2)
+      @test_object.object_relations[:has_part].should 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
+      @test_object.object_relations[:has_part].should be_empty
     end
   end
 
-
-  describe '#exists?' do
-    it 'should return true for objects that exist' do
+  
+  describe "#exists?" do
+    it "should return true for objects that exist" do
       @obj = ActiveFedora::Base.create
-      expect(ActiveFedora::Base.exists?(@obj.pid)).to be_truthy
+      ActiveFedora::Base.exists?(@obj.pid).should be_true
     end
     it "should return false for objects that don't exist" do
-      expect(ActiveFedora::Base.exists?('test:missing_object')).to be_falsey
+      ActiveFedora::Base.exists?('test:missing_object').should be_false
     end
-    it 'should return false for nil' do
-      expect(ActiveFedora::Base.exists?(nil)).to be_falsey
+    it "should return false for nil" do
+      ActiveFedora::Base.exists?(nil).should be_false
     end
-    it 'should return false for empty' do
-      expect(ActiveFedora::Base.exists?('')).to be_falsey
+    it "should return false for empty" do
+      ActiveFedora::Base.exists?('').should be_false
     end
   end
 end