active-fedora 6.8.0 → 7.0.0.pre1

data/spec/integration/ntriples_datastream_spec.rb

@@ -2,24 +2,33 @@ require 'spec_helper'
 
 describe ActiveFedora::NtriplesRDFDatastream do
   before do
+    
+    class FileVocabulary < RDF::Vocabulary("http://downlode.org/Code/RDF/File_Properties/schema#")
+      property :size
+    end
+
     class MyDatastream < ActiveFedora::NtriplesRDFDatastream
       map_predicates do |map|
-        map.title(:in => RDF::DC) do |index|
+        map.title(in: RDF::DC) do |index|
           index.as :stored_searchable, :facetable
         end
-        map.date_uploaded(:to => 'dateSubmitted', :in => RDF::DC) do |index|
+        map.date_uploaded(to: "dateSubmitted", in: RDF::DC) do |index|
           index.type :date
           index.as :stored_searchable, :sortable
         end
-        map.part(:to => 'hasPart', :in => RDF::DC)
-        map.based_near(:in => RDF::FOAF)
-        map.related_url(:to => 'seeAlso', :in => RDF::RDFS)
+        map.size(in: FileVocabulary) do |index|
+          index.type :integer
+          index.as :stored_sortable
+        end
+        map.part(to: "hasPart", in: RDF::DC)
+        map.based_near(in: RDF::FOAF)
+        map.related_url(to: "seeAlso", in: RDF::RDFS)
       end
     end
-    class RdfTest < ActiveFedora::Base
-      has_metadata :name => 'rdf', :type => MyDatastream
-      delegate_to 'rdf', [:based_near, :related_url, :part, :date_uploaded], multiple: true
-      delegate :title, to: 'rdf', multiple: false
+    class RdfTest < ActiveFedora::Base 
+      has_metadata :name=>'rdf', :type=>MyDatastream
+      has_attributes :based_near, :related_url, :part, :date_uploaded, datastream: 'rdf', multiple: true
+      has_attributes :title, :size, datastream: 'rdf', multiple: false
     end
     @subject = RdfTest.new
   end
@@ -31,107 +40,116 @@ describe ActiveFedora::NtriplesRDFDatastream do
   after do
     Object.send(:remove_const, :RdfTest)
     Object.send(:remove_const, :MyDatastream)
+    Object.send(:remove_const, :FileVocabulary)
   end
 
-  it 'should not try to send an empty datastream' do
+  it "should not try to send an empty datastream" do
     @subject.save
   end
 
-  it 'should save content properly upon save' do
-    foo = RdfTest.new(:pid => 'test:1') #Pid needs to match the subject in the loaded file
+  it "should save content properly upon save" do
+    foo = RdfTest.new(:pid=>'test:1') #Pid needs to match the subject in the loaded file
     foo.title = 'Hamlet'
     foo.save
-    expect(foo.title).to eq('Hamlet')
+    foo.title.should == 'Hamlet'
     foo.rdf.content = File.new('spec/fixtures/mixed_rdf_descMetadata.nt').read
     foo.save
-    expect(foo.title).to eq('Title of work')
+    foo.title.should == 'Title of work'
   end
 
-  it 'should delegate as_json to the fields' do
-    @subject = RdfTest.new(title: 'Title of work')
-    expect(@subject.rdf.title.as_json).to eq(['Title of work'])
-    expect(@subject.rdf.title.to_json).to eq("\[\"Title of work\"\]")
+  it "should delegate as_json to the fields" do
+    @subject = RdfTest.new(title: "Title of work")
+    @subject.rdf.title.as_json.should == ["Title of work"]
+    @subject.rdf.title.to_json.should == "\[\"Title of work\"\]"
   end
 
-  it 'should solrize even when the object is not new' do
+  it "should solrize even when the object is not new" do
     foo = RdfTest.new
-    expect(foo).to receive(:update_index).once
-    foo.title = 'title1'
+    foo.should_receive(:update_index).once
+    foo.title = "title1"
     foo.save
     foo = RdfTest.find(foo.pid)
-    expect(foo).to receive(:update_index).once
-    foo.title = 'The Work2'
-    foo.save
+    foo.should_receive(:update_index).once
+    foo.title = "The Work2"
+    foo.save  
   end
 
-  it 'should serialize dates' do
-    subject.date_uploaded = Date.parse('2012-11-02')
-    expect(subject.date_uploaded.first).to be_kind_of Date
-    solr_document = subject.to_solr
-    expect(solr_document[ActiveFedora::SolrService.solr_name('rdf__date_uploaded', type: :date)]).to eq(['2012-11-02T00:00:00Z'])
+  describe "serializing" do
+    it "should handle dates" do
+      subject.date_uploaded = Date.parse('2012-11-02')
+      subject.date_uploaded.first.should be_kind_of Date
+      solr_document = subject.to_solr
+      solr_document[ActiveFedora::SolrService.solr_name('rdf__date_uploaded', type: :date)].should == ['2012-11-02T00:00:00Z']
+    end
+    it "should handle integers" do
+      subject.size = 12345 
+      subject.size.should be_kind_of Fixnum
+      solr_document = subject.to_solr
+      solr_document[ActiveFedora::SolrService.solr_name('rdf__size', :stored_sortable, type: :integer)].should == '12345'
+    end
   end
 
-  it 'should produce a solr document' do
-    @subject = RdfTest.new(title: 'War and Peace')
+  it "should produce a solr document" do
+    @subject = RdfTest.new(title: "War and Peace")
     solr_document = @subject.to_solr
-    expect(solr_document[ActiveFedora::SolrService.solr_name('rdf__title', :facetable)]).to eq(['War and Peace'])
-    expect(solr_document[ActiveFedora::SolrService.solr_name('rdf__title', type: :string)]).to eq(['War and Peace'])
+    solr_document[ActiveFedora::SolrService.solr_name('rdf__title', :facetable)].should == ["War and Peace"]
+    solr_document[ActiveFedora::SolrService.solr_name('rdf__title', type: :string)].should == ["War and Peace"]
   end
 
-  it 'should set and recall values' do
+  it "should set and recall values" do
     @subject.title = 'War and Peace'
-    expect(@subject.rdf).to be_changed
-    @subject.based_near = 'Moscow, Russia'
-    @subject.related_url = 'http://en.wikipedia.org/wiki/War_and_Peace'
-    @subject.part = 'this is a part'
+    @subject.rdf.should be_changed
+    @subject.based_near = "Moscow, Russia"
+    @subject.related_url = "http://en.wikipedia.org/wiki/War_and_Peace"
+    @subject.part = "this is a part"
     @subject.save
-    expect(@subject.title).to eq('War and Peace')
-    expect(@subject.based_near).to eq(['Moscow, Russia'])
-    expect(@subject.related_url).to eq(['http://en.wikipedia.org/wiki/War_and_Peace'])
-    expect(@subject.part).to eq(['this is a part'])
+    @subject.title.should == 'War and Peace'
+    @subject.based_near.should == ["Moscow, Russia"]
+    @subject.related_url.should == ["http://en.wikipedia.org/wiki/War_and_Peace"]
+    @subject.part.should == ["this is a part"]    
   end
-  it 'should set, persist, and recall values' do
+  it "should set, persist, and recall values" do
     @subject.title = 'War and Peace'
-    @subject.based_near = 'Moscow, Russia'
-    @subject.related_url = 'http://en.wikipedia.org/wiki/War_and_Peace'
-    @subject.part = 'this is a part'
+    @subject.based_near = "Moscow, Russia"
+    @subject.related_url = "http://en.wikipedia.org/wiki/War_and_Peace"
+    @subject.part = "this is a part"
     @subject.save
 
     loaded = RdfTest.find(@subject.pid)
-    expect(loaded.title).to eq('War and Peace')
-    expect(loaded.based_near).to eq(['Moscow, Russia'])
-    expect(loaded.related_url).to eq(['http://en.wikipedia.org/wiki/War_and_Peace'])
-    expect(loaded.part).to eq(['this is a part'])
+    loaded.title.should == 'War and Peace'
+    loaded.based_near.should == ['Moscow, Russia']
+    loaded.related_url.should == ['http://en.wikipedia.org/wiki/War_and_Peace']
+    loaded.part.should == ['this is a part']
   end
-  it 'should set multiple values' do
-    @subject.part = ['part 1', 'part 2']
+  it "should set multiple values" do
+    @subject.part = ["part 1", "part 2"]
     @subject.save
 
     loaded = RdfTest.find(@subject.pid)
-    expect(loaded.part).to eq(['part 1', 'part 2'])
+    loaded.part.should == ['part 1', 'part 2']
   end
-  it 'should append values' do
-    @subject.part = 'thing 1'
+  it "should append values" do
+    @subject.part = "thing 1"
     @subject.save
 
-    @subject.part << 'thing 2'
-    expect(@subject.part).to eq(['thing 1', 'thing 2'])
+    @subject.part << "thing 2"
+    @subject.part.should == ["thing 1", "thing 2"]
   end
 
-  it 'should be able to save a blank document' do
-    @subject.title = ''
+  it "should be able to save a blank document" do
+    @subject.title = ""
     @subject.save
   end
 
-  it 'should load n-triples into the graph' do
+  it "should load n-triples into the graph" do
     ntrip = '<http://oregondigital.org/ns/62> <http://purl.org/dc/terms/type> "Image" .
 <http://oregondigital.org/ns/62> <http://purl.org/dc/terms/spatial> "Benton County (Ore.)" .
 '
     @subject.rdf.content = ntrip
-    expect(@subject.rdf.graph.dump(:ntriples)).to eq(ntrip)
+    @subject.rdf.graph.dump(:ntriples).should == ntrip
   end
 
-  describe 'using rdf_subject' do
+  describe "using rdf_subject" do
     before do
       # reopening existing class
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
@@ -146,12 +164,12 @@ describe ActiveFedora::NtriplesRDFDatastream do
       @subject.destroy
     end
 
-    it 'should write rdf with proper subjects' do
+    it "should write rdf with proper subjects" do
       @subject.inner_object.pid = 'test:99'
-      @subject.rdf.type = 'Frog'
+      @subject.rdf.type = "Frog"
       @subject.save!
       @subject.reload
-      expect(@subject.rdf.graph.dump(:ntriples)).to eq("<http://oregondigital.org/ns/99> <http://purl.org/dc/terms/type> \"Frog\" .\n")
+      @subject.rdf.graph.dump(:ntriples).should == "<http://oregondigital.org/ns/99> <http://purl.org/dc/terms/type> \"Frog\" .\n"
       @subject.rdf.type == ['Frog']
 
     end
@@ -159,49 +177,49 @@ describe ActiveFedora::NtriplesRDFDatastream do
   end
 
 
-  it 'should delete values' do
-    @subject.title = 'Hamlet'
-    @subject.related_url = 'http://psu.edu/'
-    @subject.related_url << 'http://projecthydra.org/'
+  it "should delete values" do
+    @subject.title = "Hamlet"
+    @subject.related_url = "http://psu.edu/"
+    @subject.related_url << "http://projecthydra.org/"
 
-    expect(@subject.title).to eq('Hamlet')
-    expect(@subject.related_url).to include('http://psu.edu/')
-    expect(@subject.related_url).to include('http://projecthydra.org/')
+    @subject.title.should == "Hamlet"
+    @subject.related_url.should include("http://psu.edu/")
+    @subject.related_url.should include("http://projecthydra.org/")
 
-    @subject.title = '' #empty string can be meaningful, don't assume delete.
-    expect(@subject.title).to eq('')
+    @subject.title = "" #empty string can be meaningful, don't assume delete.
+    @subject.title.should == ''
 
     @subject.title = nil
-    @subject.related_url.delete('http://projecthydra.org/')
-
-    expect(@subject.title).to be_nil
-    expect(@subject.related_url).to eq(['http://psu.edu/'])
-  end
-  it 'should delete multiple values at once' do
-    @subject.part = 'MacBeth'
-    @subject.part << 'Hamlet'
-    @subject.part << 'Romeo & Juliet'
-    expect(@subject.part.first).to eq('MacBeth')
-    @subject.part.delete('MacBeth', 'Romeo & Juliet')
-    expect(@subject.part).to eq(['Hamlet'])
-    expect(@subject.part.first).to eq('Hamlet')
-  end
-  it 'should ignore values to be deleted that do not exist' do
-    @subject.part = ['title1', 'title2', 'title3']
-    @subject.part.delete('title2', 'title4', 'title6')
-    expect(@subject.part).to eq(['title1', 'title3'])
-  end
-  describe 'term proxy methods' do
+    @subject.related_url.delete("http://projecthydra.org/")
+
+    @subject.title.should be_nil
+    @subject.related_url.should == ["http://psu.edu/"]
+  end
+  it "should delete multiple values at once" do
+    @subject.part = "MacBeth"
+    @subject.part << "Hamlet"
+    @subject.part << "Romeo & Juliet"
+    @subject.part.first.should == "MacBeth"
+    @subject.part.delete("MacBeth", "Romeo & Juliet")
+    @subject.part.should == ["Hamlet"]
+    @subject.part.first.should == "Hamlet"
+  end
+  it "should ignore values to be deleted that do not exist" do
+    @subject.part = ["title1", "title2", "title3"]
+    @subject.part.delete("title2", "title4", "title6")
+    @subject.part.should == ["title1", "title3"]
+  end
+  describe "term proxy methods" do
     before(:each) do
       class TitleDatastream < ActiveFedora::NtriplesRDFDatastream
         map_predicates { |map| map.title(:in => RDF::DC) }
       end
-      class Foobar < ActiveFedora::Base
-        has_metadata :name => 'rdf', :type => TitleDatastream
-        delegate :title, :to => 'rdf', multiple: true
+      class Foobar < ActiveFedora::Base 
+        has_metadata :name=>'rdf', :type=>TitleDatastream
+        has_attributes :title, datastream: 'rdf', multiple: true
       end
       @subject = Foobar.new
-      @subject.title = ['title1', 'title2', 'title3']
+      @subject.title = ["title1", "title2", "title3"]
     end
 
     after(:each) do
@@ -209,26 +227,26 @@ describe ActiveFedora::NtriplesRDFDatastream do
       Object.send(:remove_const, :TitleDatastream)
     end
 
-    it 'should support the count method to determine # of values' do
-      expect(@subject.title.count).to eq(3)
+    it "should support the count method to determine # of values" do
+      @subject.title.count.should == 3
     end
-    it 'should iterate over multiple values' do
-      expect(@subject.title).to respond_to(:each)
+    it "should iterate over multiple values" do
+      @subject.title.should respond_to(:each)
     end
-    it 'should get the first value' do
-      expect(@subject.title.first).to eq('title1')
+    it "should get the first value" do
+      @subject.title.first.should == "title1"
     end
-    it 'should evaluate equality predictably' do
-      expect(@subject.title).to eq(['title1', 'title2', 'title3'])
+    it "should evaluate equality predictably" do
+      @subject.title.should == ["title1", "title2", "title3"]
     end
-    it 'should support the empty? method' do
-      expect(@subject.title).to respond_to(:empty?)
-      expect(@subject.title.empty?).to be_falsey
-      @subject.title.delete('title1', 'title2', 'title3')
-      expect(@subject.title.empty?).to be_truthy
+    it "should support the empty? method" do
+      @subject.title.should respond_to(:empty?)
+      @subject.title.empty?.should be_false
+      @subject.title.delete("title1", "title2", "title3")
+      @subject.title.empty?.should be_true
     end
-    it 'should support the is_a? method' do
-      expect(@subject.title.is_a?(Array)).to eq(true)
+    it "should support the is_a? method" do
+      @subject.title.is_a?(Array).should == true
     end
   end
 end

data/spec/integration/om_datastream_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
-require 'solrizer'
+require "solrizer"
 
 describe ActiveFedora::OmDatastream do
-
-  describe 'a new instance with an inline datastream' do
-    before(:all) do
+  
+  describe "a new instance with an inline datastream" do
+    before(:all) do 
       class ModsArticle3 < ActiveFedora::Base
         # Uses the Hydra MODS Article profile for tracking most of the descriptive metadata
-        has_metadata 'descMetadata', type: Hydra::ModsArticleDatastream, control_group: 'X', autocreate: true
+        has_metadata :name => "descMetadata", :type => Hydra::ModsArticleDatastream, :control_group => 'X', :autocreate => true
       end
     end
 
@@ -25,38 +25,38 @@ describe ActiveFedora::OmDatastream do
       @obj.destroy
     end
 
-    it 'should report being inline' do
-      expect(@obj.descMetadata).to be_inline
+    it "should report being inline" do
+      @obj.descMetadata.should be_inline
     end
 
-    it 'should not be changed when no fields have been set' do
-      expect(@obj.descMetadata).not_to be_content_changed
+    it "should not be changed when no fields have been set" do
+      @obj.descMetadata.should_not be_content_changed
     end
-    it 'should be changed when a field has been set' do
+    it "should be changed when a field has been set" do
       @obj.descMetadata.title = 'Foobar'
-      expect(@obj.descMetadata).to be_content_changed
+      @obj.descMetadata.should be_content_changed
     end
-    describe '#changed?' do
-      it 'should not be changed if the new xml matches the old xml' do
+    describe "#changed?" do
+      it "should not be changed if the new xml matches the old xml" do
         @obj.descMetadata.content = @obj.descMetadata.content
-        expect(@obj.descMetadata).not_to be_changed
+        @obj.descMetadata.should_not be_changed
       end
 
-      it 'should not be changed if there are minor differences in whitespace' do
-        @obj.descMetadata.content = '<a><b>1</b></a>'
+      it "should not be changed if there are minor differences in whitespace" do
+        @obj.descMetadata.content = "<a><b>1</b></a>"
         @obj.save
-        expect(@obj.descMetadata).not_to be_changed
+        @obj.descMetadata.should_not be_changed
         @obj.descMetadata.content = "<a>\n<b>1</b>\n</a>"
-        expect(@obj.descMetadata).not_to be_changed
+        @obj.descMetadata.should_not be_changed
       end
     end
   end
 
-  describe 'an instance that is a managed datastream' do
+  describe "an instance that is a managed datastream" do
     before(:all) do
       class ModsArticle2 < ActiveFedora::Base
         # Uses the Hydra MODS Article profile for tracking most of the descriptive metadata
-        has_metadata 'descMetadata', type: Hydra::ModsArticleDatastream, autocreate: true
+        has_metadata :name => "descMetadata", :type => Hydra::ModsArticleDatastream, :autocreate => true
       end
     end
 
@@ -74,28 +74,28 @@ describe ActiveFedora::OmDatastream do
       @obj.destroy
     end
 
-    it 'should not report being inline' do
-      expect(@obj.descMetadata).to be_managed
+    it "should not report being inline" do
+      @obj.descMetadata.should be_managed
     end
 
-    describe '#changed?' do
-      it 'should not be changed if the new xml matches the old xml' do
+    describe "#changed?" do
+      it "should not be changed if the new xml matches the old xml" do
         @obj.descMetadata.content = @obj.descMetadata.content
-        expect(@obj.descMetadata).not_to be_changed
+        @obj.descMetadata.should_not be_changed
       end
 
-      it 'should be changed if there are minor differences in whitespace' do
-        @obj.descMetadata.content = '<a><b>1</b></a>'
+      it "should be changed if there are minor differences in whitespace" do
+        @obj.descMetadata.content = "<a><b>1</b></a>"
         @obj.save
-        expect(@obj.descMetadata).not_to be_changed
+        @obj.descMetadata.should_not be_changed
         @obj.descMetadata.content = "<a>\n<b>1</b>\n</a>"
-        expect(@obj.descMetadata).to be_changed
+        @obj.descMetadata.should be_changed
       end
     end
 
-    describe 'empty datastream content' do
-      it 'should not break when there is empty datastream content' do
-        @obj.descMetadata.content = ''
+    describe "empty datastream content" do
+      it "should not break when there is empty datastream content" do
+        @obj.descMetadata.content = ""
         @obj.save
       end
     end
@@ -108,35 +108,35 @@ describe ActiveFedora::OmDatastream do
         @solr_obj = ActiveFedora::Base.load_instance_from_solr(@obj.pid)
       end
 
-      it 'should return the same values whether getting from solr or Fedora' do
-        expect(@solr_obj.datastreams['descMetadata'].term_values(:name, :role, :text)).to eq(['Creator', 'Contributor', 'Funder', 'Host'])
-        expect(@solr_obj.datastreams['descMetadata'].term_values({:name => 0}, :role, :text)).to eq(['Creator'])
-        expect(@solr_obj.datastreams['descMetadata'].term_values({:name => 1}, :role, :text)).to eq(['Contributor'])
-        expect(@solr_obj.datastreams['descMetadata'].term_values({:name => 0}, {:role => 0}, :text)).to eq(['Creator'])
-        expect(@solr_obj.datastreams['descMetadata'].term_values({:name => 1}, {:role => 0}, :text)).to eq(['Contributor'])
-        expect(@solr_obj.datastreams['descMetadata'].term_values({:name => 1}, {:role => 1}, :text)).to eq([])
-        ar = @solr_obj.datastreams['descMetadata'].term_values(:name, {:role => 0}, :text)
-        expect(ar.length).to eq(4)
-        expect(ar.include?('Creator')).to eq(true)
-        expect(ar.include?('Contributor')).to eq(true)
-        expect(ar.include?('Funder')).to eq(true)
-        expect(ar.include?('Host')).to eq(true)
-
-        expect(@obj.datastreams['descMetadata'].term_values(:name, :role, :text)).to eq(['Creator', 'Contributor', 'Funder', 'Host'])
-        expect(@obj.datastreams['descMetadata'].term_values({:name => 0}, :role, :text)).to eq(['Creator'])
-        expect(@obj.datastreams['descMetadata'].term_values({:name => 1}, :role, :text)).to eq(['Contributor'])
-        expect(@obj.datastreams['descMetadata'].term_values({:name => 0}, {:role => 0}, :text)).to eq(['Creator'])
-        expect(@obj.datastreams['descMetadata'].term_values({:name => 1}, {:role => 0}, :text)).to eq(['Contributor'])
-        expect(@obj.datastreams['descMetadata'].term_values({:name => 1}, {:role => 1}, :text)).to eq([])
-        ar = @obj.datastreams['descMetadata'].term_values(:name, {:role => 0}, :text)
-        expect(ar.length).to eq(4)
-        expect(ar.include?('Creator')).to eq(true)
-        expect(ar.include?('Contributor')).to eq(true)
-        expect(ar.include?('Funder')).to eq(true)
-        expect(ar.include?('Host')).to eq(true)
+      it "should return the same values whether getting from solr or Fedora" do
+        @solr_obj.datastreams["descMetadata"].term_values(:name,:role,:text).should == ["Creator","Contributor","Funder","Host"]
+        @solr_obj.datastreams["descMetadata"].term_values({:name=>0},:role,:text).should == ["Creator"]
+        @solr_obj.datastreams["descMetadata"].term_values({:name=>1},:role,:text).should == ["Contributor"]
+        @solr_obj.datastreams["descMetadata"].term_values({:name=>0},{:role=>0},:text).should == ["Creator"]
+        @solr_obj.datastreams["descMetadata"].term_values({:name=>1},{:role=>0},:text).should == ["Contributor"]
+        @solr_obj.datastreams["descMetadata"].term_values({:name=>1},{:role=>1},:text).should == []
+        ar = @solr_obj.datastreams["descMetadata"].term_values(:name,{:role=>0},:text)
+        ar.length.should == 4
+        ar.include?("Creator").should == true
+        ar.include?("Contributor").should == true
+        ar.include?("Funder").should == true
+        ar.include?("Host").should == true
+
+        @obj.datastreams["descMetadata"].term_values(:name,:role,:text).should == ["Creator","Contributor","Funder","Host"]
+        @obj.datastreams["descMetadata"].term_values({:name=>0},:role,:text).should == ["Creator"]
+        @obj.datastreams["descMetadata"].term_values({:name=>1},:role,:text).should == ["Contributor"]
+        @obj.datastreams["descMetadata"].term_values({:name=>0},{:role=>0},:text).should == ["Creator"]
+        @obj.datastreams["descMetadata"].term_values({:name=>1},{:role=>0},:text).should == ["Contributor"]
+        @obj.datastreams["descMetadata"].term_values({:name=>1},{:role=>1},:text).should == []
+        ar = @obj.datastreams["descMetadata"].term_values(:name,{:role=>0},:text)
+        ar.length.should == 4
+        ar.include?("Creator").should == true
+        ar.include?("Contributor").should == true
+        ar.include?("Funder").should == true
+        ar.include?("Host").should == true
       end
     end
-
+    
     describe '.update_values' do
       before do
         @obj.descMetadata.content = File.read(fixture('mods_articles/mods_article1.xml'))
@@ -144,24 +144,24 @@ describe ActiveFedora::OmDatastream do
         @obj.reload
       end
 
-      it 'should not be dirty after .update_values is saved' do
-        @obj.datastreams['descMetadata'].update_values([{:name => 0}, {:role => 0}, :text] => 'Funder')
-        expect(@obj.datastreams['descMetadata']).to be_changed
+      it "should not be dirty after .update_values is saved" do
+        @obj.datastreams["descMetadata"].update_values([{:name=>0},{:role=>0},:text] =>"Funder")
+        @obj.datastreams["descMetadata"].should be_changed
         @obj.save
-        expect(@obj.datastreams['descMetadata']).not_to be_changed
-        expect(@obj.datastreams['descMetadata'].term_values({:name => 0}, {:role => 0}, :text)).to eq(['Funder'])
-      end
+        @obj.datastreams["descMetadata"].should_not be_changed
+        @obj.datastreams["descMetadata"].term_values({:name=>0},{:role=>0},:text).should == ["Funder"]
+      end    
     end
 
 
-    describe '.to_solr' do
+    describe ".to_solr" do
       before do
         @obj.descMetadata.journal.issue.publication_date = Date.parse('2012-11-02')
         @obj.save!
         @obj.reload
       end
       it "should solrize terms with :type=>'date' to *_dt solr terms" do
-        expect(@obj.to_solr[ActiveFedora::SolrService.solr_name('journal_issue_publication_date', type: :date)]).to eq(['2012-11-02T00:00:00Z'])
+        @obj.to_solr[ActiveFedora::SolrService.solr_name('journal_issue_publication_date', type: :date)].should == ['2012-11-02T00:00:00Z']
       end
     end
   end