bento_search 0.6.0 → 0.7.0

data/test/functional/bento_search/search_controller_test.rb

@@ -8,6 +8,12 @@ module BentoSearch
         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
@@ -37,8 +43,30 @@ module BentoSearch
       assert_not_nil assigns(:results)
       
       assert_template "bento_search/search"
+      
+      # meta tag with count
+      assert_tag(:tag => "meta", :attributes => {"itemprop" => "total_items", "content" => /^\d+$/ })
+    end
+    
+    test "failed search" do
+      get :search, {: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"
+      assert_template "bento_search/_search_error"
+      
+      assert_no_tag(:tag => "meta", :attributes => {"itemprop" => "total_items"})
     end
     
+    
+    
+    
+    
     test "custom layout config" do
       get :search, {:engine_id => "with_layout_config", :query => "my search"}
       

data/test/helper/bento_search_helper_test.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 require 'test_helper'
 
 # this seems to work? Rails view testing is a mess. 
@@ -163,6 +165,75 @@ class BentoSearchHelperTest < ActionView::TestCase
     
     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 => {}        
+    })    
+    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',    
+    }
+    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"        
+  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/helper/bento_truncate_helper_test.rb

@@ -0,0 +1,71 @@
+# encoding: UTF-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
+    
+  
+  def test_truncate_basic
+    # Basic test
+    output = bento_truncate("12345678901234567890", :length => 10)
+    assert_equal "123456789…", output
+  end
+  
+  def test_truncate_tags    
+    # With tags
+    html_input = "123456<p><b>78901234567</b>890</p>".html_safe
+    html_output = bento_truncate(html_input, :length => 10)    
+    assert html_output.html_safe?, "truncated html_safe? is still html_safe?"
+    assert_equal "123456<p><b>789…</b></p>", html_output
+  end
+  
+  def test_truncate_tag_boundary    
+    # With break on tag boundary. Yes, there's an error not accounting
+    # for length of omission marker in this particular edge case,
+    # hard to fix, good enough for now. 
+    html_input = "<p>1234567890<b>123456</b>7890</p>".html_safe
+    html_output = bento_truncate(html_input, :length => 10)
+    assert_equal "<p>1234567890…</p>", html_output    
+  end
+  
+  def test_truncate_boundary_edge_case
+    html_input = "12345<p>6789<b>0123456</b>7890</p>".html_safe
+    html_output = bento_truncate(html_input, :length => 10)
+    # yeah, weird elipses in <b> of their own, so it goes. 
+    assert_equal "12345<p>6789<b>…</b></p>", html_output
+  end
+  
+  def test_truncate_another_edge_case
+    html_input = "12345<p>67890<b>123456</b>7890</p>".html_safe
+    html_output = bento_truncate(html_input, :length => 10)
+    assert_equal "12345<p>67890…</p>", html_output
+  end
+  
+  def test_truncate_html_with_separator
+    html_input = "12345<p>67 901234<b></p>".html_safe
+    html_output = bento_truncate(html_input, :length => 10, :separator => ' ')
+    assert_equal "12345<p>67…</p>", html_output
+  end
+  
+  def test_truncate_html_with_separator_unavailable
+    html_input = "12345<p>678901234<b></p>".html_safe
+    html_output = bento_truncate(html_input, :length => 10, :separator => ' ')
+    assert_equal "12345<p>6789…</p>", html_output
+  end
+  
+  def test_truncate_html_with_boundary_separator
+    # known edge case we dont' handle, sorry. If this test
+    # fails, that could be a good thing if you've fixed the edge case!
+    html_input = "12345<p>6 8<b>90123456</b>7890</p>".html_safe
+    html_output = bento_truncate(html_input, :length => 10, :separator => ' ')
+    assert_equal "12345<p>6 8<b>9…</b></p>", html_output
+  end
+   
+    
+
+  
+end

data/test/unit/ebsco_host_engine_test.rb

@@ -58,7 +58,7 @@ class EbscoHostEngineTest < ActiveSupport::TestCase
     assert_equal ["date"], query_params["sort"]
   end
   
-  def fielded_construction
+  def test_fielded_construction
     url = @engine.query_url(:query => "cancer", :search_field => "SU")
     
     query_params = CGI.parse( URI.parse(url).query )
@@ -66,10 +66,33 @@ class EbscoHostEngineTest < ActiveSupport::TestCase
     assert_equal ["(SU cancer)"], query_params["query"]
   end
   
+  def test_peer_review_limit_construction
+    url = @engine.query_url(:query => "cancer", :search_field => "SU", :peer_reviewed_only => true)
+    
+    query_params = CGI.parse( URI.parse(url).query )
+    
+    assert_equal ["(SU cancer) AND (RV Y)"], query_params["query"]
+  end
+  
+  def test_date_limit_construction
+    url = @engine.query_url(:query => "cancer", :pubyear_start => "1980", :pubyear_end => "1989")    
+    query_params = CGI.parse( URI.parse(url).query )    
+    
+    assert_equal ["cancer AND (DT 1980-1989)"], query_params["query"]
+    
+    # just one
+    url = @engine.query_url(:query => "cancer", :pubyear_start => "1980")
+    query_params = CGI.parse( URI.parse(url).query )    
+    
+    assert_equal ["cancer AND (DT 1980-)"], query_params["query"]    
+    
+  end
+  
+  
   def test_prepare_query
-    query = @engine.ebsco_query_prepare('one :. ; two "three four" AND NOT OR five')
+    query = @engine.ebsco_query_prepare('one :. ; two "three four" and NOT OR five')
     
-    assert_equal 'one AND two AND "three four" AND five', query
+    assert_equal 'one AND two AND "three four" AND "and" AND "NOT" AND "OR" AND five', query
   end
   
   def test_removes_paren_literals
@@ -145,5 +168,89 @@ class EbscoHostEngineTest < ActiveSupport::TestCase
     assert_present results.error[:error_info]        
     
   end
+  
+  test_with_cassette("fulltext info", :ebscohost) do
+    # We count on SOME records from first 10 for this query having fulltext,
+    # if you need to re-record VCR cassette and this query doesn't work
+    # for that anymore, then pick a different query. 
+    results = @engine.search("cancer")
+    
+    results_with_fulltext = results.find_all {|r| r.custom_data["fulltext_formats"] }
+    
+    assert_present results_with_fulltext
+    
+    results_with_fulltext.each do |record|
+      array = record.custom_data["fulltext_formats"]
+      # it's an array
+      assert_kind_of Array, array
+      # who's only legal values are P, T, and C, the EBSCO vocab for formats. 
+      assert_equal array.length, array.find_all {|v| %w{P C T}.include?(v)}.length
+      
+      assert record.link_is_fulltext?, "#link_is_fulltext set"
+    end    
+    
+  end
+  
+  test_with_cassette("live book example", :ebscohost) do    
+    # We keep adjusting the EBSCOHost heuristics for guessing format,
+    # and causing regressions, this test guards against them. 
     
+    # This particular example from RILM is a book, but
+    # is getting listed as a book chapter, sort of. 
+    
+    engine = BentoSearch::EbscoHostEngine.new( @config.merge(:databases => ["rih"]) )  
+    
+    results = engine.search('"Funk: The music, the people, and the rhythm of the one"', :per_page => 1)
+    
+    result = results.first
+    
+    assert_equal "Book", result.format
+    assert_equal "St. Martin's Press", result.publisher
+    assert_equal "1996", result.year
+        
+    assert_blank result.source_title
+  end
+  
+  test_with_cassette("live pathological book_item example", :ebscohost) do
+    # this guy from RILM has really crappy metadata on EBSCO,
+    # but we still want to detect it as a book_item, not a book. 
+    
+    a = 'Heidegger and the management of the Haymarket Opera, 1713-1717'
+    
+    engine = BentoSearch::EbscoHostEngine.new( @config.merge(:databases => ["rih"]) )
+    results = engine.search('"Heidegger and the management of the Haymarket Opera, 1713-1717"')
+    result = results.first
+    
+    assert_equal :book_item, result.format
+    
+    
+    # for reasons I can't figure out, weird encoding in the hyphen makes us
+    # test start_with instead
+    assert result.title.starts_with?("Heidegger and the management of the Haymarket Opera, 1713")
+    assert result.source_title.starts_with?("Opera remade (1700")
+  end
+  
+  test_with_cassette("dissertation example", :ebscohost) do
+    # yeah, all the weird ones are from RILM
+    engine = BentoSearch::EbscoHostEngine.new( @config.merge(:databases => ["rih"]) )
+    
+    results = engine.search('"Research into free jazz in France, 1960-1975"')
+    result = results.first
+    
+    assert_equal "Research into free jazz in France, 1960-1975", result.title
+    assert_equal :dissertation, result.format 
+  end
+  
+  test_with_cassette("another dissertation", :ebscohost) do
+    # yeah, all the weird edge cases that make good tests are from RILM, it's
+    # got weird data. 
+    
+    engine = BentoSearch::EbscoHostEngine.new( @config.merge(:databases => ["rih"]) )
+    results = engine.search('"Machine gun voices: Bandits, favelas, and utopia in Brazilian funk"')
+    result = results.first
+    
+    assert_equal :dissertation, result.format
+    assert_equal "Machine gun voices: Bandits, favelas, and utopia in Brazilian funk", result.title    
+  end
+  
 end

data/test/unit/google_books_engine_test.rb

@@ -27,18 +27,26 @@ class GoogleBooksEngineTest < ActiveSupport::TestCase
     
     assert_kind_of BentoSearch::ResultItem, first
     
-    assert_not_empty first.title
-    assert_not_empty first.publisher
-    assert_not_empty first.link
-    assert_not_empty first.format
-    assert_not_nil first.year
-    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
+    assert_not_empty    first.title
+    assert_not_empty    first.publisher
+    assert_not_empty    first.link
+    assert_not_empty    first.format
+    assert_not_nil      first.year
+    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
+    
+    # assume at least one thing in the result set has an ISBN to test
+    # our ISBN-setting code. 
+    assert_present      results.find {|r| r.isbn.present? }
+    
+    assert_present      first.custom_data[:viewability]
+    
+    assert_not_nil      first.link_is_fulltext?
   end
   
   test_with_cassette("pagination", :gbs) do
@@ -79,11 +87,11 @@ class GoogleBooksEngineTest < ActiveSupport::TestCase
   def test_sort_construction
     url = @engine.send(:args_to_search_url, :query => "cancer", :sort => "date_desc")
     
-    assert_match '&sort=newest', url
+    assert_match '&orderBy=newest', url
     
     url = @engine.send(:args_to_search_url, :query => "cancer", :sort => "relevance")
     
-    assert_not_match "&sort", url    
+    assert_not_match "&orderBy", url    
   end
   
   def test_fielded_search    

data/test/unit/google_site_search_test.rb

@@ -81,7 +81,7 @@ class GoogleSiteSearchTest < ActiveSupport::TestCase
     assert_present first.journal_title # used as source_title for display url    
     
     # no openurls for google, we decided
-    assert_nil     first.to_openurl
+    assert_nil     BentoSearch::StandardDecorator.new(first, nil).to_openurl
   end
   
   test_with_cassette("with highlighting", :google_site) do
@@ -93,9 +93,7 @@ class GoogleSiteSearchTest < ActiveSupport::TestCase
 
     assert first.title.html_safe?    
     assert first.abstract.html_safe?
-    assert first.journal_title.html_safe?
-    
-    assert first.published_in.html_safe?
+    assert first.journal_title.html_safe?    
   end
   
   test_with_cassette("without highlighting", :google_site) do
@@ -119,4 +117,13 @@ class GoogleSiteSearchTest < ActiveSupport::TestCase
     assert results.empty?    
   end
   
+  test_with_cassette("gets format string", :google_site) do
+    results = @engine.search("Adobe PDF")
+        
+    # assume at least one result had a PDF format, which it does
+    # in our current VCR capture. For a new one, find a search where
+    # it does. 
+    assert_present(results.find_all {|i| i.format_str =~ /PDF/ }, "At least one result has PDF in format_str")    
+  end
+  
 end

data/test/unit/item_decorators_test.rb

@@ -3,76 +3,17 @@ require 'test_helper'
 class ItemDecoratorsTest < ActiveSupport::TestCase
   MockEngine = BentoSearch::MockEngine
   
-  # simple decorator that replaces main link
-  module Decorator
-    def link
-      "http://newlink.com"
-    end
-    
-    def other_links      
-      super + [ BentoSearch::Link.new(:label => "One", :url => "http://one.com") ]
-    end
-  end
-    
-  setup do
-    @engine = MockEngine.new(:item_decorators => [Decorator])
-  end
-  
-  test "decorators" do
-    results = @engine.search(:query => "Query")
-    
-    assert_present results            
-    
-    results.each do |result|
-      assert_kind_of Decorator, result
-      
-      assert_equal "http://newlink.com", result.link
-      
-      assert_present result.other_links
-
-      assert_equal "One",             result.other_links.first.label
-      assert_equal "http://one.com",  result.other_links.first.url          
-    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
+  ################
+  # ABove here, old style decorators on their way out. Below, new:
+  ###########
   
-  # 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
-  module MutatingDecorator    
-    def self.extended(item)
-      orig_link = item.link
-      
-      item.link = nil
-      
-      item.other_links << BentoSearch::Link.new(:label => "Some Other", :url => orig_link)      
-    end
-  end
-  
-  test "mutating decorator" do
-    @engine = MockEngine.new(:item_decorators => [MutatingDecorator], :link => "http://example2.org")
+  test "decorator specified in configuration" do
+    @engine = MockEngine.new(:for_display => {:decorator => "TestDecorator"})
     results = @engine.search("query")
     
-    assert_present results
-    
-    results.each do |result|
-      assert_blank result.link
-      assert_equal "http://example2.org", result.other_links.first.url  
-      assert_equal "Some Other",          result.other_links.first.label
-    end
-    
+    assert_equal "TestDecorator", results.first.decorator
   end
-