active-fedora 5.4.0 → 5.5.0.rc1

data/spec/integration/ntriples_datastream_spec.rb

@@ -3,9 +3,14 @@ require 'spec_helper'
 describe ActiveFedora::NtriplesRDFDatastream do
   before do
     class MyDatastream < ActiveFedora::NtriplesRDFDatastream
-      register_vocabularies RDF::DC, RDF::FOAF, RDF::RDFS
       map_predicates do |map|
-        map.title(:in => RDF::DC)
+        map.title(:in => RDF::DC) do |index|
+          index.as :searchable, :facetable, :displayable
+        end
+        map.date_uploaded(:to => "dateSubmitted", :in => RDF::DC) do |index|
+          index.type :date
+          index.as :searchable, :displayable, :sortable
+        end
         map.part(:to => "hasPart", :in => RDF::DC)
         map.based_near(:in => RDF::FOAF)
         map.related_url(:to => "seeAlso", :in => RDF::RDFS)
@@ -13,14 +18,16 @@ describe ActiveFedora::NtriplesRDFDatastream do
     end
     class RdfTest < ActiveFedora::Base 
       has_metadata :name=>'rdf', :type=>MyDatastream
-      delegate :based_near, :to=>'rdf'
-      delegate :related_url, :to=>'rdf'
-      delegate :part, :to=>'rdf'
+      delegate_to 'rdf', [:based_near, :related_url, :part, :date_uploaded]
       delegate :title, :to=>'rdf', :unique=>true
     end
     @subject = RdfTest.new
   end
 
+  subject {
+    @subject
+  }
+
   after do
     Object.send(:remove_const, :RdfTest)
     Object.send(:remove_const, :MyDatastream)
@@ -30,6 +37,48 @@ describe ActiveFedora::NtriplesRDFDatastream 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
+    foo.title = 'Hamlet'
+    foo.save
+    foo.title.should == 'Hamlet'
+    foo.rdf.content = File.new('spec/fixtures/mixed_rdf_descMetadata.nt').read
+    foo.save
+    foo.title.should == 'Title of work'
+  end
+
+  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
+    foo = RdfTest.new
+    foo.should_receive(:update_index).once
+    foo.title = "title1"
+    foo.save
+    foo = RdfTest.find(foo.pid)
+    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')
+    subject.date_uploaded.first.should be_kind_of Date
+    solr_document = subject.to_solr
+    solr_document["my_datastream__date_uploaded_dt"].should == ['2012-11-02T00:00:00Z']
+  end
+
+  it "should produce a solr document" do
+    @subject = RdfTest.new(title: "War and Peace")
+    solr_document = @subject.to_solr
+    solr_document["my_datastream__title_display"].should == ["War and Peace"]
+    solr_document["my_datastream__title_facet"].should == ["War and Peace"]
+    solr_document["my_datastream__title_t"].should == ["War and Peace"]
+  end
+
   it "should set and recall values" do
     @subject.title = 'War and Peace'
     @subject.rdf.should be_changed
@@ -149,7 +198,6 @@ describe ActiveFedora::NtriplesRDFDatastream do
   describe "term proxy methods" do
     before(:each) do
       class TitleDatastream < ActiveFedora::NtriplesRDFDatastream
-        register_vocabularies RDF::DC
         map_predicates { |map| map.title(:in => RDF::DC) }
       end
       class Foobar < ActiveFedora::Base 

data/spec/samples/hydra-mods_article_datastream.rb

@@ -54,7 +54,7 @@ module Hydra
         t.computing_id
       }
       # lookup :person, :first_name        
-      t.person(:ref=>:name, :attributes=>{:type=>"personal"}, :index_as=>[:facetable])
+      t.person(:ref=>:name, :attributes=>{:type=>"personal"}, :index_as=>[:facetable, :searchable])
       t.department(:proxy=>[:person,:description],:index_as=>[:facetable])
       t.organization(:ref=>:name, :attributes=>{:type=>"corporate"}, :index_as=>[:facetable])
       t.conference(:ref=>:name, :attributes=>{:type=>"conference"}, :index_as=>[:facetable])

data/spec/unit/active_fedora_spec.rb

@@ -92,6 +92,8 @@ describe ActiveFedora do
 
         describe "with no explicit config path" do
           it "should look for the file in the path defined at Rails.root" do
+            ActiveFedora::SolrService.stub(:load_mappings) #necessary or else it will load the solrizer config and it breaks other tests in the suite.
+            
             stub_rails(:root=>File.join(File.dirname(__FILE__),"../fixtures/rails_root"))
             ActiveFedora.init()
             ActiveFedora.config.credentials[:url].should == "http://testhost.com:8983/fedora"

data/spec/unit/base_spec.rb

@@ -384,11 +384,6 @@ describe ActiveFedora::Base do
     end
 
     describe ".to_solr" do
-      after(:all) do
-        # Revert to default mappings after running tests
-        ActiveFedora::SolrService.load_mappings
-      end
-      
       it "should provide .to_solr" do
         @test_object.should respond_to(:to_solr)
       end
@@ -419,26 +414,30 @@ describe ActiveFedora::Base do
         solr_doc["active_fedora_model_s"].should eql("FooHistory")
       end
 
-      it "should use mappings.yml to decide names of solr fields" do      
-        cdate = "2008-07-02T05:09:42Z"
-        mdate = "2009-07-07T23:37:18Z"
-        @test_object.stub(:create_date).and_return(cdate)
-        @test_object.stub(:modified_date).and_return(mdate)
-        solr_doc = @test_object.to_solr
-        solr_doc["system_create_dt"].should eql(cdate)
-        solr_doc["system_modified_dt"].should eql(mdate)
-        solr_doc[:id].should eql("#{@test_object.pid}")
-        solr_doc["active_fedora_model_s"].should eql(@test_object.class.inspect)
-        
-        ActiveFedora::SolrService.load_mappings(File.join(File.dirname(__FILE__), "..", "..", "config", "solr_mappings_af_0.1.yml"))
-        solr_doc = @test_object.to_solr
-        [:system_create_dt, :system_modified_dt, :active_fedora_model_s].each do |fn|
-          solr_doc[fn].should == nil
+      describe "using mappings.yml" do
+        before do
+          @old_mapper = ActiveFedora::SolrService.default_field_mapper.dup
+          ActiveFedora::SolrService.load_mappings(File.join(File.dirname(__FILE__), "..", "..", "config", "solr_mappings_af_0.1.yml"))
+        end
+        after do
+          ActiveFedora::SolrService.default_field_mapper = @old_mapper
+        end
+
+        it "should decide names of solr fields" do      
+          cdate = "2008-07-02T05:09:42Z"
+          mdate = "2009-07-07T23:37:18Z"
+          @test_object.stub(:create_date).and_return(cdate)
+          @test_object.stub(:modified_date).and_return(mdate)
+          
+          solr_doc = @test_object.to_solr
+          [:system_create_dt, :system_modified_dt, :active_fedora_model_s].each do |fn|
+            solr_doc[fn].should == nil
+          end
+          solr_doc["system_create_date"].should eql(cdate)
+          solr_doc["system_modified_date"].should eql(mdate)
+          solr_doc[:id].should eql("#{@test_object.pid}")
+          solr_doc["active_fedora_model_field"].should eql(@test_object.class.inspect)
         end
-        solr_doc["system_create_date"].should eql(cdate)
-        solr_doc["system_modified_date"].should eql(mdate)
-        solr_doc[:id].should eql("#{@test_object.pid}")
-        solr_doc["active_fedora_model_field"].should eql(@test_object.class.inspect)
       end
       
       it "should call .to_solr on all SimpleDatastreams and OmDatastreams, passing the resulting document to solr" do

data/spec/unit/file_configurator_spec.rb

@@ -145,6 +145,7 @@ describe ActiveFedora::FileConfigurator do
         subject.reset!
       end
       it "should load the file specified in fedora_config_path" do
+        subject.stub(:load_solrizer_config)
         subject.should_receive(:get_config_path).with(:fedora).and_return("/path/to/fedora.yml")
         subject.should_receive(:load_solr_config)
         IO.should_receive(:read).with("/path/to/fedora.yml").and_return("development:\n url: http://devfedora:8983\ntest:\n  url: http://myfedora:8080")
@@ -153,6 +154,7 @@ describe ActiveFedora::FileConfigurator do
       end
 
       it "should allow sharding" do
+        subject.stub(:load_solrizer_config)
         subject.should_receive(:get_config_path).with(:fedora).and_return("/path/to/fedora.yml")
         subject.should_receive(:load_solr_config)
         IO.should_receive(:read).with("/path/to/fedora.yml").and_return("development:\n  url: http://devfedora:8983\ntest:\n- url: http://myfedora:8080\n- url: http://myfedora:8081")
@@ -161,6 +163,7 @@ describe ActiveFedora::FileConfigurator do
       end
 
       it "should parse the file using ERb" do
+        subject.stub(:load_solrizer_config)
         subject.should_receive(:get_config_path).with(:fedora).and_return("/path/to/fedora.yml")
         subject.should_receive(:load_solr_config)
         IO.should_receive(:read).with("/path/to/fedora.yml").and_return("development:\n  url: http://devfedora:<%= 8983 %>\ntest:\n  url: http://myfedora:<%= 8081 %>")
@@ -174,6 +177,7 @@ describe ActiveFedora::FileConfigurator do
         subject.reset!
       end
       it "should load the file specified in solr_config_path" do
+        subject.stub(:load_solrizer_config)
         subject.should_receive(:get_config_path).with(:solr).and_return("/path/to/solr.yml")
         subject.should_receive(:load_fedora_config)
         IO.should_receive(:read).with("/path/to/solr.yml").and_return("development:\n  default:\n    url: http://devsolr:8983\ntest:\n  default:\n    url: http://mysolr:8080")
@@ -182,6 +186,7 @@ describe ActiveFedora::FileConfigurator do
       end
 
       it "should parse the file using ERb" do
+        subject.stub(:load_solrizer_config)
         subject.should_receive(:get_config_path).with(:solr).and_return("/path/to/solr.yml")
         subject.should_receive(:load_fedora_config)
         IO.should_receive(:read).with("/path/to/solr.yml").and_return("development:\n  default:\n    url: http://devsolr:<%= 8983 %>\ntest:\n  default:\n    url: http://mysolr:<%= 8081 %>")
@@ -246,6 +251,7 @@ describe ActiveFedora::FileConfigurator do
       subject.should respond_to(:solr_config_path)
     end
     it "loads a config from the current working directory as a second choice" do
+      subject.stub(:load_solrizer_config)
       Dir.stub(:getwd).and_return(@fake_rails_root)
       subject.init
       subject.get_config_path(:fedora).should eql("#{@fake_rails_root}/config/fedora.yml")
@@ -253,6 +259,7 @@ describe ActiveFedora::FileConfigurator do
     end
     it "loads the config that ships with this gem as a last choice" do
       Dir.stub(:getwd).and_return("/fake/path")
+      subject.stub(:load_solrizer_config)
       logger.should_receive(:warn).with("Using the default fedora.yml that comes with active-fedora.  If you want to override this, pass the path to fedora.yml to ActiveFedora - ie. ActiveFedora.init(:fedora_config_path => '/path/to/fedora.yml') - or set Rails.root and put fedora.yml into \#{Rails.root}/config.").exactly(3).times
       subject.init
       expected_config = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "config"))
@@ -276,6 +283,7 @@ describe ActiveFedora::FileConfigurator do
       end
       
       it "loads a config from Rails.root as a first choice" do
+        subject.stub(:load_solrizer_config)
         subject.init
         subject.get_config_path(:fedora).should eql("#{Rails.root}/config/fedora.yml")
         subject.solr_config_path.should eql("#{Rails.root}/config/solr.yml")

data/spec/unit/nom_datastream_spec.rb

@@ -9,7 +9,7 @@ describe ActiveFedora::NomDatastream do
           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>'
     }
@@ -23,4 +23,35 @@ describe ActiveFedora::NomDatastream do
       subject.to_solr['b_s'].should include('asdf')
     end
   end
+
+  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/"
+          }
+        }) do |t|
+          t.a :path => 'a', :xmlns => 'dc', :accessor => lambda { |x| x.text }
+        end
+      end
+
+      TerminologyOptions.from_xml %(
+        <root
+          xmlns:dc="http://purl.org/dc/elements/1.1/"
+          xmlns:dcterms="http://purl.org/dc/terms/"
+        >
+          <dc:a>123</dc:a>
+          <dcterms:a>not-part-of-a</dcterms:a>
+          <dcterms:b>abcd</dcterms:b>
+        </root>
+      )
+    }
+
+    it "should scope #a attribute to only the dc namespace" do
+      subject.a.should == ["123"]
+    end
+
+  end
 end

data/spec/unit/ntriples_datastream_spec.rb

@@ -4,7 +4,6 @@ describe ActiveFedora::NtriplesRDFDatastream do
   describe "an instance with content" do
     before do 
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
-        register_vocabularies RDF::DC, RDF::FOAF, RDF::RDFS
         map_predicates do |map|
           map.created(:in => RDF::DC)
           map.title(:in => RDF::DC)
@@ -14,21 +13,11 @@ describe ActiveFedora::NtriplesRDFDatastream do
           map.related_url(:to => "seeAlso", :in => RDF::RDFS)
         end
       end
-      class Foo < ActiveFedora::Base
-        has_metadata :name => "descMetadata", :type => MyDatastream
-        delegate :created, :to => :descMetadata
-        delegate :title, :to => :descMetadata
-        delegate :publisher, :to => :descMetadata
-        delegate :based_near, :to => :descMetadata
-        delegate :related_url, :to => :descMetadata
-      end
-      @object = Foo.new(:pid => 'test:1')
-      @subject = @object.descMetadata
+      @subject = MyDatastream.new(stub('inner object', :pid=>'test:1', :new? =>true), 'descMetadata')
       @subject.content = File.new('spec/fixtures/mixed_rdf_descMetadata.nt').read
-      @object.save
     end
     after do
-      @object.delete
+      Object.send(:remove_const, :MyDatastream)
     end
     it "should have a subject" do
       @subject.rdf_subject.should == "info:fedora/test:1"
@@ -50,10 +39,6 @@ describe ActiveFedora::NtriplesRDFDatastream do
       @subject.related_url.should == ["http://google.com/"]
     end
 
-    it "should delegate as_json to the fields" do
-      @subject.title.as_json.should == ["Title of work"]
-      @subject.title.to_json.should == "\[\"Title of work\"\]"
-    end
 
     it "should return fields that are not TermProxies" do
       @subject.created.should be_kind_of Array
@@ -98,7 +83,6 @@ describe ActiveFedora::NtriplesRDFDatastream do
   describe "an instance with a custom subject" do
     before do 
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
-        register_vocabularies RDF::DC, RDF::FOAF, RDF::RDFS
         rdf_subject { |ds| "info:fedora/#{ds.pid}/content" }
         map_predicates do |map|
           map.created(:in => RDF::DC)
@@ -126,7 +110,6 @@ describe ActiveFedora::NtriplesRDFDatastream do
   describe "a new instance" do
     before(:each) do
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
-        register_vocabularies RDF::DC
         map_predicates do |map|
           map.publisher(:in => RDF::DC)
         end
@@ -149,7 +132,6 @@ describe ActiveFedora::NtriplesRDFDatastream do
   describe "solr integration" do
     before(:all) do
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
-        register_vocabularies RDF::DC, RDF::FOAF, RDF::RDFS
         map_predicates do |map|
           map.created(:in => RDF::DC) do |index| 
             index.as :sortable, :displayable
@@ -177,33 +159,16 @@ describe ActiveFedora::NtriplesRDFDatastream do
     end
     before(:each) do  
       @subject.stub(:pid => 'test:1')
-      @subject.stub(:new? => false)
-      @sample_fields = {:my_datastream__publisher => {:values => ["publisher1"], :type => :string, :behaviors => [:facetable, :sortable, :searchable, :displayable]}, 
-        :my_datastream__based_near => {:values => ["coverage1", "coverage2"], :type => :text, :behaviors => [:displayable, :facetable, :searchable]}, 
-        :my_datastream__created => {:values => "fake-date", :type => :date, :behaviors => [:sortable, :displayable]},
-        :my_datastream__title => {:values => "fake-title", :type => :text, :behaviors => [:searchable, :displayable, :sortable]},
-        :my_datastream__related_url => {:values => "http://example.org/", :type =>:string, :behaviors => [:searchable]},
-        :my_datastream__empty_field => {:values => [], :type => :string, :behaviors => [:searchable]}
-      } 
-    end
-    after(:all) do
-      # Revert to default mappings after running tests
-      ActiveFedora::SolrService.load_mappings
     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)
     end
-    it "should provide .fields and return a Hash" do
-      @subject.should respond_to(:fields)
-      @subject.fields.should 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
     end
     it "should iterate through @fields hash" do
-      @subject.should_receive(:fields).and_return(@sample_fields)
       solr_doc = @subject.to_solr
       solr_doc["my_datastream__publisher_t"].should == ["publisher1"]
       solr_doc["my_datastream__publisher_sort"].should == ["publisher1"]
@@ -212,47 +177,20 @@ describe ActiveFedora::NtriplesRDFDatastream do
       solr_doc["my_datastream__based_near_t"].sort.should == ["coverage1", "coverage2"]
       solr_doc["my_datastream__based_near_display"].sort.should == ["coverage1", "coverage2"]
       solr_doc["my_datastream__based_near_facet"].sort.should == ["coverage1", "coverage2"]
-      solr_doc["my_datastream__created_sort"].should == ["fake-date"]
-      solr_doc["my_datastream__created_display"].should == ["fake-date"]
+      solr_doc["my_datastream__created_sort"].should == ["2009-10-10"]
+      solr_doc["my_datastream__created_display"].should == ["2009-10-10"]
       solr_doc["my_datastream__title_t"].should == ["fake-title"]
       solr_doc["my_datastream__title_sort"].should == ["fake-title"]
       solr_doc["my_datastream__title_display"].should == ["fake-title"]
       solr_doc["my_datastream__related_url_t"].should == ["http://example.org/"]
       solr_doc["my_datastream__empty_field_t"].should be_nil
-    end
-    it 'should append create keys in format field_name + _ + field_type' do
-      @subject.stub(:fields).and_return(@sample_fields)
-      
-      #should have these            
-      @subject.to_solr["my_datastream__publisher_t"].should_not be_nil
-      @subject.to_solr["my_datastream__based_near_t"].should_not be_nil
-      @subject.to_solr["my_datastream__title_t"].should_not be_nil
-      @subject.to_solr["my_datastream__related_url_t"].should_not be_nil
 
       #should NOT have these
-      @subject.to_solr["my_datastream__narrator"].should be_nil
-      @subject.to_solr["my_datastream__empty_field"].should be_nil
-      @subject.to_solr["my_datastream__creator"].should be_nil
+      solr_doc["my_datastream__narrator"].should be_nil
+      solr_doc["my_datastream__empty_field"].should be_nil
+      solr_doc["my_datastream__creator"].should be_nil
     end
-    it "should use Solr mappings to generate field names" do
-      ActiveFedora::SolrService.load_mappings(File.join(File.dirname(__FILE__), "..", "..", "config", "solr_mappings_af_0.1.yml"))
-      @subject.stub(:fields).and_return(@sample_fields)
-      solr_doc =  @subject.to_solr
 
-      #should have these            
-      solr_doc["my_datastream__publisher_field"].should == ["publisher1"]
-      solr_doc["my_datastream__based_near_field"].sort.should == ["coverage1", "coverage2"]
-      solr_doc["my_datastream__created_display"].should == ["fake-date"]
-      solr_doc["my_datastream__title_field"].should == ["fake-title"]
-        
-      solr_doc["my_datastream__title_t"].should be_nil
-      solr_doc["my_datastream__publisher_t"].should be_nil
-      solr_doc["my_datastream__based_near_t"].should be_nil
-      solr_doc["my_datastream__created_dt"].should be_nil
-      
-      # Reload default mappings
-      ActiveFedora::SolrService.load_mappings
-    end
     describe "with an actual object" do
       before(:each) do
         class Foo < ActiveFedora::Base
@@ -278,75 +216,33 @@ describe ActiveFedora::NtriplesRDFDatastream do
         @obj.save
       end
 
-      it "should save content properly upon save" do
-        foo = Foo.new(:pid => 'test:1')
-        foo.title = 'Hamlet'
-        foo.save
-        foo.title.should == ['Hamlet']
-        foo.descMetadata.content = File.new('spec/fixtures/mixed_rdf_descMetadata.nt').read
-        foo.save
-        foo.title.should == ['Title of work']
-      end
       describe ".fields()" do
-        it "should return the right # of fields" do
-          @obj.fields.keys.count.should == 5
-        end
         it "should return the right fields" do
-          @obj.fields.keys.should include(:my_datastream__related_url)
-          @obj.fields.keys.should include(:my_datastream__publisher)
-          @obj.fields.keys.should include(:my_datastream__created)
-          @obj.fields.keys.should include(:my_datastream__title)
-          @obj.fields.keys.should include(:my_datastream__based_near)
+          @obj.send(:fields).keys.should == [:created, :title, :publisher, :based_near, :related_url]
         end
         it "should return the right values" do
-          @obj.fields[:my_datastream__related_url][:values].should == ["http://example.org/blogtastic/"]
+          fields = @obj.send(:fields)
+          fields[:related_url][:values].should == ["http://example.org/blogtastic/"]
+          fields[:based_near][:values].should == ["Tacoma, WA", "Renton, WA"]
         end
         it "should return the right type information" do
-          @obj.fields[:my_datastream__created][:type].should == :date
-        end
-        it "should return multi-value fields as expected" do
-          @obj.fields[:my_datastream__based_near][:values].count.should == 2
-          @obj.fields[:my_datastream__based_near][:values].should include("Tacoma, WA")
-          @obj.fields[:my_datastream__based_near][:values].should include("Renton, WA")
-        end
-        it "should solrize even when the object is not new" do
-          foo = Foo.new
-          foo.should_receive(:update_index).once
-          foo.title = "title1"
-          foo.save
-          foo = Foo.find(foo.pid)
-          foo.should_receive(:update_index).once
-          foo.publisher = "Allah2"
-          foo.title = "The Work2"
-          foo.save  
+          fields = @obj.send(:fields)
+          fields[:created][:type].should == :date
         end
       end
       describe ".to_solr()" do
-        it "should return the right # of fields" do
-          @obj.to_solr.keys.count.should == 13
-        end
         it "should return the right fields" do
-          @obj.to_solr.keys.should include("my_datastream__related_url_t")
-          @obj.to_solr.keys.should include("my_datastream__publisher_t")
-          @obj.to_solr.keys.should include("my_datastream__publisher_sort")
-          @obj.to_solr.keys.should include("my_datastream__publisher_display")
-          @obj.to_solr.keys.should include("my_datastream__publisher_facet")
-          @obj.to_solr.keys.should include("my_datastream__created_sort")
-          @obj.to_solr.keys.should include("my_datastream__created_display")
-          @obj.to_solr.keys.should include("my_datastream__title_t")
-          @obj.to_solr.keys.should include("my_datastream__title_sort")
-          @obj.to_solr.keys.should include("my_datastream__title_display")
-          @obj.to_solr.keys.should include("my_datastream__based_near_t")
-          @obj.to_solr.keys.should include("my_datastream__based_near_facet")
-          @obj.to_solr.keys.should include("my_datastream__based_near_display")
+          @obj.to_solr.keys.count.should == 13
+          @obj.to_solr.keys.should include("my_datastream__related_url_t", "my_datastream__publisher_t", "my_datastream__publisher_sort",
+                "my_datastream__publisher_display", "my_datastream__publisher_facet", "my_datastream__created_sort",
+                "my_datastream__created_display", "my_datastream__title_t", "my_datastream__title_sort", "my_datastream__title_display",
+                "my_datastream__based_near_t", "my_datastream__based_near_facet", "my_datastream__based_near_display")
+
         end
+
         it "should return the right values" do
           @obj.to_solr["my_datastream__related_url_t"].should == ["http://example.org/blogtastic/"]
-        end
-        it "should return multi-value fields as expected" do
-          @obj.to_solr["my_datastream__based_near_t"].count.should == 2
-          @obj.to_solr["my_datastream__based_near_t"].should include("Tacoma, WA")
-          @obj.to_solr["my_datastream__based_near_t"].should include("Renton, WA")
+          @obj.to_solr["my_datastream__based_near_t"].should == ["Tacoma, WA","Renton, WA"]
         end
       end
     end