solrizer 0.2.0 → 0.3.0

data/spec/units/extractor_spec.rb

@@ -3,48 +3,57 @@ require 'solrizer'
 
 describe Solrizer::Extractor do
   
-  before(:each) do
+  before(:all) do
     @extractor = Solrizer::Extractor.new
   end
   
-  describe ".xml_to_solr" do
-    it "should turn simple xml into a solr document" do
-      desc_meta = fixture("druid-bv448hq0314-descMetadata.xml")
-      result = @extractor.xml_to_solr(desc_meta)
-      result[:type_t].should == "text"
-      result[:medium_t].should == "Paper Document"
-      result[:rights_t].should == "Presumed under copyright. Do not publish."
-      result[:date_t].should == "1985-12-30"
-      result[:format_t].should == "application/tiff"
-      result[:title_t].should == "This is a Sample Title"
-      result[:publisher_t].should == "Sample Unversity"
-
-      # ... and a hacky way of making sure that it added a field for each of the dc:medium values
-      result.inspect.include?('@value="application/tiff"').should be_true
-      result.inspect.include?('@value="application/pdf"').should be_true
+  describe "extract_hash" do
+    it "should convert a hash to a solr doc" do
+      example_hash = {"box"=>"Box 51A", "city"=>["Ann Arbor", "Hyderabad", "Palo Alto"], "person"=>["ELLIE ENGELMORE", "Reddy", "EDWARD FEIGENBAUM"], "title"=>"Letter from Ellie Engelmore to Professor K. C. Reddy", "series"=>"eaf7000", "folder"=>"Folder 15", "technology"=>["artificial intelligence"], "year"=>"1985", "organization"=>["Heuristic Programming Project", "Mathematics and Computer/Information Sciences University of Hyderabad Central University P. O. Hyder", "Professor K. C. Reddy School of Mathematics and Computer/Information Sciences"], "collection"=>"e-a-feigenbaum-collection", "state"=>["Michigan", "California"]}
+      
+      example_result = @extractor.extract_hash( example_hash )
+      example_result.should be_kind_of Solr::Document
+      example_hash.each_pair do |key,values|
+        if values.class == String
+          example_result["#{key}_facet"].should == values
+        else
+          values.each do |v|
+            example_result.inspect.include?("@name=\"#{key}_facet\"").should be_true
+            example_result.inspect.include?("@value=\"#{v}\"").should be_true
+          end
+        end        
+      end
     end
-  end
-  
-  describe "extract_rels_ext" do 
-    it "should extract the content model of the RELS-EXT datastream of a Fedora object and set hydra_type using hydra_types mapping" do
-      rels_ext = fixture("rels_ext_cmodel.xml")
-      result = @extractor.extract_rels_ext( rels_ext )
-      result[:cmodel_t].should == "info:fedora/fedora-system:ContentModel-3.0"
-      result[:hydra_type_t].should == "salt_document"
+    
+    it "should handle hashes with facets listed in a sub-hash" do
+      simple_hash = Hash[:facets => {'technology'=>["t1", "t2"], 'company'=>"c1", "person"=>["p1", "p2"]}]
+      result = @extractor.extract_hash( simple_hash )
+      result.should be_kind_of Solr::Document
+      result["technology_facet"].should == "t1"
+      result.inspect.include?('@boost=nil').should be_true
+      result.inspect.include?('@name="technology_facet"').should be_true
+      result.inspect.include?('@value="t2"').should be_true
+      result["company_facet"].should == "c1"
+      result["person_facet"].should == "p1"
+      result.inspect.include?('@name="person_facet"').should be_true
+      result.inspect.include?('@value="p2"').should be_true
       
-      # ... and a hacky way of making sure that it added a field for each of the dc:medium values
-      result.inspect.include?('@value="info:fedora/afmodel:SaltDocument"').should be_true
-      result.inspect.include?('@value="jp2_document"').should be_true
     end
-  end
+    
+    it "should create symbols from the :symbols subhash" do
+      simple_hash = Hash[:facets => {'technology'=>["t1", "t2"], 'company'=>"c1", "person"=>["p1", "p2"]}, :symbols=>{'technology'=>["t1", "t2"], 'company'=>"c1", "person"=>["p1", "p2"]}]
+      result = @extractor.extract_hash( simple_hash )
+      result.should be_kind_of Solr::Document
+      result["technology_s"].should == "t1"
+      result.inspect.include?('@name="technology_s"').should be_true
+      result.inspect.include?('@value="t2"').should be_true
+    
+      result["company_s"].should == "c1"
+      result["person_s"].should == "p1"
+      result.inspect.include?('@name="person_s"').should be_true
+      result.inspect.include?('@value="p2"').should be_true
   
-  describe "extract_hydra_types" do 
-    it "should extract the hydra_type of a Fedora object" do
-      rels_ext = fixture("rels_ext_cmodel.xml")
-      result = @extractor.extract_rels_ext( rels_ext )
-      result[:hydra_type_t].should == "salt_document"
     end
   end
   
-  
 end

data/spec/units/field_mapper_spec.rb

@@ -0,0 +1,227 @@
+require File.join( File.dirname(__FILE__), "..", "spec_helper" )
+
+describe Solrizer::FieldMapper do
+  
+  # --- Test Mappings ----
+  
+  class TestMapper0 < Solrizer::FieldMapper
+    id_field 'ident'
+    index_as :searchable, :suffix => '_s',    :default => true
+    index_as :edible,     :suffix => '_food'
+    index_as :laughable,  :suffix => '_haha', :default => true do |type|
+      type.integer :suffix => '_ihaha' do |value, field_name|
+        "How many #{field_name}s does it take to screw in a light bulb? #{value.capitalize}."
+      end
+      type.default do |value|
+        "Knock knock. Who's there? #{value.capitalize}. #{value.capitalize} who?"
+      end
+    end
+    index_as :fungible, :suffix => '_f0' do |type|
+      type.integer :suffix => '_f1'
+      type.date
+      type.default :suffix => '_f2'
+    end
+    index_as :unstemmed_searchable, :suffix => '_s' do |type|
+      type.date do |value|
+        "#{value} o'clock"
+      end
+    end
+  end
+  
+  class TestMapper1 < TestMapper0
+    index_as :searchable do |type|
+      type.date :suffix => '_d'
+    end
+    index_as :fungible, :suffix => '_f3' do |type|
+      type.garble  :suffix => '_f4'
+      type.integer :suffix => '_f5'
+    end
+  end
+  
+  before(:each) do
+    @mapper = TestMapper0.new
+  end
+  
+  after(:all) do
+  end
+  
+  # --- Tests ----
+  
+  it "should handle the id field" do
+    @mapper.id_field.should == 'ident'
+  end
+  
+  describe '.solr_name' do
+    it "should map based on index_as" do
+      @mapper.solr_name('bar', :string, :edible).should == 'bar_food'
+      @mapper.solr_name('bar', :string, :laughable).should == 'bar_haha'
+    end
+
+    it "should default the index_type to :searchable" do
+      @mapper.solr_name('foo', :string).should == 'foo_s'
+    end
+    
+    it "should map based on data type" do
+      @mapper.solr_name('foo', :integer, :fungible).should == 'foo_f1'
+      @mapper.solr_name('foo', :garble,  :fungible).should == 'foo_f2'  # based on type.default
+      @mapper.solr_name('foo', :date,    :fungible).should == 'foo_f0'  # type.date falls through to container
+    end
+  
+    it "should return nil for an unknown index types" do
+      silence do
+        @mapper.solr_name('foo', :string, :blargle).should == nil
+      end
+    end
+    
+    it "should allow subclasses to selectively override suffixes" do
+      @mapper = TestMapper1.new
+      @mapper.solr_name('foo', :date).should == 'foo_d'   # override
+      @mapper.solr_name('foo', :string).should == 'foo_s' # from super
+      @mapper.solr_name('foo', :integer, :fungible).should == 'foo_f5'  # override on data type
+      @mapper.solr_name('foo', :garble,  :fungible).should == 'foo_f4'  # override on data type
+      @mapper.solr_name('foo', :fratz,   :fungible).should == 'foo_f2'  # from super
+      @mapper.solr_name('foo', :date,    :fungible).should == 'foo_f3'  # super definition picks up override on index type
+    end
+    
+    it "should support field names as symbols" do
+      @mapper.solr_name(:active_fedora_model, :symbol).should == "active_fedora_model_s"
+    end
+    
+    it "should support scenarios where field_type is nil" do
+      mapper = Solrizer::FieldMapper::Default.new
+      mapper.solr_name(:heifer, nil, :searchable).should == "heifer_t"
+    end
+  end
+  
+  describe '.solr_names_and_values' do
+    it "should map values based on index_as" do
+      @mapper.solr_names_and_values('foo', 'bar', :string, [:searchable, :laughable, :edible]).should == {
+        'foo_s'    => ['bar'],
+        'foo_food' => ['bar'],
+        'foo_haha' => ["Knock knock. Who's there? Bar. Bar who?"]
+      }
+    end
+    
+    it "should apply default index_as mapping unless excluded with not_" do
+      @mapper.solr_names_and_values('foo', 'bar', :string, []).should == {
+        'foo_s' => ['bar'],
+        'foo_haha' => ["Knock knock. Who's there? Bar. Bar who?"]
+      }
+      @mapper.solr_names_and_values('foo', 'bar', :string, [:edible, :not_laughable]).should == {
+        'foo_s' => ['bar'],
+        'foo_food' => ['bar']
+      }
+      @mapper.solr_names_and_values('foo', 'bar', :string, [:not_searchable, :not_laughable]).should == {}
+    end
+  
+    it "should apply mappings based on data type" do
+      @mapper.solr_names_and_values('foo', 'bar', :integer, [:searchable, :laughable]).should == {
+        'foo_s'     => ['bar'],
+        'foo_ihaha' => ["How many foos does it take to screw in a light bulb? Bar."]
+      }
+    end
+    
+    it "should skip unknown index types" do
+      silence do
+        @mapper.solr_names_and_values('foo', 'bar', :string, [:blargle]).should == {
+          'foo_s' => ['bar'],
+          'foo_haha' => ["Knock knock. Who's there? Bar. Bar who?"]
+        }
+      end
+    end
+    
+    it "should generate multiple mappings when two return the _same_ solr name but _different_ values" do
+      @mapper.solr_names_and_values('roll', 'rock', :date, [:unstemmed_searchable, :not_laughable]).should == {
+        'roll_s' => ["rock o'clock", 'rock']
+      }
+    end
+    
+    it "should not generate multiple mappings when two return the _same_ solr name and the _same_ value" do
+      @mapper.solr_names_and_values('roll', 'rock', :string, [:unstemmed_searchable, :not_laughable]).should == {
+        'roll_s' => ['rock'],
+      }
+    end
+  end
+
+  describe "#load_mappings" do 
+    before(:each) do
+      class TestMapperLoading < Solrizer::FieldMapper
+      end
+    end
+    it "should take mappings file as an optional argument" do
+      file_path = File.join(File.dirname(__FILE__), "..", "fixtures","test_solr_mappings.yml")
+  	  TestMapperLoading.load_mappings(file_path)
+  	  mapper = TestMapperLoading.new
+      mappings_from_file = YAML::load(File.open(file_path))
+      mapper.id_field.should == "pid"
+      mapper.mappings[:edible].opts[:default].should == true
+      mapper.mappings[:edible].data_types[:boolean].opts[:suffix].should == "_edible_bool"
+      mappings_from_file["edible"].each_pair do |k,v|
+        mapper.mappings[:edible].data_types[k.to_sym].opts[:suffix].should == v        
+      end
+      mapper.mappings[:displayable].opts[:suffix].should == mappings_from_file["displayable"]
+      mapper.mappings[:facetable].opts[:suffix].should == mappings_from_file["facetable"]
+      mapper.mappings[:sortable].opts[:suffix].should == mappings_from_file["sortable"]
+	  end
+	  it 'should default to using the mappings from config/solr_mappings.yml' do
+	    TestMapperLoading.load_mappings
+  	  mapper = TestMapperLoading.new
+  	  default_file_path = File.join(File.dirname(__FILE__), "..", "..","config","solr_mappings.yml")
+      mappings_from_file = YAML::load(File.open(default_file_path))
+      mapper.id_field.should == mappings_from_file["id"]
+      mappings_from_file["searchable"].each_pair do |k,v|
+        mapper.mappings[:searchable].data_types[k.to_sym].opts[:suffix].should == v        
+      end
+      mapper.mappings[:displayable].opts[:suffix].should == mappings_from_file["displayable"]
+      mapper.mappings[:facetable].opts[:suffix].should == mappings_from_file["facetable"]
+      mapper.mappings[:sortable].opts[:suffix].should == mappings_from_file["sortable"]
+    end
+    it "should wipe out pre-existing mappings without affecting other FieldMappers" do
+      TestMapperLoading.load_mappings
+      file_path = File.join(File.dirname(__FILE__), "..", "fixtures","test_solr_mappings.yml")
+  	  TestMapperLoading.load_mappings(file_path)
+  	  mapper = TestMapperLoading.new
+  	  mapper.mappings[:searchable].should be_nil
+  	  default_mapper = Solrizer::FieldMapper::Default.new
+  	  default_mapper.mappings[:searchable].should_not be_nil
+  	end
+  	it "should raise an informative error if the yaml file is structured improperly"
+  	it "should raise an informative error if there is no YAML file"
+	end
+  
+  describe Solrizer::FieldMapper::Default do
+    before(:each) do
+      @mapper = Solrizer::FieldMapper::Default.new
+    end
+  	
+    it "should call the id field 'id'" do
+      @mapper.id_field.should == 'id'
+    end
+    
+    it "should apply mappings for searchable by default" do
+      # Just sanity check a couple; copy & pasting all data types is silly
+      @mapper.solr_names_and_values('foo', 'bar', :string, []).should == { 'foo_t' => ['bar'] }
+      @mapper.solr_names_and_values('foo', 'bar', :date, []).should == { 'foo_dt' => ['bar'] }
+    end
+    
+    it "should support displayable, facetable, sortable, unstemmed" do
+      @mapper.solr_names_and_values('foo', 'bar', :string, [:displayable, :facetable, :sortable, :unstemmed_searchable]).should == {
+        'foo_t' => ['bar'],
+        'foo_display' => ['bar'],
+        'foo_facet' => ['bar'],
+        'foo_sort' => ['bar'],
+        'foo_unstem_search' => ['bar'],
+      }
+    end
+  end
+  
+  def silence
+    old_level = @mapper.logger.level
+    @mapper.logger.level = 100
+    begin
+      yield
+    ensure
+      @mapper.logger.level = old_level
+    end
+  end
+end

data/spec/units/field_name_mapper_spec.rb

@@ -1,41 +1,28 @@
 require File.join( File.dirname(__FILE__), "..", "spec_helper" )
 
-# require 'solrizer'
-# require 'solrizer/field_name_mapper'
-
-class FieldNameMapperTest
-  include Solrizer::FieldNameMapper
-end
-
-def helper
-  @test_instance
-end
-
 describe Solrizer::FieldNameMapper do
   
-  before(:each) do
-    @test_instance = FieldNameMapperTest.new
+  before(:all) do
+    class TestFieldNameMapper
+      include Solrizer::FieldNameMapper
+    end
+  end
+  
+  describe "#mappings" do
+    it "should return at least an id_field value" do
+      TestFieldNameMapper.id_field.should == "id"
+    end
   end
   
-  after(:all) do
-    # Revert to default mappings after running tests
-    Solrizer::FieldNameMapper.load_mappings
+  describe '#solr_name' do
+    it "should generate solr field names" do
+      TestFieldNameMapper.solr_name(:active_fedora_model, :symbol).should == "active_fedora_model_s"
+    end
   end
   
   describe ".solr_name" do
-    it "should generate solr field names from settings in solr_mappings" do
-      helper.solr_name(:system_create, :date).should == :system_create_dt
-    end
-    it "should format the response based on the class of the input" do
-      helper.solr_name(:system_create, :date).should == :system_create_dt
-      helper.solr_name("system_create", :date).should == "system_create_dt"
-    end
-    it "should rely on whichever mappings have been loaded into the SolrService" do
-      helper.solr_name(:system_create, :date).should == :system_create_dt
-      helper.solr_name(:foo, :text).should == :foo_t
-      Solrizer::FieldNameMapper.load_mappings(File.join(File.dirname(__FILE__), "..", "fixtures", "solr_mappings_af_0.1.yml"))
-      helper.solr_name(:system_create, :date).should == :system_create_date
-      helper.solr_name(:foo, :text).should == :foo_field
+    it "should generate solr field names" do
+      TestFieldNameMapper.new.solr_name(:active_fedora_model, :symbol).should == "active_fedora_model_s"
     end
   end
 end

data/spec/units/xml_extractor_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'solrizer'
+
+describe Solrizer::XML::Extractor do
+  
+  before(:all) do
+    @extractor = Solrizer::Extractor.new
+  end
+  
+  describe ".xml_to_solr" do
+    it "should turn simple xml into a solr document" do
+      desc_meta = fixture("druid-bv448hq0314-descMetadata.xml")
+      result = @extractor.xml_to_solr(desc_meta)
+      result[:type_t].should == "text"
+      result[:medium_t].should == "Paper Document"
+      result[:rights_t].should == "Presumed under copyright. Do not publish."
+      result[:date_t].should == "1985-12-30"
+      result[:format_t].should == "application/tiff"
+      result[:title_t].should == "This is a Sample Title"
+      result[:publisher_t].should == "Sample Unversity"
+
+      # ... and a hacky way of making sure that it added a field for each of the dc:medium values
+      result.inspect.include?('@value="application/tiff"').should be_true
+      result.inspect.include?('@value="application/pdf"').should be_true
+    end
+  end
+  
+end

data/spec/units/xml_terminology_based_solrizer_spec.rb

@@ -34,8 +34,9 @@ describe Solrizer::XML::TerminologyBasedSolrizer do
       # mock_terms = {:name1=>:term1, :name2=>:term2}
       # ActiveFedora::NokogiriDatastream.stubs(:accessors).returns(mock_accessors)
       solr_doc = Solr::Document.new
+      @mods_article.field_mapper = Solrizer::FieldMapper::Default.new
       OM::Samples::ModsArticle.terminology.terms.each_pair do |k,v|
-        @mods_article.expects(:solrize_term).with(v, solr_doc)
+        @mods_article.expects(:solrize_term).with(v, solr_doc, @mods_article.field_mapper)
       end
       @mods_article.to_solr(solr_doc)
     end
@@ -49,7 +50,7 @@ describe Solrizer::XML::TerminologyBasedSolrizer do
       solr_doc[:abstract_t].should == "ABSTRACT"
       solr_doc[:title_info_1_language_t].should == "finnish"
       solr_doc[:person_1_role_0_text_t].should == "teacher"
-
+      
       # These are a holdover from an old verison of OM
       # solr_doc[:finnish_title_info_language_t].should == "finnish"
       # solr_doc[:finnish_title_info_main_title_t].should == "Artikkelin otsikko Hydrangea artiklan 1"
@@ -62,7 +63,7 @@ describe Solrizer::XML::TerminologyBasedSolrizer do
       # solr_doc.should == ""
     
     end
-  
+    
   end
 
   describe ".solrize_term" do
@@ -73,7 +74,18 @@ describe Solrizer::XML::TerminologyBasedSolrizer do
       result.should == solr_doc
       # @mods_article.solrize_term(:title_info, OM::Samples::ModsArticle.terminology.retrieve_term(:title_info), :solr_doc=>solr_doc).should == ""
     end
-  
+
+    it "should add multiple fields based on index_as" do
+      fake_solr_doc = []  # duck typing cheat: test will break if solrize_term decides to use methods other than <<
+      @mods_article.solrize_term(OM::Samples::ModsArticle.terminology.retrieve_term(:name), fake_solr_doc)
+      
+      expected_names = ["DR.", "FAMILY NAME", "GIVEN NAMES"]
+      %w(_t _display _facet).each do |suffix|
+        actual_names = fake_solr_doc.select { |field| field.name == 'name_0_namePart' + suffix }.map { |field| field.value }.sort
+        {suffix => actual_names}.should == {suffix => expected_names}
+      end
+    end
+    
   end
 
   describe ".solrize_node" do
@@ -81,8 +93,9 @@ describe Solrizer::XML::TerminologyBasedSolrizer do
       doc = Solr::Document.new
       # @mods_article.solrize_node(node, term_pointer, term, solr_doc).should equal(doc)
     end
+    
     it "should create a solr field containing node.text"
     it "should create hierarchical field entries if parents is not empty"
     it "should only create one node if parents is empty"
   end
-end
+end