active-fedora 8.2.1 → 8.2.2

data/spec/integration/complex_rdf_datastream_spec.rb

@@ -25,14 +25,14 @@ describe "Nested Rdf Objects" 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.resource.persist!
-        ds.parts.first.should_not be_new_record
+        expect(ds.parts.first).not_to be_new_record
       end
     end
 
@@ -40,24 +40,24 @@ describe "Nested Rdf Objects" do
       comp = SpecDatastream::Component.new(ds.graph)
       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
       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
       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"
       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
@@ -66,8 +66,8 @@ describe "Nested Rdf Objects" do
       comp2 = SpecDatastream::Component.new ds.graph
       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
@@ -77,7 +77,7 @@ describe "Nested Rdf Objects" do
       comp2.label = ["Crankshaft"]
       ds.parts = [comp1, comp2]
       ds.parts = []
-      ds.parts.should == []
+      expect(ds.parts).to eq([])
     end
 
     it "should load complex objects" do
@@ -87,41 +87,41 @@ _:g70350851837440 <http://purl.org/dc/terms/title> "Alternator" .
 <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
+      expect(part).to be_kind_of SpecDatastream::Component
       part.label = "Wheel bearing"
-      ds.parts.first.label.should == ['Wheel bearing']
+      expect(ds.parts.first.label).to eq(['Wheel bearing'])
     end
 
     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
       part = ds.parts.build
-      part.should be_kind_of SpecDatastream::Component
+      expect(part).to be_kind_of SpecDatastream::Component
       part.label = "Wheel bearing"
-      ds.parts.first.label.should == ['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
         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
@@ -155,9 +155,9 @@ END
         comp = SpecDatastream::MediatorUser.new ds.graph
         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::URI
+        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
@@ -165,7 +165,7 @@ 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
@@ -174,7 +174,7 @@ END
   _: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
 
@@ -221,15 +221,15 @@ END
         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
+        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

@@ -17,31 +17,31 @@ describe ActiveFedora::DatastreamCollections 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")
+      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
+      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
-      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
+      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
-      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(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
   
@@ -49,18 +49,18 @@ describe ActiveFedora::DatastreamCollections 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")
+      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
+      expect(@test_object2.named_datastreams["thumbnail"].size).to eq(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(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
   
@@ -73,37 +73,37 @@ describe ActiveFedora::DatastreamCollections do
       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.save
       @test_object2 = MockAFBaseDatastream.find(@test_object2.pid)
       
-      @test_object2.thumbnail.size.should == 1
+      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 
+      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
+      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
   

data/spec/integration/datastream_spec.rb

@@ -22,13 +22,13 @@ describe ActiveFedora::Datastream do
 
   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")
+    expect(descMetadata).to be_a_kind_of(ActiveFedora::Datastream)
+    expect(descMetadata.dsid).to eql("descMetadata")
   end
 
   it "should be able to access Datastream content using content method" do    
     descMetadata = @test_object.datastreams["descMetadata"].content
-    descMetadata.should_not be_nil
+    expect(descMetadata).not_to be_nil
   end
   
   it "should be able to update XML Datastream content and save to Fedora" do    
@@ -37,25 +37,25 @@ describe ActiveFedora::Datastream do
     title.content = "Test Title"
     xml_content.root.add_child title
     
-    @test_object.datastreams["descMetadata"].stub(:before_save)
+    allow(@test_object.datastreams["descMetadata"]).to receive(: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)
-    found.xpath('//dc/title/text()').first.inner_text.should == title.content
+    expect(found.xpath('//dc/title/text()').first.inner_text).to eq(title.content)
   end
   
   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')
-    @test_object.add_datastream(ds).should be_true
+    expect(@test_object.add_datastream(ds)).to be_truthy
     @test_object.save
-    @test_object.datastreams[dsid].should_not be_changed
+    expect(@test_object.datastreams[dsid]).not_to 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
+    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)
   end
   
   it "should be able to set the versionable attribute" do
@@ -65,26 +65,26 @@ describe ActiveFedora::Datastream do
     ds = ActiveFedora::Datastream.new(@test_object.inner_object, dsid)
     ds.content = v1
     ds.versionable = false
-    @test_object.add_datastream(ds).should be_true
+    expect(@test_object.add_datastream(ds)).to be_truthy
     @test_object.save
     to = ActiveFedora::Base.find(@test_object.pid)
     ds = to.datastreams[dsid]
-    ds.versionable.should be_false
+    expect(ds.versionable).to be_falsey
     ds.versionable = true
     to.save
     ds.content = v2
     to.save
     versions = ds.versions
-    versions.length.should == 2
+    expect(versions.length).to eq(2)
     # order of versions not guaranteed
     if versions[0].content == v2
-      versions[1].content.should == v1
-      versions[0].asOfDateTime.should be >= versions[1].asOfDateTime
+      expect(versions[1].content).to eq(v1)
+      expect(versions[0].asOfDateTime).to be >= versions[1].asOfDateTime
     else
-      versions[0].content.should == v1
-      versions[1].content.should == v2   
-      versions[1].asOfDateTime.should be >= versions[0].asOfDateTime
+      expect(versions[0].content).to eq(v1)
+      expect(versions[1].content).to eq(v2)   
+      expect(versions[1].asOfDateTime).to be >= versions[0].asOfDateTime
     end
-    ds.content.should == v2
+    expect(ds.content).to eq(v2)
   end
 end

data/spec/integration/datastreams_spec.rb

@@ -20,8 +20,8 @@ describe ActiveFedora::Datastreams do
 
     it "should work" do
       subject.save(validate: false)
-      subject.nokogiri_autocreate_on.should_not be_new
-      subject.nokogiri_autocreate_off.should be_new
+      expect(subject.nokogiri_autocreate_on).not_to be_new
+      expect(subject.nokogiri_autocreate_off).to be_new
     end
   end
 
@@ -51,21 +51,21 @@ describe ActiveFedora::Datastreams do
     end
     
     it "should create datastreams from the spec on new objects" do
-      expect(@test.without_versions.versionable).to be_false
-      expect(@test.with_versions.versionable).to be_true
+      expect(@test.without_versions.versionable).to be_falsey
+      expect(@test.with_versions.versionable).to be_truthy
       expect(@test.with_versions.dsLabel).to eql "Versioned DS"
       @test.without_versions.content= "blah blah blah"
       @test.save
-      expect(HasMetadata.find(@test.pid).without_versions.versionable).to be_false
+      expect(HasMetadata.find(@test.pid).without_versions.versionable).to be_falsey
     end
     
     it "should use ds_specs and preserve existing datastreams on migrated objects" do
       test_obj = HasMetadata.find(@base.pid, cast: false)
       expect(test_obj.datastreams["testDS"].dsLabel).to eql "Test DS"
-      expect(test_obj.datastreams["testDS"].new?).to be_false
+      expect(test_obj.datastreams["testDS"].new?).to be_falsey
       expect(test_obj.with_versions.dsLabel).to eql "Versioned DS"
-      expect(test_obj.without_versions.versionable).to be_false
-      expect(test_obj.with_versions.new?).to be_true
+      expect(test_obj.without_versions.versionable).to be_falsey
+      expect(test_obj.with_versions.new?).to be_truthy
     end
     
   end
@@ -98,34 +98,34 @@ describe ActiveFedora::Datastreams do
     end
     
     it "should create datastreams from the spec on new objects" do
-      expect(@has_file.file_ds.versionable).to be_false
+      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_true
-      expect(@has_file.file_ds2.changed?).to be_false # no autocreate
-      expect(@has_file.file_ds2.new?).to be_true
+      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
       @has_file.save
-      expect(@has_file.file_ds.versionable).to be_false
+      expect(@has_file.file_ds.versionable).to be_falsey
       test_obj = HasFile.find(@has_file.pid)
-      expect(test_obj.file_ds.versionable).to be_false
-      expect(test_obj.rels_ext.changed?).to be_false
-      expect(test_obj.file_ds.changed?).to be_false
-      expect(test_obj.file_ds2.changed?).to be_false
-      expect(test_obj.file_ds2.new?).to be_true
+      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
     end
     
     it "should use ds_specs on migrated objects" do
       test_obj = HasFile.find(@base.pid, cast: false)
-      expect(test_obj.file_ds.versionable).to be_false
-      expect(test_obj.file_ds.new?).to be_true
+      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.save
-      expect(test_obj.file_ds.versionable).to be_false
+      expect(test_obj.file_ds.versionable).to be_falsey
       # look it up again to check datastream profile
       test_obj = HasFile.find(@base.pid, cast: false)
-      expect(test_obj.file_ds.versionable).to be_false
+      expect(test_obj.file_ds.versionable).to be_falsey
       expect(test_obj.file_ds.dsLabel).to eql "File Datastream"
       test_obj = HasFile.find(@base2.pid, cast: false)
-      expect(test_obj.file_ds.versionable).to be_true
+      expect(test_obj.file_ds.versionable).to be_truthy
       expect(test_obj.file_ds.dsLabel).to eql "Pre-existing DS"
     end
   end
@@ -151,7 +151,7 @@ describe ActiveFedora::Datastreams do
       ds = @base.create_datastream('ActiveFedora::Datastream', 'someMetadata', ds_opts)
       @base.add_datastream(ds)
       @base.save
-      expect(@base.datastreams.keys.include?('someMetadata')).to be_true
+      expect(@base.datastreams.keys.include?('someMetadata')).to be_truthy
       test_obj = ActiveFedora::Base.find(@base.pid)
       expect(test_obj.datastreams['someMetadata'].content).to eql @ds_content
       expect(test_obj.datastreams['someMetadata'].controlGroup).to eql 'E'
@@ -164,7 +164,7 @@ describe ActiveFedora::Datastreams do
       ds = @base.create_datastream('ActiveFedora::Datastream', 'someMetadata', ds_opts)
       @base.add_datastream(ds)
       @base.save
-      expect(@base.datastreams.keys.include?('someMetadata')).to be_true
+      expect(@base.datastreams.keys.include?('someMetadata')).to be_truthy
       test_obj = ActiveFedora::Base.find(@base.pid)
       expect(test_obj.datastreams['someMetadata'].content).to eql @ds_content
       expect(test_obj.datastreams['someMetadata'].controlGroup).to eql 'M'