active-fedora 6.8.0 → 7.0.0.pre1

data/spec/integration/datastream_collections_spec.rb

@@ -4,8 +4,8 @@ describe ActiveFedora::DatastreamCollections do
   before(:all) do
     class MockAFBaseDatastream < ActiveFedora::Base
       include ActiveFedora::DatastreamCollections
-      has_datastream :name => 'thumbnail', :prefix => 'THUMB', :type => ActiveFedora::Datastream, :mimeType => 'image/jpeg', :controlGroup => 'M'
-      has_datastream :name => 'high', :type => ActiveFedora::Datastream, :mimeType => 'image/jpeg', :controlGroup => 'M'
+      has_datastream :name=>"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
 
@@ -15,113 +15,113 @@ describe ActiveFedora::DatastreamCollections do
   describe '#add_named_datastream' do
     it 'should add a datastream with the given name to the object in fedora' do
       @test_object2 = MockAFBaseDatastream.new
-      f = File.open(File.join( File.dirname(__FILE__), '../fixtures/minivan.jpg'), 'rb')
-      f2 = File.open(File.join( File.dirname(__FILE__), '../fixtures/dino.jpg' ), 'rb')
-      allow(f2).to receive(:original_filename).and_return('dino.jpg')
-      allow(f).to receive(:content_type).and_return('image/jpeg')
-      @test_object2.add_named_datastream('thumbnail', {:content_type => 'image/jpeg', :blob => f, :label => 'testDS'})
-      @test_object2.add_named_datastream('high', {:content_type => 'image/jpeg', :blob => f2})
+      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.stub(:original_filename).and_return("dino.jpg")
+      f.stub(:content_type).and_return("image/jpeg")
+      @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg",:blob=>f, :label=>"testDS"})
+      @test_object2.add_named_datastream("high",{:content_type=>"image/jpeg",:blob=>f2})
       ds = @test_object2.thumbnail.first
       ds2 = @test_object2.high.first
       @test_object2.save
       @test_object2 = MockAFBaseDatastream.find(@test_object2.pid)
-      expect(@test_object2.named_datastreams.keys.size).to eq(2)
-      expect(@test_object2.named_datastreams.keys.include?('thumbnail')).to eq(true)
-      expect(@test_object2.named_datastreams.keys.include?('high')).to eq(true)
-      expect(@test_object2.named_datastreams['thumbnail'].size).to eq(1)
-      expect(@test_object2.named_datastreams['high'].size).to eq(1)
-      t2_thumb1 = @test_object2.named_datastreams['thumbnail'].first
-      expect(t2_thumb1.dsid).to eq(ds.dsid)
-      expect(t2_thumb1.mimeType).to eq(ds.mimeType)
-      expect(t2_thumb1.pid).to eq(ds.pid)
-      expect(t2_thumb1.dsLabel).to eq(ds.dsLabel)
-      expect(t2_thumb1.controlGroup).to eq(ds.controlGroup)
-      t2_high1 = @test_object2.named_datastreams['high'].first
-      expect(t2_high1.dsid).to eq(ds2.dsid)
-      expect(t2_high1.mimeType).to eq(ds2.mimeType)
-      expect(t2_high1.pid).to eq(ds2.pid)
-      expect(t2_high1.dsLabel).to eq(ds2.dsLabel)
-      expect(t2_high1.controlGroup).to eq(ds2.controlGroup)
+      @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
-      f = File.open(File.join( File.dirname(__FILE__), '../fixtures/minivan.jpg'), 'rb')
-      allow(f).to receive(:content_type).and_return('image/jpeg')
-      @test_object2.add_named_file_datastream('thumbnail', f)
+      f = File.open(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"), 'rb')
+      f.stub(:content_type).and_return("image/jpeg")
+      @test_object2.add_named_file_datastream("thumbnail",f)
       ds = @test_object2.thumbnail.first
       @test_object2.save
       @test_object2 = MockAFBaseDatastream.find(@test_object2.pid)
-      expect(@test_object2.named_datastreams['thumbnail'].size).to eq(1)
-      t2_thumb1 = @test_object2.named_datastreams['thumbnail'].first
-      expect(t2_thumb1.dsid).to eq('THUMB1')
-      expect(t2_thumb1.mimeType).to eq('image/jpeg')
-      expect(t2_thumb1.pid).to eq(@test_object2.pid)
-      expect(t2_thumb1.dsLabel).to eq('minivan.jpg')
-      expect(t2_thumb1.controlGroup).to eq('M')
+      @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"
     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')
+      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')
+      f2 = File.open(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ), 'rb')
       dino = f2.read
       f2.rewind
-      allow(f).to receive(:content_type).and_return('image/jpeg')
-      allow(f).to receive(:original_filename).and_return('minivan.jpg')
-      allow(f2).to receive(:content_type).and_return('image/jpeg')
-      allow(f2).to receive(:original_filename).and_return('dino.jpg')
+      f.stub(:content_type).and_return("image/jpeg")
+      f.stub(:original_filename).and_return("minivan.jpg")
+      f2.stub(:content_type).and_return("image/jpeg")
+      f2.stub(:original_filename).and_return("dino.jpg")
       #check raise exception if dsid not supplied
-      @test_object2.add_named_datastream('thumbnail', {:file => f})
+      @test_object2.add_named_datastream("thumbnail",{:file=>f})
       @test_object2.save
       @test_object2 = MockAFBaseDatastream.find(@test_object2.pid)
-
-      expect(@test_object2.thumbnail.size).to eq(1)
-      @test_object2.thumbnail_ids == ['THUMB1']
+      
+      @test_object2.thumbnail.size.should == 1
+      @test_object2.thumbnail_ids == ["THUMB1"]
       ds = @test_object2.thumbnail.first
-      expect(ds.dsid).to eq('THUMB1')
-      expect(ds.mimeType).to eq('image/jpeg')
-      expect(ds.pid).to eq(@test_object2.pid)
-      expect(ds.dsLabel).to eq('minivan.jpg')
-      expect(ds.controlGroup).to eq('M')
+      ds.dsid.should == "THUMB1"
+      ds.mimeType.should == "image/jpeg"
+      ds.pid.should == @test_object2.pid
+      ds.dsLabel.should == "minivan.jpg"
+      ds.controlGroup.should == "M"
 
-      expect(ds.content).to eq(minivan)
-      @test_object2.update_named_datastream('thumbnail', {:file => f2, :dsid => 'THUMB1'})
+      ds.content.should == minivan 
+      @test_object2.update_named_datastream("thumbnail",{:file=>f2,:dsid=>"THUMB1"})
       @test_object2.save
       @test_object2 = MockAFBaseDatastream.find(@test_object2.pid)
-      expect(@test_object2.thumbnail.size).to eq(1)
-      @test_object2.thumbnail_ids == ['THUMB1']
+      @test_object2.thumbnail.size.should == 1
+      @test_object2.thumbnail_ids == ["THUMB1"]
       ds2 = @test_object2.thumbnail.first
-      expect(ds2.dsid).to eq('THUMB1')
-      expect(ds2.mimeType).to eq('image/jpeg')
-      expect(ds2.pid).to eq(@test_object2.pid)
-      expect(ds2.dsLabel).to eq('dino.jpg')
-      expect(ds2.controlGroup).to eq('M')
-      expect(ds2.content == dino).to be_truthy
+      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
-      f = File.open(File.join( File.dirname(__FILE__), '../fixtures/minivan.jpg'), 'rb')
-      f2 = File.open(File.join( File.dirname(__FILE__), '../fixtures/dino.jpg' ), 'rb')
-      @test_object2.add_named_datastream('thumbnail', {:content_type => 'image/jpeg', :blob => f})
-      @test_object2.add_named_datastream('thumbnail', {:content_type => 'image/jpeg', :blob => f2})
+      f = File.open(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"), 'rb')
+      f2 = File.open(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ), 'rb')
+      @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg",:blob=>f})
+      @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg",:blob=>f2})
       @test_object2.save
       @test_object2 = MockAFBaseDatastream.find(@test_object2.pid)
       named_datastreams_ids = @test_object2.named_datastreams_ids
 
       expect(named_datastreams_ids.keys.sort).to eq(['high', 'thumbnail'])
       expect(named_datastreams_ids['high']).to eq([])
-      expect(named_datastreams_ids['thumbnail'].sort).to eq(['THUMB1', 'THUMB2'])
+      expect(named_datastreams_ids['thumbnail'].sort).to eq(["THUMB1", "THUMB2"])
     end
   end
 
-end
+end

data/spec/integration/datastream_spec.rb

@@ -1,90 +1,90 @@
 require 'spec_helper'
 
 require 'active_fedora'
-require 'rexml/document'
+require "rexml/document"
 
 describe ActiveFedora::Datastream do
 
   before(:all) do
     class MockAFBase < ActiveFedora::Base
-      has_metadata :name => 'descMetadata', :type => ActiveFedora::QualifiedDublinCoreDatastream, :autocreate => true
+      has_metadata :name => "descMetadata", :type => ActiveFedora::QualifiedDublinCoreDatastream, :autocreate => true
     end
   end
-
+  
   before(:each) do
     @test_object = MockAFBase.new
     @test_object.save
   end
-
+  
   after(:each) do
     @test_object.delete
   end
 
-  it 'should be able to access Datastreams using datastreams method' do
-    descMetadata = @test_object.datastreams['descMetadata']
-    expect(descMetadata).to be_a_kind_of(ActiveFedora::Datastream)
-    expect(descMetadata.dsid).to eql('descMetadata')
+  it "should be able to access Datastreams using datastreams method" do
+    descMetadata = @test_object.datastreams["descMetadata"]
+    descMetadata.should be_a_kind_of(ActiveFedora::Datastream)
+    descMetadata.dsid.should eql("descMetadata")
   end
 
-  it 'should be able to access Datastream content using content method' do
-    descMetadata = @test_object.datastreams['descMetadata'].content
-    expect(descMetadata).not_to be_nil
+  it "should be able to access Datastream content using content method" do    
+    descMetadata = @test_object.datastreams["descMetadata"].content
+    descMetadata.should_not be_nil
   end
-
-  it 'should be able to update XML Datastream content and save to Fedora' do
-    xml_content = Nokogiri::XML::Document.parse(@test_object.datastreams['descMetadata'].content)
-    title = Nokogiri::XML::Element.new 'title', xml_content
-    title.content = 'Test Title'
+  
+  it "should be able to update XML Datastream content and save to Fedora" do    
+    xml_content = Nokogiri::XML::Document.parse(@test_object.datastreams["descMetadata"].content)
+    title = Nokogiri::XML::Element.new "title", xml_content
+    title.content = "Test Title"
     xml_content.root.add_child title
-
-    allow(@test_object.datastreams['descMetadata']).to receive(:before_save)
-    @test_object.datastreams['descMetadata'].content = xml_content.to_s
-    @test_object.datastreams['descMetadata'].save
-
+    
+    @test_object.datastreams["descMetadata"].stub(:before_save)
+    @test_object.datastreams["descMetadata"].content = xml_content.to_s
+    @test_object.datastreams["descMetadata"].save
+    
     found = Nokogiri::XML::Document.parse(@test_object.class.find(@test_object.pid).datastreams['descMetadata'].content)
-    expect(found.xpath('//dc/title/text()').first.inner_text).to eq(title.content)
+    found.xpath('//dc/title/text()').first.inner_text.should == title.content
   end
-
-  it 'should be able to update Blob Datastream content and save to Fedora' do
+  
+  it "should be able to update Blob Datastream content and save to Fedora" do    
     dsid = "ds#{Time.now.to_i}"
     ds = ActiveFedora::Datastream.new(@test_object.inner_object, dsid)
     ds.content = fixture('dino.jpg')
-    expect(@test_object.add_datastream(ds)).to be_truthy
+    @test_object.add_datastream(ds).should be_true
     @test_object.save
-    expect(@test_object.datastreams[dsid]).not_to be_changed
-    to = ActiveFedora::Base.find(@test_object.pid)
-    expect(to).not_to be_nil
-    expect(to.datastreams[dsid]).not_to be_nil
-    expect(to.datastreams[dsid].content).to eq(fixture('dino.jpg').read)
+    @test_object.datastreams[dsid].should_not be_changed
+    to = ActiveFedora::Base.find(@test_object.pid) 
+    to.should_not be_nil 
+    to.datastreams[dsid].should_not be_nil
+    to.datastreams[dsid].content.should == fixture('dino.jpg').read
   end
-
-  it 'should be able to set the versionable attribute' do
+  
+  it "should be able to set the versionable attribute" do
     dsid = "ds#{Time.now.to_i}"
-    v1 = '<version1>data</version1>'
-    v2 = '<version2>data</version2>'
+    v1 = "<version1>data</version1>"
+    v2 = "<version2>data</version2>"
     ds = ActiveFedora::Datastream.new(@test_object.inner_object, dsid)
     ds.content = v1
     ds.versionable = false
-    expect(@test_object.add_datastream(ds)).to be_truthy
+    @test_object.add_datastream(ds).should be_true
     @test_object.save
     to = ActiveFedora::Base.find(@test_object.pid)
     ds = to.datastreams[dsid]
-    expect(ds.versionable).to be_falsey
+    ds.versionable.should be_false
     ds.versionable = true
     to.save
     ds.content = v2
     to.save
     versions = ds.versions
-    expect(versions.length).to eq(2)
+    versions.length.should == 2
     # order of versions not guaranteed
     if versions[0].content == v2
-      expect(versions[1].content).to eq(v1)
-      expect(versions[0].asOfDateTime).to be >= versions[1].asOfDateTime
+      versions[1].content.should == v1
+      versions[0].asOfDateTime.should be >= versions[1].asOfDateTime
     else
-      expect(versions[0].content).to eq(v1)
-      expect(versions[1].content).to eq(v2)
-      expect(versions[1].asOfDateTime).to be >= versions[0].asOfDateTime
+      versions[0].content.should == v1
+      versions[1].content.should == v2   
+      versions[1].asOfDateTime.should be >= versions[0].asOfDateTime
     end
-    expect(ds.content).to eq(v2)
+    ds.content.should == v2
   end
 end

data/spec/integration/datastreams_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 require 'active_fedora'
-require 'rexml/document'
+require "rexml/document"
 
 describe ActiveFedora::Datastreams do
-  describe 'serializing datastreams' do
+  describe "serializing datastreams" do
     before :all do
       class TestingMetadataSerializing < ActiveFedora::Base
-        has_metadata :name => 'nokogiri_autocreate_on', :autocreate => true, :type => ActiveFedora::OmDatastream
-        has_metadata :name => 'nokogiri_autocreate_off', :autocreate => false, :type => ActiveFedora::OmDatastream
+        has_metadata :name => "nokogiri_autocreate_on", :autocreate => true, :type => ActiveFedora::OmDatastream
+        has_metadata :name => "nokogiri_autocreate_off", :autocreate => false, :type => ActiveFedora::OmDatastream
       end
     end
 
@@ -18,115 +18,115 @@ describe ActiveFedora::Datastreams do
 
     subject { TestingMetadataSerializing.new }
 
-    it 'should work' do
+    it "should work" do
       subject.save(:validate => false)
-      expect(subject.nokogiri_autocreate_on).not_to be_new
-      expect(subject.nokogiri_autocreate_off).to be_new
+      subject.nokogiri_autocreate_on.should_not be_new
+      subject.nokogiri_autocreate_off.should be_new
     end
   end
 
 
-  describe '#has_metadata' do
+  describe "#has_metadata" do
     before :all do
       class HasMetadata < ActiveFedora::Base
-        has_metadata :name => 'with_versions', :autocreate => true, :label => 'Versioned DS', :type => ActiveFedora::SimpleDatastream
-        has_metadata :name => 'without_versions', :autocreate => true, :versionable => false, :type => ActiveFedora::SimpleDatastream
+        has_metadata :name => "with_versions", :autocreate => true, :label => "Versioned DS", :type => ActiveFedora::SimpleDatastream
+        has_metadata :name => "without_versions", :autocreate => true, :versionable => false, :type => ActiveFedora::SimpleDatastream
       end
     end
     after :all do
       Object.send(:remove_const, :HasMetadata)
     end
     before :each do
-      @base = ActiveFedora::Base.new(:pid => 'test:has_metadata_base')
-      @base.add_datastream(@base.create_datastream(ActiveFedora::Datastream, 'testDS', :dsLabel => 'Test DS'))
-      @base.datastreams['testDS'].content = 'blah blah blah'
+      @base = ActiveFedora::Base.new(:pid=>"test:has_metadata_base")
+      @base.add_datastream(@base.create_datastream(ActiveFedora::Datastream, "testDS", :dsLabel => "Test DS"))
+      @base.datastreams["testDS"].content = "blah blah blah"
       @base.save
-      @test = HasMetadata.new(:pid => 'test:has_metadata_model')
+      @test = HasMetadata.new(:pid=>"test:has_metadata_model")
       @test.save
     end
-
+    
     after :each do
       @base.delete
       @test.delete
     end
-
-    it 'should create datastreams from the spec on new objects' do
-      expect(@test.without_versions.versionable).to be_falsey
-      expect(@test.with_versions.versionable).to be_truthy
-      expect(@test.with_versions.dsLabel).to eq('Versioned DS')
-      @test.without_versions.content = 'blah blah blah'
+    
+    it "should create datastreams from the spec on new objects" do
+      @test.without_versions.versionable.should be_false
+      @test.with_versions.versionable.should be_true
+      @test.with_versions.dsLabel.should == "Versioned DS"
+      @test.without_versions.content= "blah blah blah"
       @test.save
-      expect(HasMetadata.find(@test.pid).without_versions.versionable).to be_falsey
+      HasMetadata.find(@test.pid).without_versions.versionable.should be_false
     end
-
-    it 'should use ds_specs and preserve existing datastreams on migrated objects' do
+    
+    it "should use ds_specs and preserve existing datastreams on migrated objects" do
       test_obj = HasMetadata.find(@base.pid)
-      expect(test_obj.datastreams['testDS'].dsLabel).to eq('Test DS')
-      expect(test_obj.datastreams['testDS'].new?).to be_falsey
-      expect(test_obj.with_versions.dsLabel).to eq('Versioned DS')
-      expect(test_obj.without_versions.versionable).to be_falsey
-      expect(test_obj.with_versions.new?).to be_truthy
+      test_obj.datastreams["testDS"].dsLabel.should == "Test DS"
+      test_obj.datastreams["testDS"].new?.should be_false
+      test_obj.with_versions.dsLabel.should == "Versioned DS"
+      test_obj.without_versions.versionable.should be_false
+      test_obj.with_versions.new?.should be_true
     end
-
+    
   end
-
-  describe '#has_file_datastream' do
+  
+  describe "#has_file_datastream" do
     before :all do
       class HasFile < ActiveFedora::Base
-        has_file_datastream :name => 'file_ds', :versionable => false
-        has_file_datastream :name => 'file_ds2', :versionable => false, :autocreate => false
+        has_file_datastream :name => "file_ds", :versionable => false
+        has_file_datastream :name => "file_ds2", :versionable => false, :autocreate => false
       end
     end
     after :all do
       Object.send(:remove_const, :HasFile)
     end
     before :each do
-      @base = ActiveFedora::Base.new(:pid => 'test:ds_versionable_base')
+      @base = ActiveFedora::Base.new(:pid=>"test:ds_versionable_base")
       @base.save
-      @base2 = ActiveFedora::Base.new(:pid => 'test:ds_versionable_base2')
-      @base2.add_datastream(@base2.create_datastream(ActiveFedora::Datastream, 'file_ds', :versionable => true, :dsLabel => 'Pre-existing DS'))
-      @base2.datastreams['file_ds'].content = 'blah blah blah'
+      @base2 = ActiveFedora::Base.new(:pid=>"test:ds_versionable_base2")
+      @base2.add_datastream(@base2.create_datastream(ActiveFedora::Datastream,"file_ds", :versionable=>true,:dsLabel=>"Pre-existing DS"))
+      @base2.datastreams["file_ds"].content = "blah blah blah"
       @base2.save
-      @has_file = HasFile.new(:pid => 'test:ds_versionable_has_file')
+      @has_file = HasFile.new(:pid=>"test:ds_versionable_has_file")
       @has_file.save
     end
-
+    
     after :each do
       @base.delete
       @base2.delete
       @has_file.delete
     end
-
-    it 'should create datastreams from the spec on new objects' do
-      expect(@has_file.file_ds.versionable).to be_falsey
-      @has_file.file_ds.content = 'blah blah blah'
-      expect(@has_file.file_ds.changed?).to be_truthy
-      expect(@has_file.file_ds2.changed?).to be_falsey # no autocreate
-      expect(@has_file.file_ds2.new?).to be_truthy
+    
+    it "should create datastreams from the spec on new objects" do
+      @has_file.file_ds.versionable.should be_false
+      @has_file.file_ds.content = "blah blah blah"
+      @has_file.file_ds.changed?.should be_true
+      @has_file.file_ds2.changed?.should be_false # no autocreate
+      @has_file.file_ds2.new?.should be_true
       @has_file.save
-      expect(@has_file.file_ds.versionable).to be_falsey
+      @has_file.file_ds.versionable.should be_false
       test_obj = HasFile.find(@has_file.pid)
-      expect(test_obj.file_ds.versionable).to be_falsey
-      expect(test_obj.rels_ext.changed?).to be_falsey
-      expect(test_obj.file_ds.changed?).to be_falsey
-      expect(test_obj.file_ds2.changed?).to be_falsey
-      expect(test_obj.file_ds2.new?).to be_truthy
+      test_obj.file_ds.versionable.should be_false
+      test_obj.rels_ext.changed?.should be_false
+      test_obj.file_ds.changed?.should be_false
+      test_obj.file_ds2.changed?.should be_false
+      test_obj.file_ds2.new?.should be_true
     end
-
-    it 'should use ds_specs on migrated objects' do
+    
+    it "should use ds_specs on migrated objects" do
       test_obj = HasFile.find(@base.pid)
-      expect(test_obj.file_ds.versionable).to be_falsey
-      expect(test_obj.file_ds.new?).to be_truthy
-      test_obj.file_ds.content = 'blah blah blah'
+      test_obj.file_ds.versionable.should be_false
+      test_obj.file_ds.new?.should be_true
+      test_obj.file_ds.content = "blah blah blah"
       test_obj.save
-      expect(test_obj.file_ds.versionable).to be_falsey
+      test_obj.file_ds.versionable.should be_false
       # look it up again to check datastream profile
       test_obj = HasFile.find(@base.pid)
-      expect(test_obj.file_ds.versionable).to be_falsey
-      expect(test_obj.file_ds.dsLabel).to eq('File Datastream')
+      test_obj.file_ds.versionable.should be_false
+      test_obj.file_ds.dsLabel.should == "File Datastream"
       test_obj = HasFile.find(@base2.pid)
-      expect(test_obj.file_ds.versionable).to be_truthy
-      expect(test_obj.file_ds.dsLabel).to eq('Pre-existing DS')
+      test_obj.file_ds.versionable.should be_true
+      test_obj.file_ds.dsLabel.should == "Pre-existing DS"
     end
   end
 end