active-fedora 6.7.8 → 6.8.0

data/spec/unit/has_and_belongs_to_many_collection_spec.rb

@@ -1,45 +1,45 @@
 require 'spec_helper'
 
 describe ActiveFedora::Associations::HasAndBelongsToManyAssociation do
-  it "should call add_relationship" do
-    subject = double("subject", :new_record? => false, :pid => 'subject:a', :internal_uri => 'info:fedora/subject:a', :ids_for_outbound => [])
-    predicate = double(:klass => double.class, :options=>{:property=>'predicate'}, :class_name=> nil)
-    ActiveFedora::SolrService.stub(:query).and_return([])
+  it 'should call add_relationship' do
+    subject = double('subject', :new_record? => false, :pid => 'subject:a', :internal_uri => 'info:fedora/subject:a', :ids_for_outbound => [])
+    predicate = double(:klass => double.class, :options => {:property => 'predicate'}, :class_name => nil)
+    allow(ActiveFedora::SolrService).to receive(:query).and_return([])
     ac = ActiveFedora::Associations::HasAndBelongsToManyAssociation.new(subject, predicate)
-    object = double("object", :new_record? => false, :pid => 'object:b', :save => nil)
-  
-    subject.should_receive(:add_relationship).with('predicate', object)
- 
+    object = double('object', :new_record? => false, :pid => 'object:b', :save => nil)
+
+    expect(subject).to receive(:add_relationship).with('predicate', object)
+
     ac << object
 
   end
 
-  it "should call add_relationship on subject and object when inverse_of given" do
-    subject = double("subject", :new_record? => false, :pid => 'subject:a', :internal_uri => 'info:fedora/subject:a', :ids_for_outbound => [])
-    predicate = double(:klass => double.class, :options=>{:property=>'predicate', :inverse_of => 'inverse_predicate'}, :class_name=> nil)
-    ActiveFedora::SolrService.stub(:query).and_return([])
+  it 'should call add_relationship on subject and object when inverse_of given' do
+    subject = double('subject', :new_record? => false, :pid => 'subject:a', :internal_uri => 'info:fedora/subject:a', :ids_for_outbound => [])
+    predicate = double(:klass => double.class, :options => {:property => 'predicate', :inverse_of => 'inverse_predicate'}, :class_name => nil)
+    allow(ActiveFedora::SolrService).to receive(:query).and_return([])
     ac = ActiveFedora::Associations::HasAndBelongsToManyAssociation.new(subject, predicate)
-    object = double("object", :new_record? => false, :pid => 'object:b', :save => nil)
-  
-    subject.should_receive(:add_relationship).with('predicate', object)
- 
-    object.should_receive(:add_relationship).with('inverse_predicate', subject)
- 
+    object = double('object', :new_record? => false, :pid => 'object:b', :save => nil)
+
+    expect(subject).to receive(:add_relationship).with('predicate', object)
+
+    expect(object).to receive(:add_relationship).with('inverse_predicate', subject)
+
     ac << object
 
   end
 
-  it "should call solr query multiple times" do
+  it 'should call solr query multiple times' do
 
-    subject = double("subject", :new_record? => false, :pid => 'subject:a', :internal_uri => 'info:fedora/subject:a', :ids_for_outbound => [])
-    predicate = double(:klass => double.class, :options=>{:property=>'predicate', solr_page_size:10}, :class_name=> nil)
+    subject = double('subject', :new_record? => false, :pid => 'subject:a', :internal_uri => 'info:fedora/subject:a', :ids_for_outbound => [])
+    predicate = double(:klass => double.class, :options => {:property => 'predicate', solr_page_size: 10}, :class_name => 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([])
+    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 ')
+    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

data/spec/unit/has_many_collection_spec.rb

@@ -1,17 +1,17 @@
 require 'spec_helper'
 
 describe ActiveFedora::Associations::HasManyAssociation do
-  it "should call add_relationship" do
-    subject = double("subject", :new_record? => false, :pid => 'subject:a', :internal_uri => 'info:fedora/subject:a')
-    predicate = double(:klass => double.class, :options=>{:property=>'predicate'}, :class_name=> nil)
-    ActiveFedora::SolrService.stub(:query).and_return([])
+  it 'should call add_relationship' do
+    subject = double('subject', :new_record? => false, :pid => 'subject:a', :internal_uri => 'info:fedora/subject:a')
+    predicate = double(:klass => double.class, :options => {:property => 'predicate'}, :class_name => nil)
+    allow(ActiveFedora::SolrService).to receive(:query).and_return([])
     ac = ActiveFedora::Associations::HasManyAssociation.new(subject, predicate)
-    object = double("object", :new_record? => false, :pid => 'object:b', :save => nil)
-  
-    object.should_receive(:add_relationship).with('predicate', subject)
- 
+    object = double('object', :new_record? => false, :pid => 'object:b', :save => nil)
+
+    expect(object).to receive(:add_relationship).with('predicate', subject)
+
     ac << object
 
   end
-  
+
 end

data/spec/unit/inheritance_spec.rb

@@ -3,31 +3,31 @@ require 'spec_helper'
 describe ActiveFedora::Base do
   before(:each) do
     class Foo < ActiveFedora::Base
-      has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"foostream" do|m|
-        m.field "foostream", :string
+      has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'foostream' do|m|
+        m.field 'foostream', :string
       end
-      has_metadata :type=>ActiveFedora::QualifiedDublinCoreDatastream, :name=>"dcstream" 
+      has_metadata :type => ActiveFedora::QualifiedDublinCoreDatastream, :name => 'dcstream'
     end
-    class Bar  < ActiveFedora::Base
-      has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"barstream" do |m|
-        m.field "barfield", :string
+    class Bar < ActiveFedora::Base
+      has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'barstream' do |m|
+        m.field 'barfield', :string
       end
     end
   end
 
   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
+  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)
@@ -35,4 +35,3 @@ describe ActiveFedora::Base do
   end
 
 end
-  

data/spec/unit/model_spec.rb

@@ -1,74 +1,64 @@
 require 'spec_helper'
 
-describe ActiveFedora::Model do
-  
-  before(:all) do
-    module SpecModel
-      class Basic < ActiveFedora::Base
-      end
-    end
-    @model_query = "has_model_s:#{solr_uri("info:fedora/afmodel:SpecModel_Basic")}"
+module SpecModelM
+  class Basic < ActiveFedora::Base
   end
-  
-  after(:all) do
-    Object.send(:remove_const, :SpecModel)
+  class CamelCased
+    include ActiveFedora::Model
+    def name
+      self.class.to_s
+    end
   end
-  
+end
+
+describe ActiveFedora::Model do
+
   describe '.solr_query_handler' do
     after do
-      # reset to default
-      SpecModel::Basic.solr_query_handler = 'standard'
+      SpecModelM::Basic.solr_query_handler = 'standard' # reset to default
     end
-    it "should have a default" do
-      SpecModel::Basic.solr_query_handler.should == 'standard'
+    it 'should have a default' do
+      expect(SpecModelM::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'
+    it 'should be settable' do
+      SpecModelM::Basic.solr_query_handler = 'search'
+      expect(SpecModelM::Basic.solr_query_handler).to eq('search')
     end
   end
-  
-  describe "URI translation" do
-    before :all do
-      module SpecModel
-        class CamelCased
-          include ActiveFedora::Model
-        end
-      end
 
+  describe 'URI translation' do
+    before :each do
+      @camel = SpecModelM::CamelCased.new
     end
-    
-    after :all do
-      SpecModel.send(:remove_const, :CamelCased)
+    it '#to_class_uri' do
+      expect(@camel.to_class_uri).to eq 'info:fedora/afmodel:SpecModelM_CamelCased'
     end
-    subject {SpecModel::CamelCased}
-    
-    its(:to_class_uri) {should == 'info:fedora/afmodel:SpecModel_CamelCased' }
-  
-    context "with the namespace declared in the model" do
-      before do
-        subject.stub(:pid_namespace).and_return("test-cModel")
+
+    context 'with the namespace declared in the model' do
+      it '#to_class_uri' do
+        expect(@camel).to receive(:pid_namespace).and_return('test-cModel')
+        expect(@camel.to_class_uri).to eq 'info:fedora/test-cModel:SpecModelM_CamelCased'
       end
-      its(:to_class_uri) {should == 'info:fedora/test-cModel:SpecModel_CamelCased' }
     end
-    context "with the suffix declared in the model" do
-      before do
-        subject.stub(:pid_suffix).and_return("-TEST-SUFFIX")
+
+    context 'with the suffix declared in the model' do
+      it '#to_class_uri' do
+        expect(@camel).to receive(:pid_suffix).and_return('-TEST-SUFFIX')
+        expect(@camel.to_class_uri).to eq 'info:fedora/afmodel:SpecModelM_CamelCased-TEST-SUFFIX'
       end
-      its(:to_class_uri) {should == 'info:fedora/afmodel:SpecModel_CamelCased-TEST-SUFFIX' }
     end
-  
-    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']
+
+    describe '.classname_from_uri' do
+      it 'should turn an afmodel URI into a Model class name' do
+        expect(ActiveFedora::Model.classname_from_uri('info:fedora/afmodel:SpecModelM_CamelCased')).to eq(['SpecModelM::CamelCased', 'afmodel'])
       end
-      it "should not change plurality" do
-        ActiveFedora::Model.classname_from_uri('info:fedora/afmodel:MyMetadata').should == ['MyMetadata', 'afmodel']
+      it 'should not change plurality' do
+        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']
+      it 'should capitalize the first letter' do
+        expect(ActiveFedora::Model.classname_from_uri('info:fedora/afmodel:image')).to eq(['Image', 'afmodel'])
       end
     end
   end
-  
+
 end

data/spec/unit/nom_datastream_spec.rb

@@ -1,40 +1,40 @@
 require 'spec_helper'
 
 describe ActiveFedora::NomDatastream do
-  describe "test" do
+  describe 'test' do
     subject {
       class MyNomDatastream < ActiveFedora::NomDatastream
-       
+
         set_terminology do |t|
           t.a :path => '//a', :accessor => lambda { |x| x.text }, :index => 'a_s'
           t.b :path => '//b', :index => 'b_s'
         end
-      end 
+      end
 
       MyNomDatastream.from_xml '<root><a>123</a><b><c>asdf</c></b></root>'
     }
 
-    it "should work" do
-      subject.a.should include("123")
+    it 'should work' do
+      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')
+    it 'should to_solr' do
+      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'
+    it 'should be a managed datastream' do
+      expect(subject.controlGroup).to eq('M')
     end
   end
 
-  describe "with options for .set_terminology" do
+  describe 'with options for .set_terminology' do
     subject {
       class TerminologyOptions < ActiveFedora::NomDatastream
         set_terminology({
           :namespaces => {
-            'dc' => "http://purl.org/dc/elements/1.1/",
-            'dcterms' => "http://purl.org/dc/terms/"
+            'dc' => 'http://purl.org/dc/elements/1.1/',
+            'dcterms' => 'http://purl.org/dc/terms/'
           }
         }) do |t|
           t.a :path => 'a', :xmlns => 'dc', :accessor => lambda { |x| x.text }
@@ -53,8 +53,8 @@ describe ActiveFedora::NomDatastream do
       )
     }
 
-    it "should scope #a attribute to only the dc namespace" do
-      subject.a.should == ["123"]
+    it 'should scope #a attribute to only the dc namespace' do
+      expect(subject.a).to eq(['123'])
     end
 
   end

data/spec/unit/ntriples_datastream_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe ActiveFedora::NtriplesRDFDatastream do
-  describe "an instance with content" do
-    before do 
+  describe 'an instance with content' do
+    before do
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
         map_predicates do |map|
           map.created(:in => RDF::DC)
@@ -11,84 +11,84 @@ describe ActiveFedora::NtriplesRDFDatastream do
           map.creator(:in => RDF::DC)
           map.educationLevel(:in => RDF::DC)
           map.based_near(:in => RDF::FOAF)
-          map.related_url(:to => "seeAlso", :in => RDF::RDFS)
+          map.related_url(:to => 'seeAlso', :in => RDF::RDFS)
         end
       end
-      @subject = MyDatastream.new(double('inner object', :pid=>'test:1', :new_record? =>true), 'descMetadata')
+      @subject = MyDatastream.new(double('inner object', :pid => 'test:1', :new_record? => true), 'descMetadata')
       @subject.content = File.new('spec/fixtures/mixed_rdf_descMetadata.nt').read
     end
     after do
       Object.send(:remove_const, :MyDatastream)
     end
-    it "should have a subject" do
-      @subject.rdf_subject.should == "info:fedora/test:1"
+    it 'should have a subject' do
+      expect(@subject.rdf_subject).to eq('info:fedora/test:1')
     end
-    it "should have controlGroup" do
-      @subject.controlGroup.should == 'M'
+    it 'should have controlGroup' do
+      expect(@subject.controlGroup).to eq('M')
     end
-    it "should have mimeType" do
-      @subject.mimeType.should == 'text/plain'
+    it 'should have mimeType' do
+      expect(@subject.mimeType).to eq('text/plain')
     end
-    it "should have dsid" do
-      @subject.dsid.should == 'descMetadata'
+    it 'should have dsid' do
+      expect(@subject.dsid).to eq('descMetadata')
     end
-    it "should have fields" do
-      @subject.created.should == ["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.should == ["http://google.com/"]
+    it 'should have fields' do
+      expect(@subject.created).to eq(['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).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"]
+    it 'should be able to call enumerable methods on the fields' do
+      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
+    it 'should return fields that are not TermProxies' do
+      expect(@subject.created).to be_kind_of Array
     end
-    it "should have method missing" do
-      lambda{@subject.frank}.should raise_exception NoMethodError
+    it 'should have method missing' do
+      expect{@subject.frank}.to raise_exception NoMethodError
     end
 
-    it "should set fields" do
+    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"]
+    it 'should set rdf literal fields' do
+      @subject.creator = RDF.Literal('Geoff Ryman')
+      expect(@subject.creator).to eq(['Geoff Ryman'])
     end
-    it "should append fields" do
+    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 == []
+    it 'should delete fields' do
+      @subject.related_url.delete(RDF::URI('http://google.com/'))
+      expect(@subject.related_url).to eq([])
     end
   end
 
-  describe "some dummy instances" do
+  describe 'some dummy instances' do
     before do
       @one = ActiveFedora::RDFDatastream.new('fakepid', 'myFoobar')
       @two = ActiveFedora::RDFDatastream.new('fakepid', 'myQuix')
     end
-    it "should generate predictable prexies" do
-      @one .prefix("baz").should == :my_foobar__baz
-      @two.prefix("baz").should == :my_quix__baz
+    it 'should generate predictable prexies' do
+      expect(@one .prefix('baz')).to eq(:my_foobar__baz)
+      expect(@two.prefix('baz')).to eq(:my_quix__baz)
     end
   end
 
-  describe "an instance with a custom subject" do
-    before do 
+  describe 'an instance with a custom subject' do
+    before do
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
         rdf_subject { |ds| "info:fedora/#{ds.pid}/content" }
         map_predicates do |map|
@@ -96,7 +96,7 @@ describe ActiveFedora::NtriplesRDFDatastream do
           map.title(:in => RDF::DC)
           map.publisher(:in => RDF::DC)
           map.based_near(:in => RDF::FOAF)
-          map.related_url(:to => "seeAlso", :in => RDF::RDFS)
+          map.related_url(:to => 'seeAlso', :in => RDF::RDFS)
         end
       end
       @subject = MyDatastream.new(@inner_object, 'mixed_rdf')
@@ -109,16 +109,16 @@ describe ActiveFedora::NtriplesRDFDatastream do
       Object.send(:remove_const, :MyDatastream)
     end
 
-    it "should have fields" do
-      @subject.title.should == ["Title of datastream"]
+    it 'should have fields' do
+      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'
+    it 'should have a custom subject' do
+      expect(@subject.rdf_subject).to eq('info:fedora/test:1/content')
     end
   end
 
-  describe "a new instance" do
+  describe 'a new instance' do
     before(:each) do
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
         map_predicates do |map|
@@ -131,35 +131,35 @@ describe ActiveFedora::NtriplesRDFDatastream do
     after(:each) do
       Object.send(:remove_const, :MyDatastream)
     end
-    it "should support to_s method" do
-      @subject.publisher.to_s.should == [].to_s
-      @subject.publisher = "Bob"
-      @subject.publisher.to_s.should == ["Bob"].to_s
-      @subject.publisher << "Jim"
-      @subject.publisher.to_s.should == ["Bob", "Jim"].to_s
+    it 'should support to_s method' do
+      expect(@subject.publisher.to_s).to eq([].to_s)
+      @subject.publisher = 'Bob'
+      expect(@subject.publisher.to_s).to eq(['Bob'].to_s)
+      @subject.publisher << 'Jim'
+      expect(@subject.publisher.to_s).to eq(['Bob', 'Jim'].to_s)
     end
  end
 
-  describe "solr integration" do
+  describe 'solr integration' do
     before(:all) do
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
         map_predicates do |map|
-          map.created(:in => RDF::DC) do |index| 
+          map.created(:in => RDF::DC) do |index|
             index.as :sortable, :displayable
             index.type :date
           end
           map.title(:in => RDF::DC) do |index|
             index.as :stored_searchable, :sortable
-            index.type :text 
+            index.type :text
           end
-          map.publisher(:in => RDF::DC) do |index| 
+          map.publisher(:in => RDF::DC) do |index|
             index.as :facetable, :sortable, :stored_searchable
           end
           map.based_near(:in => RDF::FOAF) do |index|
-            index.as :facetable, :stored_searchable 
+            index.as :facetable, :stored_searchable
             index.type :text
           end
-          map.related_url(:to => "seeAlso", :in => RDF::RDFS) do |index|
+          map.related_url(:to => 'seeAlso', :in => RDF::RDFS) do |index|
             index.as :stored_searchable
           end
           map.rights(:in => RDF::DC)
@@ -171,35 +171,35 @@ describe ActiveFedora::NtriplesRDFDatastream do
     after(:all) do
       Object.send(:remove_const, :MyDatastream)
     end
-    before(:each) do  
+    before(:each) do
       @subject.stub(:pid => 'test:1')
     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)
+    it 'should provide .to_solr and return a SolrDocument' do
+      expect(@subject).to respond_to(:to_solr)
+      expect(@subject.to_solr).to be_kind_of(Hash)
     end
-    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
+    it 'should optionally allow you to provide the Solr::Document to add fields to and return that document when done' do
+      doc = {}
+      expect(@subject.to_solr(doc)).to eq(doc)
     end
-    it "should iterate through @fields hash" do
+    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
+    describe 'with an actual object' do
       before(:each) do
         class Foo < ActiveFedora::Base
-          has_metadata :name => "descMetadata", :type => MyDatastream
+          has_metadata :name => 'descMetadata', :type => MyDatastream
           delegate :created, :to => :descMetadata, multiple: true
           delegate :title, :to => :descMetadata, multiple: true
           delegate :publisher, :to => :descMetadata, multiple: true
@@ -210,49 +210,49 @@ describe ActiveFedora::NtriplesRDFDatastream do
         @obj = MyDatastream.new(@inner_object, 'solr_rdf')
         repository = double()
           @obj.stub(:repository => repository, :pid => 'test:1')
-          repository.stub(:modify_datastream)
-          repository.stub(:add_datastream)
-        @obj.created = "2012-03-04"
-        @obj.title = "Of Mice and Men, The Sequel"
+          allow(repository).to receive(:modify_datastream)
+          allow(repository).to receive(:add_datastream)
+        @obj.created = '2012-03-04'
+        @obj.title = 'Of Mice and Men, The Sequel'
         @obj.publisher = "Bob's Blogtastic Publishing"
-        @obj.based_near = ["Tacoma, WA", "Renton, WA"]
-        @obj.related_url = "http://example.org/blogtastic/"
+        @obj.based_near = ['Tacoma, WA', 'Renton, WA']
+        @obj.related_url = 'http://example.org/blogtastic/'
         @obj.rights = "Totally open, y'all"
         @obj.save
       end
 
-      describe ".fields()" do
-        it "should return the right fields" do
-          @obj.send(:fields).keys.should == ["created", "title", "publisher", "based_near", "related_url"]
+      describe '.fields()' do
+        it 'should return the right fields' do
+          expect(@obj.send(:fields).keys).to eq(['created', 'title', 'publisher', 'based_near', 'related_url'])
         end
-        it "should return the right values" do
+        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
+        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),
-                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), 
-                ActiveFedora::SolrService.solr_name("solr_rdf__created", :sortable, type: :date),
-                ActiveFedora::SolrService.solr_name("solr_rdf__created", :displayable), 
-                ActiveFedora::SolrService.solr_name("solr_rdf__title", type: :string),
-                ActiveFedora::SolrService.solr_name("solr_rdf__title", :sortable),
-                ActiveFedora::SolrService.solr_name("solr_rdf__based_near", type: :string),
-                ActiveFedora::SolrService.solr_name("solr_rdf__based_near", :facetable))
+      describe '.to_solr()' do
+        it 'should return the right fields' do
+          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),
+                ActiveFedora::SolrService.solr_name('solr_rdf__created', :sortable, type: :date),
+                ActiveFedora::SolrService.solr_name('solr_rdf__created', :displayable),
+                ActiveFedora::SolrService.solr_name('solr_rdf__title', type: :string),
+                ActiveFedora::SolrService.solr_name('solr_rdf__title', :sortable),
+                ActiveFedora::SolrService.solr_name('solr_rdf__based_near', type: :string),
+                ActiveFedora::SolrService.solr_name('solr_rdf__based_near', :facetable))
 
         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"]
+        it 'should return the right values' do
+          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