bento_search 0.0.1

data/test/unit/openurl_creator_test.rb

@@ -0,0 +1,111 @@
+class OpenurlCreatorTest < ActiveSupport::TestCase
+  
+  def test_create_article
+    item = BentoSearch::ResultItem.new(
+        :format => "Article",
+        :title => "My Title",
+        :subtitle => "A Nice One",
+        :year => 2012,
+        :volume => "10",
+        :issue => "1",
+        :start_page => "1",
+        :end_page => "100",
+        :journal_title => "Journal of Fakes",
+        :issn => "12345678",
+        :doi => "XXXX",                        
+      )
+    item.authors << BentoSearch::Author.new(:first => "John", :last => "Smith")
+    
+    r = BentoSearch::OpenurlCreator.new(item).to_openurl.referent
+    
+    assert_equal "journal",     r.format
+    
+    assert_equal "article",      r.metadata["genre"]
+    
+    assert_equal "2012",          r.metadata["date"]
+    assert_equal "10",          r.metadata["volume"]
+    assert_equal "1",           r.metadata["issue"]
+    assert_equal "1",           r.metadata["spage"]
+    assert_equal "100",         r.metadata["epage"]
+    assert_equal "Journal of Fakes", r.metadata["jtitle"]
+    assert_equal "12345678",    r.metadata["issn"]
+    assert_include r.identifiers, "info:doi:XXXX"
+    
+    assert_equal "John",        r.metadata["aufirst"]
+    assert_equal "Smith",       r.metadata["aulast"]
+    assert_equal "Smith, J",    r.metadata["au"]
+    
+    assert_equal "My Title: A Nice One",  r.metadata["atitle"]
+        
+  end
+  
+  def test_numeric_conversion
+    item = BentoSearch::ResultItem.new(
+        :format => "Article",
+        :title => "My Title",
+        :subtitle => "A Nice One",
+        :year => 2012,
+        :volume => 10,
+        :issue => 1,
+        :start_page => 1,
+        :end_page => 100,        
+        :issn => "12345678",                              
+      )
+    
+    
+    r = BentoSearch::OpenurlCreator.new(item).to_openurl.referent
+    
+    assert_equal "1", r.metadata["issue"]
+  end
+  
+  def test_create_book
+    item = BentoSearch::ResultItem.new(
+      :format => "Book",
+      :title => "My Book",
+      :year => 2012,
+      :publisher => "Brothers, Inc.",
+      :isbn => "1234567X"
+      )
+    
+    item.authors << BentoSearch::Author.new(:first => "John", :last => "Smith")
+    
+    r = BentoSearch::OpenurlCreator.new(item).to_openurl.referent
+      
+    assert_equal "book", r.format
+    
+    assert_equal "My Book",         r.metadata["btitle"]
+    assert_equal "Brothers, Inc.",  r.metadata["pub"]
+    assert_equal "1234567X",        r.metadata["isbn"]
+    assert_equal "2012",              r.metadata["date"]
+      
+  end
+  
+  def create_hardcoded_kev
+    item = BentoSearch::ResultItem.new(
+      :format => "Book",
+      :title => "Something",
+      :openurl_kev_co => "rft.title=Foo+Bar&rft.au=Smith"
+      )
+    
+    r = BentoSearch::OpenurlCreator.new(item).to_openurl.referent
+    
+    assert_equal  "article",    r.format
+    assert_equal  "Foo Bar",    r.metadata["title"]
+    assert_equal  "Smith",      r.metadata["au"]
+
+  end
+  
+  def result_item_to_openurl
+    item = BentoSearch::ResultItem.new(
+      :format => "Book",
+      :title => "Something",
+      :openurl_kev_co => "rft.title=Foo+Bar&rft.au=Smith"
+      )
+    
+    openurl = item.to_openurl
+    
+    assert_kind_of OpenURL::ContextObject, openurl
+  end
+  
+  
+end

data/test/unit/pagination_test.rb

@@ -0,0 +1,59 @@
+require 'test_helper'
+
+# Test the BentoSearch::Results::Pagination object
+class PaginationTest < ActiveSupport::TestCase
+  Pagination = BentoSearch::Results::Pagination
+  
+  def test_implicit_page
+    pag = Pagination.new(100, {:per_page => 10})
+    
+    assert_equal 1, pag.current_page
+    assert_equal 1, pag.start_record
+    assert_equal 10, pag.end_record
+    assert pag.first_page?
+    assert ! pag.last_page?
+    assert_equal 100, pag.count_records
+    assert_equal 10, pag.total_pages
+    assert_equal 10, pag.per_page    
+  end
+  
+  def test_last_page
+    pag = Pagination.new(100, {:page => 5, :start => 80, :per_page => 20})
+    
+    assert_equal 5, pag.current_page
+    assert_equal 81, pag.start_record
+    assert_equal 100, pag.end_record
+    assert ! pag.first_page?
+    assert pag.last_page?
+    assert_equal 100, pag.count_records
+    assert_equal 5, pag.total_pages
+    assert_equal 20, pag.per_page
+  end
+  
+  def test_uneven_pages
+    pag = Pagination.new(95, {:page => 10, :start => 90, :per_page => 10})
+    
+    assert_equal 10, pag.current_page
+    assert_equal 91, pag.start_record
+    assert_equal 95, pag.end_record
+    assert ! pag.first_page?
+    assert pag.last_page?
+    assert_equal 95, pag.count_records
+    assert_equal 10, pag.total_pages
+    assert_equal 10, pag.per_page
+  end
+  
+  def test_empty_args
+    pag = Pagination.new(nil, {})
+    
+    assert_equal 1, pag.current_page
+    assert_equal 0, pag.start_record
+    assert_equal 0, pag.end_record
+    assert pag.first_page?
+    assert pag.last_page?
+    assert_equal 0, pag.count_records
+    assert_equal 0, pag.total_pages
+  end
+  
+  
+end

data/test/unit/primo_engine_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+class PrimoEngineTest < ActiveSupport::TestCase
+  extend TestWithCassette
+  
+  @@host_port   = (ENV['PRIMO_HOST_PORT'] || 'EXAMPLE.ORG:80' )
+  @@institution = (ENV['PRIMO_INSTITUTION'] || 'DUMMY_INSTITUTION')
+  
+  VCR.configure do |c|
+    c.filter_sensitive_data("EXAMPLE.ORG:80", :primo) { @@host_port }
+    c.filter_sensitive_data("DUMMY_INSTITUTION", :primo) { @@institution }
+  end
+  
+  def setup
+    @engine = BentoSearch::PrimoEngine.new(:host_port => @@host_port, :institution => @@institution)
+  end
+  
+  
+  test_with_cassette("search smoke test", :primo) do    
+    results = @engine.search_implementation(:query => "globalization from below", :per_page => 10)
+    
+    assert_present results, "has results"
+    
+    assert_present results.total_items, "has total_items"
+    
+    first = results[6]
+    
+    # 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|
+      assert_present first.send(attr), "must have #{attr}"
+    end
+    
+  end
+  
+end

data/test/unit/register_engine_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+
+
+class RegisterEngineTest < ActiveSupport::TestCase
+  class BentoSearch::DummyEngine
+    include BentoSearch::SearchEngine
+  end
+    
+  def teardown
+    BentoSearch.reset_engine_registrations!
+  end
+  
+  test "can register and retrieve engine" do
+    BentoSearch.register_engine("test_engine") do |conf|
+      conf.engine = "BentoSearch::DummyEngine"      
+      conf.api_key = "dummy"
+    end
+    
+    engine = BentoSearch.get_engine("test_engine")
+    
+    assert_kind_of BentoSearch::DummyEngine, engine    
+    assert_equal "dummy", engine.configuration.api_key
+    
+  end
+  
+  test "can register with engine name assumed in BentoSearch::" do
+    BentoSearch.register_engine("test_engine") do |conf|
+      conf.engine = "DummyEngine"      
+      conf.api_key = "dummy"
+    end
+    
+    assert_kind_of BentoSearch::DummyEngine, BentoSearch.get_engine("test_engine")
+  end
+  
+  test "raises for no engine class" do
+    assert_raises(ArgumentError) do
+      BentoSearch.register_engine("test_engine") do |conf|              
+        conf.api_key = "dummy"
+      end
+    end
+  end
+  
+  
+  test "raises on unregistered engine access" do
+    assert_raise(BentoSearch::NoSuchEngine) { BentoSearch.get_engine("not_registered")}
+  end
+  
+end
+  

data/test/unit/result_item_display_test.rb

@@ -0,0 +1,39 @@
+require 'test_helper'
+
+
+
+class ResultItemDisplayTest < ActiveSupport::TestCase
+  Author = BentoSearch::Author
+  ResultItem = BentoSearch::ResultItem
+  
+  test "author with first and last" do
+    author = Author.new(:last => "Smith", :first => "John")
+    
+    str = ResultItem.new.author_display(author)
+    
+    assert_equal "Smith, J", str    
+  end
+  
+  test "author with display form and just last" do
+    author = Author.new(:last => "Smith", :display => "Display Form")
+    
+    str = ResultItem.new.author_display(author)
+    
+    assert_equal "Display Form", str
+  end
+  
+  test "Author with just last" do
+    author = Author.new(:last => "Johnson")
+    
+    str = ResultItem.new.author_display(author)
+    
+    assert_equal "Johnson", str
+    
+  end
+  
+  test "Missing title" do
+    assert_equal I18n.translate("bento_search.missing_title"), ResultItem.new.complete_title
+  end
+    
+  
+end

data/test/unit/result_item_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+
+
+class ResultItemTest < ActiveSupport::TestCase
+  ResultItem = BentoSearch::ResultItem
+  
+  def test_has_custom_data
+    r = ResultItem.new
+    
+    assert_not_nil r.custom_data
+    assert_kind_of Hash, r.custom_data
+  end
+  
+  def test_can_dup_and_set_attributes
+    # Need to be able to dup and set at least basic attributes without
+    # changing original. Used by SummonEngine for making sure
+    # openurl does not have highlighting tags in it when generated. 
+    
+    r = ResultItem.new(:title => "original")
+    
+    assert_equal "original", r.title
+    
+    dup = r.dup
+    dup.title = "new"
+    
+    assert_equal "new", dup.title
+    assert_equal "original", r.title
+    
+    assert_not_same dup, r
+    
+    
+  end
+  
+  
+end

data/test/unit/scopus_engine_test.rb

@@ -0,0 +1,130 @@
+require 'test_helper'
+
+require 'cgi'
+require 'uri'
+
+# Set shell env SCOPUS_KEY to your api key to test fresh http
+# connections, if you can't use the ones cached by VCR. 
+
+class ScopusEngineTest < ActiveSupport::TestCase
+  extend TestWithCassette
+  
+  # Filter API key out of VCR cache for tag :scopus, which we'll use
+  # in this test. 
+  @@api_key = (ENV["SCOPUS_KEY"] || "DUMMY_API_KEY")
+  VCR.configure do |c|
+    c.filter_sensitive_data("DUMMY_API_KEY", :scopus) { @@api_key }
+  end
+  
+  def setup
+    @engine = BentoSearch::ScopusEngine.new(:api_key => @@api_key)
+  end
+  
+  
+  def test_construct_search_url
+    url = @engine.send(:scopus_url, :query => "one two")
+    
+    assert_equal "http://api.elsevier.com/content/search/index:SCOPUS?query=one+two&sort=refeid", url
+  end
+  
+  def test_construct_fielded_search_url
+    url = @engine.send(:scopus_url, :query => "one two", :search_field => "AUTH")
+    
+    assert_equal "http://api.elsevier.com/content/search/index:SCOPUS?query=AUTH%28one+two%29&sort=refeid", url
+  end
+  
+  def test_construct_search_with_per_page
+    url = @engine.send(:scopus_url, :query => "one two", :per_page => 30)
+    
+    assert_equal "http://api.elsevier.com/content/search/index:SCOPUS?query=one+two&count=30&sort=refeid", url
+  end
+  
+  def test_construct_search_with_sort
+    url = @engine.send(:scopus_url, :query => "one two", :sort => "date_desc")
+    
+    assert_equal "http://api.elsevier.com/content/search/index:SCOPUS?query=one+two&sort=-datesort%2C%2Bauth", url
+    
+    url = @engine.send(:scopus_url, :query => "one two", :sort => "relevance")
+    
+    assert_equal "http://api.elsevier.com/content/search/index:SCOPUS?query=one+two&sort=refeid", url
+    
+  end
+  
+  def test_construct_default_relevance_sort
+    url_implicit = @engine.send(:scopus_url, :query => "one two")
+    url_explicit = @engine.send(:scopus_url, :query => "one two", :sort => "relevance")
+    
+    assert_equal url_explicit, url_implicit
+  end
+    
+  
+  def test_construct_with_pagination
+    url = @engine.send(:scopus_url, :query => "one two", :start => 20, :per_page => 10)
+    
+    query_hash = CGI.parse(URI.parse(url).query)
+    
+    assert_equal ["20"], query_hash["start"]
+    assert_equal ["10"], query_hash["count"]    
+  end
+  
+  
+  test_with_cassette("bad api key should return error response", :scopus) do
+    @engine = BentoSearch::ScopusEngine.new(:api_key => "BAD_KEY_ERROR")
+    
+    results = @engine.search(:query => "cancer")
+    
+    assert results.failed?, "response.failed? should be"  
+  end
+  
+  test_with_cassette("simple search", :scopus) do
+    results = @engine.search(:query => "cancer")
+    
+    assert_not_nil results.total_items, "total_items not nil"
+    assert_kind_of Fixnum, results.total_items
+    
+    assert_not_nil results.start, "start not nil"
+    assert_not_nil results.per_page, "per_page not nil"
+    
+    assert_equal 10, results.length
+    
+    sample_result = results.first
+    
+    assert_present sample_result.title
+    assert_present sample_result.link
+    assert_present sample_result.journal_title
+    assert_kind_of Integer, sample_result.year
+    assert_present sample_result.issn
+    assert_present sample_result.volume
+    assert_present sample_result.issue
+    assert_present sample_result.start_page
+    
+    assert_present sample_result.authors    
+    
+    assert_present sample_result.format
+    
+  end
+  
+  test_with_cassette("zero results search", :scopus) do
+    results = @engine.search(:query => "aldfjkadf lakdj zdfzzzz")
+    assert ! results.failed?, "results not marked failed"
+    assert_equal 0, results.size
+  end
+  
+  test_with_cassette("escaped chars", :scopus) do
+    results = @engine.search(:query => "monkey:(brain)")
+    
+    assert ! results.failed?, "results not marked failed"
+  end
+    
+    
+  
+  test_with_cassette("fielded search", :scopus) do
+    results = @engine.search(:query => "cancer", :semantic_search_field => :title)
+
+    assert results.first.title.downcase.include?("cancer"), "Title includes query term"    
+  end
+  
+  
+    
+  
+end