borrow_direct 0.9.0

data/test/find_item_test.rb

@@ -0,0 +1,159 @@
+require 'test_helper'
+
+require 'borrow_direct/find_item'
+
+
+
+describe "FindItem", :vcr do
+  before do
+    @requestable_item_isbn     = "9810743734" # item is in BD, and can be requested
+    @locally_avail_item_isbn   = "0745649890"  # item is in BD, but is avail locally so not BD-requestable
+    @not_requestable_item_isbn = "1441190090" # in BD, and we don't have it, but no libraries let us borrow (in this case, it's an ebook)
+    @returns_PUBFI002_ISBN     = "0109836413" # BD returns an error PUBFI002 for this one, which we want to treat as simply not available. 
+  end
+  
+
+
+  describe "with defaults" do
+    before do
+      @original_symbol = BorrowDirect::Defaults.library_symbol
+      @original_bar    = BorrowDirect::Defaults.find_item_patron_barcode
+      BorrowDirect::Defaults.library_symbol = "OUR_SYMBOL"      
+      BorrowDirect::Defaults.find_item_patron_barcode = "OUR_BARCODE"      
+    end
+    after do 
+      BorrowDirect::Defaults.library_symbol = @original_symbol    
+      BorrowDirect::Defaults.find_item_patron_barcode = @original_bar
+    end
+
+    it "uses defaults" do
+      finder = BorrowDirect::FindItem.new
+
+      assert_equal "OUR_SYMBOL",  finder.patron_library_symbol
+      assert_equal "OUR_BARCODE", finder.patron_barcode
+    end
+  end
+
+  describe "query production" do
+    it "exact search works" do
+      finder = BorrowDirect::FindItem.new("barcodeX", "libraryX")
+      hash   = finder.send(:exact_search_request_hash, :isbn, "2")
+
+      assert_equal BorrowDirect::Defaults.partnership_id, hash["PartnershipId"]
+      assert_equal "barcodeX", hash["Credentials"]["Barcode"]
+      assert_equal "libraryX", hash["Credentials"]["LibrarySymbol"]
+
+      assert_equal "ISBN", hash["ExactSearch"].first["Type"]
+      assert_equal "2", hash["ExactSearch"].first["Value"]
+    end
+
+    it "works with multiple values" do
+      finder = BorrowDirect::FindItem.new("barcodeX", "libraryX")
+      hash   = finder.send(:exact_search_request_hash, :isbn, ["2", "3"])
+
+      exact_searches = hash["ExactSearch"]
+
+      assert_length 2, exact_searches
+
+      assert_include exact_searches, {"Type"=>"ISBN", "Value"=>"2"}
+      assert_include exact_searches, {"Type"=>"ISBN", "Value"=>"3"}
+    end
+  end
+
+  describe "#find_item_request" do
+
+    it "raises on no search critera" do
+      assert_raises(ArgumentError) do
+        BorrowDirect::FindItem.new("whatever", "whatever").find_item_request
+      end
+    end
+
+    it "raises on multiple search critera" do
+      assert_raises(ArgumentError) do
+        BorrowDirect::FindItem.new("whatever", "whatever").find_item_request(:isbn => "1", :issn => "1")
+      end
+    end
+
+    it "raises on unrecognized search criteria" do
+      assert_raises(ArgumentError) do
+        BorrowDirect::FindItem.new("whatever", "whatever").find_item_request(:whoknows => "1")
+      end
+    end
+
+
+    it "finds a requestable item" do
+      assert_present BorrowDirect::FindItem.new(VCRFilter[:bd_patron] , VCRFilter[:bd_library_symbol]).find_item_request(:isbn => @requestable_item_isbn)    
+    end
+
+    it "finds a locally available item" do
+      assert_present BorrowDirect::FindItem.new(VCRFilter[:bd_patron] , VCRFilter[:bd_library_symbol]).find_item_request(:isbn => @locally_avail_item_isbn)    
+    end
+
+    it "finds an item that does not exist in BD" do
+      assert_present BorrowDirect::FindItem.new(VCRFilter[:bd_patron] , VCRFilter[:bd_library_symbol]).find_item_request(:isbn => "NO_SUCH_THING")
+    end
+
+    it "works with multiple values" do
+      assert_present BorrowDirect::FindItem.new(VCRFilter[:bd_patron] , VCRFilter[:bd_library_symbol]).find_item_request(:isbn => [@requestable_item_isbn, @locally_avail_item_isbn])
+    end
+
+    describe "with expected error PUBFI002" do
+      it "returns result" do
+        assert_present BorrowDirect::FindItem.new(VCRFilter[:bd_patron] , VCRFilter[:bd_library_symbol]).find_item_request(:isbn => @returns_PUBFI002_ISBN )
+      end
+    end
+  end
+
+  describe "find with Response" do
+    before do
+      @find_item = BorrowDirect::FindItem.new(VCRFilter[:bd_patron] , VCRFilter[:bd_library_symbol])
+    end
+
+    it "requestable for requestable item" do
+      assert_equal true, @find_item.find(:isbn => @requestable_item_isbn).requestable?
+    end
+
+    it "requestable with multiple items if at least one is requestable" do
+      assert_equal true, @find_item.find(:isbn => [@requestable_item_isbn, "NO_SUCH_ISBN"]).requestable?
+    end
+
+    it "not requestable for locally available item" do
+      assert_equal false, @find_item.find(:isbn => @locally_avail_item_isbn).requestable?
+    end
+
+    it "not requestable for item that does not exist in BD" do
+      assert_equal false, @find_item.find(:isbn => "NO_SUCH_THING").requestable?
+    end
+
+    it "not requestable for item that no libraries will lend" do
+      assert_equal false, @find_item.find(:isbn => @not_requestable_item_isbn).requestable?
+    end
+
+    it "not requestable for item that BD returns PUBFI002" do
+      assert_equal false, @find_item.find(:isbn => @returns_PUBFI002_ISBN).requestable?
+    end
+
+    it "has an auth_id" do
+      assert_present @find_item.find(:isbn => @requestable_item_isbn).auth_id
+    end
+
+    it "has nil auth_id when BD doesn't want to give us one" do
+      assert_nil @find_item.find(:isbn => @returns_PUBFI002_ISBN).auth_id
+    end
+
+    it "has pickup locations" do
+      pickup_locations = @find_item.find(:isbn => @requestable_item_isbn).pickup_locations
+
+      assert_present pickup_locations
+      assert_kind_of Array, pickup_locations
+    end
+
+    it "has nil pickup locations when BD doesn't want to give us them" do
+      assert_nil @find_item.find(:isbn => @returns_PUBFI002_ISBN).pickup_locations
+    end
+
+  end
+
+
+
+end

data/test/generate_query_test.rb

@@ -0,0 +1,91 @@
+require 'uri'
+require 'cgi'
+
+describe "GenerateQuery" do
+  before do
+    @test_base = "http://example.org"
+  end
+
+  describe "query_url_with" do
+
+    it "raises on unknown field" do
+      assert_raises(ArgumentError) do
+        BorrowDirect::GenerateQuery.new(@test_base).query_url_with(:invalid_thing => "foo")
+      end
+    end
+
+    it "generates query" do
+      generate_query = BorrowDirect::GenerateQuery.new(@test_base)
+
+      url = generate_query.query_url_with(:title => "This is a title", :author => "This is an author")
+
+      assert url.start_with? @test_base
+
+      parsed_url = URI.parse(url)
+      url_query  = CGI.parse( parsed_url.query )
+
+      assert_present url_query
+
+      assert_length 1, url_query["query"]
+
+      query_text = url_query["query"].first
+
+      parts = query_text.split(" and ")
+
+      assert_length 2, parts
+
+      assert_include parts, 'ti="This is a title"'
+      assert_include parts, 'au="This is an author"'
+    end
+  end
+
+  describe "best_known_item_query_url_with" do
+    it "uses only isbn when available" do
+      generate_query = BorrowDirect::GenerateQuery.new(@test_base)
+
+      url = generate_query.best_known_item_query_url_with(:isbn => "OUR_ISBN", :title => "This is a title", :author => "This is an author")
+
+      assert url.start_with? @test_base
+
+      parsed_url = URI.parse(url)
+      url_query  = CGI.parse( parsed_url.query )
+
+      assert_present url_query
+
+      assert_length 1, url_query["query"]
+
+      query_text = url_query["query"].first
+
+      parts = query_text.split(" and ")
+
+      assert_length 1, parts
+
+      assert_include parts, 'isbn="OUR_ISBN"'      
+    end
+
+    it "uses author and title when it has to" do
+      generate_query = BorrowDirect::GenerateQuery.new(@test_base)
+
+      url = generate_query.best_known_item_query_url_with(:title => "This is a title", :author => "This is an author")
+
+      assert url.start_with? @test_base
+
+      parsed_url = URI.parse(url)
+      url_query  = CGI.parse( parsed_url.query )
+
+      assert_present url_query
+
+      assert_length 1, url_query["query"]
+
+      query_text = url_query["query"].first
+
+      parts = query_text.split(" and ")
+
+      assert_length 2, parts
+
+      assert_include parts, 'ti="This is a title"'
+      assert_include parts, 'au="This is an author"'
+    end
+
+  end
+end

data/test/request_item_test.rb

@@ -0,0 +1,109 @@
+require 'test_helper'
+require 'vcr'
+
+require 'borrow_direct/authentication'
+require 'borrow_direct/request_item'
+
+
+
+
+
+describe "RequestItem", :vcr => {:tag => :bd_requestitem } do 
+  before do
+    @requestable_item_isbn     = "9797994864" # item is in BD, and can be requested
+    @locally_avail_item_isbn   = "0745649890"  # item is in BD, but is avail locally so not BD-requestable
+    @not_requestable_item_isbn = "1441190090" # in BD, and we don't have it, but no libraries let us borrow (in this case, it's an ebook)
+    @returns_PUBRI004_ISBN     = "0109836413" # BD returns an error PUBRI004 for this one, which we want to treat as simply not available. 
+    @pickup_location           = "Some location" # BD seems to allow anything, which is disturbing
+  end
+
+
+
+  it "raises on no search critera" do
+    assert_raises(ArgumentError) do
+      BorrowDirect::RequestItem.new("whatever").request_item_request
+    end
+  end
+
+  it "raises on multiple search critera" do
+    assert_raises(ArgumentError) do
+      BorrowDirect::RequestItem.new("whatever").request_item_request(nil, :isbn => "1", :issn => "1")
+    end
+  end
+
+  it "raises on unrecognized search criteria" do
+    assert_raises(ArgumentError) do
+      BorrowDirect::RequestItem.new("whatever").request_item_request(nil, :whoknows => "1")
+    end
+  end
+
+
+  it "raw requests an unrequestable item" do    
+
+    resp = BorrowDirect::RequestItem.new(VCRFilter[:bd_patron] , VCRFilter[:bd_library_symbol]).request_item_request(nil, :isbn => @not_requestable_item_isbn)
+
+    assert_present resp
+    assert_present resp["Request"]
+  end
+
+  it "uses manually set auth_id" do
+    bd          = BorrowDirect::RequestItem.new("bad_patron" , "bad_symbol")
+    bd.auth_id  = BorrowDirect::Authentication.new(VCRFilter[:bd_patron] , VCRFilter[:bd_library_symbol]).get_auth_id  
+    resp        = bd.request_item_request(nil, :isbn => @requestable_item_isbn)
+
+    assert_present resp
+    assert_present resp["Request"]
+  end
+
+  describe "make_request" do
+    it "make_request for a requestable item" do
+      request_id = BorrowDirect::RequestItem.new(VCRFilter[:bd_patron] , VCRFilter[:bd_library_symbol]).make_request(nil, :isbn => @requestable_item_isbn)
+
+      assert_present request_id    
+    end
+
+    it "make_request for an unrequestable item" do
+      resp = BorrowDirect::RequestItem.new(VCRFilter[:bd_patron] , VCRFilter[:bd_library_symbol]).make_request(nil, :isbn => @not_requestable_item_isbn)
+
+      assert_nil resp
+    end
+
+    it "make_request for a locally available item" do
+      resp = BorrowDirect::RequestItem.new(VCRFilter[:bd_patron] , VCRFilter[:bd_library_symbol]).make_request(nil, :isbn => @locally_avail_item_isbn)
+
+      assert_nil resp
+    end
+
+    it "says no for item that BD returns PUBRI004" do
+      assert_nil BorrowDirect::RequestItem.new(VCRFilter[:bd_patron] , VCRFilter[:bd_library_symbol]).make_request(nil, :isbn => @returns_PUBRI004_ISBN)
+    end
+
+  end
+
+  describe "with pickup location and requestable item" do
+    it "still works" do
+      request_id = BorrowDirect::RequestItem.new(VCRFilter[:bd_patron] , VCRFilter[:bd_library_symbol]).make_request(@pickup_location, :isbn => @requestable_item_isbn)
+
+      assert_present request_id    
+    end
+  end
+
+  describe "make_request!" do
+    it "returns number for succesful request" do
+      request_id = BorrowDirect::RequestItem.new(VCRFilter[:bd_patron] , VCRFilter[:bd_library_symbol]).make_request!(nil, :isbn => @requestable_item_isbn)
+
+      assert_present request_id    
+    end
+
+    it "raises for unrequestable" do
+      error = assert_raises(BorrowDirect::Error) do
+        request_id = BorrowDirect::RequestItem.new(VCRFilter[:bd_patron] , VCRFilter[:bd_library_symbol]).make_request!(nil, :isbn => @not_requestable_item_isbn)
+      end
+    end
+    
+  end
+
+
+
+
+end

data/test/request_query_test.rb

@@ -0,0 +1,113 @@
+require 'test_helper'
+require 'httpclient'
+
+
+
+
+describe "RequestQuery", :vcr => {:tag => :bd_request_query} do
+  before do 
+    @requestable_item_isbn     = "9797994864" # item is in BD, and can be requested
+  end
+
+  it "raw request to verify the BD HTTP API" do
+
+    # Get the auth code
+
+    auth_uri = BorrowDirect::Defaults.api_base.chomp("/") + "/portal-service/user/authentication/patron"
+    auth_hash = {
+        "AuthenticationInformation" => {
+          "LibrarySymbol" => VCRFilter[:bd_library_symbol],
+          "PatronId" => VCRFilter[:bd_patron]
+        }
+      } 
+
+    headers = { "Content-Type" => "application/json", 
+        "User-Agent" => "ruby borrow_direct gem #{BorrowDirect::VERSION} (HTTPClient #{HTTPClient::VERSION}) https://github.com/jrochkind/borrow_direct", 
+        "Accept-Language" => "en"
+      }
+    http = HTTPClient.new
+    response = http.post auth_uri, JSON.generate(auth_hash), headers
+    response_hash = JSON.parse response.body
+    auth_id = response_hash["Authentication"]["AuthnUserInfo"]["AId"]
+
+    
+    # Now use it to make a RequestQuery request. Note, BD API requires
+    # you to use the same User-Agent you used to receive the auth id. 
+
+
+      query = {
+        "aid" => auth_id,
+        "type" => "open",
+        "fullRecord" => "0"
+      }
+
+      uri = BorrowDirect::Defaults.api_base.chomp("/") + "/portal-service/request/query/my"            
+
+      http = HTTPClient.new
+      http_response = http.get uri, query, headers
+
+      assert_equal 200, http_response.code
+      assert_present http_response.body
+
+      response_hash = JSON.parse http_response.body
+
+      assert_present response_hash
+      assert_present response_hash["QueryResult"]
+      assert_kind_of Array, response_hash["QueryResult"]["MyRequestRecords"]      
+  end
+
+  describe "raw request_query_request" do
+    it "returns results" do
+      request_query = BorrowDirect::RequestQuery.new(VCRFilter[:bd_patron], VCRFilter[:bd_library_symbol])
+      response = request_query.request_query_request
+
+      assert_present response      
+      assert_kind_of Hash, response
+      assert_present response["QueryResult"]["MyRequestRecords"]
+      assert_kind_of Array, response["QueryResult"]["MyRequestRecords"]
+    end
+  end
+
+  describe "requests" do
+    it "fetches default records" do
+      request_query = BorrowDirect::RequestQuery.new(VCRFilter[:bd_patron], VCRFilter[:bd_library_symbol])
+      results = request_query.requests
+
+      assert_kind_of Array, results
+
+      item = results.sample
+
+      [ :request_number, :title, :request_status].each do |key|
+        assert_present item.send key
+      end
+
+      [:allow_renew, :allow_cancel].each do |key|
+        assert_includes [true, false], item.send(key)
+      end
+
+      [:request_status_date, :date_submitted].each do |key|
+        assert_present item.send(key)
+        assert_kind_of DateTime, item.send(key)
+      end
+    end
+
+    it "fetches full records" do
+      request_query = BorrowDirect::RequestQuery.new(VCRFilter[:bd_patron], VCRFilter[:bd_library_symbol])
+      results = request_query.requests("all", true)
+
+      assert_kind_of Array, results
+      # too hard to test presence of each attributes, as not every item has every
+      # attribute and too hard to find examples to test. 
+    end
+
+  end
+
+
+
+
+
+
+end
+
+
+

data/test/request_test.rb

@@ -0,0 +1,141 @@
+require 'test_helper'
+require 'borrow_direct/request'
+
+
+
+
+describe "Request", :vcr => {:tag => :bd_request} do
+  before do
+    @successful_item_isbn = "9810743734"
+  end
+
+
+  it "raises on bad path"  do
+    assert_raises(BorrowDirect::HttpError) do
+      response = BorrowDirect::Request.new("/no/such/path").request( "foo" => "bar" )
+    end
+  end
+
+  it "raises on bad request hash" do
+    assert_raises(BorrowDirect::HttpError) do
+      response = BorrowDirect::Request.new("/dws/item/available").request( "foo" => "bar" )
+    end
+  end
+
+  it "gets BD error info" do
+    request = {
+        "PartnershipId" => "BAD_ID",
+        "Credentials" => {
+            "LibrarySymbol" => "librarySymbol",
+            "Barcode" => "barcode/patronId"
+        },
+        "ExactSearch" => [
+            {
+                "Type" => "type",
+                "Value" => "value"
+            }
+        ]
+    }
+
+    e = assert_raises(BorrowDirect::Error) do
+      response = BorrowDirect::Request.new("/dws/item/available").request( request )      
+    end
+
+    refute_nil e
+    refute_nil e.message
+    refute_nil e.bd_code
+  end
+
+  it "can make a succesful request" do
+      request = {
+          "PartnershipId" => "BD",
+          "Credentials" => {
+              "LibrarySymbol" => VCRFilter[:bd_library_symbol],
+              "Barcode" => VCRFilter[:bd_patron]
+          },
+          "ExactSearch" => [
+              {
+                  "Type" => "ISBN",
+                  "Value" => @successful_item_isbn
+              }
+          ]
+      }
+
+      
+    response = BorrowDirect::Request.new("/dws/item/available").request( request )      
+  end
+
+  it "uses timeout for HttpClient" do
+    request = BorrowDirect::Request.new("/some/path")
+    request.timeout = 5
+
+    http_client = request.http_client
+
+    assert_equal 5, http_client.send_timeout
+    assert_equal 5, http_client.receive_timeout
+    assert_equal 5, http_client.connect_timeout
+  end
+
+  describe "with expected errors" do
+    it "still returns result" do
+      request = {
+          "PartnershipId" => "BAD_ID",
+          "Credentials" => {
+              "LibrarySymbol" => "librarySymbol",
+              "Barcode" => "barcode/patronId"
+          },
+          "ExactSearch" => [
+              {
+                  "Type" => "type",
+                  "Value" => "value"
+              }
+          ]
+      }
+
+      bd = BorrowDirect::Request.new("/dws/item/available")
+      bd.expected_error_codes << "PUBFI003"
+      response = bd.request( request )      
+
+      assert_present response
+    
+    end
+  end
+
+  describe "authentication id" do
+    it "starts out nil" do
+      assert_nil BorrowDirect::Request.new("/").auth_id
+    end
+
+    it "manually set one will be used without fetch" do
+      r = BorrowDirect::Request.new("/")
+      r.auth_id = "OUR_AUTH_ID"
+
+      assert_equal "OUR_AUTH_ID", r.need_auth_id("wont_use_this", "or_this")
+    end
+
+    it "automatically fetches one when needed" do
+      r = BorrowDirect::Request.new("/")
+      auth_id = r.need_auth_id(VCRFilter[:bd_patron], VCRFilter[:bd_library_symbol])
+
+      assert_present auth_id
+      assert_equal auth_id, r.auth_id
+    end
+
+    it "can refetch when instructed" do
+      r = BorrowDirect::Request.new("/")
+
+      r.auth_id = "OLD_BAD_AUTH_ID"
+      fetched = r.fetch_auth_id!(VCRFilter[:bd_patron], VCRFilter[:bd_library_symbol])
+
+      assert_present r.auth_id
+      assert_equal fetched, r.auth_id
+      refute_equal "OLD_BAD_AUTH_ID", r.auth_id
+    end
+
+    it "takes with_auth_id" do
+      r = BorrowDirect::Request.new("/").with_auth_id("OUR_AUTH_ID")
+      assert_equal "OUR_AUTH_ID", r.auth_id
+    end
+  end
+
+end

data/test/support/assertions.rb

@@ -0,0 +1,23 @@
+# Useful assertions not provided by minitest-spec
+
+def assert_present(arg, msg = nil)
+  msg ||= "#{arg.inspect} is empty or not present"
+
+  is_present = arg.respond_to?(:empty?) ? !arg.empty? : !!arg
+
+  assert is_present, msg
+end
+
+def assert_length(length, array, msg = nil)
+  msg ||= "Expected #{array.inspect} to be length #{length}"
+
+  assert (array.respond_to?(:length) && array.length == length), msg
+end
+
+def assert_include(collection, item, msg = nil)
+  assert_respond_to(collection, :include?, "The collection must respond to :include?.")
+    
+  msg ||= "#{collection.inspect.slice(0,10)} expected to include\#{item}"
+
+  assert collection.include?(item), msg
+end

data/test/support/vcr_filter.rb

@@ -0,0 +1,45 @@
+require 'vcr'
+
+# Convenience for using VCR's filter_sensitive_data according to our common
+# pattern. 
+#
+# For a sensitive piece of information, set in your shell environment variable eg:
+#
+# BD_FINDITEM_PATRON="patron_barcode"
+#
+# Then call in a test:
+#     VCRFilter.sensitive_data! :bd_finditem_patron
+#
+# In the tests, when you need to use the piece of data somewhere, use
+#     VCRFilter[:bd_library_symbol]
+#
+# eg
+#     BorrowDirect::FindItem.new(VCRFilter[:bd_finditem_patron]) 
+#
+# Optional but recommended, use VCR cassette tags...
+#     VCRFilter.sensitive_data!, :bd_finditem_patron, :bd_finditem_tests
+#     #...
+#     describe "BD finditem items", :vcr => {:tag => :bd_finditem_tests}
+#
+# When recording a new cassette, the value from ENV will be used in interactions
+# with remote service, but won't be saved in your on disk cassettes -- it will
+# be saved as eg DUMMY_BD_FINDITEM_PATRON instead. 
+#
+# When running from recorded cassettes, you don't need to have the ENV defined, but
+# when (re-)recording a cassette, you of course do. 
+module VCRFilter
+  @@data = {}
+  def self.[](key) ; @@data[key.to_s.downcase] ; end
+  def self.[]=(key, value) ; @@data[key.to_s.downcase] = value ; end
+
+  def self.sensitive_data!(key, vcr_tag = nil)      
+    env_key     = key.to_s.upcase
+    dummy_value = "DUMMY_#{env_key}"
+
+    self[key] = (ENV[env_key] || dummy_value)
+
+    VCR.configure do |c|
+      c.filter_sensitive_data( dummy_value, vcr_tag ) { self[key]  }
+    end
+  end
+end