bento_search 0.0.1

data/test/unit/ebsco_host_engine_test.rb

@@ -0,0 +1,134 @@
+require 'test_helper'
+
+require 'cgi'
+require 'uri'
+
+class EbscoHostEngineTest < ActiveSupport::TestCase
+  extend TestWithCassette
+  
+  @@profile_id = (ENV['EBSCOHOST_PROFILE'] || 'DUMMY_PROFILE')
+  @@profile_pwd = (ENV['EBSCOHOST_PWD'] || 'DUMMY_PWD')
+  @@dbs_to_test = (ENV['EBSCOHOST_TEST_DBS'] || %w{a9h awn} )
+  
+  VCR.configure do |c|
+    c.filter_sensitive_data("prof=DUMMY_PROFILE", :ebscohost) { "prof=#{@@profile_id}" }
+    c.filter_sensitive_data("pwd=DUMMY_PWD", :ebscohost) { "pwd=#{@@profile_pwd}" }
+  end
+  
+  
+  def setup
+    @config = {
+      :profile_id => @@profile_id,
+      :profile_password => @@profile_pwd,
+      :databases => @@dbs_to_test
+    }
+    
+    @engine = BentoSearch::EbscoHostEngine.new( @config )             
+  end
+  
+  
+  def test_url_construction
+    url = @engine.query_url(:query => "cancer", :start => 10, :per_page => 5)
+    
+    assert_present url
+    
+    query_params = CGI.parse( URI.parse(url).query )
+
+    assert_equal [@engine.configuration.profile_id], query_params["prof"]
+    assert_equal [@engine.configuration.profile_password], query_params["pwd"]
+    
+    assert_equal ["cancer"], query_params["query"]
+    
+    assert_equal ["5"], query_params["numrec"]
+    assert_equal ["11"], query_params["startrec"]
+    
+    # default sort relevance
+    assert_equal ["relevance"], query_params["sort"]
+    
+    @engine.configuration.databases.each do |db|
+      assert_include query_params["db"], db
+    end    
+  end
+  
+  def test_date_sort_construction
+    url = @engine.query_url(:query => "cancer", :sort => "date_desc")
+    
+    query_params = CGI.parse( URI.parse(url).query )
+    
+    assert_equal ["date"], query_params["sort"]
+  end
+  
+  def fielded_construction
+    url = @engine.query_url(:query => "cancer", :search_field => "SU")
+    
+    query_params = CGI.parse( URI.parse(url).query )
+    
+    assert_equal ["(SU cancer)"], query_params["query"]
+  end
+  
+  def test_prepare_query
+    query = @engine.ebsco_query_prepare('one :. ; two "three four" AND NOT OR five')
+    
+    assert_equal 'one AND two AND "three four" AND five', query
+  end
+  
+  def test_removes_paren_literals
+    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")
+    
+    assert_present results
+    assert ! results.failed?
+    
+    first = results.first
+    
+    assert_present first.title
+    assert_present first.authors  
+    assert_present first.year
+    
+    assert_present first.format
+    assert_present first.format_str
+  end
+  
+  test_with_cassette("get_info", :ebscohost) do
+    xml = @engine.get_info
+    
+    assert_present xml
+    
+    assert_present xml.xpath("./info/dbInfo/db")    
+  end
+  
+  test_with_cassette("error bad password", :ebscohost) do    
+    error_engine = BentoSearch::EbscoHostEngine.new(
+      :profile_id       => "bad",
+      :profile_password => "bad",
+      :databases        => @@dbs_to_test
+      )
+    
+    results = error_engine.search(:query => "cancer")    
+    assert results.failed?    
+    assert_present results.error[:error_info]
+  end
+    
+    
+  test_with_cassette("error bad db", :ebscohost) do
+    error_engine = BentoSearch::EbscoHostEngine.new( 
+      :profile_id => @@profile_id,
+      :profile_password => @@profile_pwd,
+      :databases => ["bad", "does_not_exist"]
+    )    
+    
+    results = error_engine.search(:query => "cancer")    
+    assert results.failed?    
+    assert_present results.error[:error_info]        
+    
+  end
+    
+end

data/test/unit/eds_engine_test.rb

@@ -0,0 +1,105 @@
+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')
+  
+  
+  VCR.configure do |c|
+    c.filter_sensitive_data("DUMMY_USER_ID", :eds) { @@user_id }
+    c.filter_sensitive_data("DUMMY_PWD", :eds) { @@password }
+  end
+
+  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. 
+    BentoSearch::EdsEngine.remembered_auth = nil
+
+    
+    @engine = BentoSearch::EdsEngine.new(:user_id => @@user_id, :password => @@password, :profile => @@profile, :auth => true)
+  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    
+    
+    assert_present exception.http_status
+    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 
+  #
+  #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
+  
+  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. 
+      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      
+  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        
+      
+      BentoSearch::EdsEngine.remembered_auth = nil
+  end
+  
+  test_with_cassette("basic search smoke test", :eds) do
+      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.format_str
+  end
+  
+  
+end
+

data/test/unit/google_books_engine_test.rb

@@ -0,0 +1,93 @@
+require 'test_helper'
+
+class GoogleBooksEngineTest < ActiveSupport::TestCase
+  extend TestWithCassette
+  
+  def setup    
+    @engine = BentoSearch::GoogleBooksEngine.new
+    # tell it not to send our bad API key
+  end
+
+  
+  
+  test_with_cassette("search", :gbs) do
+    results = @engine.search("cancer")
+    
+    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_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_not_empty first.authors
+    assert_not_empty first.authors.first.display
+  end
+  
+  test_with_cassette("pagination", :gbs) do
+    results = @engine.search("cancer", :per_page => 20, :start => 40)
+    
+    assert ! results.failed?
+    
+    assert_equal 20, results.length
+    
+    assert_equal 20, results.per_page
+    assert_equal 20, results.size
+    assert_equal 40, results.start
+  end
+
+    
+  
+  test_with_cassette("error condition", :gbs) do       
+    # send a bad API key on purpose to get error
+    @engine = BentoSearch::GoogleBooksEngine.new(:api_key => "BAD_KEY")
+    
+    results = @engine.search("cancer")      
+    
+    assert results.failed?
+    assert_not_nil results.error
+    assert_not_nil results.error[:status]
+    assert_not_nil results.error[:error_info]            
+  end
+  
+  
+  def test_sort_construction
+    url = @engine.send(:args_to_search_url, :query => "cancer", :sort => "date_desc")
+    
+    assert_match '&sort=newest', url
+    
+    url = @engine.send(:args_to_search_url, :query => "cancer", :sort => "relevance")
+    
+    assert_not_match "&sort", url    
+  end
+  
+  def test_fielded_search    
+    # Have to use protected methods to get at what we want to test. 
+    # Is there a better way to factor this for testing?
+    norm_args = @engine.send(:parse_search_arguments, 'cancer "by radiation"', :search_field => :intitle)
+    url = @engine.send(:args_to_search_url, norm_args)
+    
+    query_params = CGI.parse( URI.parse(url).query )
+    
+    assert_match /^|\sintitle\:cancer\s|$/, query_params["q"].first
+    assert_match /^|\sintitle\:"by radiation"\s|$/, query_params["q"].first
+  end
+    
+  
+end

data/test/unit/item_decorators_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+
+class LinkDecoratorsTest < ActiveSupport::TestCase
+  # 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
+  
+  # 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")
+    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
+    
+  end
+
+    
+
+  
+end

data/test/unit/multi_searcher_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+# Doesn't really test the concurrency, but basic smoke test with fake
+# searchers. 
+class MultiSearcherTest < ActiveSupport::TestCase
+  setup do
+    BentoSearch.register_engine("one") do |conf|
+      conf.engine = "MockEngine"      
+    end
+    BentoSearch.register_engine("two") do |conf|
+      conf.engine = "MockEngine"      
+    end
+    BentoSearch.register_engine("three") do |conf|
+      conf.engine = "MockEngine"      
+    end
+  end
+  
+  teardown do
+    BentoSearch.reset_engine_registrations!
+  end
+  
+  
+  def test_multisearch
+    searcher = BentoSearch::MultiSearcher.new(:one, :two, :three)
+    start_returnval = searcher.start("cancer")
+    
+    assert_same searcher, start_returnval
+    
+    results = searcher.results
+    
+    assert_kind_of Hash, results
+    assert_equal ["one", "two", "three"].sort, results.keys.sort
+    
+    ["one", "two", "three"].each do |key|
+      assert_kind_of BentoSearch::Results, results[key]
+    end
+    
+    # call results again, we get an empty hash, can only call
+    # results once per start. 
+    new_results = searcher.results
+    assert_kind_of Hash, new_results
+    assert_empty new_results
+    
+  end
+    
+  
+  
+  
+end