bento_search 0.5.0 → 0.6.0

data/test/functional/bento_search/search_controller_test.rb

@@ -13,6 +13,17 @@ module BentoSearch
         # no allow_routable_results
       end
       
+      BentoSearch.register_engine("with_layout_config") do |config|
+        config.engine = "MockEngine"
+        
+        config.allow_routable_results = true
+        
+        config.for_display do |display|
+          display.ajax do |ajax|
+            ajax.wrapper_template = "bento_search/wrap_with_count"
+          end
+        end
+      end
     end
     
     def teardown     
@@ -28,6 +39,17 @@ module BentoSearch
       assert_template "bento_search/search"
     end
     
+    test "custom layout config" do
+      get :search, {:engine_id => "with_layout_config", :query => "my search"}
+      
+      assert_response :success
+      
+      assert_not_nil assigns(:partial_wrapper)
+      
+      assert_template "bento_search/_wrap_with_count"
+      assert_template "bento_search/search"
+    end
+    
     test "non-routable engine" do
       get :search, {:engine_id => "not_routable", :query => "my search"}
       
@@ -40,6 +62,22 @@ module BentoSearch
       assert_response 404
     end
     
+        
+    test "respects public_settable_search_args" do
+      get :search, {:engine_id => "mock", 
+          'query' => "query", 'sort' => "sort", 'per_page' => "15", 
+      'page' => "6", 'search_field' => "title", 'not_allowed' => "not allowed"}
+      
+      
+      search_args = assigns[:engine].last_args
+      
+      [:query, :sort, :per_page, :page, :search_field].each do |allowed_key|
+        assert search_args.has_key?(allowed_key)
+      end
+      assert ! search_args.has_key?(:not_allowed)
+      assert ! search_args.has_key?("not_allowed")
+    end
+    
     test "custom before filter" do
       # Okay, we're going to do a weird thing with a custom controller subclass
       # we can add a custom before filter like a local app might. 
@@ -74,6 +112,7 @@ module BentoSearch
       
     end
     
+
     
         
     

data/test/helper/bento_search_helper_test.rb

@@ -1,5 +1,8 @@
 require 'test_helper'
 
+# this seems to work? Rails view testing is a mess. 
+require 'sprockets/helpers/rails_helper'
+
 class BentoSearchHelperTest < ActionView::TestCase
   include BentoSearchHelper
   
@@ -8,13 +11,11 @@ class BentoSearchHelperTest < ActionView::TestCase
   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
@@ -89,6 +90,8 @@ class BentoSearchHelperTest < ActionView::TestCase
     
     div = results.find(:attributes => {:class => "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"])    
@@ -97,12 +100,35 @@ class BentoSearchHelperTest < ActionView::TestCase
     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"})
+    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 = div.find(:tag => "img")), "Has spinner gif"
+    assert (img = loading_msg.find(:tag => "img")), "Has spinner gif"
     assert_equal I18n.translate("bento_search.ajax_loading"), img.attributes["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)
+
+    div = results.find(:attributes => {:class => "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"})
+    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
@@ -121,6 +147,22 @@ class BentoSearchHelperTest < ActionView::TestCase
       assert_equal key, hash[ I18n.translate(key, :scope => "bento_search.sort_keys") ]
     end            
   end
+  
+  def test_sort_hash_for_no_i18n
+    # 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
 
   
 end

data/test/unit/ebsco_host_engine_test.rb

@@ -80,6 +80,18 @@ class EbscoHostEngineTest < ActiveSupport::TestCase
     assert_equal ["cancer "], query_params["query"]
   end
   
+  def test_removes_question_marks
+    # who knows why, ebsco doesn't like question marks even inside
+    # quoted phrases, some special char to ebsco. 
+    url = @engine.query_url(:query => "cancer?", :sort => "date_desc")    
+    query_params = CGI.parse( URI.parse(url).query )    
+    assert_equal ["cancer "], query_params["query"]
+    
+    url = @engine.query_url(:query => '"cancer?"', :sort => "date_desc")
+    query_params = CGI.parse( URI.parse(url).query )    
+    assert_equal ['"cancer "'], query_params["query"]
+  end
+  
   test_with_cassette("live search smoke test", :ebscohost) do
   
     results = @engine.search(:query => "cancer")
@@ -95,6 +107,9 @@ class EbscoHostEngineTest < ActiveSupport::TestCase
     
     assert_present first.format
     assert_present first.format_str
+    
+    assert_present first.language_code
+    assert_present first.language_str
   end
   
   test_with_cassette("get_info", :ebscohost) do

data/test/unit/google_books_engine_test.rb

@@ -35,6 +35,7 @@ class GoogleBooksEngineTest < ActiveSupport::TestCase
     assert_not_empty first.abstract
     assert first.abstract.html_safe?
     
+    assert_present first.language_code
     
     assert_not_empty first.authors
     assert_not_empty first.authors.first.display

data/test/unit/google_site_search_test.rb

@@ -0,0 +1,122 @@
+require 'test_helper'
+
+require 'uri'
+require 'cgi'
+
+# To run these tests without VCR cassettes, need
+# 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 )    
+
+    assert_equal ["hours policies"], query_params["q"]
+  end
+  
+  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    
+  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    
+    results = @engine.search("books")
+    
+    assert_present results
+    assert_present results.total_items
+    assert_kind_of Fixnum, 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    
+    
+    # no openurls for google, we decided
+    assert_nil     first.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.abstract.html_safe?
+    assert first.journal_title.html_safe?
+    
+    assert first.published_in.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.abstract.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?    
+  end
+  
+end

data/test/unit/item_decorators_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class LinkDecoratorsTest < ActiveSupport::TestCase
+class ItemDecoratorsTest < ActiveSupport::TestCase
   MockEngine = BentoSearch::MockEngine
   
   # simple decorator that replaces main link
@@ -35,6 +35,17 @@ class LinkDecoratorsTest < ActiveSupport::TestCase
     end    
   end
   
+  test "decorator as string" do
+    @engine = MockEngine.new(:item_decorators => ["::ItemDecoratorsTest::Decorator"])
+    
+    results = @engine.search(:query => "Query")
+    
+    results.each do |result|
+      assert_kind_of Decorator, result
+    end
+
+  end
+  
   # Is it a good idea to have a decorator that mutates on 'extend'?
   # I'm not sure, I think probably not, but it is possible.
   # Here we'll use it to move an original link to other links

data/test/unit/openurl_creator_test.rb

@@ -1,3 +1,5 @@
+require 'test_helper'
+
 class OpenurlCreatorTest < ActiveSupport::TestCase
   
   def test_create_article
@@ -80,7 +82,7 @@ class OpenurlCreatorTest < ActiveSupport::TestCase
       
   end
   
-  def create_hardcoded_kev
+  def test_create_hardcoded_kev
     item = BentoSearch::ResultItem.new(
       :format => "Book",
       :title => "Something",
@@ -89,13 +91,13 @@ class OpenurlCreatorTest < ActiveSupport::TestCase
     
     r = BentoSearch::OpenurlCreator.new(item).to_openurl.referent
     
-    assert_equal  "article",    r.format
+    assert_equal  "journal",    r.format
     assert_equal  "Foo Bar",    r.metadata["title"]
     assert_equal  "Smith",      r.metadata["au"]
 
   end
   
-  def result_item_to_openurl
+  def test_result_item_to_openurl
     item = BentoSearch::ResultItem.new(
       :format => "Book",
       :title => "Something",
@@ -107,5 +109,19 @@ class OpenurlCreatorTest < ActiveSupport::TestCase
     assert_kind_of OpenURL::ContextObject, openurl
   end
   
+  def test_strip_tags     
+    item = BentoSearch::ResultItem.new(      
+      :title => "<b>My Title</b>".html_safe,
+      :year => 2012,
+      :isbn => "XXXX",                        
+      )
+    
+    openurl = item.to_openurl
+    
+    assert_equal "My Title", openurl.referent.metadata["title"]
+  end
+  
+  
+  
   
 end

data/test/unit/primo_engine_test.rb

@@ -2,12 +2,14 @@ require 'test_helper'
 
 class PrimoEngineTest < ActiveSupport::TestCase
   extend TestWithCassette
-  
-  @@host_port   = (ENV['PRIMO_HOST_PORT'] || 'EXAMPLE.ORG:80' )
+ 
+  # dummy host needs to be in all lowercase, and not explicitly
+  # say '80' to work right with VCR 
+  @@host_port   = (ENV['PRIMO_HOST_PORT'] || 'example.org' )
   @@institution = (ENV['PRIMO_INSTITUTION'] || 'DUMMY_INSTITUTION')
   
   VCR.configure do |c|
-    c.filter_sensitive_data("EXAMPLE.ORG:80", :primo) { @@host_port }
+    c.filter_sensitive_data("example.org", :primo) { @@host_port }
     c.filter_sensitive_data("DUMMY_INSTITUTION", :primo) { @@institution }
   end
   

data/test/unit/result_item_test.rb

@@ -27,10 +27,45 @@ class ResultItemTest < ActiveSupport::TestCase
     assert_equal "new", dup.title
     assert_equal "original", r.title
     
-    assert_not_same dup, r
+    assert_not_same dup, r        
+  end
+  
+  def test_openurl_disabled
+    r = ResultItem.new(:title => "original")
+    
+    assert_present r.to_openurl
+    
+    r.openurl_disabled = true
+    
+    assert_nil r.to_openurl    
+  end
+  
+  def test_language
+    r = ResultItem.new(:title => "something", :language_code => "en")    
+    assert_equal "en",      r.language_code
+    assert_equal "English", r.language_str
+    
+    r = ResultItem.new(:title => "something", :language_code => "eng")
+    assert_equal "eng",      r.language_code
+    assert_equal "English", r.language_str
     
+    # language_str override
+    r = ResultItem.new(:title => "something", :language_code => "en", :language_str => "Weird English")
+    assert_equal "en",            r.language_code
+    assert_equal "Weird English", r.language_str
+    
+    # language_str only
+    r = ResultItem.new(:title => "something", :language_str => "English")
+    assert_nil r.language_code
+    assert_equal "English", r.language_str
     
   end
   
+  def test_bad_language_code
+    r = ResultItem.new(:title => "something", :language_code => "not_valid")
+    
+    assert_equal "not_valid", r.language_code
+    assert_nil r.language_str
+  end
   
 end