bento_search 1.5.0 → 1.6.0

data/lib/bento_search/version.rb

@@ -1,3 +1,3 @@
 module BentoSearch
-  VERSION = "1.5.0"
+  VERSION = "1.6.0"
 end

data/test/dummy/config/boot.rb

@@ -1,10 +1,5 @@
-require 'rubygems'
-gemfile = File.expand_path('../../../../Gemfile', __FILE__)
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../../../Gemfile', __FILE__)
 
-if File.exist?(gemfile)
-  ENV['BUNDLE_GEMFILE'] = gemfile
-  require 'bundler'
-  Bundler.setup
-end
-
-$:.unshift File.expand_path('../../../../lib', __FILE__)
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
+$LOAD_PATH.unshift File.expand_path('../../../../lib', __FILE__)

data/test/dummy/db/schema.rb

@@ -0,0 +1,15 @@
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# Note that this schema.rb definition is the authoritative source for your
+# database schema. If you need to create the application database on another
+# system, you should be using db:schema:load, not running all the migrations
+# from scratch. The latter is a flawed and unsustainable approach (the more migrations
+# you'll amass, the slower it'll run and the greater likelihood for issues).
+#
+# It's strongly recommended that you check this file into your version control system.
+
+ActiveRecord::Schema.define(version: 0) do
+
+end

data/test/functional/bento_search/search_controller_test.rb

@@ -7,23 +7,23 @@ module BentoSearch
         config.engine = "MockEngine"
         config.allow_routable_results = true
       end
-      
+
       BentoSearch.register_engine("failed_response") do |config|
         config.engine = "MockEngine"
         config.allow_routable_results = true
         config.error = {:message => "faked error"}
       end
-      
+
       BentoSearch.register_engine("not_routable") do |config|
         config.engine = "MockEngine"
         # 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"
@@ -31,119 +31,125 @@ module BentoSearch
         end
       end
     end
-    
-    def teardown     
+
+    def teardown
       BentoSearch.reset_engine_registrations!
     end
-    
-    
+
+
     test "search" do
-      get :search, {:engine_id => "mock", :query => "my search"}
+      get_search_with_params :engine_id => "mock", :query => "my search"
       assert_response :success
       assert_not_nil assigns(:results)
-      
+
       assert_template "bento_search/search/search"
-      
+
       # meta tag with count
       meta_tag = assert_select("meta[itemprop=total_items][content]", :count => 1 )
-      assert_match /^\d+$/, meta_tag.attribute("content").text
+      assert_match(/^\d+$/, meta_tag.attribute("content").text)
     end
-    
+
     test "failed search" do
-      get :search, {:engine_id => "failed_response", :query => "my search"}
-      
+      get_search_with_params :engine_id => "failed_response", :query => "my search"
+
       # should this really be a success? Yes, I think so, we don't
       # want to stop ajax from getting it, it'll just have an error
       # message in the HTML. Should it maybe have an html5 meta microdata
       # warning?
       assert_response :success
-      
+
       assert_template "bento_search/search/search"
       assert_template "bento_search/_search_error"
-      
+
       assert_select("meta[itemprop=total_items]", :count => 0)
     end
-    
-    
-    
-    
-    
+
+
+
+
+
     test "custom layout config" do
-      get :search, {:engine_id => "with_layout_config", :query => "my search"}
-      
+      get_search_with_params :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/search"
     end
-    
+
     test "non-routable engine" do
-      get :search, {:engine_id => "not_routable", :query => "my search"}
-      
+      get_search_with_params :engine_id => "not_routable", :query => "my search"
+
       assert_response 403
     end
-    
+
     test "non-existent engine" do
-      get :search, {:engine_id => "not_existing", :query => "my search"}
-      
+      get_search_with_params :engine_id => "not_existing", :query => "my search"
+
       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"}
-      
-      
+      get_search_with_params :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. 
+      # we can add a custom before filter like a local app might.
       #
-      # SUPER HACKY, but I dunno what else to do. 
-      
+      # SUPER HACKY, but I dunno what else to do.
+
       class CustomSearchController < BentoSearch::SearchController
         before_filter :deny_everyone
-        
+
         def deny_everyone
           raise BentoSearch::SearchController::AccessDenied
         end
       end
-      
 
-      
+
+
       orig_controller = @controller
-      
+
       begin
         Rails.application.routes.draw do
           get "/custom_search" => "bento_search/search_controller_test/custom_search#search"
         end
         @controller = CustomSearchController.new
-        
-        get :search, {:engine_id => "mock", :query => "my search"}
-        
+
+        get_search_with_params :engine_id => "mock", :query => "my search"
+
         assert_response 403
       ensure
         @controller = orig_controller
         Rails.application.reload_routes!
       end
-      
+
+    end
+
+
+    # Do rails4 or rails5
+    def get_search_with_params(params)
+      if Gem::Version.new(Rails.version) >= Gem::Version.new(5.0)
+        get :search, params: params
+      else
+        get :search, params
+      end
     end
-    
 
-    
-        
-    
   end
 end

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