bento_search 0.0.1

data/test/unit/search_engine_base_test.rb

@@ -0,0 +1,178 @@
+require 'test_helper'
+
+class ParseSearchArgumentsTest < ActiveSupport::TestCase
+  class Dummy
+    include BentoSearch::SearchEngine
+    
+    def search_implementation(args)
+      # no-op for now
+      BentoSearch::Results.new
+    end
+    
+    def test_parse(*args)
+      # original method is protected, this is a lame way
+      # to expose it. 
+      parse_search_arguments(*args)
+    end
+    
+    def max_per_page
+      40
+    end
+    
+    def search_field_definitions
+      {
+        "my_title" => {:semantic => :title},
+        "my_author" => {:semantic => :author},
+        "my_other" => nil
+      }
+    end
+    
+  end  
+  
+  
+  def test_single_arg
+    d = Dummy.new
+    
+    args = d.test_parse("query")
+    
+    assert_equal( {:query => "query", :per_page => BentoSearch::SearchEngine::DefaultPerPage }, args )        
+  end
+  
+  def test_two_arg
+    d = Dummy.new
+    
+    args = d.test_parse("query", :arg => "1")
+    
+    assert_equal( {:query => "query", :arg => "1", :per_page => BentoSearch::SearchEngine::DefaultPerPage }, args )
+  end
+  
+     
+  
+  def test_convert_page_to_start
+    d = Dummy.new
+    
+    args = d.test_parse(:query => "query", :page => 1, :per_page => 20)
+    
+    assert_equal 0, args[:start]
+    assert_equal 1, args[:page]
+    assert_equal 20, args[:per_page]
+    
+    args = d.test_parse(:query => "query", :page => 3, :per_page => 20)
+
+    assert_equal 40, args[:start]
+    assert_equal 3, args[:page]
+    assert_equal 20, args[:per_page]    
+  end
+  
+  def test_convert_start_to_page
+    d = Dummy.new
+    
+    # rounds down to get closest 'page' if need be. 
+    args = d.test_parse(:query => "query", :start => '19', :per_page => '20')
+    
+    assert_equal 19, args[:start]
+    assert_equal 1,  args[:page]
+    
+    args = d.test_parse(:query => "query", :start => '20', :per_page => '20')
+    assert_equal 2,  args[:page]
+  end
+  
+  
+  def test_pagination_to_integer
+    d = Dummy.new
+    
+    args = d.test_parse(:query => "query", :page => "1", :per_page => "20")
+    assert_equal 0, args[:start]
+    assert_equal 1, args[:page]
+    assert_equal 20, args[:per_page]
+    
+    args = d.test_parse(:query => "query", :start => "20", :per_page => "20")
+    assert_equal 20, args[:start]    
+    assert_equal 20, args[:per_page]
+    
+  end
+  
+  def test_ignore_blank_pagination_args
+    d = Dummy.new
+    
+    args = d.test_parse(:query => "query", :page => "", :per_page => "", :start => "")
+    
+    assert ! (args.has_key? :page)
+    assert ! (args.has_key? :start)
+    assert  (args.has_key? :per_page) # default per page always provided    
+  end
+  
+  def test_enforce_max_per_page
+    d = Dummy.new
+    
+    assert_raise(ArgumentError) { d.test_parse(:query => "query", :per_page => 1000) }        
+  end
+    
+  def test_search_field_keys    
+    assert_equal ["my_title", "my_author", "my_other"], Dummy.new.search_keys
+    assert_equal ["title", "author"], Dummy.new.semantic_search_keys
+  end
+  
+  def test_semantic_search_map
+    assert_equal( {"title" => "my_title", "author" => "my_author"}, 
+      Dummy.new.semantic_search_map)
+  end
+  
+  def test_translate_search_field_semantics
+    d = Dummy.new
+    
+    args = d.test_parse(:query => "query", :semantic_search_field => :title)
+    
+    assert ! (args.has_key? :semantic_search_field), "translates semantic_search_field to search_field"
+    assert_equal "my_title", args[:search_field]
+    
+    assert_raise(ArgumentError, "Raises for undefined semantic_search_field") do
+      d.test_parse(:query => "query", :semantic_search_field => :subject)
+    end
+  end
+  
+  def test_semantic_blank_ignored
+    d = Dummy.new
+    
+    args1 = d.test_parse(:query => "query", :semantic_search_field => nil)
+    args2 = d.test_parse(:query => "query", :semantic_search_field => nil)
+    
+    assert_nil args1[:search_field]
+    assert_nil args2[:search_field]
+  end
+  
+  def test_semantic_string_or_symbol
+    d = Dummy.new
+    
+    args1 = d.test_parse(:query => "query", :semantic_search_field => :title)
+    args2 = d.test_parse(:query => "query", :semantic_search_field => "title")
+    
+    assert_equal args1, args2    
+  end
+  
+  def test_converts_sort_to_string
+    d = Dummy.new
+    
+    args = d.test_parse(:query => "query", :sort => :title_asc)
+    
+    assert_equal "title_asc", args[:sort]
+  end
+  
+  def test_sets_timing
+    d = Dummy.new
+    results = d.search("foo")
+    
+    assert_not_nil results.timing
+  end
+    
+  def test_passes_arbitrary_keys
+    d = Dummy.new
+    args = d.test_parse(:query => "foo", :custom_auth => true)
+    
+    assert_present args[:custom_auth]
+    assert_equal true, args[:custom_auth]
+    
+  end
+  
+end
+

data/test/unit/search_engine_test.rb

@@ -0,0 +1,95 @@
+require 'test_helper'
+
+
+
+class SearchEngineTest < ActiveSupport::TestCase
+  
+    def setup
+      @dummy_class = Class.new do
+        include BentoSearch::SearchEngine
+        
+        def self.required_configuration
+          ["required.key"]
+        end
+        
+        def search_implementation(arguments)
+          #no-op for now
+          BentoSearch::Results.new
+        end
+        
+      end
+    end
+  
+
+    test "takes configuration" do
+      conf = Confstruct::Configuration.new( :foo => "foo", :bar => "bar", :required => {:key => "required key"} )
+      engine = @dummy_class.new(conf)
+      
+      assert_not_nil engine.configuration
+      assert_equal engine.configuration.foo, "foo"
+      assert_equal engine.configuration.bar, "bar"      
+    end
+    
+    test "required configuration keys" do
+      conf = Confstruct::Configuration.new( :foo => "foo", :bar => "bar" )
+      assert_raise ArgumentError do
+        @dummy_class.new(conf)
+      end      
+    end
+    
+    test "merges default configuration" do
+      @dummy_class = Class.new do
+        include BentoSearch::SearchEngine
+        def self.default_configuration
+          { :one => "default",
+            :two => "default",
+            :array => [:a, :b, :c],
+            :nested => {:one => "default", :two => "default"}
+          }
+        end
+      end
+      
+      engine = @dummy_class.new( :two => "new", :array => ["one", "two"], :nested => {:two => "new"}, :required => {:key => "required key"} )
+      
+      assert_kind_of Confstruct::Configuration, engine.configuration
+      assert_equal "default"      , engine.configuration.one
+      assert_equal "new"          , engine.configuration.two
+      assert_equal "default"      , engine.configuration.nested.one
+      assert_equal "new"          , engine.configuration.nested.two
+      assert_equal ["one", "two"] , engine.configuration.array      
+    end
+    
+    test "no default configuration" do
+      @dummy_class = Class.new do
+        include BentoSearch::SearchEngine
+      end
+      
+      engine = @dummy_class.new( :one => "one" )
+      
+      assert_kind_of Confstruct::Configuration, engine.configuration
+      assert_equal "one", engine.configuration.one
+    end
+      
+    test "sets metadata on results" do
+      engine = MockEngine.new(:id => "foo")
+      
+      results = engine.search(:query => "cancer", :per_page => 20)
+      
+      assert_present results.search_args
+      assert_equal "foo", results.engine_id
+      
+      pagination = results.pagination
+      assert_present pagination
+      
+      assert_equal 20, pagination.per_page
+      assert_equal 1, pagination.current_page
+      assert_equal 1, pagination.start_record
+      assert_equal 20, pagination.end_record
+      assert pagination.first_page?
+      
+      assert_present pagination.total_pages
+      assert_present pagination.count_records
+            
+    end
+
+end

data/test/unit/summon_engine_test.rb

@@ -0,0 +1,161 @@
+require 'test_helper'
+
+require 'cgi'
+require 'uri'
+
+#
+# To run queries live (without recorded VCR), you must have ENV variables
+# set: SUMMON_ACCESS_ID and SUMMON_SECRET_KEY
+
+
+class SummonEngineTest < ActiveSupport::TestCase
+  extend TestWithCassette
+  
+  @@access_id   = (ENV['SUMMON_ACCESS_ID']  || "DUMMY_ACCESS_ID")
+  @@secret_key  = (ENV['SUMMON_SECRET_KEY'] || "DUMMY_SECRET_KEY")
+  
+  VCR.configure do |c|
+    c.filter_sensitive_data("DUMMY_ACCESS_ID", :summon)  { @@access_id }
+    c.filter_sensitive_data("DUMMY_SECRET_KEY", :summon) { @@secret_key }
+  end
+  
+  def setup
+    @engine = BentoSearch::SummonEngine.new('access_id' => @@access_id, 
+      'secret_key' => @@secret_key)
+  end
+  
+  def test_request_construction 
+    uri, headers = @engine.construct_request(:query => "elephant's")
+    
+    
+    assert_present headers
+    assert_present headers["Content-Type"]
+    assert_present headers["Accept"]
+    assert_present headers["x-summon-date"]
+    assert_present headers["Authorization"]
+    
+    
+    assert_present uri
+    query_params = CGI.parse( URI.parse(uri).query )
+    assert_present query_params["s.q"]        
+  end
+  
+  def test_summon_escape
+    uri, headers = @engine.construct_request(:query=> "Foo: A) \\Bar \"a phrase\"")
+    
+    query_params = CGI.parse( URI.parse(uri).query )
+    
+    assert_present (query = query_params["s.q"].first)
+    
+    # double backslashes are escaping for ruby string literal,
+    # it's actually only a single backslash in output. 
+    assert_equal "Foo\\: A\\) \\\\Bar \"a phrase\"", query
+  end
+  
+  def test_sort_construction
+    uri, headers = @engine.construct_request(:query => "elephants", :sort => "date_desc")
+    
+    query_params = CGI.parse( URI.parse(uri).query )
+    
+    assert_present (sort = query_params["s.sort"].first )
+    
+    assert_equal("PublicationDate:desc", sort)
+    
+  end
+  
+  def test_fielded_search_construction
+    uri, headers = @engine.construct_request(:query => "eleph)ants", :search_field => "SomeField")
+    
+    query_params = CGI.parse( URI.parse(uri).query )
+
+    assert_equal "SomeField:(eleph\\\)ants)", query_params["s.q"].first
+  end
+  
+  def test_pagination_construction
+    uri, headers = @engine.construct_request(:query => "elephants_per_page", :per_page => 20, :page => 2)
+    
+    query_params = CGI.parse( URI.parse(uri).query )
+    
+    assert_equal "20", query_params["s.ps"].first
+    assert_equal "2",  query_params["s.pn"].first
+  end
+  
+  def test_authenticated_user_construction 
+    uri, headers = @engine.construct_request(:query => "elephants", :auth => true)
+    
+    query_params = CGI.parse( URI.parse(uri).query )
+    
+    assert_present query_params['s.role']
+    assert_equal "authenticated", query_params['s.role'].first   
+  end        
+  
+  def test_construct_fixed_param_config
+    engine = BentoSearch::SummonEngine.new('access_id' => @@access_id, 
+      'secret_key' => @@secret_key,
+      'fixed_params' => {
+        "s.fvf" => ["ContentType,Newspaper Article,true", "ContentType,Book,true"],
+        "s.role" => "authenticated"
+      })
+    
+    uri, headers = engine.construct_request(:query => "elephants")
+    
+    query_params = CGI.parse( URI.parse(uri).query )
+    
+    assert_include query_params["s.fvf"], "ContentType,Newspaper Article,true"
+    assert_include query_params["s.fvf"], "ContentType,Book,true"
+    assert_include query_params["s.role"], "authenticated"
+    
+  end
+  
+  def test_construct_no_highlighting
+    engine = BentoSearch::SummonEngine.new('access_id' => @@access_id, 
+      'secret_key' => @@secret_key,
+      'highlighting' => false)
+    
+    uri, headers = engine.construct_request(:query => "elephants")
+    
+    query_params = CGI.parse( URI.parse(uri).query )
+    
+    assert_include query_params['s.hl'], "false"
+  end
+  
+  test_with_cassette("bad auth", :summon) do
+    engine = BentoSearch::SummonEngine.new('access_id' => "bad_access_id", :secret_key => 'bad_secret_key')
+    
+    results = engine.search("elephants")
+    
+    assert results.failed?, "should return #failed?"   
+  end
+    
+  
+  test_with_cassette("search", :summon) do
+    results = @engine.search("elephants")
+
+    assert ! results.failed?
+    
+    assert_present results
+    
+    assert_present results.total_items
+    assert_not_equal 0, results.total_items
+    
+    first = results.first
+    
+    assert_present first.title
+    assert_present first.format_str
+  end
+  
+  test_with_cassette("proper tags for snippets", :summon) do
+    results = @engine.search("cancer")
+    
+    first = results.first
+    
+    assert_include first.title, '<b class="bento_search_highlight">' 
+    
+    assert first.title.html_safe?, "title is HTML safe"
+    
+    assert_present first.custom_data['raw_title']
+    assert_not_include first.custom_data['raw_title'], '<b class="bento_search_highlight">'
+    
+  end
+  
+end

data/test/unit/xerxes_engine_test.rb

@@ -0,0 +1,70 @@
+require 'test_helper'
+
+require 'cgi'
+require 'uri'
+
+# If you need to re-record cassette, you need to REMOVE
+# the :refresh_wait => 0 below, along with
+# the :record => once in the use_cassette
+class XerxesEngineTest < ActiveSupport::TestCase
+  extend TestWithCassette
+  
+  def setup    
+    conf = Confstruct::Configuration.new( :base_url => "http://jhsearch.library.jhu.edu/",
+      :databases => ["JHU04066","JHU06614"] ,
+      # when we have a VCR recorded, we don't need to wait
+      # if re-recording, change this key to nil. 
+      :refresh_wait => 0 
+      )
+    @engine = BentoSearch::XerxesEngine.new( conf )
+  end
+
+  
+  def test_construct_xerxes_url
+    url = @engine.send(:xerxes_search_url, {:query => "skin disease"})
+    
+    uri = nil
+    assert_nothing_raised { uri = URI.parse(url) } 
+    
+    assert uri.to_s.start_with?(@engine.configuration.base_url), "starts with base_url"
+    
+    query_hash = CGI.parse( uri.query )
+    
+    assert_equal ["metasearch"],  query_hash["base"]
+    assert_equal ["search"],      query_hash["action"]
+    #assert_equal [@engine.configuration.xerxes_context], query_hash["context"]
+    assert_equal ["WRD"],         query_hash["field"]
+    assert_equal ["skin disease"],query_hash["query"]
+    
+    @engine.configuration.databases.each do |db|    
+      assert query_hash["database"].include?(   db   )
+    end        
+  end
+  
+  test_with_cassette("live search", :xerxes, :record => :none) do
+    results = @engine.search("skin disease")
+    
+    assert results.length > 0, "returns results"
+    
+    record = results.first
+    
+    assert_present record.title
+    assert_present record.format
+    assert_present record.link
+    assert_present record.volume
+    assert_present record.issue
+    assert_present record.start_page
+    assert_present record.end_page
+    assert_present record.abstract
+    assert_present record.openurl_kev_co
+    assert_present record.journal_title
+    assert_present record.issn
+    
+    assert_operator record.authors.length, :>, 0
+    
+    assert_present record.authors.first.first
+    assert_present record.authors.first.last
+    
+  end
+  
+end