bento_search 1.7.0.beta.1 → 1.7.0

data/app/views/bento_search/_ajax_loading.html.erb

@@ -0,0 +1,17 @@
+<% # An initially hidden div with loading msg/spinner that will be shown
+   # by js on ajax load
+%>
+
+<noscript>
+  <%= I18n.t("bento_search.ajax_noscript") %>
+</noscript>
+
+<%=
+  content_tag(:div,
+    :class => "bento_search_ajax_loading",
+    :style => "display:none") do
+      image_tag("bento_search/large_loader.gif",
+        :alt => I18n.translate("bento_search.ajax_loading")
+      )
+    end
+%>

data/app/views/bento_search/_link.html.erb

@@ -1,6 +1,6 @@
-<%= link_to(link.label, link.url, 
-      :rel    => link.rel, 
+<%= link_to(link.label, link.url,
+      :rel    => link.rel,
       :class  => (link.style_classes + ["bento_search_link", "btn", "btn-mini", "btn-default", "btn-sm"]),
-      :target => link.target
+      :target => local_assigns[:target] || link.target
       ) %>
 

data/lib/bento_search.rb

@@ -47,6 +47,18 @@ module BentoSearch
   # Avoid deprecation warnings in ruby 2.3.0
   RubyTimeoutClass = (defined?(Timeout::Error) ? Timeout::Error : TimeoutError)
 
+  @@defaults = Confstruct::Configuration.new(
+    error_partial: 'bento_search/search_error',
+    item_partial: 'bento_search/std_item',
+    no_results_partial: 'bento_search/no_results',
+    ajax_loading_partial: 'bento_search/ajax_loading'
+  )
+  def self.set_defaults(hash)
+    @@defaults.merge!(hash)
+  end
+  def self.defaults
+    @@defaults
+  end
 end
 
 

data/lib/bento_search/engine.rb

@@ -1,5 +1,7 @@
 module BentoSearch
   class Engine < ::Rails::Engine
     #isolate_namespace BentoSearch
+
+    config.assets.precompile += %w( bento_search/large_loader.gif )
   end
 end

data/lib/bento_search/version.rb

@@ -1,3 +1,3 @@
 module BentoSearch
-  VERSION = "1.7.0.beta.1"
+  VERSION = "1.7.0"
 end

data/test/search_engines/eds_engine_test.rb

@@ -2,12 +2,14 @@ require 'test_helper'
 
 class EdsEngineTest < ActiveSupport::TestCase
   extend TestWithCassette
-  
+
   @@user_id   = (ENV['EDS_USER_ID'] || 'DUMMY_USER_ID')
   @@password  = (ENV['EDS_PASSWORD'] || 'DUMMY_PWD')
-  @@profile   = (ENV['EDS_PROFILE'] || 'edsapi')
-  
-  
+  @@profile   = (ENV['EDS_PROFILE'] || 'wsapi')
+  # something where the first hit will be from catalog for the profile above
+  @@catalog_result_query = (ENV['EDS_CATALOG_RESULT_QUERY'] || 'New York exposed the gilded age police scandal that launched the progressive era Daniel Czitrom')
+  @@catalog_ebook_result_query = (ENV['EDS_CATALOG_EBOOK_RESULT_QUERY'] || 'Stakeholder forum on federal wetlands mitigation environmental law institute')
+  @@catalog_custom_result_query = (ENV['EDS_CATALOG_CUSTOM_RESULT_QUERY'] || 'Drafting New York Civil-Litigation Documents Part XXIV Summary-Judgment Motions Continued')
   VCR.configure do |c|
     c.filter_sensitive_data("DUMMY_USER_ID", :eds) { @@user_id }
     c.filter_sensitive_data("DUMMY_PWD", :eds) { @@password }
@@ -16,140 +18,170 @@ class EdsEngineTest < ActiveSupport::TestCase
   def setup
     # Class-level remembered auth token messes up our VCR-recording,
     # since one test will try to use an auth token fetched by a different
-    # test. For testing, blank out the cache before each test. 
+    # test. For testing, blank out the cache before each test.
     BentoSearch::EdsEngine.remembered_auth = nil
 
     @config = {:user_id => @@user_id, :password => @@password, :profile => @@profile, :auth => true}
     @engine = BentoSearch::EdsEngine.new(@config)
   end
-  
+
   test "construct simple search, with comma escaping" do
     url = @engine.construct_search_url(:query => "foo, bar,baz")
-    
+
     query_params = CGI.parse( URI.parse(url).query )
 
     assert_equal ["all"], query_params["searchmode"]
-    
+
     assert_equal ["detailed"], query_params["view"]
-    
-    assert_equal ["AND,foo  bar baz"], query_params["query"]   
+
+    assert_equal ["AND,foo  bar baz"], query_params["query"]
   end
-  
+
   test "only_source_types config" do
     engine = BentoSearch::EdsEngine.new( @config.merge(:only_source_types => [
       "Academic Journals", "Magazines"
       ]))
-    
+
     url = engine.construct_search_url(:query => "cancer", :per_page => 10)
-    
+
     query_params = CGI.parse( URI.parse(url).query )
-    
+
     # should be
     # facetfilter=1,SourceType:Academic Journals,SourceType:Magazines
     # but with value query encoded
-    
+
     assert_equal 1, query_params["facetfilter"].length
-    
+
     facetfilter = query_params["facetfilter"].first
-    
+
     parts = facetfilter.split(",")
-    
+
     assert_equal 3, parts.length
-    
+
     assert_equal "1", parts.first
-    
+
     assert_includes parts, "SourceType:Academic Journals"
-    assert_includes parts, "SourceType:Magazines"        
+    assert_includes parts, "SourceType:Magazines"
   end
-  
+
   def test_has_http_timeout_set
     assert_equal BentoSearch::EdsEngine::HttpTimeout, @engine.http_client.receive_timeout
     assert_equal BentoSearch::EdsEngine::HttpTimeout, @engine.http_client.send_timeout
     assert_equal BentoSearch::EdsEngine::HttpTimeout, @engine.http_client.connect_timeout
-  end 
+  end
+
 
-  
   test_with_cassette("get_auth_token failure", :eds) do
     engine = BentoSearch::EdsEngine.new(:user_id => "bad", :password => "bad", :profile => "bad")
     exception = assert_raise(BentoSearch::EdsEngine::EdsCommException) do
       token = engine.get_auth_token
-    end    
-    
+    end
+
     assert_present exception.http_status
-    assert_present exception.http_body    
+    assert_present exception.http_body
   end
-  
+
   test_with_cassette("get_auth_token", :eds) do
     token = @engine.get_auth_token
-    
+
     assert_present token
   end
-  
+
   # No idea why VCR is having buggy problems with record and playback of this request
-  # We'll emcompass it in the get_with_auth test 
+  # We'll emcompass it in the get_with_auth test
   #
-  #test_with_cassette("with_session", :eds, :match_requests_on => [:method, :uri, :headers, :body]) do    
+  #test_with_cassette("with_session", :eds, :match_requests_on => [:method, :uri, :headers, :body]) do
   #  @engine.with_session do |session_token|
   #    assert_present session_token
-  #  end      
+  #  end
   #end
-  
+
   test_with_cassette("get_with_auth", :eds) do
     @engine.with_session do |session_token|
       assert_present session_token
-      
+
       # Coudln't get 'info' request to work even as a test, let's
-      # try a simple search. 
+      # try a simple search.
       url = "#{@engine.configuration.base_url}info"
       response = @engine.get_with_auth(url, session_token)
-      
+
       assert_present response
       assert_kind_of Nokogiri::XML::Document, response
-      
-      assert_nil response.at_xpath("//ErrorNumber"), "no error report in result"             
-    end      
+
+      assert_nil response.at_xpath("//ErrorNumber"), "no error report in result"
+    end
   end
-  
+
   test_with_cassette("get_with_auth recovers from bad auth", :eds) do
       @engine.with_session do |session_token|
         BentoSearch::EdsEngine.remembered_auth = "BAD"
-        
+
         url = "#{@engine.configuration.base_url}info"
         response = @engine.get_with_auth(url, session_token)
-        
+
         assert_present response
         assert_kind_of Nokogiri::XML::Document, response
-        
-        assert_nil response.at_xpath("//ErrorNumber"), "no error report in result"             
-      end        
-      
+
+        assert_nil response.at_xpath("//ErrorNumber"), "no error report in result"
+      end
+
       BentoSearch::EdsEngine.remembered_auth = nil
   end
-  
+
   test_with_cassette("basic search smoke test", :eds) do
-      results = @engine.search("cancer")    
-      
+      results = @engine.search("cancer")
+
       assert_present results
-      
+
       assert_present results.total_items
-      
+
       first = results.first
 
       assert_present first.title
       assert first.title.html_safe? # yeah, for now we use EDS html
-      
+
       assert_present first.abstract
       assert_present first.abstract.html_safe?
-      
-      assert_present first.custom_data["citation_blob"]      
-      
+
+      assert_present first.custom_data["citation_blob"]
+
+      assert_present first.source_title
+      assert_present first.issn
+      assert_present first.volume
+      assert_present first.issue
+      assert_present first.year
+      assert_present first.publication_date
+      assert_present first.start_page
+      assert_present first.end_page
+
+      assert_present first.doi
+
       assert_present first.format_str
-      
+
       assert_present first.unique_id
       # EDS id is db name, colon, accession number
       assert_match /.+\:.+/, first.unique_id
   end
-  
-  
+
+  test_with_cassette("catalog query", :eds) do
+    results = @engine.search(@@catalog_result_query)
+
+    cat_result = results.first
+
+    assert_present cat_result.custom_data[:holdings]
+    assert cat_result.custom_data[:holdings].all? { |h| h.location.present? && h.call_number.present? }
+  end
+
+  test_with_cassette("catalog ebook query", :eds) do
+    result = @engine.search(@@catalog_ebook_result_query).first
+
+    assert_present result.other_links
+  end
+
+  test_with_cassette("FullText CustomLink", :eds) do
+    result = @engine.search(@@catalog_custom_result_query).first
+    assert_present result
+    assert result.other_links.any? { |r| r.label.present? && r.label != "Link" && r.url.present? && URI::regexp =~ r.url && r.rel == "alternate"}
+  end
 end
 

data/test/search_engines/search_engine_base_test.rb

@@ -288,5 +288,16 @@ class ParseSearchArgumentsTest < ActiveSupport::TestCase
     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
 

data/test/search_engines/search_engine_test.rb

@@ -132,6 +132,7 @@ class SearchEngineTest < ActiveSupport::TestCase
 
       assert          results.failed?, "marked failed"
       assert_present  results.error
+      assert_present  results.error[:exception]
       assert_equal    "raises", results.engine_id
       assert_present  results.search_args
       assert_equal    "foo", results.search_args[:query]
@@ -139,6 +140,17 @@ class SearchEngineTest < ActiveSupport::TestCase
       assert_equal(  {:foo => "foo"}, results.display_configuration )
     end
 
+    test "can set auto rescued exceptions on instance" do
+      engine = MockEngine.new(:id => "raises", :raise_exception_class => "StandardError", :for_display => {:foo => "foo"})
+      engine.auto_rescued_exceptions = [StandardError]
+
+      results = engine.search("foo", :per_page => 20)
+
+      assert          results.failed?, "marked failed"
+      assert_present  results.error
+      assert_present  results.error[:exception]
+    end
+
 
     test "has empty :for_display config" do
       engine = MockEngine.new

data/test/unit/concurrent_searcher_test.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+
+# Doesn't really test the concurrency, but basic smoke test with fake
+# searchers.
+class ConcurrentSearcherTest < ActiveSupport::TestCase
+  setup do
+    BentoSearch.register_engine("one") do |conf|
+      conf.engine = "MockEngine"
+    end
+    BentoSearch.register_engine("two") do |conf|
+      conf.engine = "MockEngine"
+    end
+    BentoSearch.register_engine("three") do |conf|
+      conf.engine = "MockEngine"
+    end
+
+    BentoSearch.register_engine("raiser") do |conf|
+      conf.engine = "MockEngine"
+      conf.raise_exception_class = "StandardError"
+    end
+  end
+
+  teardown do
+    BentoSearch.reset_engine_registrations!
+  end
+
+
+  def test_concurrent_search
+    searcher = BentoSearch::ConcurrentSearcher.new(:one, :two, :three)
+    returnval = searcher.search("cancer")
+
+    assert_same searcher, returnval
+
+    results = searcher.results
+
+    assert_kind_of Hash, results
+    assert_equal ["one", "two", "three"].sort, results.keys.sort
+
+    ["one", "two", "three"].each do |key|
+      assert_kind_of BentoSearch::Results, results[key]
+    end
+
+    # call results again, we get the exact same hash back.
+    new_results = searcher.results
+    assert_kind_of Hash, new_results
+    assert( results.equal? new_results )
+  end
+
+  def test_results_before_search
+    searcher = BentoSearch::ConcurrentSearcher.new(:one, :two, :three)
+
+    assert_raises(ArgumentError) do
+      results = searcher.results
+    end
+  end
+
+
+  def test_concurrent_search_uncaught_exception
+    searcher = BentoSearch::ConcurrentSearcher.new(:one, :raiser, :two)
+    results = searcher.search("cancer").results
+
+    [:one, :two].each do |success_engine_id|
+      assert( results[success_engine_id.to_s].kind_of?(BentoSearch::Results) )
+      assert( !results[success_engine_id.to_s].failed? )
+    end
+
+
+    error_results = results["raiser"]
+
+    assert( error_results.kind_of?(BentoSearch::Results) )
+    assert( error_results.failed? )
+    assert( error_results.error[:exception].present? )
+    assert( error_results.engine_id == "raiser" )
+  end
+end

data/test/unit/multi_searcher_test.rb

@@ -21,29 +21,26 @@ class MultiSearcherTest < ActiveSupport::TestCase
 
 
   def test_multisearch
-    searcher = BentoSearch::MultiSearcher.new(:one, :two, :three)
-    start_returnval = searcher.start("cancer")
+    ActiveSupport::Deprecation.silence do
+      searcher = BentoSearch::MultiSearcher.new(:one, :two, :three)
+      start_returnval = searcher.start("cancer")
 
-    assert_same searcher, start_returnval
+      assert_same searcher, start_returnval
 
-    results = searcher.results
+      results = searcher.results
 
-    assert_kind_of Hash, results
-    assert_equal ["one", "two", "three"].sort, results.keys.sort
+      assert_kind_of Hash, results
+      assert_equal ["one", "two", "three"].sort, results.keys.sort
 
-    ["one", "two", "three"].each do |key|
-      assert_kind_of BentoSearch::Results, results[key]
-    end
-
-    # call results again, we get an empty hash, can only call
-    # results once per start.
-    new_results = searcher.results
-    assert_kind_of Hash, new_results
-    assert_empty new_results
+      ["one", "two", "three"].each do |key|
+        assert_kind_of BentoSearch::Results, results[key]
+      end
 
+      # call results again, we get an empty hash, can only call
+      # results once per start.
+      new_results = searcher.results
+      assert_kind_of Hash, new_results
+      assert_empty new_results
+    end
   end
-
-
-
-
 end