bento_search 0.8.0 → 0.9.0

data/test/helper/bento_search_helper_test.rb

@@ -24,7 +24,15 @@ class BentoSearchHelperTest < ActionView::TestCase
     results = MockEngine.new.search(:query => "foo")
     bento_search(results)    
     
-    assert_select("div.bento_item", 10)    
+    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
@@ -81,6 +89,8 @@ class BentoSearchHelperTest < ActionView::TestCase
     assert_raises(ArgumentError) { bento_search(MockEngine.new, :load => :ajax_auto) }
   end
   
+
+  
   def test_ajax_load 
     BentoSearch.register_engine("test_engine") do |conf|
       conf.engine = "MockEngine"

data/test/unit/ebsco_host_engine_test.rb

@@ -88,6 +88,22 @@ class EbscoHostEngineTest < ActiveSupport::TestCase
     
   end
   
+  def test_per_search_databases_construction
+    url = @engine.query_url(:query => "cancer", :databases => ["aaa", "bbb"])
+    
+    query_params = CGI.parse( URI.parse(url).query )
+    
+    assert_equal ["aaa", "bbb"].to_set, query_params["db"].to_set    
+  end
+  
+  def test_lookup_by_accession_number_construction
+    url = @engine.query_url(:query => "123456", :search_field => "AN")
+    
+    query_params = CGI.parse( URI.parse(url).query )
+    
+    assert_equal ["(AN 123456)"], query_params["query"]
+  end
+  
   
   def test_prepare_query
     query = @engine.ebsco_query_prepare('one :. ; two "three four" and NOT OR five')
@@ -115,6 +131,13 @@ class EbscoHostEngineTest < ActiveSupport::TestCase
     assert_equal ['"cancer "'], query_params["query"]
   end
   
+  def test_has_http_timeout_set
+    assert_equal BentoSearch::EbscoHostEngine::HttpTimeout, @engine.http_client.receive_timeout
+    assert_equal BentoSearch::EbscoHostEngine::HttpTimeout, @engine.http_client.send_timeout
+    assert_equal BentoSearch::EbscoHostEngine::HttpTimeout, @engine.http_client.connect_timeout
+  end      
+
+  
   test_with_cassette("live search smoke test", :ebscohost) do
   
     results = @engine.search(:query => "cancer")
@@ -133,6 +156,10 @@ class EbscoHostEngineTest < ActiveSupport::TestCase
     
     assert_present first.language_code
     assert_present first.language_str
+    
+    assert_present first.unique_id
+    # db name, colon, accession number. 
+    assert_match /.+\:.+/, first.unique_id
   end
   
   test_with_cassette("get_info", :ebscohost) do
@@ -253,4 +280,36 @@ class EbscoHostEngineTest < ActiveSupport::TestCase
     assert_equal "Machine gun voices: Bandits, favelas, and utopia in Brazilian funk", result.title    
   end
   
+  test_with_cassette("live #get(identifier) round trip", :ebscohost) do
+    results = @engine.search("cancer")
+    
+    assert (! results.failed?)
+    
+    item = @engine.get( results.first.unique_id )
+    
+    assert_not_nil  item
+    assert_kind_of  BentoSearch::ResultItem, item
+  end
+  
+  test_with_cassette("live get(id) with no results raises", :ebscohost) do
+    assert_raise(BentoSearch::NotFound) do 
+      results = @engine.get("a9h:bar")
+    end
+  end
+  
+  test_with_cassette("live get(id) on bad db raises", :ebscohost) do
+    assert_raise(Exception) do
+      results = @engine.get("badbad:bar")
+    end
+  end
+    
+  
+  test("illegal arg for get with id with no colon") do
+    assert_raise ArgumentError do
+      @engine.get("no_colon_in_here")
+    end
+  end
+    
+      
+  
 end

data/test/unit/eds_engine_test.rb

@@ -61,6 +61,12 @@ class EdsEngineTest < ActiveSupport::TestCase
     assert_include parts, "SourceType:Academic Journals"
     assert_include 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 
 
   
   test_with_cassette("get_auth_token failure", :eds) do
@@ -138,6 +144,10 @@ class EdsEngineTest < ActiveSupport::TestCase
       assert_present first.custom_data["citation_blob"]      
       
       assert_present first.format_str
+      
+      assert_present first.unique_id
+      # EDS id is db name, colon, accession number
+      assert_match /.+\:.+/, first.unique_id
   end
   
   

data/test/unit/google_books_engine_test.rb

@@ -27,6 +27,8 @@ class GoogleBooksEngineTest < ActiveSupport::TestCase
     
     assert_kind_of BentoSearch::ResultItem, first
     
+    assert_not_empty    first.unique_id
+    
     assert_not_empty    first.title
     assert_not_empty    first.publisher
     assert_not_empty    first.link
@@ -81,6 +83,24 @@ class GoogleBooksEngineTest < ActiveSupport::TestCase
     assert ! results.failed?
     assert_equal 0, results.total_items
   end
+  
+  test_with_cassette("live get(id)", :gbs) do
+    results = @engine.search 'cancer'
+    
+    assert_present results
+    
+    item = @engine.get(results.first.unique_id)
+    
+    assert_present    item
+    assert_kind_of    BentoSearch::ResultItem, item
+    assert_equal      results.first.unique_id, item.unique_id    
+  end
+  
+  test_with_cassette("live get(id) with not found id", :gbs) do
+    assert_raise(BentoSearch::NotFound) do
+      @engine.get("NOT EXISTING")
+    end
+  end
 
   
   

data/test/unit/primo_engine_test.rb

@@ -42,7 +42,7 @@ class PrimoEngineTest < ActiveSupport::TestCase
     # not every result has every field, but at time we recorded
     # with VCR, this result for this search did. Sorry, a bit fragile. 
     # publisher
-    %w{format_str format title authors volume issue start_page end_page journal_title issn doi abstract}.each do |attr|
+    %w{format_str format title authors volume issue start_page end_page journal_title issn doi abstract unique_id}.each do |attr|
       assert_present first.send(attr), "must have #{attr}"
     end
     

data/test/unit/ris_creator_test.rb

@@ -0,0 +1,159 @@
+require 'test_helper'
+
+class RISCreatorTest < ActiveSupport::TestCase
+  RISCreator = BentoSearch::RISCreator
+  ResultItem = BentoSearch::ResultItem
+  Author     = BentoSearch::Author
+  
+  # Parses an RIS file into a simpel data structure easier to test:
+  # an array of two element arrays, where each two element array is 
+  # (tag, field).  This method MAY also assert that the thing basically
+  # looks like a proper RIS file. 
+  def ris_parse(str)
+    assert_match /\A\r\n/, str, "RIS records begin with \r\n seperator"
+    str.gsub!(/\A(\r\n)+/, '') # remove any at the beginning, multiple are fine
+    
+    assert_match /\r\n\Z/, str, "Our RIS records end up with \r\n so they are concat-able with blank lines in between"
+    str.gsub!(/(\r\n)+\Z/, '') # remove any at the end, multiple are fine
+    
+    lines = str.split("\r\n", -1)
+            
+    assert_present lines, "RIS files are composed of multiple lines seperated by \r\n"
+            
+    # trim blank lines off beginning or end, they're allowed. Also "ER" tag
+    # off the end, make sure it's there then trim it. 
+    assert_equal "ER  - ", lines.last, "RIS records end in `ER  - `"
+    lines.pop # throw it away now. 
+    
+    return lines.collect do |line|            
+      line =~ /^([A-Z][A-Z0-9])  - (.*)$/
+      tag = $1 ; value = $2
+      assert (tag.present? && value.present?), "Individual RIS lines are composed of `TG  - VALUE`, not `#{line}`"
+      [tag, value]
+    end
+  end
+  
+  
+  @@article = ResultItem.new(
+    :format => "Article",
+    :title => "Some Article",
+    :source_title => "Some Journal",
+    :issn => "12345678",
+    :volume => "10",
+    :issue => "3",
+    :start_page => "100",
+    :end_page => "110",
+    :doi => '10.1000/182',
+    :abstract => "This is an abstract",
+    :authors => [
+      Author.new(:first => "John", :last => "Smith", :middle => "Q"),
+      Author.new(:first => "Maria", :last => "Lopez"),
+      Author.new(:display => "Some Guy")
+    ]
+  )
+  
+  @@article_with_full_date = ResultItem.new(
+    :format => "Article",
+    :title => "Something",
+    :source_title => "Some Magazine",
+    :start_page => "123",
+    :publication_date => Date.new(2011,9,1)
+  )
+  
+  @@book = ResultItem.new(
+    :format => "Book",
+    :title => "Some Book",
+    :isbn => "1234567890",
+    :publisher => "Some Publisher",
+    :year => "1990",
+    :authors => [
+      Author.new(:first => "John", :last => "Smith", :middle => "Q")
+    ]
+  )
+  
+  @@book_chapter = ResultItem.new(
+    :format   => :book_item,
+    :title    => 'Some Chapter',
+    :source_title => "Book Title",
+    :year     => '1991',
+    :publisher => "Some Pub",
+    :start_page => '10',
+    :authors => [
+      Author.new(:first => "John", :last => "Smith", :middle => "Q")
+    ]
+  )
+  
+  @@dissertation = ResultItem.new(
+    :format => :dissertation,
+    :title => "Areoformation and the new science",
+    :publisher => "University of Mars",
+    :year => "2150",
+    :authors => [
+      Author.new(:display => "mztlbplk q. frakdf")
+    ]
+  )
+
+
+  def test_article        
+    lines = ris_parse RISCreator.new(@@article).export    
+    
+    assert_include lines, ['TY', 'JOUR']
+    assert_include lines, ['TI', @@article.title]
+    assert_include lines, ['T2', @@article.source_title]
+    assert_include lines, ['SN', @@article.issn]
+    assert_include lines, ['VL', @@article.volume]
+    assert_include lines, ['IS', @@article.issue]
+    assert_include lines, ['SP', @@article.start_page]    
+    assert_include lines, ['EP', @@article.end_page]
+    assert_include lines, ['DO', @@article.doi]
+    assert_include lines, ['AB', @@article.abstract]
+
+    assert_include lines, ['AU', "Smith, John Q."]
+    assert_include lines, ['AU', "Lopez, Maria"]
+    assert_include lines, ['AU', "Some Guy"]
+  end
+  
+  def test_book
+    lines = ris_parse RISCreator.new(@@book).export
+    
+    assert_include lines, ['TY', 'BOOK']
+    assert_include lines, ['TI', @@book.title]
+    assert_include lines, ['PY', @@book.year]
+    assert_include lines, ['PB', @@book.publisher]
+    assert_include lines, ['SN', @@book.isbn]
+    
+    assert_include lines, ['AU', "Smith, John Q."]
+  end
+  
+  def test_book_chapter
+    lines = ris_parse RISCreator.new(@@book_chapter).export
+    
+    assert_include lines, ['TY', 'CHAP']
+    
+    assert_include lines, ['TI', @@book_chapter.title]
+    assert_include lines, ['T2', @@book_chapter.source_title]
+    assert_include lines, ['PY', @@book_chapter.year]
+    assert_include lines, ['PB', @@book_chapter.publisher]
+    assert_include lines, ['SP', @@book_chapter.start_page]
+  end
+  
+  def test_dissertation
+    lines = ris_parse RISCreator.new(@@dissertation).export
+    
+    assert_include lines, ['TY', 'THES']
+    
+    assert_include lines, ['TI', @@dissertation.title]
+    assert_include lines, ['PB', @@dissertation.publisher]
+    assert_include lines, ['PY', @@dissertation.year]
+  end
+  
+  def test_article_with_full_date
+    lines = ris_parse RISCreator.new(@@article_with_full_date).export
+    
+    assert_include lines, ['TY', 'JOUR']
+    
+    assert_include lines, ['DA', '2011/09/01']    
+  end
+  
+    
+end

data/test/unit/scopus_engine_test.rb

@@ -102,6 +102,8 @@ class ScopusEngineTest < ActiveSupport::TestCase
     
     assert_present sample_result.format
     
+    assert_present sample_result.unique_id
+    
   end
   
   test_with_cassette("zero results search", :scopus) do

data/test/unit/search_engine_test.rb

@@ -103,6 +103,43 @@ class SearchEngineTest < ActiveSupport::TestCase
             
     end
     
+    test "sets metadata on items" do
+      engine = MockEngine.new(:id => "foo", :for_display => {:key => "value", :decorator => "Foo"})      
+      results = engine.search(:query => "cancer")
+      record = results.first
+      
+      assert_present record.engine_id
+      assert_present record.display_configuration
+      assert_present record.decorator      
+    end
+    
+    test "failed sets metadata on results" do
+      engine = MockEngine.new(:id => "fail_engine", :error => {:message => "failed"}, :for_display => {:foo => "foo"})
+      
+      results = engine.search(:query => "cancer", :per_page => 20)
+      
+      assert          results.failed?
+      assert_present  results.error
+      assert_equal    "fail_engine", results.engine_id
+      assert_present  results.search_args
+      assert_equal(  {:foo => "foo"}, results.display_configuration )       
+    end
+    
+    test "auto rescued exception, with proper metadata" do
+      engine = MockEngine.new(:id => "raises", :raise_exception_class => 'TimeoutError', :for_display => {:foo => "foo"})
+      
+      results = engine.search("foo", :per_page => 20)
+      
+      assert          results.failed?, "marked failed"
+      assert_present  results.error      
+      assert_equal    "raises", results.engine_id
+      assert_present  results.search_args
+      assert_equal    "foo", results.search_args[:query]
+      
+      assert_equal(  {:foo => "foo"}, results.display_configuration )
+    end
+      
+    
     test "has empty :for_display config" do
       engine = MockEngine.new
       

data/test/unit/summon_engine_test.rb

@@ -158,6 +158,8 @@ class SummonEngineTest < ActiveSupport::TestCase
     
     # just smoke test to make sure it's set to something
     assert_not_nil first.link_is_fulltext?
+    
+    assert_present  first.unique_id
   end
   
   test_with_cassette("proper tags for snippets", :summon) do
@@ -174,4 +176,23 @@ class SummonEngineTest < ActiveSupport::TestCase
     
   end
   
+  test_with_cassette("live #get(id)", :summon) do
+    results = @engine.search("cancer")
+    
+    assert_present results
+    
+    item = @engine.get(results.first.unique_id)
+    
+    assert_not_nil item
+    assert_kind_of BentoSearch::ResultItem, item    
+    
+    assert_equal results.first.unique_id, item.unique_id    
+  end
+  
+  test_with_cassette("live get(id) on non-existing id", :summon) do
+    assert_raise(BentoSearch::NotFound) do 
+      item = @engine.get("NONE SUCH")
+    end
+  end
+  
 end

data/test/unit/worldcat_sru_dc_engine_test.rb

@@ -0,0 +1,151 @@
+require 'test_helper'
+
+require 'cgi'
+require 'uri'
+
+#
+#
+# Using the MARCXML response is way too much work, but the XML 'DC' response
+# is awfully stunted. We do what we can with it, but resulting metadata
+# is weird. 
+#
+class WorldcatSruDcEngineTest < ActiveSupport::TestCase
+  extend TestWithCassette
+
+  @@api_key = ENV["WORLDCAT_API_KEY"] || "DUMMY_API_KEY"
+  
+  VCR.configure do |c|
+    c.filter_sensitive_data("DUMMY_API_KEY", :worldcat_sru_dc) { @@api_key }
+  end
+
+  
+  def setup
+    @config = {:api_key => @@api_key}
+    @engine = BentoSearch::WorldcatSruDcEngine.new(@config)
+  end
+  
+  def test_construct_url
+    query = 'cancer\'s "one two"'
+    url = @engine.construct_query_url(:query => query, :per_page => 10)
+    
+    query_hash = CGI.parse(URI.parse(url).query)
+
+    assert_equal [@engine.configuration.api_key],      query_hash["wskey"]
+    assert_equal ['info:srw/schema/1/dc'], query_hash["recordSchema"]
+    assert_equal [@engine.construct_cql_query(:query => query)],   query_hash["query"]
+  end
+  
+  def test_construct_pagination
+    url = @engine.construct_query_url(:query => "cancer", :per_page => 20, :start => 20)
+    
+    query_hash = CGI.parse(URI.parse(url).query)
+    
+    assert_equal ["20"],  query_hash["maximumRecords"]
+    assert_equal ["21"],  query_hash["startRecord"]
+  end
+  
+  def test_construct_sort
+    url = @engine.construct_query_url(:query => "cancer", :sort => "date_desc")
+      
+    query_hash = CGI.parse(URI.parse(url).query)
+    
+    assert_present query_hash["sortKeys"]
+  end
+  
+  def test_construct_fielded_search
+    cql = @engine.construct_cql_query(:query => "cancer", :search_field => "srw.ti")
+    
+    assert_equal 'srw.ti = "cancer"', cql
+  end
+  
+  def test_construct_servicelevel
+    url = @engine.construct_query_url(:query => "cancer")    
+    query_hash = CGI.parse(URI.parse(url).query)
+    assert_not_include query_hash["servicelevel"], "full"
+        
+    url = @engine.construct_query_url(:query => "cancer auth", :auth => true)    
+    query_hash = CGI.parse(URI.parse(url).query)
+    assert_include query_hash["servicelevel"], "full"
+    
+    default_on = BentoSearch::WorldcatSruDcEngine.new(@config.merge(:auth => true))
+    
+    url = default_on.construct_query_url(:query => "cancer")    
+    query_hash = CGI.parse(URI.parse(url).query)
+    assert_include query_hash["servicelevel"], "full"
+    
+    url = default_on.construct_query_url(:query => "cancer", :auth => false)    
+    query_hash = CGI.parse(URI.parse(url).query)
+    assert_not_include query_hash["servicelevel"], "full"    
+  end
+  
+  def test_construct_cql
+    # test proper escaping and such
+    cql = @engine.construct_cql_query(:query => "alpha's beta \"one two\" thr\"ee")
+
+    components = cql.split(" AND ")
+    
+    assert_equal 4, components.length
+    
+    ["srw.kw = \"beta\"", 
+     "srw.kw = \"alpha's\"", 
+     "srw.kw = \"one two\"",  
+     "srw.kw = \"thr\\\"ee\""].each do |clause|
+      assert_include components, clause
+    end        
+  end
+  
+  test_with_cassette("max_out_pagination", :worldcat_sru_dc) do
+    #worldcat maxes out at start 9999, we silently correct
+    results = @engine.search("cancer", :start => 100000, :per_page => 10)
+    
+    assert         ! results.failed?
+    assert_present results
+    assert_equal   9999, results.pagination.start_record
+    assert_equal   1000, results.pagination.current_page
+  end
+  
+  test_with_cassette("smoke test", :worldcat_sru_dc) do
+    results = @engine.search("anarchism")
+    
+    assert_present results
+    
+    assert_present results.total_items
+    
+    first = results.first
+    
+    assert_present first.unique_id
+    
+    assert_present first.title
+    assert_present first.authors
+    assert_present first.publisher
+    assert_present first.oclcnum
+    
+    assert_present first.year
+    
+    assert_present first.abstract
+    
+    assert_present first.link
+    
+    assert_present first.language_code      
+  end
+  
+  test_with_cassette("live get(id)", :worldcat_sru_dc) do
+    results = @engine.search("anarchism")
+    
+    assert_present results
+    
+    item = @engine.get( results.first.unique_id)
+    
+    assert_present  item
+    assert_kind_of  BentoSearch::ResultItem, item
+    assert_equal    results.first.unique_id, item.unique_id
+  end
+  
+  test_with_cassette("live get(id) for bad id", :worldcat_sru_dc) do
+    assert_raise(BentoSearch::NotFound) do
+      @engine.get("NOT EXISTING")
+    end
+  end
+  
+  
+end