active-fedora 8.7.0 → 9.0.0.beta1

data/spec/unit/has_many_association_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe ActiveFedora::Associations::HasManyAssociation do
+  before do
+    class Book < ActiveFedora::Base
+    end
+    class Page < ActiveFedora::Base
+    end
+  end
+
+  after do
+    Object.send(:remove_const, :Book)
+    Object.send(:remove_const, :Page)
+  end
+  let(:book) { Book.new('subject-a') }
+  let(:page) { Page.new('object-b') }
+
+  describe "setting the foreign key" do
+    before do
+      allow(book).to receive(:new_record?).and_return(false)
+      allow(page).to receive(:save).and_return(true)
+      allow(ActiveFedora::SolrService).to receive(:query).and_return([])
+    end
+
+    let(:reflection) { Book.create_reflection(:has_many, 'pages', { predicate: ActiveFedora::RDF::RelsExt.isPartOf }, Book) }
+    let(:association) { ActiveFedora::Associations::HasManyAssociation.new(book, reflection) }
+
+    it "should set the book_id attribute" do
+      expect(association).to receive(:callback).twice
+      expect(page).to receive(:[]=).with('book_id', book.id)
+      association.concat page
+    end
+  end
+
+  describe "Finding a polymorphic inverse relation" do
+
+    before do
+      # :books must come first, so that we can test that is being passed over in favor of :contents
+      Page.has_many :books, predicate: ActiveFedora::RDF::RelsExt.isPartOf, class_name: 'ActiveFedora::Base'
+      Page.has_and_belongs_to_many :contents, predicate: ActiveFedora::RDF::RelsExt.isPartOf, class_name: 'ActiveFedora::Base'
+    end
+    let(:book_reflection) { Book.create_reflection(:has_many, 'pages', { predicate: ActiveFedora::RDF::RelsExt.isPartOf }, Book) }
+    let(:association) { ActiveFedora::Associations::HasManyAssociation.new(book, book_reflection) }
+
+    subject { association.send(:find_polymorphic_inverse, page) }
+
+    it "should find the HABTM reflection" do
+      expect(subject.name).to eq :contents
+    end
+  end
+end

data/spec/unit/indexing_service_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe ActiveFedora::IndexingService do
+  let(:indexer) { described_class.new(object) }
+  let(:object) { ActiveFedora::Base.new }
+
+  subject { indexer.send(:solrize_relationships) }
+
+  describe "#solrize_relationships" do
+    let(:person_reflection) { double('person', foreign_key: 'person_id', kind_of?: true, solr_key: 'http://fedora.info/definitions/v4/rels-ext#isMemberOf_ssim') }
+    let(:location_reflection) { double('location', foreign_key: 'location_id', kind_of?: true, solr_key: 'http://fedora.info/definitions/v4/rels-ext#isPartOf_ssim') }
+    let(:reflections) { { 'person' => person_reflection, 'location' => location_reflection } }
+
+    it "should serialize the relationships into a Hash" do
+      expect(object).to receive(:[]).with('person_id').and_return('info:fedora/demo:10')
+      expect(object).to receive(:[]).with('location_id').and_return('info:fedora/demo:11')
+      expect(object.class).to receive(:reflections).and_return(reflections)
+      expect(subject[ActiveFedora::SolrService.solr_name("http://fedora.info/definitions/v4/rels-ext#isMemberOf", :symbol)]).to eq "info:fedora/demo:10"
+      expect(subject[ActiveFedora::SolrService.solr_name("http://fedora.info/definitions/v4/rels-ext#isPartOf", :symbol)]).to eq "info:fedora/demo:11"
+    end
+  end
+
+end

data/spec/unit/indexing_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe ActiveFedora::Indexing do
+  context "internal methods" do
+    before :all do
+      class SpecNode
+        include ActiveFedora::Indexing
+      end
+    end
+    after :all do
+      Object.send(:remove_const, :SpecNode)
+    end
+
+    subject { SpecNode.new }
+
+    describe "#create_needs_index?" do
+      subject { SpecNode.new.send(:create_needs_index?) }
+      it { should be true }
+    end
+
+    describe "#update_needs_index?" do
+      subject { SpecNode.new.send(:update_needs_index?) }
+      it { should be true }
+    end
+  end
+end

data/spec/unit/inheritance_spec.rb

@@ -1,15 +1,15 @@
 require 'spec_helper'
 
 describe ActiveFedora::Base do
-  before(:each) do
+  before do
     class Foo < ActiveFedora::Base
-      has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"foostream" do|m|
+      has_metadata "foostream", type: ActiveFedora::SimpleDatastream do |m|
         m.field "foostream", :string
       end
-      has_metadata :type=>ActiveFedora::QualifiedDublinCoreDatastream, :name=>"dcstream" 
+      has_metadata 'dcstream', type: ActiveFedora::QualifiedDublinCoreDatastream
     end
     class Bar  < ActiveFedora::Base
-      has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"barstream" do |m|
+      has_metadata 'barstream', type: ActiveFedora::SimpleDatastream do |m|
         m.field "barfield", :string
       end
     end
@@ -17,17 +17,16 @@ describe ActiveFedora::Base do
 
   it "doesn't overwrite stream specs" do
     f = Foo.new
-    expect(f.datastreams.size).to eq(3)
-    streams = f.datastreams.values.map{|x| x.class.to_s}.sort
-    expect(streams.pop).to eq("ActiveFedora::SimpleDatastream")
-    expect(streams.pop).to eq("ActiveFedora::RelsExtDatastream")
-    expect(streams.pop).to eq("ActiveFedora::QualifiedDublinCoreDatastream")
+    expect(f.attached_files.size).to eq 2
+    streams = f.attached_files.values.map{|x| x.class.to_s}.sort
+    expect(streams.pop).to eq "ActiveFedora::SimpleDatastream"
+    expect(streams.pop).to eq "ActiveFedora::QualifiedDublinCoreDatastream"
   end
 
   it "should work for multiple types" do
     b = Foo.new
     f = Bar.new
-    expect(b.class.ds_specs).not_to eq(f.class.ds_specs)
+    expect(b.class.ds_specs).to_not eq f.class.ds_specs
   end
   after do
     Object.send(:remove_const, :Bar)

data/spec/unit/model_spec.rb

@@ -7,7 +7,6 @@ describe ActiveFedora::Model do
       class Basic < ActiveFedora::Base
       end
     end
-    @model_query = "has_model_s:#{solr_uri("info:fedora/afmodel:SpecModel_Basic")}"
   end
   
   after(:all) do
@@ -15,44 +14,27 @@ describe ActiveFedora::Model do
   end
   
   describe '.solr_query_handler' do
+    subject { SpecModel::Basic.solr_query_handler }
     after do
       # reset to default
       SpecModel::Basic.solr_query_handler = 'standard'
     end
-    it "should have a default" do
-      expect(SpecModel::Basic.solr_query_handler).to eq('standard')
-    end
-    it "should be settable" do
-      SpecModel::Basic.solr_query_handler = 'search'
-      expect(SpecModel::Basic.solr_query_handler).to eq('search')
+
+    it { should eq 'standard' }
+
+    context "when setting to something besides the default" do
+      before { SpecModel::Basic.solr_query_handler = 'search' }
+
+      it { should eq 'search' }
     end
   end
-  
-  describe "URI translation" do
-    before :all do
-      module SpecModel
-        class CamelCased
-          include ActiveFedora::Model
-        end
-      end
-    end
-    
-    after :all do
-      SpecModel.send(:remove_const, :CamelCased)
-    end
-    subject {SpecModel::CamelCased}
-  
-    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:SpecModel_CamelCased')).to eq(['SpecModel::CamelCased', 'afmodel'])
-      end
-      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
-        expect(ActiveFedora::Model.classname_from_uri('info:fedora/afmodel:image')).to eq(['Image', 'afmodel'])
-      end
+
+  describe ".from_class_uri" do
+    subject { ActiveFedora::Model.from_class_uri(uri) }
+    context "a blank string" do
+      before { expect(ActiveFedora::Base.logger).to receive(:warn) }
+      let(:uri) { '' }
+      it { should be_nil }
     end
   end
-  
 end

data/spec/unit/nom_datastream_spec.rb

@@ -4,15 +4,18 @@ describe ActiveFedora::NomDatastream 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>'
+      MyNomDatastream.new
     }
+    before do
+      subject.content = '<root><a>123</a><b><c>asdf</c></b></root>'
+    end
 
     it "should work" do
       expect(subject.a).to include("123")
@@ -22,10 +25,6 @@ describe ActiveFedora::NomDatastream 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
-      expect(subject.controlGroup).to eq('M')
-    end
   end
 
   describe "with options for .set_terminology" do
@@ -41,7 +40,11 @@ describe ActiveFedora::NomDatastream do
         end
       end
 
-      TerminologyOptions.from_xml %(
+      TerminologyOptions.new
+    }
+
+    before do
+      subject.content = %(
         <root
           xmlns:dc="http://purl.org/dc/elements/1.1/"
           xmlns:dcterms="http://purl.org/dc/terms/"
@@ -51,10 +54,10 @@ describe ActiveFedora::NomDatastream do
           <dcterms:b>abcd</dcterms:b>
         </root>
       )
-    }
+    end
 
     it "should scope #a attribute to only the dc namespace" do
-      expect(subject.a).to eq(["123"])
+      expect(subject.a).to eq ["123"]
     end
 
   end

data/spec/unit/ntriples_datastream_spec.rb

@@ -4,103 +4,100 @@ describe ActiveFedora::NtriplesRDFDatastream do
   describe "an instance with content" do
     before do
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
-        property :created, predicate: RDF::DC.created
-        property :title, predicate: RDF::DC.title
-        property :publisher, predicate: RDF::DC.publisher
-        property :creator, predicate: RDF::DC.creator
-        property :educationLevel, predicate: RDF::DC.educationLevel
-        property :based_near, predicate: RDF::FOAF.based_near
-        property :related_url, predicate: RDF::RDFS.seeAlso
+        property :created, predicate: ::RDF::DC.created
+        property :title, predicate: ::RDF::DC.title
+        property :publisher, predicate: ::RDF::DC.publisher
+        property :creator, predicate: ::RDF::DC.creator
+        property :educationLevel, predicate: ::RDF::DC.educationLevel
+        property :based_near, predicate: ::RDF::FOAF.based_near
+        property :related_url, predicate: ::RDF::RDFS.seeAlso
       end
-      @subject = MyDatastream.new(double('inner object', pid: 'test:1', :new_record? => true), 'descMetadata')
+      @subject = MyDatastream.new(ActiveFedora::Base.id_to_uri '/test:1/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
-      expect(@subject.rdf_subject).to eq("info:fedora/test:1")
+      expect(@subject.rdf_subject).to eq "http://localhost:8983/fedora/rest/test/test:1"
     end
-    it "should have controlGroup" do
-      expect(@subject.controlGroup).to eq('M')
-    end
-    it "should have mimeType" do
-      expect(@subject.mimeType).to eq('application/n-triples')
-    end
-    it "should have dsid" do
-      expect(@subject.dsid).to eq('descMetadata')
+    it "should have mime_type" do
+      expect(@subject.mime_type).to eq 'text/plain'
     end
     it "should have fields" do
-      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/")
+      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
-      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"])
+      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}"}
-      expect(val).to eq(["0. Title of work"])
+      expect(val).to eq ["0. Title of work"]
     end
 
     it "should return fields that are not TermProxies" do
       expect(@subject.created).to be_kind_of Array
     end
     it "should have method missing" do
-      expect{@subject.frank}.to raise_exception NoMethodError
+      expect(lambda{@subject.frank}).to raise_exception NoMethodError
     end
 
     it "should set fields" do
       @subject.publisher = "St. Martin's Press"
-      expect(@subject.publisher).to eq(["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")
-      expect(@subject.creator).to eq(["Geoff Ryman"])
+      expect(@subject.creator).to eq ["Geoff Ryman"]
     end
     it "should append fields" do
       @subject.publisher << "St. Martin's Press"
-      expect(@subject.publisher).to eq(["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/"))
-      expect(@subject.related_url).to eq([])
+      expect(@subject.related_url).to eq []
     end
   end
 
   describe "some dummy instances" do
     before do
-      @one = ActiveFedora::RDFDatastream.new('fakepid', 'myFoobar')
-      @two = ActiveFedora::RDFDatastream.new('fakepid', 'myQuix')
+      @one = ActiveFedora::RDFDatastream.new
+      @two = ActiveFedora::RDFDatastream.new
     end
     it "should generate predictable prexies" do
-      expect(@one.apply_prefix("baz")).to eq('my_foobar__baz')
-      expect(@two.apply_prefix("baz")).to eq('my_quix__baz')
+      expect(@one.apply_prefix("baz", 'myFoobar')).to eq 'my_foobar__baz'
+      expect(@two.apply_prefix("baz", 'myQuix')).to eq 'my_quix__baz'
     end
   end
 
   describe "an instance with a custom subject" do
     before do
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
-        rdf_subject { |ds| "info:fedora/#{ds.pid}/content" }
-        property :created, predicate: RDF::DC.created
-        property :title, predicate: RDF::DC.title
-        property :publisher, predicate: RDF::DC.publisher
-        property :based_near, predicate: RDF::FOAF.based_near
-        property :related_url, predicate: RDF::RDFS.seeAlso
+        rdf_subject { |ds| "http://localhost:8983/fedora/rest/test/#{ds.id}/content" }
+        property :created, predicate: ::RDF::DC.created
+        property :title, predicate: ::RDF::DC.title
+        property :publisher, predicate: ::RDF::DC.publisher
+        property :based_near, predicate: ::RDF::FOAF.based_near
+        property :related_url, predicate: ::RDF::RDFS.seeAlso
       end
-      @inner_object = double('inner object', pid: 'test:1', :new_record? => true)
-      @subject = MyDatastream.new(@inner_object, 'mixed_rdf')
-      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
+      @subject = MyDatastream.new
+      allow(@subject).to receive(:id).and_return 'test:1'
+      allow(@subject).to receive(:new_record?).and_return false
+      allow(@subject).to receive(:remote_content).and_return remote_content
+    end
+
+    let(:remote_content) do
+      File.new('spec/fixtures/mixed_rdf_descMetadata.nt').read
     end
 
     after do
@@ -108,113 +105,95 @@ describe ActiveFedora::NtriplesRDFDatastream do
     end
 
     it "should have fields" do
-      expect(@subject.title).to eq(["Title of datastream"])
+      expect(@subject.title).to eq ["Title of datastream"]
     end
 
     it "should have a custom subject" do
-      expect(@subject.rdf_subject).to eq('info:fedora/test:1/content')
+      expect(@subject.rdf_subject).to eq 'http://localhost:8983/fedora/rest/test/test:1/content'
     end
   end
 
   describe "a new instance" do
     before(:each) do
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
-        property :publisher, predicate: RDF::DC.publisher
+        property :publisher, predicate: ::RDF::DC.publisher
       end
-      @subject = MyDatastream.new(@inner_object, 'mixed_rdf')
-      allow(@subject).to receive_messages(pid: 'test:1', repository: ActiveFedora::Base.connection_for_pid(0))
+      @subject = MyDatastream.new
     end
     after(:each) do
       Object.send(:remove_const, :MyDatastream)
     end
     it "should support to_s method" do
-      expect(@subject.publisher.to_s).to eq([].to_s)
+      expect(@subject.publisher.to_s).to eq [].to_s
       @subject.publisher = "Bob"
-      expect(@subject.publisher.to_s).to eq(["Bob"].to_s)
+      expect(@subject.publisher.to_s).to eq ["Bob"].to_s
       @subject.publisher << "Jim"
-      expect(@subject.publisher.to_s).to eq(["Bob", "Jim"].to_s)
+      expect(@subject.publisher.to_s).to eq ["Bob", "Jim"].to_s
     end
  end
 
   describe "solr integration" do
     before(:all) do
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
-        property :created, predicate: RDF::DC.created do |index|
+        property :created, predicate: ::RDF::DC.created do |index|
           index.as :sortable, :displayable
           index.type :date
         end
-        property :title, predicate: RDF::DC.title do |index|
+        property :title, predicate: ::RDF::DC.title do |index|
           index.as :stored_searchable, :sortable
           index.type :text
         end
-        property :publisher, predicate: RDF::DC.publisher do |index|
+        property :publisher, predicate: ::RDF::DC.publisher do |index|
           index.as :facetable, :sortable, :stored_searchable
         end
-        property :based_near, predicate: RDF::FOAF.based_near do |index|
+        property :based_near, predicate: ::RDF::FOAF.based_near do |index|
           index.as :facetable, :stored_searchable
           index.type :text
         end
-        property :related_url, predicate: RDF::RDFS.seeAlso do |index|
+        property :related_url, predicate: ::RDF::RDFS.seeAlso do |index|
           index.as :stored_searchable
         end
-        property :rights, predicate: RDF::DC.rights
+        property :rights, predicate: ::RDF::DC.rights
       end
-      @subject = MyDatastream.new(@inner_object, 'solr_rdf')
-      @subject.content = File.new('spec/fixtures/solr_rdf_descMetadata.nt').read
     end
+
     after(:all) do
       Object.send(:remove_const, :MyDatastream)
     end
+
     before(:each) do
-      allow(@subject).to receive_messages(pid: 'test:1')
+      @subject = MyDatastream.new
+      @subject.content = File.new('spec/fixtures/solr_rdf_descMetadata.nt').read
       @subject.serialize
     end
+
     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 have a solr_name method" do
-      expect(MyDatastream.new(nil, 'descMetadata').primary_solr_name(:based_near)).to eq 'desc_metadata__based_near_tesim'
-      expect(MyDatastream.new(nil, 'props').primary_solr_name(:title)).to eq 'props__title_tesim'
+      expect(MyDatastream.new.primary_solr_name(:based_near, 'descMetadata')).to eq 'desc_metadata__based_near_tesim'
+      expect(MyDatastream.new.primary_solr_name(:title, 'props')).to eq 'props__title_tesim'
     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
-      expect(@subject.to_solr(doc)).to eq(doc)
+      expect(@subject.to_solr(doc)).to eq doc
     end
-    it "should iterate through @fields hash" do
-      solr_doc = @subject.to_solr
-      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
       before(:each) do
         class Foo < ActiveFedora::Base
           has_metadata "descMetadata", type: MyDatastream
           has_attributes :created, :title, :publisher, :based_near, :related_url, :rights, datastream: :descMetadata, multiple: true
         end
-        @obj = MyDatastream.new(@inner_object, 'solr_rdf')
-        repository = double()
-          allow(@obj).to receive_messages(repository: repository, pid: 'test:1')
-          allow(repository).to receive(:modify_datastream)
-          allow(repository).to receive(:add_datastream)
+        @obj = MyDatastream.new
         @obj.created = Date.parse("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.rights = "Totally open, y'all"
-        @obj.save
       end
       after do
         Object.send(:remove_const, :Foo)
@@ -223,21 +202,23 @@ describe ActiveFedora::NtriplesRDFDatastream do
 
       describe ".fields()" do
         it "should return the right fields" do
-          expect(@obj.send(:fields).keys).to eq(["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)
-          expect(fields[:related_url][:values]).to eq(["http://example.org/blogtastic/"])
-          expect(fields[:based_near][:values]).to eq(["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)
-          expect(fields[:created][:type]).to eq(:date)
+          expect(fields[:created][:type]).to eq :date
         end
       end
+
       describe ".to_solr()" do
+        subject { @obj.to_solr({}, name: 'solrRdf') }
         it "should return the right fields" do
-          expect(@obj.to_solr.keys).to include(ActiveFedora::SolrService.solr_name("solr_rdf__related_url", type: :string),
+          expect(subject.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 +232,12 @@ describe ActiveFedora::NtriplesRDFDatastream do
         end
 
         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"])
+          expect(subject[ActiveFedora::SolrService.solr_name("solr_rdf__related_url", type: :string)]).to eq ["http://example.org/blogtastic/"]
+          expect(subject[ActiveFedora::SolrService.solr_name("solr_rdf__based_near", type: :string)]).to eq ["Tacoma, WA","Renton, WA"]
+          expect(subject[ActiveFedora::SolrService.solr_name("solr_rdf__based_near", :facetable)]).to eq ["Tacoma, WA","Renton, WA"]
+          expect(subject[ActiveFedora::SolrService.solr_name("solr_rdf__publisher", type: :string)]).to eq ["Bob's Blogtastic Publishing"]
+          expect(subject[ActiveFedora::SolrService.solr_name("solr_rdf__publisher", :sortable)]).to eq "Bob's Blogtastic Publishing"
+          expect(subject[ActiveFedora::SolrService.solr_name("solr_rdf__publisher", :facetable)]).to eq ["Bob's Blogtastic Publishing"]
         end
       end
     end