active-fedora 8.2.1 → 8.2.2

data/spec/unit/has_and_belongs_to_many_collection_spec.rb

@@ -15,15 +15,15 @@ describe ActiveFedora::Associations::HasAndBelongsToManyAssociation do
 
   it "should call add_relationship" do
     subject = Book.new(pid: 'subject:a')
-    subject.stub(:new_record? => false, save: true)
+    allow(subject).to receive_messages(:new_record? => false, save: true)
     predicate = Book.create_reflection(:has_and_belongs_to_many, 'pages', {:property=>'predicate'}, nil)
-    ActiveFedora::SolrService.stub(:query).and_return([])
+    allow(ActiveFedora::SolrService).to receive(:query).and_return([])
     ac = ActiveFedora::Associations::HasAndBelongsToManyAssociation.new(subject, predicate)
-    ac.should_receive(:callback).twice
+    expect(ac).to receive(:callback).twice
     object = Page.new(:pid => 'object:b')
-    object.stub(:new_record? => false, save: true)
+    allow(object).to receive_messages(:new_record? => false, save: true)
   
-    subject.should_receive(:add_relationship).with('predicate', object)
+    expect(subject).to receive(:add_relationship).with('predicate', object)
  
     ac << object
 
@@ -31,17 +31,17 @@ describe ActiveFedora::Associations::HasAndBelongsToManyAssociation do
 
   it "should call add_relationship on subject and object when inverse_of given" do
     subject = Book.new(pid: 'subject:a')
-    subject.stub(:new_record? => false, save: true)
+    allow(subject).to receive_messages(:new_record? => false, save: true)
     predicate = Book.create_reflection(:has_and_belongs_to_many, 'pages', {:property=>'predicate', :inverse_of => 'inverse_predicate'}, nil)
-    ActiveFedora::SolrService.stub(:query).and_return([])
+    allow(ActiveFedora::SolrService).to receive(:query).and_return([])
     ac = ActiveFedora::Associations::HasAndBelongsToManyAssociation.new(subject, predicate)
-    ac.should_receive(:callback).twice
+    expect(ac).to receive(:callback).twice
     object = Page.new(:pid => 'object:b')
-    object.stub(:new_record? => false, save: true)
+    allow(object).to receive_messages(:new_record? => false, save: true)
   
-    subject.should_receive(:add_relationship).with('predicate', object)
+    expect(subject).to receive(:add_relationship).with('predicate', object)
  
-    object.should_receive(:add_relationship).with('inverse_predicate', subject)
+    expect(object).to receive(:add_relationship).with('inverse_predicate', subject)
  
     ac << object
 
@@ -50,15 +50,15 @@ describe ActiveFedora::Associations::HasAndBelongsToManyAssociation do
   it "should call solr query multiple times" do
 
     subject = Book.new(pid: 'subject:a')
-    subject.stub(:new_record? => false, save: true)
+    allow(subject).to receive_messages(:new_record? => false, save: true)
     predicate = Book.create_reflection(:has_and_belongs_to_many, 'pages', {:property=>'predicate', :solr_page_size => 10}, nil)
     ids = []
     0.upto(15) {|i| ids << i.to_s}
     query1 = ids.slice(0,10).map {|i| "_query_:\"{!raw f=id}#{i}\""}.join(" OR ")
     query2 = ids.slice(10,10).map {|i| "_query_:\"{!raw f=id}#{i}\""}.join(" OR ")
-    subject.should_receive(:ids_for_outbound).and_return(ids)
-    ActiveFedora::SolrService.should_receive(:query).with(query1, {:rows=>10}).and_return([])
-    ActiveFedora::SolrService.should_receive(:query).with(query2, {:rows=>10}).and_return([])
+    expect(subject).to receive(:ids_for_outbound).and_return(ids)
+    expect(ActiveFedora::SolrService).to receive(:query).with(query1, {:rows=>10}).and_return([])
+    expect(ActiveFedora::SolrService).to receive(:query).with(query2, {:rows=>10}).and_return([])
 
     ac = ActiveFedora::Associations::HasAndBelongsToManyAssociation.new(subject, predicate)
     ac.find_target
@@ -88,7 +88,7 @@ describe ActiveFedora::Associations::HasAndBelongsToManyAssociation do
     let(:collection) {Collection.create().tap {|c| c.members << thing}}
 
     it "should call destroy" do
-      expect(collection.destroy).to_not raise_error
+      expect { collection.destroy }.to_not raise_error
     end
 
   end

data/spec/unit/has_many_collection_spec.rb

@@ -15,18 +15,18 @@ describe ActiveFedora::Associations::HasManyAssociation do
 
   subject { Book.new(pid: 'subject:a') }
   before {
-    subject.stub(:new_record? => false, save: true)
+    allow(subject).to receive_messages(:new_record? => false, save: true)
   }
 
   it "should call add_relationship" do
     reflection = Book.create_reflection(:has_many, 'pages', {:property=>'predicate'}, Book)
-    ActiveFedora::SolrService.stub(:query).and_return([])
+    allow(ActiveFedora::SolrService).to receive(:query).and_return([])
     ac = ActiveFedora::Associations::HasManyAssociation.new(subject, reflection)
-    ac.should_receive(:callback).twice
+    expect(ac).to receive(:callback).twice
     object = Page.new(:pid => 'object:b')
-    object.stub(:new_record? => false, save: true)
+    allow(object).to receive_messages(:new_record? => false, save: true)
   
-    object.should_receive(:add_relationship).with('predicate', subject)
+    expect(object).to receive(:add_relationship).with('predicate', subject)
  
     ac << object
 

data/spec/unit/inheritance_spec.rb

@@ -17,17 +17,17 @@ describe ActiveFedora::Base do
 
   it "doesn't overwrite stream specs" do
     f = Foo.new
-    f.datastreams.size.should == 3
+    expect(f.datastreams.size).to eq(3)
     streams = f.datastreams.values.map{|x| x.class.to_s}.sort
-    streams.pop.should == "ActiveFedora::SimpleDatastream"
-    streams.pop.should == "ActiveFedora::RelsExtDatastream"
-    streams.pop.should == "ActiveFedora::QualifiedDublinCoreDatastream"
+    expect(streams.pop).to eq("ActiveFedora::SimpleDatastream")
+    expect(streams.pop).to eq("ActiveFedora::RelsExtDatastream")
+    expect(streams.pop).to eq("ActiveFedora::QualifiedDublinCoreDatastream")
   end
 
   it "should work for multiple types" do
     b = Foo.new
     f = Bar.new
-    b.class.ds_specs.should_not == f.class.ds_specs
+    expect(b.class.ds_specs).not_to eq(f.class.ds_specs)
   end
   after do
     Object.send(:remove_const, :Bar)

data/spec/unit/model_spec.rb

@@ -20,11 +20,11 @@ describe ActiveFedora::Model do
       SpecModel::Basic.solr_query_handler = 'standard'
     end
     it "should have a default" do
-      SpecModel::Basic.solr_query_handler.should == 'standard'
+      expect(SpecModel::Basic.solr_query_handler).to eq('standard')
     end
     it "should be settable" do
       SpecModel::Basic.solr_query_handler = 'search'
-      SpecModel::Basic.solr_query_handler.should == 'search'
+      expect(SpecModel::Basic.solr_query_handler).to eq('search')
     end
   end
   
@@ -44,13 +44,13 @@ describe ActiveFedora::Model do
   
     describe ".classname_from_uri" do 
       it "should turn an afmodel URI into a Model class name" do
-        ActiveFedora::Model.classname_from_uri('info:fedora/afmodel:SpecModel_CamelCased').should == ['SpecModel::CamelCased', 'afmodel']
+        expect(ActiveFedora::Model.classname_from_uri('info:fedora/afmodel:SpecModel_CamelCased')).to eq(['SpecModel::CamelCased', 'afmodel'])
       end
       it "should not change plurality" do
-        ActiveFedora::Model.classname_from_uri('info:fedora/afmodel:MyMetadata').should == ['MyMetadata', 'afmodel']
+        expect(ActiveFedora::Model.classname_from_uri('info:fedora/afmodel:MyMetadata')).to eq(['MyMetadata', 'afmodel'])
       end
       it "should capitalize the first letter" do
-        ActiveFedora::Model.classname_from_uri('info:fedora/afmodel:image').should == ['Image', 'afmodel']
+        expect(ActiveFedora::Model.classname_from_uri('info:fedora/afmodel:image')).to eq(['Image', 'afmodel'])
       end
     end
   end

data/spec/unit/nom_datastream_spec.rb

@@ -15,16 +15,16 @@ describe ActiveFedora::NomDatastream do
     }
 
     it "should work" do
-      subject.a.should include("123")
+      expect(subject.a).to include("123")
     end
 
     it "should to_solr" do
-      subject.to_solr['a_s'].should include('123')
-      subject.to_solr['b_s'].should include('asdf')
+      expect(subject.to_solr['a_s']).to include('123')
+      expect(subject.to_solr['b_s']).to include('asdf')
     end
 
     it "should be a managed datastream" do
-      subject.controlGroup.should == 'M'
+      expect(subject.controlGroup).to eq('M')
     end
   end
 
@@ -54,7 +54,7 @@ describe ActiveFedora::NomDatastream do
     }
 
     it "should scope #a attribute to only the dc namespace" do
-      subject.a.should == ["123"]
+      expect(subject.a).to eq(["123"])
     end
 
   end

data/spec/unit/ntriples_datastream_spec.rb

@@ -19,59 +19,59 @@ describe ActiveFedora::NtriplesRDFDatastream do
       Object.send(:remove_const, :MyDatastream)
     end
     it "should have a subject" do
-      @subject.rdf_subject.should == "info:fedora/test:1"
+      expect(@subject.rdf_subject).to eq("info:fedora/test:1")
     end
     it "should have controlGroup" do
-      @subject.controlGroup.should == 'M'
+      expect(@subject.controlGroup).to eq('M')
     end
     it "should have mimeType" do
-      @subject.mimeType.should == 'application/n-triples'
+      expect(@subject.mimeType).to eq('application/n-triples')
     end
     it "should have dsid" do
-      @subject.dsid.should == 'descMetadata'
+      expect(@subject.dsid).to eq('descMetadata')
     end
     it "should have fields" do
-      @subject.created.should == [Date.parse('2010-12-31')]
-      @subject.title.should == ["Title of work"]
-      @subject.publisher.should == ["Penn State"]
-      @subject.based_near.should == ["New York, NY, US"]
-      @subject.related_url.length.should == 1
-      @subject.related_url.first.rdf_subject.should == "http://google.com/"
+      expect(@subject.created).to eq([Date.parse('2010-12-31')])
+      expect(@subject.title).to eq(["Title of work"])
+      expect(@subject.publisher).to eq(["Penn State"])
+      expect(@subject.based_near).to eq(["New York, NY, US"])
+      expect(@subject.related_url.length).to eq(1)
+      expect(@subject.related_url.first.rdf_subject).to eq("http://google.com/")
     end
 
     it "should be able to call enumerable methods on the fields" do
-      @subject.title.join(', ').should == "Title of work"
-      @subject.title.count.should == 1
-      @subject.title.size.should == 1
-      @subject.title[0].should == "Title of work"
-      @subject.title.to_a.should == ["Title of work"]
+      expect(@subject.title.join(', ')).to eq("Title of work")
+      expect(@subject.title.count).to eq(1)
+      expect(@subject.title.size).to eq(1)
+      expect(@subject.title[0]).to eq("Title of work")
+      expect(@subject.title.to_a).to eq(["Title of work"])
       val = []
       @subject.title.each_with_index {|v, i| val << "#{i}. #{v}"}
-      val.should == ["0. Title of work"]
+      expect(val).to eq(["0. Title of work"])
     end
 
     it "should return fields that are not TermProxies" do
-      @subject.created.should be_kind_of Array
+      expect(@subject.created).to be_kind_of Array
     end
     it "should have method missing" do
-      lambda{@subject.frank}.should raise_exception NoMethodError
+      expect{@subject.frank}.to raise_exception NoMethodError
     end
 
     it "should set fields" do
       @subject.publisher = "St. Martin's Press"
-      @subject.publisher.should == ["St. Martin's Press"]
+      expect(@subject.publisher).to eq(["St. Martin's Press"])
     end
     it "should set rdf literal fields" do
       @subject.creator = RDF.Literal("Geoff Ryman")
-      @subject.creator.should == ["Geoff Ryman"]
+      expect(@subject.creator).to eq(["Geoff Ryman"])
     end
     it "should append fields" do
       @subject.publisher << "St. Martin's Press"
-      @subject.publisher.should == ["Penn State", "St. Martin's Press"]
+      expect(@subject.publisher).to eq(["Penn State", "St. Martin's Press"])
     end
     it "should delete fields" do
       @subject.related_url.delete(RDF::URI("http://google.com/"))
-      @subject.related_url.should == []
+      expect(@subject.related_url).to eq([])
     end
   end
 
@@ -81,8 +81,8 @@ describe ActiveFedora::NtriplesRDFDatastream do
       @two = ActiveFedora::RDFDatastream.new('fakepid', 'myQuix')
     end
     it "should generate predictable prexies" do
-      @one.apply_prefix("baz").should == 'my_foobar__baz'
-      @two.apply_prefix("baz").should == 'my_quix__baz'
+      expect(@one.apply_prefix("baz")).to eq('my_foobar__baz')
+      expect(@two.apply_prefix("baz")).to eq('my_quix__baz')
     end
   end
 
@@ -98,8 +98,8 @@ describe ActiveFedora::NtriplesRDFDatastream do
       end
       @inner_object = double('inner object', pid: 'test:1', :new_record? => true)
       @subject = MyDatastream.new(@inner_object, 'mixed_rdf')
-      @subject.stub(pid: 'test:1')
-      @subject.stub(:new_record? => false)
+      allow(@subject).to receive_messages(pid: 'test:1')
+      allow(@subject).to receive_messages(:new_record? => false)
       @subject.content = File.new('spec/fixtures/mixed_rdf_descMetadata.nt').read
     end
 
@@ -108,11 +108,11 @@ describe ActiveFedora::NtriplesRDFDatastream do
     end
 
     it "should have fields" do
-      @subject.title.should == ["Title of datastream"]
+      expect(@subject.title).to eq(["Title of datastream"])
     end
 
     it "should have a custom subject" do
-      @subject.rdf_subject.should == 'info:fedora/test:1/content'
+      expect(@subject.rdf_subject).to eq('info:fedora/test:1/content')
     end
   end
 
@@ -122,17 +122,17 @@ describe ActiveFedora::NtriplesRDFDatastream do
         property :publisher, predicate: RDF::DC.publisher
       end
       @subject = MyDatastream.new(@inner_object, 'mixed_rdf')
-      @subject.stub(pid: 'test:1', repository: ActiveFedora::Base.connection_for_pid(0))
+      allow(@subject).to receive_messages(pid: 'test:1', repository: ActiveFedora::Base.connection_for_pid(0))
     end
     after(:each) do
       Object.send(:remove_const, :MyDatastream)
     end
     it "should support to_s method" do
-      @subject.publisher.to_s.should == [].to_s
+      expect(@subject.publisher.to_s).to eq([].to_s)
       @subject.publisher = "Bob"
-      @subject.publisher.to_s.should == ["Bob"].to_s
+      expect(@subject.publisher.to_s).to eq(["Bob"].to_s)
       @subject.publisher << "Jim"
-      @subject.publisher.to_s.should == ["Bob", "Jim"].to_s
+      expect(@subject.publisher.to_s).to eq(["Bob", "Jim"].to_s)
     end
  end
 
@@ -166,12 +166,12 @@ describe ActiveFedora::NtriplesRDFDatastream do
       Object.send(:remove_const, :MyDatastream)
     end
     before(:each) do
-      @subject.stub(pid: 'test:1')
+      allow(@subject).to receive_messages(pid: 'test:1')
       @subject.serialize
     end
     it "should provide .to_solr and return a SolrDocument" do
-      @subject.should respond_to(:to_solr)
-      @subject.to_solr.should be_kind_of(Hash)
+      expect(@subject).to respond_to(:to_solr)
+      expect(@subject.to_solr).to be_kind_of(Hash)
     end
 
     it "should have a solr_name method" do
@@ -181,20 +181,20 @@ describe ActiveFedora::NtriplesRDFDatastream do
 
     it "should optionally allow you to provide the Solr::Document to add fields to and return that document when done" do
       doc = Hash.new
-      @subject.to_solr(doc).should == doc
+      expect(@subject.to_solr(doc)).to eq(doc)
     end
     it "should iterate through @fields hash" do
       solr_doc = @subject.to_solr
-      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__publisher", type: :string)].should == ["publisher1"]
-      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__publisher", :sortable)].should == "publisher1"
-      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__publisher", :facetable)].should == ["publisher1"]
-      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__based_near", type: :string)].should == ["coverage1", "coverage2"]
-      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__based_near", :facetable)].should == ["coverage1", "coverage2"]
-      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__created", :sortable, type: :date)].should == "2009-10-10T00:00:00Z"
-      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__created", :displayable)].should == ["2009-10-10"]
-      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__title", type: :string)].should == ["fake-title"]
-      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__title", :sortable)].should == "fake-title"
-      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__related_url", type: :string)].should == ["http://example.org/"]
+      expect(solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__publisher", type: :string)]).to eq(["publisher1"])
+      expect(solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__publisher", :sortable)]).to eq("publisher1")
+      expect(solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__publisher", :facetable)]).to eq(["publisher1"])
+      expect(solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__based_near", type: :string)]).to eq(["coverage1", "coverage2"])
+      expect(solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__based_near", :facetable)]).to eq(["coverage1", "coverage2"])
+      expect(solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__created", :sortable, type: :date)]).to eq("2009-10-10T00:00:00Z")
+      expect(solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__created", :displayable)]).to eq(["2009-10-10"])
+      expect(solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__title", type: :string)]).to eq(["fake-title"])
+      expect(solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__title", :sortable)]).to eq("fake-title")
+      expect(solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__related_url", type: :string)]).to eq(["http://example.org/"])
     end
 
     describe "with an actual object" do
@@ -205,9 +205,9 @@ describe ActiveFedora::NtriplesRDFDatastream do
         end
         @obj = MyDatastream.new(@inner_object, 'solr_rdf')
         repository = double()
-          @obj.stub(repository: repository, pid: 'test:1')
-          repository.stub(:modify_datastream)
-          repository.stub(:add_datastream)
+          allow(@obj).to receive_messages(repository: repository, pid: 'test:1')
+          allow(repository).to receive(:modify_datastream)
+          allow(repository).to receive(:add_datastream)
         @obj.created = Date.parse("2012-03-04")
         @obj.title = "Of Mice and Men, The Sequel"
         @obj.publisher = "Bob's Blogtastic Publishing"
@@ -223,21 +223,21 @@ describe ActiveFedora::NtriplesRDFDatastream do
 
       describe ".fields()" do
         it "should return the right fields" do
-          @obj.send(:fields).keys.should == ["created", "title", "publisher", "based_near", "related_url"]
+          expect(@obj.send(:fields).keys).to eq(["created", "title", "publisher", "based_near", "related_url"])
         end
         it "should return the right values" do
           fields = @obj.send(:fields)
-          fields[:related_url][:values].should == ["http://example.org/blogtastic/"]
-          fields[:based_near][:values].should == ["Tacoma, WA", "Renton, WA"]
+          expect(fields[:related_url][:values]).to eq(["http://example.org/blogtastic/"])
+          expect(fields[:based_near][:values]).to eq(["Tacoma, WA", "Renton, WA"])
         end
         it "should return the right type information" do
           fields = @obj.send(:fields)
-          fields[:created][:type].should == :date
+          expect(fields[:created][:type]).to eq(:date)
         end
       end
       describe ".to_solr()" do
         it "should return the right fields" do
-          @obj.to_solr.keys.should include(ActiveFedora::SolrService.solr_name("solr_rdf__related_url", type: :string),
+          expect(@obj.to_solr.keys).to include(ActiveFedora::SolrService.solr_name("solr_rdf__related_url", type: :string),
                 ActiveFedora::SolrService.solr_name("solr_rdf__publisher", type: :string),
                 ActiveFedora::SolrService.solr_name("solr_rdf__publisher", :sortable),
                 ActiveFedora::SolrService.solr_name("solr_rdf__publisher", :facetable),
@@ -251,8 +251,8 @@ describe ActiveFedora::NtriplesRDFDatastream do
         end
 
         it "should return the right values" do
-          @obj.to_solr[ActiveFedora::SolrService.solr_name("solr_rdf__related_url", type: :string)].should == ["http://example.org/blogtastic/"]
-          @obj.to_solr[ActiveFedora::SolrService.solr_name("solr_rdf__based_near", type: :string)].should == ["Tacoma, WA","Renton, WA"]
+          expect(@obj.to_solr[ActiveFedora::SolrService.solr_name("solr_rdf__related_url", type: :string)]).to eq(["http://example.org/blogtastic/"])
+          expect(@obj.to_solr[ActiveFedora::SolrService.solr_name("solr_rdf__based_near", type: :string)]).to eq(["Tacoma, WA","Renton, WA"])
         end
       end
     end

data/spec/unit/om_datastream_spec.rb

@@ -21,14 +21,14 @@ describe ActiveFedora::OmDatastream do
   before(:each) do
     @mock_inner = double('inner object')
     @mock_repo = double('repository')
-    @mock_repo.stub(:datastream_dissemination=>'My Content', :config=>{}, :datastream_profile=>{})
-    @mock_inner.stub(:repository).and_return(@mock_repo)
-    @mock_inner.stub(:pid)
-    @mock_inner.stub(:new_record? => false)
+    allow(@mock_repo).to receive_messages(:datastream_dissemination=>'My Content', :config=>{}, :datastream_profile=>{})
+    allow(@mock_inner).to receive(:repository).and_return(@mock_repo)
+    allow(@mock_inner).to receive(:pid)
+    allow(@mock_inner).to receive_messages(:new_record? => false)
     @test_ds = ActiveFedora::OmDatastream.new(@mock_inner, "descMetadata")
-    @test_ds.stub(:new? => false, :profile => {}, :datastream_content => '<test_xml/>')
+    allow(@test_ds).to receive_messages(:new? => false, :profile => {}, :datastream_content => '<test_xml/>')
     @test_ds.content="<test_xml/>"
-    @test_ds.stub(:new? => false)
+    allow(@test_ds).to receive_messages(:new? => false)
   end
   
   its(:metadata?) { should be true}
@@ -36,36 +36,36 @@ describe ActiveFedora::OmDatastream do
   its(:controlGroup) { should == "M"}
 
   it "should include the Solrizer::XML::TerminologyBasedSolrizer for .to_solr support" do
-    ActiveFedora::OmDatastream.included_modules.should include(OM::XML::TerminologyBasedSolrizer)
+    expect(ActiveFedora::OmDatastream.included_modules).to include(OM::XML::TerminologyBasedSolrizer)
   end
   
   describe '#new' do
     it 'should provide #new' do
-      ActiveFedora::OmDatastream.should respond_to(:new)
-      @test_ds.ng_xml.should be_instance_of(Nokogiri::XML::Document)
+      expect(ActiveFedora::OmDatastream).to respond_to(:new)
+      expect(@test_ds.ng_xml).to be_instance_of(Nokogiri::XML::Document)
     end
     it 'should load xml from blob if provided' do
       test_ds1 = ActiveFedora::OmDatastream.new(nil, 'ds1')
       test_ds1.content="<xml><foo/></xml>"
-      test_ds1.ng_xml.to_xml.should be_equivalent_to("<?xml version=\"1.0\"?>\n<xml>\n  <foo/>\n</xml>\n")
+      expect(test_ds1.ng_xml.to_xml).to be_equivalent_to("<?xml version=\"1.0\"?>\n<xml>\n  <foo/>\n</xml>\n")
     end
     it "should initialize from #xml_template if no xml is provided" do
-      ActiveFedora::OmDatastream.should_receive(:xml_template).and_return("<fake template/>")
+      expect(ActiveFedora::OmDatastream).to receive(:xml_template).and_return("<fake template/>")
       n = ActiveFedora::OmDatastream.new
-      n.ng_xml.should be_equivalent_to("<fake template/>")
+      expect(n.ng_xml).to be_equivalent_to("<fake template/>")
     end
   end
 
   describe "#prefix" do
     subject { ActiveFedora::OmDatastream.new(nil, 'descMetadata') }
     it "should be \"\#{dsid.underscore}__\"" do
-      subject.send(:prefix).should == "desc_metadata__"
+      expect(subject.send(:prefix)).to eq("desc_metadata__")
     end
   end
   
   describe '#xml_template' do
     it "should return an empty xml document" do
-      ActiveFedora::OmDatastream.xml_template.to_xml.should be_equivalent_to("<?xml version=\"1.0\"?>\n<xml/>\n")
+      expect(ActiveFedora::OmDatastream.xml_template.to_xml).to be_equivalent_to("<?xml version=\"1.0\"?>\n<xml/>\n")
     end
   end
 
@@ -116,25 +116,25 @@ describe ActiveFedora::OmDatastream do
     
     it "should apply submitted hash to corresponding datastream field values" do
       result = @mods_ds.update_indexed_attributes( {[{":person"=>"0"}, "role"]=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"} })
-      result.should == {"person_0_role"=>["role1", "role2", "role3"]}
-      @mods_ds.property_values('//oxns:name[@type="personal"][1]/oxns:role').should == ["role1","role2","role3"]
+      expect(result).to eq({"person_0_role"=>["role1", "role2", "role3"]})
+      expect(@mods_ds.property_values('//oxns:name[@type="personal"][1]/oxns:role')).to eq(["role1","role2","role3"])
     end
     it "should support single-value arguments (as opposed to a hash of values with array indexes as keys)" do
       # In other words, { "fubar"=>"dork" } should have the same effect as { "fubar"=>{"0"=>"dork"} }
       result = @mods_ds.update_indexed_attributes( { [{":person"=>"0"}, "role"]=>"the role" } )
-      result.should == {"person_0_role"=>["the role"]}
-      @mods_ds.term_values('//oxns:name[@type="personal"][1]/oxns:role').first.should == "the role"
+      expect(result).to eq({"person_0_role"=>["the role"]})
+      expect(@mods_ds.term_values('//oxns:name[@type="personal"][1]/oxns:role').first).to eq("the role")
     end
     it "should do nothing if field key is a string (must be an array or symbol).  Will not accept xpath queries!" do
       xml_before = @mods_ds.to_xml
       expect(ActiveFedora::Base.logger).to receive(:warn).with "WARNING: descMetadata ignoring {\"fubar\" => \"the role\"} because \"fubar\" is a String (only valid OM Term Pointers will be used).  Make sure your html has the correct field_selector tags in it."
-      @mods_ds.update_indexed_attributes( { "fubar"=>"the role" } ).should == {}
-      @mods_ds.to_xml.should == xml_before
+      expect(@mods_ds.update_indexed_attributes( { "fubar"=>"the role" } )).to eq({})
+      expect(@mods_ds.to_xml).to eq(xml_before)
     end
     it "should do nothing if there is no accessor corresponding to the given field key" do
       xml_before = @mods_ds.to_xml
-      @mods_ds.update_indexed_attributes( { [{"fubar"=>"0"}]=>"the role" } ).should == {}
-      @mods_ds.to_xml.should == xml_before
+      expect(@mods_ds.update_indexed_attributes( { [{"fubar"=>"0"}]=>"the role" } )).to eq({})
+      expect(@mods_ds.to_xml).to eq(xml_before)
     end
     
     ### Examples copied over form metadata_datastream_spec
@@ -142,30 +142,30 @@ describe ActiveFedora::OmDatastream do
     it "should work for text fields" do 
       att= {[{"person"=>"0"},"description"]=>{"-1"=>"mork", "1"=>"york"}}
       result = @mods_ds.update_indexed_attributes(att)
-      result.should == {"person_0_description"=>["mork","york"]}
-      @mods_ds.get_values([{:person=>0},:description]).should == ['mork', 'york']
+      expect(result).to eq({"person_0_description"=>["mork","york"]})
+      expect(@mods_ds.get_values([{:person=>0},:description])).to eq(['mork', 'york'])
       att= {[{"person"=>"0"},"description"]=>{"-1"=>"dork"}}
       result2 = @mods_ds.update_indexed_attributes(att)
-      result2.should == {"person_0_description"=>["dork"]}
-      @mods_ds.get_values([{:person=>0},:description]).should == ['dork']
+      expect(result2).to eq({"person_0_description"=>["dork"]})
+      expect(@mods_ds.get_values([{:person=>0},:description])).to eq(['dork'])
     end
     
     it "should allow deleting of values and should delete values so that to_xml does not return emtpy nodes" do
       att= {[{"person"=>"0"},"description"]=>{"0"=>"york", "1"=>"mangle","2"=>"mork"}}
       @mods_ds.update_indexed_attributes(att)
-      @mods_ds.get_values([{"person"=>"0"},"description"]).should == ['york', 'mangle', 'mork']
+      expect(@mods_ds.get_values([{"person"=>"0"},"description"])).to eq(['york', 'mangle', 'mork'])
       
       @mods_ds.update_indexed_attributes({[{"person"=>"0"},{"description" => '1'} ]=> nil})
-      @mods_ds.get_values([{"person"=>"0"},"description"]).should == ['york', 'mork']
+      expect(@mods_ds.get_values([{"person"=>"0"},"description"])).to eq(['york', 'mork'])
       
       @mods_ds.update_indexed_attributes({[{"person"=>"0"},{"description" => '0'}]=>:delete})
-      @mods_ds.get_values([{"person"=>"0"},"description"]).should == ['mork']
+      expect(@mods_ds.get_values([{"person"=>"0"},"description"])).to eq(['mork'])
     end
     
     it "should set changed to true" do
-      @mods_ds.get_values([{:title_info=>0},:main_title]).should == ["ARTICLE TITLE", "TITLE OF HOST JOURNAL"]
+      expect(@mods_ds.get_values([{:title_info=>0},:main_title])).to eq(["ARTICLE TITLE", "TITLE OF HOST JOURNAL"])
       @mods_ds.update_indexed_attributes [{"title_info"=>"0"},"main_title"]=>{"-1"=>"mork"}
-      @mods_ds.should be_changed
+      expect(@mods_ds).to be_changed
     end
   end
   
@@ -177,92 +177,92 @@ describe ActiveFedora::OmDatastream do
     end
     
     it "should call lookup with field_name and return the text values from each resulting node" do
-      @mods_ds.should_receive(:term_values).with("--my xpath--").and_return(["value1", "value2"])
-      @mods_ds.get_values("--my xpath--").should == ["value1", "value2"]
+      expect(@mods_ds).to receive(:term_values).with("--my xpath--").and_return(["value1", "value2"])
+      expect(@mods_ds.get_values("--my xpath--")).to eq(["value1", "value2"])
     end
     it "should assume that field_names that are strings are xpath queries" do
-      ActiveFedora::OmDatastream.should_receive(:accessor_xpath).never
-      @mods_ds.should_receive(:term_values).with("--my xpath--").and_return(["abstract1", "abstract2"])
-      @mods_ds.get_values("--my xpath--").should == ["abstract1", "abstract2"]
+      expect(ActiveFedora::OmDatastream).to receive(:accessor_xpath).never
+      expect(@mods_ds).to receive(:term_values).with("--my xpath--").and_return(["abstract1", "abstract2"])
+      expect(@mods_ds.get_values("--my xpath--")).to eq(["abstract1", "abstract2"])
     end
   end
 
   describe '.save' do
     it "should provide .save" do
-      @test_ds.should respond_to(:save)
+      expect(@test_ds).to respond_to(:save)
     end
     it "should persist the product of .to_xml in fedora" do
-      @mock_repo.stub(:datastream).and_return('')
-      @test_ds.stub(:new? => true)
-      @test_ds.stub(:ng_xml_changed? => true)
-      @test_ds.stub(:to_xml => "fake xml")
-      @mock_repo.should_receive(:add_datastream).with(:pid => nil, :dsid => 'descMetadata', :versionable => true, :content => 'fake xml', :controlGroup => 'M', :dsState => 'A', :mimeType=>'text/xml')
+      allow(@mock_repo).to receive(:datastream).and_return('')
+      allow(@test_ds).to receive_messages(:new? => true)
+      allow(@test_ds).to receive_messages(:ng_xml_changed? => true)
+      allow(@test_ds).to receive_messages(:to_xml => "fake xml")
+      expect(@mock_repo).to receive(:add_datastream).with(:pid => nil, :dsid => 'descMetadata', :versionable => true, :content => 'fake xml', :controlGroup => 'M', :dsState => 'A', :mimeType=>'text/xml')
 
       @test_ds.serialize!
       @test_ds.save
-      @test_ds.mimeType.should == 'text/xml'
+      expect(@test_ds.mimeType).to eq('text/xml')
     end
   end
   
   describe 'setting content' do
     subject { ActiveFedora::OmDatastream.new(@mock_inner, "descMetadata") }
     it "should update the content" do
-      subject.stub(:new? => false )
+      allow(subject).to receive_messages(:new? => false )
       subject.content = "<a />"
-      subject.content.should == '<a/>'
+      expect(subject.content).to eq('<a/>')
     end
 
     it "should mark the object as changed" do
-      subject.stub(:new? => false, :controlGroup => 'M')
+      allow(subject).to receive_messages(:new? => false, :controlGroup => 'M')
       subject.content = "<a />"
-      subject.should be_changed
+      expect(subject).to be_changed
     end
 
     it "update ngxml and mark the xml as loaded" do
-      subject.stub(:new? => false )
+      allow(subject).to receive_messages(:new? => false )
       subject.content = "<a />"
-      subject.ng_xml.to_xml.should =~ /<a\/>/
-      subject.xml_loaded.should be true
+      expect(subject.ng_xml.to_xml).to match(/<a\/>/)
+      expect(subject.xml_loaded).to be true
     end
   end
   
   describe 'ng_xml=' do
     before do
-      @mock_inner.stub(:new_record? => true)
+      allow(@mock_inner).to receive_messages(:new_record? => true)
       @test_ds2 = ActiveFedora::OmDatastream.new(@mock_inner, "descMetadata")
     end
     it "should parse raw xml for you" do
       @test_ds2.ng_xml = @sample_raw_xml
-      @test_ds2.ng_xml.class.should == Nokogiri::XML::Document
-      @test_ds2.ng_xml.to_xml.should be_equivalent_to(@sample_raw_xml)
+      expect(@test_ds2.ng_xml.class).to eq(Nokogiri::XML::Document)
+      expect(@test_ds2.ng_xml.to_xml).to be_equivalent_to(@sample_raw_xml)
     end
 
     it "Should always set a document when an Element is passed" do
       @test_ds2.ng_xml = Nokogiri::XML(@sample_raw_xml).xpath('//xmlelement').first
-      @test_ds2.ng_xml.should be_kind_of Nokogiri::XML::Document
-      @test_ds2.ng_xml.to_xml.should be_equivalent_to("<xmlelement/>")
+      expect(@test_ds2.ng_xml).to be_kind_of Nokogiri::XML::Document
+      expect(@test_ds2.ng_xml.to_xml).to be_equivalent_to("<xmlelement/>")
     end
     it "should mark the datastream as changed" do
-      @test_ds2.stub(:new? => false, :controlGroup => 'M')
-      @test_ds2.should_not be_changed 
+      allow(@test_ds2).to receive_messages(:new? => false, :controlGroup => 'M')
+      expect(@test_ds2).not_to be_changed 
       @test_ds2.ng_xml = @sample_raw_xml
-      @test_ds2.should be_changed
+      expect(@test_ds2).to be_changed
     end
   end
   
   describe '.to_xml' do
     it "should provide .to_xml" do
-      @test_ds.should respond_to(:to_xml)
+      expect(@test_ds).to respond_to(:to_xml)
     end
     
     it "should ng_xml.to_xml" do
-      @test_ds.stub(:ng_xml => Nokogiri::XML::Document.parse("<text_document/>"))
-      @test_ds.to_xml.should == "<text_document/>"       
+      allow(@test_ds).to receive_messages(:ng_xml => Nokogiri::XML::Document.parse("<text_document/>"))
+      expect(@test_ds.to_xml).to eq("<text_document/>")       
     end
     
     it 'should accept an optional Nokogiri::XML Document as an argument and insert its fields into that (mocked test)' do
       doc = Nokogiri::XML::Document.parse("<test_document/>")
-      doc.root.should_receive(:add_child)#.with(@test_ds.ng_xml.root)
+      expect(doc.root).to receive(:add_child)#.with(@test_ds.ng_xml.root)
       @test_ds.to_xml(doc)
     end
     
@@ -270,15 +270,15 @@ describe ActiveFedora::OmDatastream do
       expected_result = "<test_document><foo/><test_xml/></test_document>"
       doc = Nokogiri::XML::Document.parse("<test_document><foo/></test_document>")
       result = @test_ds.to_xml(doc)
-      doc.should be_equivalent_to expected_result
-      result.should be_equivalent_to expected_result
+      expect(doc).to be_equivalent_to expected_result
+      expect(result).to be_equivalent_to expected_result
     end
     
     it 'should add to root of Nokogiri::XML::Documents, but add directly to the elements if a Nokogiri::XML::Node is passed in' do
       doc = Nokogiri::XML::Document.parse("<test_document/>")
       el = Nokogiri::XML::Node.new("test_element", Nokogiri::XML::Document.new)
-      @test_ds.to_xml(doc).should be_equivalent_to "<test_document><test_xml/></test_document>"
-      @test_ds.to_xml(el).should be_equivalent_to "<test_element/>"
+      expect(@test_ds.to_xml(doc)).to be_equivalent_to "<test_document><test_xml/></test_document>"
+      expect(@test_ds.to_xml(el)).to be_equivalent_to "<test_element/>"
     end
     
   end
@@ -286,7 +286,7 @@ describe ActiveFedora::OmDatastream do
   describe '.from_solr' do
     it "should set the internal_solr_doc attribute to the solr document passed in" do 
       @test_ds.from_solr(@solr_doc)
-      @test_ds.internal_solr_doc.should == @solr_doc
+      expect(@test_ds.internal_solr_doc).to eq(@solr_doc)
     end
   end
 
@@ -302,47 +302,47 @@ describe ActiveFedora::OmDatastream do
  
     it "should return correct values from solr_doc given different term pointers" do
       mock_term = double("OM::XML::Term")
-      mock_term.stub(:type).and_return(:text)
+      allow(mock_term).to receive(:type).and_return(:text)
       mock_terminology = double("OM::XML::Terminology")
-      mock_terminology.stub(:retrieve_term).and_return(mock_term)
-      ActiveFedora::OmDatastream.stub(:terminology).and_return(mock_terminology)
+      allow(mock_terminology).to receive(:retrieve_term).and_return(mock_term)
+      allow(ActiveFedora::OmDatastream).to receive(:terminology).and_return(mock_terminology)
       @mods_ds.from_solr(@solr_doc)
       term_pointer = [:name,:role,:roleTerm]
-      @mods_ds.get_values_from_solr(:name,:role,:roleTerm).should == ["creator","submitter","teacher"]
+      expect(@mods_ds.get_values_from_solr(:name,:role,:roleTerm)).to eq(["creator","submitter","teacher"])
       ar = @mods_ds.get_values_from_solr({:name=>0},:role,:roleTerm)
-      ar.length.should == 2
-      ar.include?("creator").should == true
-      ar.include?("submitter").should == true
-      @mods_ds.get_values_from_solr({:name=>1},:role,:roleTerm).should == ["teacher"]
-      @mods_ds.get_values_from_solr({:name=>0},{:role=>0},:roleTerm).should == ["creator"]
-      @mods_ds.get_values_from_solr({:name=>0},{:role=>1},:roleTerm).should == ["submitter"]
-      @mods_ds.get_values_from_solr({:name=>0},{:role=>2},:roleTerm).should == []
-      @mods_ds.get_values_from_solr({:name=>1},{:role=>0},:roleTerm).should == ["teacher"]
-      @mods_ds.get_values_from_solr({:name=>1},{:role=>1},:roleTerm).should == []
+      expect(ar.length).to eq(2)
+      expect(ar.include?("creator")).to eq(true)
+      expect(ar.include?("submitter")).to eq(true)
+      expect(@mods_ds.get_values_from_solr({:name=>1},:role,:roleTerm)).to eq(["teacher"])
+      expect(@mods_ds.get_values_from_solr({:name=>0},{:role=>0},:roleTerm)).to eq(["creator"])
+      expect(@mods_ds.get_values_from_solr({:name=>0},{:role=>1},:roleTerm)).to eq(["submitter"])
+      expect(@mods_ds.get_values_from_solr({:name=>0},{:role=>2},:roleTerm)).to eq([])
+      expect(@mods_ds.get_values_from_solr({:name=>1},{:role=>0},:roleTerm)).to eq(["teacher"])
+      expect(@mods_ds.get_values_from_solr({:name=>1},{:role=>1},:roleTerm)).to eq([])
       ar = @mods_ds.get_values_from_solr(:name,{:role=>0},:roleTerm)
-      ar.length.should == 2
-      ar.include?("creator").should == true
-      ar.include?("teacher").should == true
-      @mods_ds.get_values_from_solr(:name,{:role=>1},:roleTerm).should == ["submitter"]
+      expect(ar.length).to eq(2)
+      expect(ar.include?("creator")).to eq(true)
+      expect(ar.include?("teacher")).to eq(true)
+      expect(@mods_ds.get_values_from_solr(:name,{:role=>1},:roleTerm)).to eq(["submitter"])
     end
   end
 
   describe '.has_solr_name?' do
     it "should return true if the given key exists in the solr document passed in" do
-      @test_ds.has_solr_name?(ActiveFedora::SolrService.solr_name("test_ds__name_0_role_0_roleTerm", type: :string),@solr_doc).should == true
-      @test_ds.has_solr_name?(ActiveFedora::SolrService.solr_name("test_ds__name_0_role_0_roleTerm", type: :string).to_sym,@solr_doc).should == true
-      @test_ds.has_solr_name?(ActiveFedora::SolrService.solr_name("test_ds__name_1_role_1_roleTerm", type: :string),@solr_doc).should == false
+      expect(@test_ds.has_solr_name?(ActiveFedora::SolrService.solr_name("test_ds__name_0_role_0_roleTerm", type: :string),@solr_doc)).to eq(true)
+      expect(@test_ds.has_solr_name?(ActiveFedora::SolrService.solr_name("test_ds__name_0_role_0_roleTerm", type: :string).to_sym,@solr_doc)).to eq(true)
+      expect(@test_ds.has_solr_name?(ActiveFedora::SolrService.solr_name("test_ds__name_1_role_1_roleTerm", type: :string),@solr_doc)).to eq(false)
       #if not doc passed in should be new empty solr doc and always return false
-      @test_ds.has_solr_name?(ActiveFedora::SolrService.solr_name("test_ds__name_0_role_0_roleTerm", type: :string)).should == false
+      expect(@test_ds.has_solr_name?(ActiveFedora::SolrService.solr_name("test_ds__name_0_role_0_roleTerm", type: :string))).to eq(false)
     end
   end
 
   describe '.is_hierarchical_term_pointer?' do
     it "should return true only if the pointer passed in is an array that contains a hash" do
-      @test_ds.is_hierarchical_term_pointer?(*[:image,{:tag1=>1},:tag2]).should == true
-      @test_ds.is_hierarchical_term_pointer?(*[:image,:tag1,{:tag2=>1}]).should == true
-      @test_ds.is_hierarchical_term_pointer?(*[:image,:tag1,:tag2]).should == false
-      @test_ds.is_hierarchical_term_pointer?(nil).should == false      
+      expect(@test_ds.is_hierarchical_term_pointer?(*[:image,{:tag1=>1},:tag2])).to eq(true)
+      expect(@test_ds.is_hierarchical_term_pointer?(*[:image,:tag1,{:tag2=>1}])).to eq(true)
+      expect(@test_ds.is_hierarchical_term_pointer?(*[:image,:tag1,:tag2])).to eq(false)
+      expect(@test_ds.is_hierarchical_term_pointer?(nil)).to eq(false)      
     end
   end
 
@@ -360,11 +360,11 @@ describe ActiveFedora::OmDatastream do
       rescue
         found_exception = true
       end
-      found_exception.should == true
+      expect(found_exception).to eq(true)
     end
 
     it "should update a value internally call OM::XML::TermValueOperators::update_values if internal_solr_doc is not set" do
-      @mods_ds.stub(:om_update_values).once()
+      allow(@mods_ds).to receive(:om_update_values).once()
       term_pointer = [:name,:role,:roleTerm]
       @mods_ds.update_values([{":person"=>"0"}, "role", "text"]=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"})
     end
@@ -373,7 +373,7 @@ describe ActiveFedora::OmDatastream do
       mods_ds = Hydra::ModsArticleDatastream.new
       mods_ds.content=fixture(File.join("mods_articles","mods_article1.xml")).read
       mods_ds.update_values([{":person"=>"0"}, "role", "text"]=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"})
-      mods_ds.should be_changed
+      expect(mods_ds).to be_changed
     end
   end
 
@@ -385,7 +385,7 @@ describe ActiveFedora::OmDatastream do
     end
 
     it "should call OM::XML::term_values if internal_solr_doc is not set and return values from xml" do
-      @mods_ds.stub(:om_term_values).once()
+      allow(@mods_ds).to receive(:om_term_values).once()
       term_pointer = [:name,:role,:roleTerm]
       @mods_ds.term_values(*term_pointer)
     end
@@ -394,7 +394,7 @@ describe ActiveFedora::OmDatastream do
     it "should call get_values_from_solr if internal_solr_doc is set" do
       @mods_ds.from_solr(@solr_doc)
       term_pointer = [:name,:role,:roleTerm]
-      @mods_ds.stub(:get_values_from_solr).once()
+      allow(@mods_ds).to receive(:get_values_from_solr).once()
       @mods_ds.term_values(*term_pointer)
     end
   end
@@ -414,8 +414,8 @@ describe ActiveFedora::OmDatastream do
       Object.send(:remove_const, :MyObj)
     end
     it "should not load the descMetadata datastream when calling content_changed?" do
-      @obj.inner_object.repository.should_not_receive(:datastream_dissemination).with(hash_including(:dsid=>'descMetadata'))
-      @obj.descMetadata.should_not be_content_changed
+      expect(@obj.inner_object.repository).not_to receive(:datastream_dissemination).with(hash_including(:dsid=>'descMetadata'))
+      expect(@obj.descMetadata).not_to be_content_changed
     end
   end
 end