bento_search 1.5.0 → 1.6.0

data/test/search_engines/doaj_articles_engine_test.rb

@@ -5,7 +5,7 @@ require 'cgi'
 class DoajArticlesEngineTest < ActiveSupport::TestCase
   extend TestWithCassette
 
-  def setup    
+  def setup
     @engine = BentoSearch::DoajArticlesEngine.new
     # tell it not to send our bad API key
   end
@@ -13,15 +13,15 @@ class DoajArticlesEngineTest < ActiveSupport::TestCase
   test_with_cassette("basic search", :doaj_articles) do
     results = @engine.search("Breast cancer patients with lobular cancer more commonly have a father than a mother diagnosed with cancer")
 
-    assert_kind_of BentoSearch::Results, results    
+    assert_kind_of BentoSearch::Results, results
     assert ! results.failed?
 
     assert_not_nil results.total_items
     assert_equal 0, results.start
     assert_equal 10, results.per_page
-    
+
     assert_not_empty results
-    
+
     first = results.first
 
     assert_present first.unique_id
@@ -52,11 +52,11 @@ class DoajArticlesEngineTest < ActiveSupport::TestCase
 
   test_with_cassette("pagination", :doaj_articles) do
     results = @engine.search("cancer", :per_page => 20, :page => 3)
-    
+
     assert ! results.failed?
-    
+
     assert_equal 20, results.length
-    
+
     assert_equal 20, results.size
     assert_equal 40, results.start
     assert_equal 20, results.per_page
@@ -70,7 +70,7 @@ class DoajArticlesEngineTest < ActiveSupport::TestCase
     assert results.failed?
     assert_kind_of Hash, results.error
     assert_present results.error[:message]
-    assert_present results.error[:status]    
+    assert_present results.error[:status]
   end
 
   test_with_cassette("live #get(identifier) round trip", :doaj_articles) do
@@ -197,4 +197,4 @@ class DoajArticlesEngineTest < ActiveSupport::TestCase
     assert_equal ["article.created_date:desc"], query["sort"]
   end
 
-  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,114 @@ 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_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 +144,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 +153,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 +170,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 +201,81 @@ 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
-  
+
 end
 

data/test/search_engines/search_engine_test.rb

@@ -4,50 +4,50 @@ require 'test_helper'
 
 class SearchEngineTest < ActiveSupport::TestCase
   MockEngine = BentoSearch::MockEngine
-  
+
     test "takes configuration" do
       conf = Confstruct::Configuration.new( :foo => "foo", :bar => "bar", :top => {:next => "required key"} )
       engine = MockEngine.new(conf)
-      
+
       assert_not_nil engine.configuration
       assert_equal "foo", engine.configuration.foo
       assert_equal "bar", engine.configuration.bar
       assert_equal "required key", engine.configuration.top.next
     end
-    
+
     test "nested configuration with hash" do
       # possible bug in Confstruct make sure we're working around
-      # if needed. 
+      # if needed.
       # https://github.com/mbklein/confstruct/issues/14
       engine = MockEngine.new("top" => {"one" => "two"})
-      
-      assert_equal "two", engine.configuration.top.one       
+
+      assert_equal "two", engine.configuration.top.one
     end
-    
+
     test "nested required config key" do
       requires_class = Class.new(MockEngine) do
         def self.required_configuration
           ["required.mykey"]
         end
       end
-            
+
       assert_raise ArgumentError do
         requires_class.new
-      end      
-      
+      end
+
       assert_raise ArgumentError do
         requires_class.new(:requires => {})
       end
-      
+
       assert_raise ArgumentError do
         requires_class.new(:required => {:mykey => nil})
       end
-      
+
       assert_nothing_raised do
         requires_class.new(:required => {:mykey => "foo"})
       end
     end
-     
+
     test "merges default configuration" do
       @dummy_class = Class.new do
         include BentoSearch::SearchEngine
@@ -59,120 +59,120 @@ class SearchEngineTest < ActiveSupport::TestCase
           }
         end
       end
-      
+
       engine = @dummy_class.new( :two => "new", :array => ["one", "two"], :nested => {:two => "new"}, :required => {:mykey => "required key"} )
-      
+
       assert_kind_of Confstruct::Configuration, engine.configuration
       assert_equal "default"      , engine.configuration.one
       assert_equal "new"          , engine.configuration.two
       assert_equal "default"      , engine.configuration.nested.one
       assert_equal "new"          , engine.configuration.nested.two
-      assert_equal ["one", "two"] , engine.configuration.array      
+      assert_equal ["one", "two"] , engine.configuration.array
     end
-    
+
     test "no default configuration" do
       @dummy_class = Class.new do
         include BentoSearch::SearchEngine
       end
-      
+
       engine = @dummy_class.new( :one => "one" )
-      
+
       assert_kind_of Confstruct::Configuration, engine.configuration
       assert_equal "one", engine.configuration.one
     end
-      
+
     test "sets metadata on results" do
       engine = MockEngine.new(:id => "foo")
-      
+
       results = engine.search(:query => "cancer", :per_page => 20)
-      
+
       assert_present results.search_args
       assert_equal "foo", results.engine_id
-      
+
       pagination = results.pagination
       assert_present pagination
-      
+
       assert_equal 20, pagination.per_page
       assert_equal 1, pagination.current_page
       assert_equal 1, pagination.start_record
       assert_equal 20, pagination.end_record
       assert pagination.first_page?
-      
+
       assert_present pagination.total_pages
       assert_present pagination.count_records
-            
+
     end
-    
+
     test "sets metadata on items" do
-      engine = MockEngine.new(:id => "foo", :for_display => {:mykey => "value", :decorator => "Foo"})      
+      engine = MockEngine.new(:id => "foo", :for_display => {:mykey => "value", :decorator => "Foo"})
       results = engine.search(:query => "cancer")
       record = results.first
-      
+
       assert_present record.engine_id
       assert_present record.display_configuration
-      assert_present record.decorator      
+      assert_present record.decorator
     end
-    
+
     test "failed sets metadata on results" do
       engine = MockEngine.new(:id => "fail_engine", :error => {:message => "failed"}, :for_display => {:foo => "foo"})
-      
+
       results = engine.search(:query => "cancer", :per_page => 20)
-      
+
       assert          results.failed?
       assert_present  results.error
       assert_equal    "fail_engine", results.engine_id
       assert_present  results.search_args
-      assert_equal(  {:foo => "foo"}, results.display_configuration )       
+      assert_equal(  {:foo => "foo"}, results.display_configuration )
     end
-    
+
     test "auto rescued exception, with proper metadata" do
-      engine = MockEngine.new(:id => "raises", :raise_exception_class => 'TimeoutError', :for_display => {:foo => "foo"})
-      
+      engine = MockEngine.new(:id => "raises", :raise_exception_class => BentoSearch::RubyTimeoutClass.name, :for_display => {:foo => "foo"})
+
       results = engine.search("foo", :per_page => 20)
-      
+
       assert          results.failed?, "marked failed"
-      assert_present  results.error      
+      assert_present  results.error
       assert_equal    "raises", results.engine_id
       assert_present  results.search_args
       assert_equal    "foo", results.search_args[:query]
-      
+
       assert_equal(  {:foo => "foo"}, results.display_configuration )
     end
-      
-    
+
+
     test "has empty :for_display config" do
       engine = MockEngine.new
-      
+
       assert_not_nil engine.configuration.for_display
     end
-    
+
     test "error results still filled out okay" do
       engine = MockEngine.new(:error => {:msg => "forced error"}, :id => "test")
-      
+
       results = engine.search("foo")
-      
+
       assert_present results.search_args
       assert_equal "test", results.engine_id
-      
+
       pagination = nil
       assert_nothing_raised {  pagination = results.pagination  }
-      
+
       assert_present pagination
       assert_equal 0, pagination.count_records
-      
+
     end
-    
-    
+
+
     test "carries display configuration over to results" do
-      engine = MockEngine.new(:id => "foo", 
+      engine = MockEngine.new(:id => "foo",
         :for_display => {:foo => "bar", :nested => {"one" => "two"}}
       )
-      
+
       results = engine.search("foo")
 
       assert_present  results.display_configuration
-      assert_present  results.display_configuration.foo      
-      assert_present  results.display_configuration.nested.one                  
+      assert_present  results.display_configuration.foo
+      assert_present  results.display_configuration.nested.one
     end
-    
+
 end