bento_search 1.5.0 → 2.0.0.rc1

data/test/helper/bento_search_helper_test.rb

@@ -1,246 +1,246 @@
 # encoding: UTF-8
+require 'nokogiri'
 
 require 'test_helper'
 
 class BentoSearchHelperTest < ActionView::TestCase
   include BentoSearchHelper
-  
+
   MockEngine = BentoSearch::MockEngine
-  
+
   def teardown
     BentoSearch.reset_engine_registrations!
   end
-  
+
   def setup
     # Make routing work
-    @routes = Rails.application.routes   
-    
+    @routes = Rails.application.routes
+
   end
-  
+
   def test_with_results_arg
     results = MockEngine.new.search(:query => "foo")
-    bento_search(results)    
-    
+    bento_search(results)
+
     assert_select("div.bento_item", 10)
   end
-  
+
   def test_custom_partial
     results = MockEngine.new(:for_display => {:item_partial => "test_custom_item_partial"})
-    
+
     bento_search(results)
-    
+
     assert_select("p.custom_item_partial")
   end
-  
+
   def test_with_failed_search
     results = BentoSearch::Results.new
     results.error = {:error => true}
-    
+
     assert results.failed?
-    
-    response = HTML::Document.new(bento_search(results))
-    
-    assert (no_results_div = response.find(:attributes => {:class => "bento_search_error alert alert-error"})), "has search_error div"
-    
-    assert no_results_div.match(Regexp.new I18n.translate("bento_search.search_error")), "has error message"
 
-    assert_nil response.find(:attributes => {:class => "bento_item"})    
+    response = Nokogiri::HTML(bento_search(results))
+
+    assert (no_results_div = response.at_css(".bento_search_error.alert.alert-error")), "has search_error div"
+
+    assert no_results_div.text =~ Regexp.new(I18n.translate("bento_search.search_error")), "has error message"
+
+    assert_nil response.at_css(".bento_item")
   end
-  
+
   def test_with_empty_results
     results = MockEngine.new(:num_results => 0).search(:query => "foo")
-    
-    response = HTML::Document.new(bento_search(results))
-    
-    assert (no_results_div = response.find(:attributes => {:class => "bento_search_no_results"})), "has no_results div"
-    assert no_results_div.match(Regexp.new(I18n.translate("bento_search.no_results")))
 
-    
-    assert_nil response.find(:attributes => {:class => "bento_item"}), "has no results message"
+    response = Nokogiri::HTML(bento_search(results))
+
+    assert (no_results_div = response.at_css(".bento_search_no_results")), "has no_results div"
+    assert no_results_div.text =~ (Regexp.new(I18n.translate("bento_search.no_results")))
+
+    assert_nil response.at_css(".bento_item"), "has no results message"
   end
-  
+
   def test_with_engine_arg
     engine = MockEngine.new
     bento_search(engine, :query => "QUERY")
-    
+
     assert_select("div.bento_item", 10).each_with_index do |node, i|
       assert_select node, "*", /QUERY/
       assert_select node, "*", /#{i +1 }/
-    end    
+    end
   end
-  
+
   def test_with_registered_id
     BentoSearch.register_engine("test_engine") do |conf|
       conf.engine = "MockEngine"
     end
-    
+
     bento_search("test_engine", :query => "QUERY")
-    
+
     assert_select("div.bento_item", 10).each_with_index do |node, i|
       assert_select node, "*", /QUERY/
-      assert_select node, "*", /#{i +1 }/      
-    end    
+      assert_select node, "*", /#{i +1 }/
+    end
   end
-  
+
   def test_ajax_load_without_registration
     assert_raises(ArgumentError) { bento_search(MockEngine.new, :load => :ajax_auto) }
   end
-  
 
-  
-  def test_ajax_load 
+
+
+  def test_ajax_load
     BentoSearch.register_engine("test_engine") do |conf|
       conf.engine = "MockEngine"
     end
-    
+
     results = bento_search("test_engine", :query => "QUERY", :load => :ajax_auto)
-    results = HTML::Document.new(results)
-    
-    
-    div = results.find(:attributes => {:class => "bento_search_ajax_wait"})
+    results = Nokogiri::HTML(results)
+
+
+    div = results.at_css(".bento_search_ajax_wait")
     assert div, "produces div.bento_search_ajax_wait"
+
     assert_equal "ajax_auto", div["data-bento-search-load"], "has data-bento-search-load attribute"
 
-    
-    assert_present div.attributes["data-bento-ajax-url"]    
-    url = URI.parse(div.attributes["data-bento-ajax-url"])    
+    assert_present div["data-bento-ajax-url"]
+    url = URI.parse(div["data-bento-ajax-url"])
     assert_equal "/bento/test_engine", url.path
-    
+
     query = CGI.parse(url.query.gsub("&amp;", "&")) # gsub weirdness of HTML::Tag
     assert_equal ["QUERY"], query["query"]
     assert_empty query["load"]
-    
+
     # hidden loading msg
-    loading_msg = div.find(:attributes => {:class => "bento_search_ajax_loading"})
+    loading_msg = div.at_css(".bento_search_ajax_loading")
     assert_present loading_msg, "bento_search_ajax_loading present"
     assert_match /display\:none/, loading_msg["style"], "loading has CSS style hidden"
-        
-    assert div.find(:tag => "noscript"), "has <noscript> tag"
-    
-    assert (img = loading_msg.find(:tag => "img")), "Has spinner gif"
-    assert_equal I18n.translate("bento_search.ajax_loading"), img.attributes["alt"]
+
+    assert div.at_css("noscript"), "has <noscript> tag"
+
+    assert (img = loading_msg.at_css("img")), "Has spinner gif"
+    assert_equal I18n.translate("bento_search.ajax_loading"), img["alt"]
   end
-  
+
   def test_ajax_triggered_load
     BentoSearch.register_engine("test_engine") do |conf|
       conf.engine = "MockEngine"
     end
-    
+
     results = bento_search("test_engine", :query => "QUERY", :load => :ajax_triggered)
-    results = HTML::Document.new(results)
+    results = Nokogiri::HTML(results)
 
-    div = results.find(:attributes => {:class => "bento_search_ajax_wait"})
+    div = results.at_css(".bento_search_ajax_wait")
     assert div, "produces div.bento_search_ajax_wait"
     assert_equal "ajax_triggered", div["data-bento-search-load"], "has data-bento-search-load attribute"
 
     # hidden loading msg
-    loading_msg = div.find(:attributes => {:class => "bento_search_ajax_loading"})
+    loading_msg = div.at_css(".bento_search_ajax_loading")
     assert_present loading_msg, "bento_search_ajax_loading present"
     assert_match /display\:none/, loading_msg["style"], "loading has CSS style hidden"
   end
-    
-    
+
+
   def test_sort_hash_for
     tested_keys = %w{title_asc date_desc relevance author_asc}
-    
+
     sort_definitions = {}
     tested_keys.each {|k| sort_definitions[k] = {}}
-    
+
     engine = MockEngine.new(:sort_definitions => sort_definitions)
 
     hash = bento_sort_hash_for(engine)
-    
+
     assert_present hash
-    
+
     tested_keys.each do |key|
       assert_equal key, hash[ I18n.translate(key, :scope => "bento_search.sort_keys") ]
-    end            
+    end
   end
-  
+
   def test_sort_hash_for_no_i18n
-    # If there's no 18n key available, use reasonable humanized approximation 
-    
+    # If there's no 18n key available, use reasonable humanized approximation
+
     engine = MockEngine.new(:sort_definitions => {"no_key_test" => {}})
-    
+
     hash = bento_sort_hash_for(engine)
-            
+
     assert_present hash
-    
+
     key = hash.key("no_key_test")
-      
+
     assert_no_match /translation missing/, key
-    
+
     assert_equal "No Key Test", key
   end
-  
+
   def test_field_hash_for
     # generic
     hash = bento_field_hash_for(nil)
-    
+
     assert_equal I18n.t("bento_search.search_fields").invert, hash
-    
+
     # specific engine
     engine = MockEngine.new(:search_field_definitions => {
         :mytitle => {:semantic => :title},
         :myauthor => {:semantic => :author},
         :myissn => {:semantic => :issn},
-        :mycustom => {}        
-    })    
+        :mycustom => {}
+    })
     hash = bento_field_hash_for(engine)
     expected = { I18n.t("bento_search.search_fields.title") => 'title',
       I18n.t("bento_search.search_fields.author") => 'author',
-      I18n.t("bento_search.search_fields.issn") => 'issn',    
+      I18n.t("bento_search.search_fields.issn") => 'issn',
     }
     assert_equal expected, hash
-    
+
     # only
     hash = bento_field_hash_for(engine, :only => :author)
     assert_equal( {"Author" => "author"}, hash )
     hash = bento_field_hash_for(engine, :only => ["author", "title"])
     assert_equal( {"Title" => "title", "Author" => "author"}, hash )
-     
+
     # except
-    
-    
+
+
   end
-  
+
   def test_bento_decorate
     item = BentoSearch::ResultItem.new(:title => "foo")
-    
+
     decorated = bento_decorate(item)
-    
+
     assert_kind_of BentoSearch::StandardDecorator, decorated
-    
+
     assert_equal "foo", decorated.title
-    
-    assert decorated.send("_h").respond_to?(:url_for), "has ActionView helpers available internally"        
+
+    assert decorated.send("_h").respond_to?(:url_for), "has ActionView helpers available internally"
   end
-  
+
   def test_bento_decorate_with_yield
     item = BentoSearch::ResultItem.new(:title => "foo")
-    
+
     got_here = false
-    
+
     bento_decorate(item) do |decorated|
       got_here = true
       assert_equal "foo", decorated.title
     end
-    
+
     assert got_here, "Yielded block is called"
-    
+
   end
-  
+
   class SomeDecorator < BentoSearch::StandardDecorator ; end
-  
+
   def test_bento_decorate_with_custom_decorator
     item = BentoSearch::ResultItem.new(:title => "foo", :decorator => "BentoSearchHelperTest::SomeDecorator")
-    
+
     decorated = bento_decorate(item)
-    
+
     assert_kind_of BentoSearchHelperTest::SomeDecorator, decorated
   end
 
-    
 
-  
+
+
 end

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/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