bento_search 1.5.0 → 2.0.0.rc1

data/test/search_engines/google_site_search_test.rb

@@ -7,123 +7,123 @@ require 'cgi'
 # ENV GOOGLE_SITE_SEARCH_KEY and GOOGLE_SITE_SEARCH_CX
 class GoogleSiteSearchTest < ActiveSupport::TestCase
   extend TestWithCassette
-  
+
   @@api_key = ENV["GOOGLE_SITE_SEARCH_KEY"] || "DUMMY_API_KEY"
   @@cx      = ENV["GOOGLE_SITE_SEARCH_CX"] || "DUMMY_CX"
-  
+
   VCR.configure do |c|
     c.filter_sensitive_data("DUMMY_API_KEY", :google_site) { @@api_key }
     c.filter_sensitive_data("DUMMY_CX", :google_site) { @@cx }
   end
-  
+
   setup do
     @config = {:api_key => @@api_key, :cx => @@cx}
     @engine = BentoSearch::GoogleSiteSearchEngine.new(@config)
   end
-  
+
   test("basic query construction") do
     url = @engine.send(:construct_query, {:query => "hours policies"})
-    
-    query_params = CGI.parse( URI.parse(url).query )    
+
+    query_params = CGI.parse( URI.parse(url).query )
 
     assert_equal ["hours policies"], query_params["q"]
   end
-  
-  test("pagination construction") do    
+
+  test("pagination construction") do
     url = @engine.send(:construct_query, {:query => "books", :per_page => 5, :start => 10})
-    
+
     query_params = CGI.parse( URI.parse(url).query )
-    
+
     assert_equal ["5"], query_params["num"]
     assert_equal ["11"], query_params["start"]
   end
-  
+
   test("silently refuses to paginate too far") do
     # google won't let you paginate past ~10 pages, (101 - num). We silently
     # refuse
-    
+
     url = @engine.send(:construct_query, {:query => "books", :start => 110})
-    
+
     query_params = CGI.parse( URI.parse(url).query )
-    
+
     assert_equal ["91"], query_params["start"]
   end
-  
+
   test_with_cassette("pagination object is correct for actual page when you ask for too far", :google_site) do
     results = @engine.search("books", :start => 1000)
-    
+
     pagination = results.pagination
-    
+
     assert_equal 10, pagination.current_page
-    assert_equal 91, pagination.start_record    
+    assert_equal 91, pagination.start_record
   end
-  
+
   test("sort query construction") do
     url = @engine.send(:construct_query, {:query => "books", :sort => "date_desc"})
-    
+
     query_params = CGI.parse( URI.parse(url).query )
-    
+
     assert_equal ["date"], query_params["sort"]
   end
-  
-  test_with_cassette("basic smoke test", :google_site) do    
+
+  test_with_cassette("basic smoke test", :google_site) do
     results = @engine.search("books")
-    
+
     assert_present results
     assert_present results.total_items
-    assert_kind_of Fixnum, results.total_items
-    
+    assert_kind_of 1.class, results.total_items
+
     first = results.first
-    
+
     assert_present first.title
     assert_present first.link
     assert_present first.abstract
-    assert_present first.journal_title # used as source_title for display url    
-    
+    assert_present first.journal_title # used as source_title for display url
+
     # no openurls for google, we decided
     assert_nil     BentoSearch::StandardDecorator.new(first, nil).to_openurl
   end
-  
+
   test_with_cassette("with highlighting", :google_site) do
     engine = BentoSearch::GoogleSiteSearchEngine.new(@config.merge(:highlighting => true))
-    
+
     results = engine.search("books")
-    
+
     first = results.first
 
-    assert first.title.html_safe?    
+    assert first.title.html_safe?
     assert first.abstract.html_safe?
-    assert first.journal_title.html_safe?    
+    assert first.journal_title.html_safe?
   end
-  
+
   test_with_cassette("without highlighting", :google_site) do
     engine = BentoSearch::GoogleSiteSearchEngine.new(@config.merge(:highlighting => false))
-    
+
     results = engine.search("books")
-    
+
     first = results.first
-    
-    assert ! first.title.html_safe?    
+
+    assert ! first.title.html_safe?
     assert ! first.abstract.html_safe?
-    assert ! first.journal_title.html_safe?        
+    assert ! first.journal_title.html_safe?
   end
-  
+
   test_with_cassette("empty result set", :google_site) do
     results = nil
     assert_nothing_raised { results = @engine.search('"adfa lakjdr xavier aldkfj 92323kjadf"') }
-    
+
     assert ! results.failed?
-    
-    assert results.empty?    
+
+    assert results.empty?
   end
-  
+
   test_with_cassette("gets format string", :google_site) do
     results = @engine.search("PDF")
 
     # assume at least one result had a PDF format, which it does
     # in our current VCR capture. For a new one, find a search where
-    # it does. 
-    assert_present(results.find_all {|i| i.format_str =~ /PDF/ }, "At least one result has PDF in format_str")    
+    # it does.
+    assert_present(results.find_all {|i| i.format_str =~ /PDF/ }, "At least one result has PDF in format_str")
   end
-  
+
 end

data/test/search_engines/scopus_engine_test.rb

@@ -4,32 +4,32 @@ require 'cgi'
 require 'uri'
 
 # Set shell env SCOPUS_KEY to your api key to test fresh http
-# connections, if you can't use the ones cached by VCR. 
+# connections, if you can't use the ones cached by VCR.
 
 class ScopusEngineTest < ActiveSupport::TestCase
   extend TestWithCassette
-  
+
   # Filter API key out of VCR cache for tag :scopus, which we'll use
-  # in this test. 
+  # in this test.
   @@api_key = (ENV["SCOPUS_KEY"] || "DUMMY_API_KEY")
   VCR.configure do |c|
     c.filter_sensitive_data("DUMMY_API_KEY", :scopus) { @@api_key }
   end
-  
+
   def setup
     @engine = BentoSearch::ScopusEngine.new(:api_key => @@api_key)
   end
-  
-  
+
+
   def test_construct_search_url
     url = @engine.send(:scopus_url, :query => "one two")
-    
+
     assert_equal "http://api.elsevier.com/content/search/index:SCOPUS?query=one+two&sort=refeid", url
   end
-  
+
   def test_construct_fielded_search_url
     url = @engine.send(:scopus_url, :query => "one two", :search_field => "AUTH")
-    
+
     assert_equal "http://api.elsevier.com/content/search/index:SCOPUS?query=AUTH%28one+two%29&sort=refeid", url
   end
 
@@ -46,66 +46,66 @@ class ScopusEngineTest < ActiveSupport::TestCase
     assert_includes query_components, "AUTH(John Smith)"
     assert_includes query_components, "TITLE(Terrible Diseases)"
   end
-  
+
   def test_construct_search_with_per_page
     url = @engine.send(:scopus_url, :query => "one two", :per_page => 30)
-    
+
     assert_equal "http://api.elsevier.com/content/search/index:SCOPUS?query=one+two&count=30&sort=refeid", url
   end
-  
+
   def test_construct_search_with_sort
     url = @engine.send(:scopus_url, :query => "one two", :sort => "date_desc")
-    
+
     assert_equal "http://api.elsevier.com/content/search/index:SCOPUS?query=one+two&sort=-datesort%2C%2Bauth", url
-    
+
     url = @engine.send(:scopus_url, :query => "one two", :sort => "relevance")
-    
+
     assert_equal "http://api.elsevier.com/content/search/index:SCOPUS?query=one+two&sort=refeid", url
-    
+
   end
-  
+
   def test_construct_default_relevance_sort
     url_implicit = @engine.send(:scopus_url, :query => "one two")
     url_explicit = @engine.send(:scopus_url, :query => "one two", :sort => "relevance")
-    
+
     assert_equal url_explicit, url_implicit
   end
-    
-  
+
+
   def test_construct_with_pagination
     url = @engine.send(:scopus_url, :query => "one two", :start => 20, :per_page => 10)
-    
+
     query_hash = CGI.parse(URI.parse(url).query)
-    
+
     assert_equal ["20"], query_hash["start"]
-    assert_equal ["10"], query_hash["count"]    
+    assert_equal ["10"], query_hash["count"]
   end
-  
-  
+
+
   test_with_cassette("bad api key should return error response", :scopus) do
     @engine = BentoSearch::ScopusEngine.new(:api_key => "BAD_KEY_ERROR")
-    
+
     results = @engine.search(:query => "cancer")
 
-    assert results.failed?, "response.failed? should be"  
+    assert results.failed?, "response.failed? should be"
 
     assert_present results.error[:error_info]
     assert_includes results.error[:error_info], "AUTHORIZATION_ERROR"
   end
-  
+
   test_with_cassette("simple search", :scopus) do
     results = @engine.search(:query => "cancer")
-    
+
     assert_not_nil results.total_items, "total_items not nil"
-    assert_kind_of Fixnum, results.total_items
-    
+    assert_kind_of 1.class, results.total_items
+
     assert_not_nil results.start, "start not nil"
     assert_not_nil results.per_page, "per_page not nil"
-    
+
     assert_equal 10, results.length
-    
+
     sample_result = results.first
-    
+
     assert_present sample_result.title
     assert_present sample_result.link
     assert_present sample_result.journal_title
@@ -114,37 +114,37 @@ class ScopusEngineTest < ActiveSupport::TestCase
     assert_present sample_result.volume
     assert_present sample_result.issue
     assert_present sample_result.start_page
-    
-    assert_present sample_result.authors    
-    
+
+    assert_present sample_result.authors
+
     assert_present sample_result.format
-    
+
     assert_present sample_result.unique_id
-    
+
   end
-  
+
   test_with_cassette("zero results search", :scopus) do
     results = @engine.search(:query => "aldfjkadf lakdj zdfzzzz")
     assert ! results.failed?, "results not marked failed"
     assert_equal 0, results.size
   end
-  
+
   test_with_cassette("escaped chars", :scopus) do
     results = @engine.search(:query => "monkey:(brain)")
-    
+
     assert ! results.failed?, "results not marked failed"
   end
-    
-    
-  
+
+
+
   test_with_cassette("fielded search", :scopus) do
     results = @engine.search(:query => "cancer", :semantic_search_field => :title)
 
-    assert results.first.title.downcase.include?("cancer"), "Title includes query term"    
+    assert results.first.title.downcase.include?("cancer"), "Title includes query term"
   end
-  
+
   test_with_cassette("multi-field search", :scopus) do
-    results = @engine.search(:query => 
+    results = @engine.search(:query =>
       { :title => "Protein measurement with the folin phenol reagent",
         :author => "Lowry",
         :issn => "0021-9258"
@@ -168,12 +168,12 @@ class ScopusEngineTest < ActiveSupport::TestCase
     })
 
     assert ! results.failed?
-    assert_equal 1, results.total_items 
+    assert_equal 1, results.total_items
 
     item = results.first
 
     assert item.title.start_with?("Architects and planners in the middle of a road war")
   end
-    
-  
+
+
 end

data/test/search_engines/search_engine_base_test.rb

@@ -5,22 +5,22 @@ class ParseSearchArgumentsTest < ActiveSupport::TestCase
 
   class Dummy
     include BentoSearch::SearchEngine
-    
+
     def search_implementation(args)
       # no-op for now
       BentoSearch::Results.new
     end
-    
+
     def test_parse(*args)
       # original method is protected, this is a lame way
-      # to expose it. 
+      # to expose it.
       parse_search_arguments(*args)
     end
-    
+
     def max_per_page
       40
     end
-    
+
     def search_field_definitions
       {
         "my_title" => {:semantic => :title},
@@ -28,114 +28,125 @@ class ParseSearchArgumentsTest < ActiveSupport::TestCase
         "my_other" => nil
       }
     end
-    
-  end  
-  
-  
+
+  end
+
+
   def test_single_arg
     d = Dummy.new
-    
+
     args = d.test_parse("query")
-    
-    assert_equal( {:query => "query", :per_page => BentoSearch::SearchEngine::DefaultPerPage }, args )        
+
+    assert_equal( {:query => "query", :per_page => BentoSearch::SearchEngine::DefaultPerPage }, args )
   end
-  
+
   def test_two_arg
     d = Dummy.new
-    
+
     args = d.test_parse("query", :arg => "1")
-    
+
     assert_equal( {:query => "query", :arg => "1", :per_page => BentoSearch::SearchEngine::DefaultPerPage }, args )
   end
-  
-     
-  
+
+
+
   def test_convert_page_to_start
     d = Dummy.new
-    
+
     args = d.test_parse(:query => "query", :page => 1, :per_page => 20)
-    
+
     assert_equal 0, args[:start]
     assert_equal 1, args[:page]
     assert_equal 20, args[:per_page]
-    
+
     args = d.test_parse(:query => "query", :page => 3, :per_page => 20)
 
     assert_equal 40, args[:start]
     assert_equal 3, args[:page]
-    assert_equal 20, args[:per_page]    
+    assert_equal 20, args[:per_page]
   end
-  
+
   def test_convert_start_to_page
     d = Dummy.new
-    
-    # rounds down to get closest 'page' if need be. 
+
+    # rounds down to get closest 'page' if need be.
     args = d.test_parse(:query => "query", :start => '19', :per_page => '20')
-    
+
     assert_equal 19, args[:start]
     assert_equal 1,  args[:page]
-    
+
     args = d.test_parse(:query => "query", :start => '20', :per_page => '20')
     assert_equal 2,  args[:page]
   end
-  
-  
+
+
   def test_pagination_to_integer
     d = Dummy.new
-    
+
     args = d.test_parse(:query => "query", :page => "1", :per_page => "20")
     assert_equal 0, args[:start]
     assert_equal 1, args[:page]
     assert_equal 20, args[:per_page]
-    
+
     args = d.test_parse(:query => "query", :start => "20", :per_page => "20")
-    assert_equal 20, args[:start]    
+    assert_equal 20, args[:start]
     assert_equal 20, args[:per_page]
-    
+
   end
-  
+
   def test_ignore_blank_pagination_args
     d = Dummy.new
-    
+
     args = d.test_parse(:query => "query", :page => "", :per_page => "", :start => "")
-    
+
     assert ! (args.has_key? :page)
     assert ! (args.has_key? :start)
-    assert  (args.has_key? :per_page) # default per page always provided    
+    assert  (args.has_key? :per_page) # default per page always provided
   end
-  
+
   def test_enforce_max_per_page
     d = Dummy.new
-    
-    assert_raise(ArgumentError) { d.test_parse(:query => "query", :per_page => 1000) }        
+
+    assert_raise(ArgumentError) { d.test_parse(:query => "query", :per_page => 1000) }
+  end
+
+  def test_default_per_page
+    d = Dummy.new
+
+    args = d.test_parse(:query => "query")
+    assert_equal(Dummy::DefaultPerPage, args[:per_page])
+
+    d.configuration[:default_per_page] = 2
+    args = d.test_parse(:query => "query")
+    assert_equal(2, args[:per_page])
   end
-    
-  def test_search_field_keys    
+
+  def test_search_field_keys
     assert_equal ["my_title", "my_author", "my_other"], Dummy.new.search_keys
     assert_equal ["title", "author"], Dummy.new.semantic_search_keys
   end
-  
+
   def test_semantic_search_map
-    assert_equal( {"title" => "my_title", "author" => "my_author"}, 
+    assert_equal( {"title" => "my_title", "author" => "my_author"},
       Dummy.new.semantic_search_map)
   end
-  
+
   def test_translate_search_field_semantics
     d = Dummy.new
-    
+
     args = d.test_parse(:query => "query", :semantic_search_field => :title)
-    
+
     assert ! (args.has_key? :semantic_search_field), "translates semantic_search_field to search_field"
     assert_equal "my_title", args[:search_field]
-    
+
     assert_raise(ArgumentError, "Raises for undefined semantic_search_field when asked") do
       d.test_parse(:query => "query", :semantic_search_field => :subject, :unrecognized_search_field => :raise)
     end
     # without the :unrecognized_search_field => :raise, ignore
     args = d.test_parse(:query => "query", :semantic_search_field => :subject)
-    assert_nil args[:search_field]    
+    assert_nil args[:search_field]
   end
-  
+
   def test_unrecognized_search_field
     d = Dummy.new
     assert_raise(ArgumentError, "Raises for undefined search field when asked") do
@@ -144,7 +155,7 @@ class ParseSearchArgumentsTest < ActiveSupport::TestCase
     assert_nothing_raised do
       d.test_parse(:query => "query", :search_field => "I_made_this_up")
     end
-    
+
     # combine config and args
     engine = BentoSearch::MockEngine.new(:unrecognized_search_field => :raise)
     assert_raise(ArgumentError, "Raises for undefined search field when asked") do
@@ -153,7 +164,7 @@ class ParseSearchArgumentsTest < ActiveSupport::TestCase
     assert_nothing_raised do
       engine.normalized_search_arguments(:query => "query", :search_field => "I_made_this_up", :unrecognized_search_field => :ignore)
     end
-    
+
   end
 
 
@@ -170,26 +181,26 @@ class ParseSearchArgumentsTest < ActiveSupport::TestCase
     end
 
     it "converts semantic search fields" do
-      engine = MockEngine.new(:multi_field_search => true, 
+      engine = MockEngine.new(:multi_field_search => true,
         :search_field_definitions => {
           "internal_title_field"  => {:semantic => :title},
-          "internal_author_field" => {:semantic => :author}  
+          "internal_author_field" => {:semantic => :author}
         })
 
       engine.search(:query => {:title => "title query", :author => "author query"})
 
       assert_equal(
-        { "internal_title_field"  => "title query", 
+        { "internal_title_field"  => "title query",
           "internal_author_field" => "author query"},
         engine.last_args[:query]
       )
     end
 
     it "passes through other fields" do
-      engine = MockEngine.new(:multi_field_search => true, 
+      engine = MockEngine.new(:multi_field_search => true,
         :search_field_definitions => {
           "internal_title_field"  => {:semantic => :title},
-          "internal_author_field" => {:semantic => :author}  
+          "internal_author_field" => {:semantic => :author}
         })
 
       engine.search(:query => {"internal_title_field" => "query", "other field" => "query"})
@@ -201,81 +212,92 @@ class ParseSearchArgumentsTest < ActiveSupport::TestCase
     end
 
     it "complains on unrecognized field if configured" do
-      engine = MockEngine.new(:multi_field_search => true, 
+      engine = MockEngine.new(:multi_field_search => true,
         :unrecognized_search_field => "raise",
         :search_field_definitions => {
           "internal_title_field"  => {:semantic => :title},
-          "internal_author_field" => {:semantic => :author}  
-        })      
+          "internal_author_field" => {:semantic => :author}
+        })
       assert_raises(ArgumentError) do
         engine.search(:query => {"internal_title_field" => "query", "other field" => "query"})
       end
     end
   end
-  
+
   def test_semantic_blank_ignored
     d = Dummy.new
-    
+
     args1 = d.test_parse(:query => "query", :semantic_search_field => nil)
     args2 = d.test_parse(:query => "query", :semantic_search_field => nil)
-    
+
     assert_nil args1[:search_field]
     assert_nil args2[:search_field]
   end
-  
+
   def test_semantic_string_or_symbol
     d = Dummy.new
-    
+
     args1 = d.test_parse(:query => "query", :semantic_search_field => :title)
     args2 = d.test_parse(:query => "query", :semantic_search_field => "title")
-    
-    assert_equal args1, args2    
+
+    assert_equal args1, args2
   end
-  
+
   def test_converts_sort_to_string
     d = Dummy.new
-    
+
     args = d.test_parse(:query => "query", :sort => :title_asc)
-    
+
     assert_equal "title_asc", args[:sort]
   end
-  
+
   def test_sets_timing
     d = Dummy.new
     results = d.search("foo")
-    
+
     assert_not_nil results.timing
-    assert_not_nil results.timing_ms    
+    assert_not_nil results.timing_ms
   end
-    
+
   def test_passes_arbitrary_keys
     d = Dummy.new
     args = d.test_parse(:query => "foo", :custom_auth => true)
-    
+
     assert_present args[:custom_auth]
     assert_equal true, args[:custom_auth]
-    
+
   end
-  
+
   def test_rescues_exceptions
     horrible_engine = Class.new do
       include BentoSearch::SearchEngine
-      
+
       def search_implementation(args)
-        raise TimeoutError.new("I am a horrible engine")
+        raise BentoSearch::RubyTimeoutClass.new("I am a horrible engine")
       end
     end
-    
+
     engine = horrible_engine.new
-    
-    results =  engine.search("cancer") 
-    
+
+    results =  engine.search("cancer")
+
     assert_not_nil results
     assert results.failed?, "results marked failed"
     assert_not_nil results.error[:exception], "results.error has exception"
-    
-    assert_equal "I am a horrible engine", results.error[:exception].message, "results.error has right exception"    
+
+    assert_equal "I am a horrible engine", results.error[:exception].message, "results.error has right exception"
   end
-  
+
+  def test_cover_consistency_api
+    d = Dummy.new()
+    assert_nil d.engine_id
+    assert_equal({}, d.display_configuration)
+
+    d = Dummy.new(id: 'test', for_display: { testkey: 'test' })
+    assert_equal 'test', d.engine_id
+    assert_equal({ testkey: 'test' }, d.display_configuration)
+
+  end
+
 end