active-fedora 9.0.0.beta2 → 9.0.0.beta3

data/spec/integration/base_spec.rb

@@ -21,7 +21,7 @@ describe "A base object with metadata" do
       obj = ActiveFedora::Base.find(@obj.id)
       expect(obj.foo).to_not be_new_record
       expect(obj.foo.person).to eq ['bob']
-      person_field = ActiveFedora::SolrService.solr_name('foo__person', type: :string)
+      person_field = ActiveFedora::SolrQueryBuilder.solr_name('foo__person', type: :string)
       solr_result = ActiveFedora::SolrService.query("{!raw f=id}#{@obj.id}", :fl=>"id #{person_field}").first
       expect(solr_result).to eq("id"=>@obj.id, person_field =>['bob'])
     end
@@ -40,7 +40,7 @@ describe "A base object with metadata" do
       end
       it "should save the datastream." do
         expect(MockAFBaseRelationship.find(@release.id).foo.person).to eq ['frank']
-        person_field = ActiveFedora::SolrService.solr_name('foo__person', type: :string)
+        person_field = ActiveFedora::SolrQueryBuilder.solr_name('foo__person', type: :string)
         expect(ActiveFedora::SolrService.query("id:\"#{@release.id}\"", :fl=>"id #{person_field}").first).to eq("id"=>@release.id, person_field =>['frank'])
       end
     end

data/spec/integration/collection_association_spec.rb

@@ -55,4 +55,13 @@ describe ActiveFedora::Base do
       end
     end
   end
+
+  # TODO: Bug described in issue #609
+  describe "#select" do
+    it "should choose a subset of objects in the relationship" do
+      pending "method has private visibility"
+      expect(library.books.select([:id])).to include(book1.id)
+    end
+  end
+
 end

data/spec/integration/file_spec.rb

@@ -12,6 +12,36 @@ describe ActiveFedora::File do
     end
   end
 
+  context "stand alone operation with UploadedFile" do
+    before(:all) do
+      module ActionDispatch
+        module Http
+          class UploadedFile
+
+            def initialize
+              @content = StringIO.new("hello world")
+            end
+
+            def read(a, b)
+              return @content.read(a, b)
+            end
+            
+            def size
+              @content.length
+            end
+
+          end
+        end
+      end
+    end
+
+    it "should save" do
+      subject.content = ActionDispatch::Http::UploadedFile.new
+      subject.save
+      expect(subject).not_to be_new_record
+    end
+  end
+
   context "when autocreate is true" do
     before(:all) do
       class MockAFBase < ActiveFedora::Base

data/spec/integration/full_featured_model_spec.rb

@@ -142,7 +142,7 @@ describe ActiveFedora::Base do
     @properties_sample_values.each_pair do |field, value|
       next if field == :hard_copy_availability #FIXME HYDRA-824
       next if field == :location #FIXME HYDRA-825
-      expect((@solr_result[ActiveFedora::SolrService.solr_name(field, type: :string)] || @solr_result[ActiveFedora::SolrService.solr_name(field, type: :date)])).to eq [::Solrizer::Extractor.format_node_value(value)]
+      expect((@solr_result[ActiveFedora::SolrQueryBuilder.solr_name(field, type: :string)] || @solr_result[ActiveFedora::SolrQueryBuilder.solr_name(field, type: :date)])).to eq [::Solrizer::Extractor.format_node_value(value)]
     end
 
     @dublin_core_sample_values.each_pair do |field, value|

data/spec/integration/ntriples_datastream_spec.rb

@@ -78,21 +78,21 @@ describe ActiveFedora::NtriplesRDFDatastream 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']
+      expect(solr_document[ActiveFedora::SolrQueryBuilder.solr_name('rdf__date_uploaded', type: :date)]).to eq ['2012-11-02T00:00:00Z']
     end
     it "should handle integers" do
-      subject.filesize = 12345 
+      subject.filesize = 12345
       expect(subject.filesize).to be_kind_of Fixnum
       solr_document = subject.to_solr
-      expect(solr_document[ActiveFedora::SolrService.solr_name('rdf__filesize', :stored_sortable, type: :integer)]).to eq '12345'
+      expect(solr_document[ActiveFedora::SolrQueryBuilder.solr_name('rdf__filesize', :stored_sortable, type: :integer)]).to eq '12345'
     end
   end
 
   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"]
+    expect(solr_document[ActiveFedora::SolrQueryBuilder.solr_name('rdf__title', :facetable)]).to eq ["War and Peace"]
+    expect(solr_document[ActiveFedora::SolrQueryBuilder.solr_name('rdf__title', type: :string)]).to eq ["War and Peace"]
   end
 
   it "should set and recall values" do

data/spec/integration/om_datastream_spec.rb

@@ -73,7 +73,7 @@ describe ActiveFedora::OmDatastream do
       obj.reload
     end
     it "should solrize terms with :type=>'date' to *_dt solr terms" do
-      expect(obj.to_solr[ActiveFedora::SolrService.solr_name('desc_metadata__journal_issue_publication_date', type: :date)]).to eq ['2012-11-02T00:00:00Z']
+      expect(obj.to_solr[ActiveFedora::SolrQueryBuilder.solr_name('desc_metadata__journal_issue_publication_date', type: :date)]).to eq ['2012-11-02T00:00:00Z']
     end
   end
 end

data/spec/integration/{solr_service_spec.rb → query_result_builder_spec.rb}

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
-describe ActiveFedora::SolrService do
+describe ActiveFedora::QueryResultBuilder do
   describe "#reify_solr_results" do
     before(:each) do
       class FooObject < ActiveFedora::Base
         def self.id_namespace
           "foo"
         end
-  
+
         has_metadata :name => "descMetadata", :type => ActiveFedora::QualifiedDublinCoreDatastream
       end
       @test_object = ActiveFedora::Base.new
@@ -27,24 +27,22 @@ describe ActiveFedora::SolrService do
       @foo_content = @foo_object.attached_files['descMetadata'].content
     end
     after(:each) do
-      @test_object.delete
-      @foo_object.delete
       Object.send(:remove_const, :FooObject)
     end
     it "should return an array of objects that are of the class stored in active_fedora_model_s" do
       query = "id\:#{RSolr.escape(@test_object.id)} OR id\:#{RSolr.escape(@foo_object.id)}"
       solr_result = ActiveFedora::SolrService.query(query)
-      result = ActiveFedora::SolrService.reify_solr_results(solr_result)
+      result = ActiveFedora::QueryResultBuilder.reify_solr_results(solr_result)
       expect(result.length).to eq 2
       result.each do |r|
         expect((r.class == ActiveFedora::Base || r.class == FooObject)).to be true
       end
     end
-    
+
     it 'should #reify a lightweight object as a new instance' do
       query = "id\:#{RSolr.escape(@foo_object.id)}"
       solr_result = ActiveFedora::SolrService.query(query)
-      result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
+      result = ActiveFedora::QueryResultBuilder.reify_solr_results(solr_result,{:load_from_solr=>true})
       expect(result.first).to be_instance_of FooObject
     end
   end

data/spec/integration/relation_delegation_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe ActiveFedora::Model do
-  
-  before(:all) do 
+
+  before(:all) do
     module ModelIntegrationSpec
       class Basic < ActiveFedora::Base
         has_metadata :name => "properties", :type => ActiveFedora::SimpleDatastream do |m|
@@ -15,7 +15,7 @@ describe ActiveFedora::Model do
 
         def to_solr(doc = {})
           doc = super
-          doc[ActiveFedora::SolrService.solr_name('foo', :sortable)] = doc[ActiveFedora::SolrService.solr_name('foo', type: :string)]
+          doc[ActiveFedora::SolrQueryBuilder.solr_name('foo', :sortable)] = doc[ActiveFedora::SolrQueryBuilder.solr_name('foo', type: :string)]
           doc
         end
       end

data/spec/integration/scoped_query_spec.rb

@@ -15,7 +15,7 @@ describe "scoped queries" do
 
         def to_solr(doc = {})
           doc = super
-          doc[ActiveFedora::SolrService.solr_name('foo', :sortable)] = doc[ActiveFedora::SolrService.solr_name('foo', type: :string)]
+          doc[ActiveFedora::SolrQueryBuilder.solr_name('foo', :sortable)] = doc[ActiveFedora::SolrQueryBuilder.solr_name('foo', type: :string)]
           doc
         end
 
@@ -66,12 +66,12 @@ describe "scoped queries" do
       end
 
       it "should query" do
-        field = ActiveFedora::SolrService.solr_name('foo', type: :string)
+        field = ActiveFedora::SolrQueryBuilder.solr_name('foo', type: :string)
         expect(ModelIntegrationSpec::Basic.where(field => 'Beta')).to eq [test_instance1]
         expect(ModelIntegrationSpec::Basic.where('foo' => 'Beta')).to eq [test_instance1]
       end
       it "should order" do
-        expect(ModelIntegrationSpec::Basic.order(ActiveFedora::SolrService.solr_name('foo', :sortable) + ' asc')).to eq [test_instance2, test_instance1, test_instance3]
+        expect(ModelIntegrationSpec::Basic.order(ActiveFedora::SolrQueryBuilder.solr_name('foo', :sortable) + ' asc')).to eq [test_instance2, test_instance1, test_instance3]
       end
       it "should limit" do
         expect(ModelIntegrationSpec::Basic.limit(1)).to eq [test_instance1]
@@ -81,7 +81,7 @@ describe "scoped queries" do
       end
 
       it "should chain queries" do
-        expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').order(ActiveFedora::SolrService.solr_name('foo', :sortable) + ' asc').limit(1)).to eq [test_instance2]
+        expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrQueryBuilder.solr_name('bar', type: :string) => 'Peanuts').order(ActiveFedora::SolrQueryBuilder.solr_name('foo', :sortable) + ' asc').limit(1)).to eq [test_instance2]
       end
 
       it "should wrap string conditions with parentheses" do
@@ -89,26 +89,26 @@ describe "scoped queries" do
       end
 
       it "should chain where queries" do
-        expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').where("#{ActiveFedora::SolrService.solr_name('foo', type: :string)}:bar").where_values).to eq ["#{ActiveFedora::SolrService.solr_name('bar', type: :string)}:Peanuts", "(#{ActiveFedora::SolrService.solr_name('foo', type: :string)}:bar)"]
+        expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrQueryBuilder.solr_name('bar', type: :string) => 'Peanuts').where("#{ActiveFedora::SolrQueryBuilder.solr_name('foo', type: :string)}:bar").where_values).to eq ["#{ActiveFedora::SolrQueryBuilder.solr_name('bar', type: :string)}:Peanuts", "(#{ActiveFedora::SolrQueryBuilder.solr_name('foo', type: :string)}:bar)"]
       end
 
       it "should chain count" do
-        expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').count).to eq 2
+        expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrQueryBuilder.solr_name('bar', type: :string) => 'Peanuts').count).to eq 2
       end
 
       it "calling first should not affect the relation's ability to get all results later" do
-        relation = ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts')
+        relation = ModelIntegrationSpec::Basic.where(ActiveFedora::SolrQueryBuilder.solr_name('bar', type: :string) => 'Peanuts')
         expect {relation.first}.not_to change {relation.to_a.size}
       end
 
       it "calling where should not affect the relation's ability to get all results later" do
-        relation = ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts')
-        expect {relation.where(ActiveFedora::SolrService.solr_name('foo', type: :string) => 'bar')}.not_to change {relation.to_a.size}
+        relation = ModelIntegrationSpec::Basic.where(ActiveFedora::SolrQueryBuilder.solr_name('bar', type: :string) => 'Peanuts')
+        expect {relation.where(ActiveFedora::SolrQueryBuilder.solr_name('foo', type: :string) => 'bar')}.not_to change {relation.to_a.size}
       end
 
       it "calling order should not affect the original order of the relation later" do
-        relation = ModelIntegrationSpec::Basic.order(ActiveFedora::SolrService.solr_name('foo', :sortable) + ' asc')
-        expect {relation.order(ActiveFedora::SolrService.solr_name('foo', :sortable) + ' desc')}.not_to change {relation.to_a}
+        relation = ModelIntegrationSpec::Basic.order(ActiveFedora::SolrQueryBuilder.solr_name('foo', :sortable) + ' asc')
+        expect {relation.order(ActiveFedora::SolrQueryBuilder.solr_name('foo', :sortable) + ' desc')}.not_to change {relation.to_a}
       end
     end
 

data/spec/integration/solr_instance_loader_spec.rb

@@ -66,6 +66,14 @@ describe ActiveFedora::SolrInstanceLoader do
         expect(object.foo).to eq ['baz']
       end
     end
+
+    context "with children" do
+      let(:loader) { ActiveFedora::SolrInstanceLoader.new(Foo, obj.id) }
+
+      it "should have stub implementation of the children" do
+        expect(subject.descMetadata).to be_kind_of ActiveFedora::LoadableFromJson::SolrBackedMetadataFile
+      end
+    end
   end
 
   context "with a solr doc" do

data/spec/integration/versionable_spec.rb

@@ -29,7 +29,8 @@ describe "a versionable class" do
 
     it "should have one version" do
       expect(subject.versions.size).to eq 1
-      expect(subject.versions.first).to be_kind_of ::RDF::Literal
+      expect(subject.versions.first).to be_kind_of String
+      expect(subject.versions.first).to end_with "version1"
     end
 
     context "two times" do
@@ -41,8 +42,8 @@ describe "a versionable class" do
 
       it "should have two versions" do
         expect(subject.versions.size).to eq 2
-        subject.versions.each do |version|
-          expect(version).to be_kind_of ::RDF::Literal
+        subject.versions.each_index do |index|
+          expect(subject.versions[index]).to end_with "version"+(index+1).to_s
         end
       end
 
@@ -126,7 +127,7 @@ describe "a versionable rdf datastream" do
       end
 
       it "should have one version" do
-        expect(subject.versions.first).to be_kind_of ::RDF::Literal
+        expect(subject.versions.first).to end_with "version1"
       end
 
       it "should have a title" do
@@ -146,8 +147,8 @@ describe "a versionable rdf datastream" do
 
         it "should have two versions" do
           expect(subject.versions.size).to eq 2
-          subject.versions.each do |version|
-            expect(version).to be_kind_of ::RDF::Literal
+          subject.versions.each_index do |index|
+            expect(subject.versions[index]).to end_with "version"+(index+1).to_s
           end
         end
 
@@ -255,8 +256,7 @@ describe "a versionable OM datastream" do
       end
 
       it "should have one version" do
-        expect(subject.versions.size).to eq 1
-        expect(subject.versions.first).to be_kind_of ::RDF::Literal
+        expect(subject.versions.first).to end_with "version1"
       end
 
       it "should have a title" do
@@ -277,8 +277,8 @@ describe "a versionable OM datastream" do
 
         it "should have two unique versions" do
           expect(subject.versions.size).to eq 2
-          subject.versions.each do |version|
-            expect(version).to be_kind_of ::RDF::Literal
+          subject.versions.each_index do |index|
+            expect(subject.versions[index]).to end_with "version"+(index+1).to_s
           end
         end
 
@@ -384,7 +384,7 @@ describe "a versionable binary datastream" do
         expect(subject.versions.size).to eq 1
         expect(subject.original_name).to eql(first_name)
         expect(subject.content.size).to eq first_file.size
-        expect(subject.versions.first).to be_kind_of ::RDF::Literal
+        expect(subject.versions.first).to end_with "version1"
       end
 
       context "two times" do
@@ -401,8 +401,24 @@ describe "a versionable binary datastream" do
           expect(subject.versions.size).to eq 2
           expect(subject.original_name).to eql(second_name)
           expect(subject.content.size).to eq second_file.size
-          subject.versions.each do |version|
-            expect(version).to be_kind_of ::RDF::Literal
+          subject.versions.each_index do |index|
+            expect(subject.versions[index]).to end_with "version"+(index+1).to_s
+          end
+        end
+
+        context "with fixity checking" do
+          let(:results) do
+            results = Array.new
+            subject.versions.each do |uri|
+              results << ActiveFedora::FixityService.new(uri).check
+            end
+            return results
+          end
+
+          it "should report on the fixity of each version" do
+            results.each do |result|
+              expect(result).to be true
+            end
           end
         end
 
@@ -436,7 +452,9 @@ describe "a versionable binary datastream" do
               expect(subject.versions.size).to eq 3
               expect(subject.original_name).to eql(first_name)
               expect(subject.content.size).to eq first_file.size
-              expect(subject.versions.first).to be_kind_of ::RDF::Literal
+              subject.versions.each_index do |index|
+                expect(subject.versions[index]).to end_with "version"+(index+1).to_s
+              end
             end
 
           end

data/spec/unit/base_spec.rb

@@ -264,15 +264,15 @@ describe ActiveFedora::Base do
         expect(@test_object).to receive(:modified_date).and_return(DateTime.parse("2012-03-07T03:12:02Z")).twice
         allow(@test_object).to receive(:id).and_return('changeme:123')
         solr_doc = @test_object.to_solr
-        expect(solr_doc[ActiveFedora::SolrService.solr_name("system_create", :stored_sortable, type: :date)]).to eql("2012-03-04T03:12:02Z")
-        expect(solr_doc[ActiveFedora::SolrService.solr_name("system_modified", :stored_sortable, type: :date)]).to eql("2012-03-07T03:12:02Z")
+        expect(solr_doc[ActiveFedora::SolrQueryBuilder.solr_name("system_create", :stored_sortable, type: :date)]).to eql("2012-03-04T03:12:02Z")
+        expect(solr_doc[ActiveFedora::SolrQueryBuilder.solr_name("system_modified", :stored_sortable, type: :date)]).to eql("2012-03-07T03:12:02Z")
         expect(solr_doc[:id]).to eql("changeme:123")
       end
 
       it "should add self.class as the :active_fedora_model" do
         @test_history = FooHistory.new()
         solr_doc = @test_history.to_solr
-        expect(solr_doc[ActiveFedora::SolrService.solr_name("active_fedora_model", :stored_sortable)]).to eql("FooHistory")
+        expect(solr_doc[ActiveFedora::SolrQueryBuilder.solr_name("active_fedora_model", :stored_sortable)]).to eql("FooHistory")
       end
 
       it "should call .to_solr on all datastreams, passing the resulting document to solr" do

data/spec/unit/indexing_service_spec.rb

@@ -15,8 +15,8 @@ describe ActiveFedora::IndexingService 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"
+      expect(subject[ActiveFedora::SolrQueryBuilder.solr_name("http://fedora.info/definitions/v4/rels-ext#isMemberOf", :symbol)]).to eq "info:fedora/demo:10"
+      expect(subject[ActiveFedora::SolrQueryBuilder.solr_name("http://fedora.info/definitions/v4/rels-ext#isPartOf", :symbol)]).to eq "info:fedora/demo:11"
     end
   end
 

data/spec/unit/ntriples_datastream_spec.rb

@@ -218,26 +218,26 @@ describe ActiveFedora::NtriplesRDFDatastream do
       describe ".to_solr()" do
         subject { @obj.to_solr({}, name: 'solrRdf') }
         it "should return the right fields" do
-          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),
-                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))
+          expect(subject.keys).to include(ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__related_url", type: :string),
+                ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__publisher", type: :string),
+                ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__publisher", :sortable),
+                ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__publisher", :facetable),
+                ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__created", :sortable, type: :date),
+                ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__created", :displayable),
+                ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__title", type: :string),
+                ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__title", :sortable),
+                ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__based_near", type: :string),
+                ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__based_near", :facetable))
 
         end
 
         it "should return the right values" do
-          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"]
+          expect(subject[ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__related_url", type: :string)]).to eq ["http://example.org/blogtastic/"]
+          expect(subject[ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__based_near", type: :string)]).to eq ["Tacoma, WA","Renton, WA"]
+          expect(subject[ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__based_near", :facetable)]).to eq ["Tacoma, WA","Renton, WA"]
+          expect(subject[ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__publisher", type: :string)]).to eq ["Bob's Blogtastic Publishing"]
+          expect(subject[ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__publisher", :sortable)]).to eq "Bob's Blogtastic Publishing"
+          expect(subject[ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__publisher", :facetable)]).to eq ["Bob's Blogtastic Publishing"]
         end
       end
     end

data/spec/unit/om_datastream_spec.rb

@@ -262,16 +262,16 @@ describe ActiveFedora::OmDatastream do
   
 
   describe '.has_solr_name?' do
-    let(:name0_role0) { ActiveFedora::SolrService.solr_name("desc_metadata__name_0_role_0_roleTerm", type: :string) }
-    let(:name1_role1) { ActiveFedora::SolrService.solr_name("desc_metadata__name_1_role_1_roleTerm", type: :string) }
+    let(:name0_role0) { ActiveFedora::SolrQueryBuilder.solr_name("desc_metadata__name_0_role_0_roleTerm", type: :string) }
+    let(:name1_role1) { ActiveFedora::SolrQueryBuilder.solr_name("desc_metadata__name_1_role_1_roleTerm", type: :string) }
     let(:solr_doc) do
       {"id"=>"mods_article1",
-      ActiveFedora::SolrService.solr_name("desc_metadata__name_role_roleTerm", type: :string) =>["creator","submitter","teacher"],
-      ActiveFedora::SolrService.solr_name("desc_metadata__name_0_role", type: :string)=>"\r\ncreator\r\nsubmitter\r\n",
-      ActiveFedora::SolrService.solr_name("desc_metadata__name_1_role", type: :string)=>"\r\n teacher \r\n",
+      ActiveFedora::SolrQueryBuilder.solr_name("desc_metadata__name_role_roleTerm", type: :string) =>["creator","submitter","teacher"],
+      ActiveFedora::SolrQueryBuilder.solr_name("desc_metadata__name_0_role", type: :string)=>"\r\ncreator\r\nsubmitter\r\n",
+      ActiveFedora::SolrQueryBuilder.solr_name("desc_metadata__name_1_role", type: :string)=>"\r\n teacher \r\n",
       name0_role0 =>"creator",
-      ActiveFedora::SolrService.solr_name("desc_metadata__name_0_role_1_roleTerm", type: :string)=>"submitter",
-      ActiveFedora::SolrService.solr_name("desc_metadata__name_1_role_0_roleTerm", type: :string)=>["teacher"]}
+      ActiveFedora::SolrQueryBuilder.solr_name("desc_metadata__name_0_role_1_roleTerm", type: :string)=>"submitter",
+      ActiveFedora::SolrQueryBuilder.solr_name("desc_metadata__name_1_role_0_roleTerm", type: :string)=>["teacher"]}
     end
 
     it "should return true if the given key exists in the solr document passed in" do