active-fedora 6.7.8 → 6.8.0

data/spec/integration/bug_spec.rb

@@ -2,14 +2,14 @@ require 'spec_helper'
 
 require 'active_fedora'
 require 'active_fedora/model'
-require "rexml/document"
+require 'rexml/document'
 include ActiveFedora::Model
 
 describe 'bugs' do
   before do
     class FooHistory < ActiveFedora::Base
-      has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"someData" do |m|
-        m.field "fubar", :string
+      has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'someData' do |m|
+        m.field 'fubar', :string
       end
     end
     @test_object = FooHistory.new
@@ -26,17 +26,17 @@ describe 'bugs' do
     }.to raise_error(ActiveFedora::ObjectNotFoundError)
   end
 
-  it "should not clobber everything when setting a value" do
-    @test_object.someData.fubar=['initial']
+  it 'should not clobber everything when setting a value' do
+    @test_object.someData.fubar = ['initial']
     @test_object.save!
 
     x = FooHistory.find(@test_object.pid)
-    x.someData.fubar = ["replacement"] # set a new value
+    x.someData.fubar = ['replacement'] # set a new value
     x.save!
 
 
     x = FooHistory.find(@test_object.pid)
-    x.someData.fubar.should == ["replacement"] # recall the value
+    expect(x.someData.fubar).to eq(['replacement']) # recall the value
     x.save
   end
 end

data/spec/integration/complex_rdf_datastream_spec.rb

@@ -1,258 +1,258 @@
 require 'spec_helper'
 
-describe "Nested Rdf Objects" do
-  describe "without type" do
-    before(:each) do 
+describe 'Nested Rdf Objects' do
+  describe 'without type' do
+    before(:each) do
       class SpecDatastream < ActiveFedora::NtriplesRDFDatastream
         map_predicates do |map|
-          map.parts(:in=> RDF::DC, :to=>'hasPart', :class_name=>'Component')
+          map.parts(:in => RDF::DC, :to => 'hasPart', :class_name => 'Component')
         end
 
         class Component
           include ActiveFedora::RdfObject
           map_predicates do |map|
-            map.label(:in=> RDF::DC, :to=>'title')
+            map.label(:in => RDF::DC, :to => 'title')
           end
         end
       end
 
     end
-    
+
     after(:each) do
       Object.send(:remove_const, :SpecDatastream)
     end
 
     let (:ds) do
-      mock_obj = double(:mock_obj, :pid=>'test:124', :new_record? => true)
+      mock_obj = double(:mock_obj, :pid => 'test:124', :new_record? => true)
       ds = SpecDatastream.new(mock_obj)
     end
 
-    describe "#new_record?" do
-      it "should be true when its built" do
+    describe '#new_record?' do
+      it 'should be true when its built' do
         v = ds.parts.build(label: 'Alternator')
-        v.should be_new_record
+        expect(v).to be_new_record
       end
 
       it "should not be new when it's loaded from fedora" do
         ds.content = '_:g70324142325120 <http://purl.org/dc/terms/title> "Alternator" .
 <info:fedora/test:124> <http://purl.org/dc/terms/hasPart> _:g70324142325120 .'
-        ds.parts.first.should_not be_new_record
+        expect(ds.parts.first).not_to be_new_record
       end
     end
 
-    it "should not choke on invalid data" do
+    it 'should not choke on invalid data' do
       # set a string in the graph where model expects a node
-      ds.parts = ["foo"]
+      ds.parts = ['foo']
       expect {ds.parts.inspect}.to raise_error(ArgumentError, "Expected the value of http://purl.org/dc/terms/hasPart to be an RDF object but it is a String \"foo\"")
     end
-    
-    it "should be able to nest a complex object" do
+
+    it 'should be able to nest a complex object' do
       comp = SpecDatastream::Component.new(ds.graph)
-      comp.label = ["Alternator"]
+      comp.label = ['Alternator']
       ds.parts = comp
-      ds.parts.first.label.should == ["Alternator"]
+      expect(ds.parts.first.label).to eq(['Alternator'])
     end
 
-    it "should be able to replace attributes" do
+    it 'should be able to replace attributes' do
       v = ds.parts.build(label: 'Alternator')
-      ds.parts.first.label.should == ['Alternator']
+      expect(ds.parts.first.label).to eq(['Alternator'])
       ds.parts.first.label = ['Distributor']
-      ds.parts.first.label.should == ['Distributor']
+      expect(ds.parts.first.label).to eq(['Distributor'])
     end
 
-    it "should be able to replace objects" do
+    it 'should be able to replace objects' do
       ds.parts.build(label: 'Alternator')
       ds.parts.build(label: 'Distributor')
-      ds.parts.size.should == 2
+      expect(ds.parts.size).to eq(2)
       comp = SpecDatastream::Component.new(ds.graph)
-      comp.label = "Injector port"
+      comp.label = 'Injector port'
       ds.parts = [comp]
-      ds.parts.size.should == 1
+      expect(ds.parts.size).to eq(1)
     end
 
-    it "should be able to nest many complex objects" do
+    it 'should be able to nest many complex objects' do
       comp1 = SpecDatastream::Component.new ds.graph
-      comp1.label = ["Alternator"]
+      comp1.label = ['Alternator']
       comp2 = SpecDatastream::Component.new ds.graph
-      comp2.label = ["Crankshaft"]
+      comp2.label = ['Crankshaft']
       ds.parts = [comp1, comp2]
-      ds.parts.first.label.should == ["Alternator"]
-      ds.parts.last.label.should == ["Crankshaft"]
+      expect(ds.parts.first.label).to eq(['Alternator'])
+      expect(ds.parts.last.label).to eq(['Crankshaft'])
     end
 
-    it "should be able to clear complex objects" do
+    it 'should be able to clear complex objects' do
       comp1 = SpecDatastream::Component.new ds.graph
-      comp1.label = ["Alternator"]
+      comp1.label = ['Alternator']
       comp2 = SpecDatastream::Component.new ds.graph
-      comp2.label = ["Crankshaft"]
+      comp2.label = ['Crankshaft']
       ds.parts = [comp1, comp2]
       ds.parts = []
-      ds.parts.should == []
+      expect(ds.parts).to eq([])
     end
 
-    it "should load complex objects" do
+    it 'should load complex objects' do
       ds.content = <<END
 _:g70350851837440 <http://purl.org/dc/terms/title> "Alternator" .
 <info:fedora/test:124> <http://purl.org/dc/terms/hasPart> _:g70350851837440 .
 <info:fedora/test:124> <http://purl.org/dc/terms/hasPart> _:g70350851833380 .
 _:g70350851833380 <http://purl.org/dc/terms/title> "Crankshaft" .
 END
-      ds.parts.first.label.should == ["Alternator"]
+      expect(ds.parts.first.label).to eq(['Alternator'])
     end
 
     it "should build complex objects when a parent node doesn't exist" do
       part = ds.parts.build
-      part.should be_kind_of SpecDatastream::Component
-      part.label = "Wheel bearing"
-      ds.parts.first.label.should == ['Wheel bearing']
+      expect(part).to be_kind_of SpecDatastream::Component
+      part.label = 'Wheel bearing'
+      expect(ds.parts.first.label).to eq(['Wheel bearing'])
     end
 
-    it "should not create a child node when hitting the accessor" do
+    it 'should not create a child node when hitting the accessor' do
       ds.parts
-      ds.parts.first.should be_nil
-      ds.serialize.should == ''
+      expect(ds.parts.first).to be_nil
+      expect(ds.serialize).to eq('')
     end
 
-    it "should build complex objects when a parent node exists" do
+    it 'should build complex objects when a parent node exists' do
       part = ds.parts.build
-      part.should be_kind_of SpecDatastream::Component
-      part.label = "Wheel bearing"
-      ds.parts.first.label.should == ['Wheel bearing']
+      expect(part).to be_kind_of SpecDatastream::Component
+      part.label = 'Wheel bearing'
+      expect(ds.parts.first.label).to eq(['Wheel bearing'])
     end
 
-    describe "#first_or_create" do
-      it "should return a result if the predicate exists" do
+    describe '#first_or_create' do
+      it 'should return a result if the predicate exists' do
         part1 = ds.parts.build
         part2 = ds.parts.build
-        ds.parts.first_or_create.should == part1
+        expect(ds.parts.first_or_create).to eq(part1)
       end
 
       it "should create a new result if the predicate doesn't exist" do
-        ds.parts.should == []
+        expect(ds.parts).to eq([])
         part = ds.parts.first_or_create(label: 'Front control arm bushing')
-        part.label.should == ['Front control arm bushing']
-        ds.parts.should == [part]
+        expect(part.label).to eq(['Front control arm bushing'])
+        expect(ds.parts).to eq([part])
       end
 
     end
   end
 
 
-  describe "with type" do
-    describe "one class per assertion" do 
-      before(:each) do 
+  describe 'with type' do
+    describe 'one class per assertion' do
+      before(:each) do
         class SpecDatastream < ActiveFedora::NtriplesRDFDatastream
           map_predicates do |map|
-            map.mediator(:in=> RDF::DC, :class_name=>'MediatorUser')
+            map.mediator(:in => RDF::DC, :class_name => 'MediatorUser')
           end
 
           class MediatorUser
             include ActiveFedora::RdfObject
             rdf_type RDF::DC.AgentClass
             map_predicates do |map|
-              map.title(:in=> RDF::DC)
+              map.title(:in => RDF::DC)
             end
           end
         end
       end
-      
+
       after(:each) do
         Object.send(:remove_const, :SpecDatastream)
       end
 
       let (:ds) do
-        mock_obj = double(:mock_obj, :pid=>'test:124', :new_record? => true)
+        mock_obj = double(:mock_obj, :pid => 'test:124', :new_record? => true)
         ds = SpecDatastream.new(mock_obj)
       end
 
 
-      it "should store the type of complex objects when type is specified" do
+      it 'should store the type of complex objects when type is specified' do
         comp = SpecDatastream::MediatorUser.new ds.graph
-        comp.title = ["Doctor"]
+        comp.title = ['Doctor']
         ds.mediator = comp
-        ds.mediator.first.type.first.should be_instance_of RDF::URI
-        ds.mediator.first.type.first.to_s.should == "http://purl.org/dc/terms/AgentClass"
-        ds.mediator.first.title.first.should == 'Doctor'
+        expect(ds.mediator.first.type.first).to be_instance_of RDF::Vocabulary::Term
+        expect(ds.mediator.first.type.first.to_s).to eq('http://purl.org/dc/terms/AgentClass')
+        expect(ds.mediator.first.title.first).to eq('Doctor')
       end
 
-      it "should add the type of complex object when it is not provided" do
+      it 'should add the type of complex object when it is not provided' do
         ds.content = <<END
   _:g70350851837440 <http://purl.org/dc/terms/title> "Mediation Person" .
   <info:fedora/test:124> <http://purl.org/dc/terms/mediator> _:g70350851837440 .
 END
-        ds.mediator.first.type.first.to_s.should == "http://purl.org/dc/terms/AgentClass"
+        expect(ds.mediator.first.type.first.to_s).to eq('http://purl.org/dc/terms/AgentClass')
       end
 
-      it "should add load the type of complex objects when provided (superceeding what is specified by the class)" do
+      it 'should add load the type of complex objects when provided (superceeding what is specified by the class)' do
         ds.content = <<END
   _:g70350851837440 <http://purl.org/dc/terms/title> "Mediation Orgainzation" .
   _:g70350851837440 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.ebu.ch/metadata/ontologies/ebucore#Organisation> .
   <info:fedora/test:124> <http://purl.org/dc/terms/mediator> _:g70350851837440 .
 END
-        ds.mediator.first.type.first.to_s.should == "http://www.ebu.ch/metadata/ontologies/ebucore#Organisation"
+        expect(ds.mediator.first.type.first.to_s).to eq('http://www.ebu.ch/metadata/ontologies/ebucore#Organisation')
       end
     end
 
-    describe "shared assertion to different classes" do
-      before(:each) do 
-        class EbuCore < RDF::Vocabulary("http://www.ebu.ch/metadata/ontologies/ebucore#")
+    describe 'shared assertion to different classes' do
+      before(:each) do
+        class EbuCore < RDF::Vocabulary('http://www.ebu.ch/metadata/ontologies/ebucore#')
           property :isEpisodeOf
           property :title
         end
-        
+
         class SpecDatastream < ActiveFedora::NtriplesRDFDatastream
           map_predicates do |map|
-            map.series(:to => 'isEpisodeOf', :in=> EbuCore, :class_name=>'Series')
-            map.program(:to => 'isEpisodeOf', :in=> EbuCore, :class_name=>'Program')
+            map.series(:to => 'isEpisodeOf', :in => EbuCore, :class_name => 'Series')
+            map.program(:to => 'isEpisodeOf', :in => EbuCore, :class_name => 'Program')
           end
 
           class Series
             include ActiveFedora::RdfObject
             rdf_type 'http://www.ebu.ch/metadata/ontologies/ebucore#Series'
             map_predicates do |map|
-              map.title(:in=> EbuCore)
+              map.title(:in => EbuCore)
             end
           end
 
-          class Program 
+          class Program
             include ActiveFedora::RdfObject
             rdf_type 'http://www.ebu.ch/metadata/ontologies/ebucore#Programme'
             map_predicates do |map|
-              map.title(:in=> EbuCore)
+              map.title(:in => EbuCore)
             end
           end
         end
 
       end
-      
+
       after(:each) do
         Object.send(:remove_const, :SpecDatastream)
       end
 
       let (:ds) do
-        mock_obj = double(:mock_obj, :pid=>'test:124', :new_record? => true)
+        mock_obj = double(:mock_obj, :pid => 'test:124', :new_record? => true)
         ds = SpecDatastream.new(mock_obj)
       end
 
 
-      it "should store the type of complex objects when type is specified" do
+      it 'should store the type of complex objects when type is specified' do
         series = SpecDatastream::Series.new ds.graph
-        series.title = ["renovating bathrooms"]
+        series.title = ['renovating bathrooms']
         ds.series = series
 
         program = SpecDatastream::Program.new ds.graph
-        program.title = ["This old House"]
+        program.title = ['This old House']
         ds.program = program
 
-        ds.program.first.type.size.should == 1
-        ds.program.first.type.first.to_s.should == 'http://www.ebu.ch/metadata/ontologies/ebucore#Programme' 
-        ds.series.first.type.size.should == 1
-        ds.series.first.type.first.to_s.should == 'http://www.ebu.ch/metadata/ontologies/ebucore#Series' 
+        expect(ds.program.first.type.size).to eq(1)
+        expect(ds.program.first.type.first.to_s).to eq('http://www.ebu.ch/metadata/ontologies/ebucore#Programme')
+        expect(ds.series.first.type.size).to eq(1)
+        expect(ds.series.first.type.first.to_s).to eq('http://www.ebu.ch/metadata/ontologies/ebucore#Series')
       end
 
-      it "should create an object of the correct type" do
-        ds.program.build.should be_kind_of SpecDatastream::Program
-        ds.series.build.should be_kind_of SpecDatastream::Series
+      it 'should create an object of the correct type' do
+        expect(ds.program.build).to be_kind_of SpecDatastream::Program
+        expect(ds.series.build).to be_kind_of SpecDatastream::Series
       end
     end
   end

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')
-      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})
+      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})
       ds = @test_object2.thumbnail.first
       ds2 = @test_object2.high.first
       @test_object2.save
       @test_object2 = MockAFBaseDatastream.find(@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
+      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)
     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')
-      f.stub(: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')
+      allow(f).to receive(: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)
-      @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"
+      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')
     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
-      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")
+      allow(f).to receive(:content_type).and_return('image/jpeg')
+      allow(f).to receive(:original_filename).and_return('minivan.jpg')
+      allow(f2).to receive(:content_type).and_return('image/jpeg')
+      allow(f2).to receive(:original_filename).and_return('dino.jpg')
       #check raise exception if dsid not supplied
-      @test_object2.add_named_datastream("thumbnail",{:file=>f})
+      @test_object2.add_named_datastream('thumbnail', {:file => f})
       @test_object2.save
       @test_object2 = MockAFBaseDatastream.find(@test_object2.pid)
-      
-      @test_object2.thumbnail.size.should == 1
-      @test_object2.thumbnail_ids == ["THUMB1"]
+
+      expect(@test_object2.thumbnail.size).to eq(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"
+      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.content.should == minivan 
-      @test_object2.update_named_datastream("thumbnail",{:file=>f2,:dsid=>"THUMB1"})
+      expect(ds.content).to eq(minivan)
+      @test_object2.update_named_datastream('thumbnail', {:file => f2, :dsid => 'THUMB1'})
       @test_object2.save
       @test_object2 = MockAFBaseDatastream.find(@test_object2.pid)
-      @test_object2.thumbnail.size.should == 1
-      @test_object2.thumbnail_ids == ["THUMB1"]
+      expect(@test_object2.thumbnail.size).to eq(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
+      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
     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