gbip 0.7.1 → 0.8.0

data/CHANGELOG

@@ -1,3 +1,11 @@
+v0.8.0 (7th November)
+- Add checks for additional error codes, and raise an appropriate error
+- overhauled specs
+
+v0.7.1 (14th October)
+- Correctly parse API responses that contain a # in their data
+- Use ISBN13s in queries. No change to user API (we accept ISBN10s or ISBN13s)
+
 v0.7 (2nd October 2008)
 - Moved out of the RBook namespace
 - Added GBIP::Title#to_yaml

data/Rakefile

@@ -5,7 +5,7 @@ require 'rake/testtask'
 require "rake/gempackagetask"
 require 'spec/rake/spectask'
 
-PKG_VERSION = "0.7.1"
+PKG_VERSION = "0.8.0"
 PKG_NAME = "gbip"
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 RUBYFORGE_PROJECT = 'rbook'

data/lib/gbip.rb

@@ -18,5 +18,8 @@ require 'rbook/isbn'
 #  puts gbip.find("0091835135").inspect
 #
 module GBIP
-  class InvalidLoginError  < RuntimeError; end
+  class Error < RuntimeError; end
+  class InvalidRequestError  < Error; end
+  class InvalidLoginError < Error; end
+  class SystemUnavailableError  < Error; end
 end

data/lib/gbip/pos.rb

@@ -15,10 +15,9 @@ module GBIP
     POS_PORT = 7052
 
     # creates a new POS object ready to perform a search
-    def initialize(username, password, socket_class = nil)
+    def initialize(username, password)
       @username = username
       @password = password
-      @socket_class = socket_class || TCPSocket
     end
 
     # search for the specified ISBN on globalbooksinprint.com.
@@ -37,7 +36,7 @@ module GBIP
       options = {:timeout => 10}.merge(options)
 
       isbn = RBook::ISBN.convert_to_isbn13(isbn.to_s) || isbn.to_s
-      return default_return if isbn.nil?
+      return default_return unless RBook::ISBN.valid_isbn13?(isbn)
 
       request_format = "POS"
       account_type = "3"
@@ -60,11 +59,25 @@ module GBIP
       request_string << "#{version}\t#{supplier}\t#{request}\t#{filters}\t#{records}\t#{sort_order}\t"
       request_string << "#{markets}\t"
 
-      sock = @socket_class.new(POS_SERVER, POS_PORT)
+      sock = TCPSocket.new(POS_SERVER, POS_PORT)
       sock.print request_string
       response = Timeout::timeout(options[:timeout]) { sock.gets(nil) }
       sock.close
 
+      # error handling
+      case response.to_s[0,1]
+      when "5"
+        raise GBIP::InvalidRequestError, "Unknown Account Type or Request Version"
+      when "6"
+        raise GBIP::InvalidLoginError, "Invalid username or password"
+      when "7"
+        raise GBIP::InvalidRequestError, "Bad Data"
+      when "8"
+        raise GBIP::InvalidRequestError, "Invalid Request Version"
+      when "9"
+        raise GBIP::SystemUnavailableError, "System Unavailable"
+      end
+
       # split the response into header/body
       idx = response.index("#")
       if idx.nil?
@@ -86,11 +99,6 @@ module GBIP
         #titles_arr[-1] = titles_arr.last[1,titles_arr.last.size-1]
       end
 
-      # raise an exception if incorrect login details were provided
-      if header.first.eql?("66")
-        raise GBIP::InvalidLoginError, "Invalid username or password"
-      end
-
       if titles_arr.size == 0
         # return nil if no matching records found
         return nil

data/specs/pos_class_spec.rb

@@ -1,78 +1,151 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
 
 require 'gbip'
-require File.dirname(__FILE__) + "/mock_tcpsocket"
+require File.dirname(__FILE__) + "/spec_helper"
 require File.dirname(__FILE__) + "/timeout_tcpsocket"
 
 context "A new POS object" do
 
   setup do
-    @valid_username = "user"
-    @valid_password = "pass"
-    @invalid_password = "word"
-    @valid_isbn10 = "1741146712"
-    @valid_isbn13 = "9781741146714"
-    @valid_isbn13_hash = "9781590599358"
-    @notfound_isbn10 = "0571228526"
-    @notfound_isbn13 = "9780571228522"
-    @valid_isbn10_with_no_warehouses = "0732282721"
+    @username = "user"
+    @password = "pass"
+    @isbn10   = "1741146712"
+    @isbn13   = "9781741146714"
   end
 
   #####################
   #  :first searches
   #####################
+
+  specify "should raise an exception when an invalid request is made" do
+    # Mock TCPSocket to return an invalid request error code
+    data = File.read(File.dirname(__FILE__) + "/responses/invalid_account.txt").strip
+    socket = TCPSocket.stub_instance(:print => true, :close => true, :gets => data)
+    TCPSocket.stub_method(:new => socket)
+
+    pos = GBIP::POS.new(@username, @password)
+    lambda { pos.find(:first, @isbn10) }.should raise_error(GBIP::InvalidRequestError)
+  end
+
   specify "should raise an exception when an invalid username or password is supplied" do
-    pos = GBIP::POS.new(@valid_username, @invalid_password, MockTCPSocket)
-    lambda { pos.find(:first, @valid_isbn10) }.should raise_error(GBIP::InvalidLoginError)
+    # Mock TCPSocket to return an invalid login error code
+    data = File.read(File.dirname(__FILE__) + "/responses/invalid_login.txt").strip
+    socket = TCPSocket.stub_instance(:print => true, :close => true, :gets => data)
+    TCPSocket.stub_method(:new => socket)
+
+    pos = GBIP::POS.new(@valid_username, @invalid_password)
+    lambda { pos.find(:first, @isbn10) }.should raise_error(GBIP::InvalidLoginError)
+  end
+
+  specify "should raise an exception when an bad data is requested" do
+    # Mock TCPSocket to return a bad data error code
+    data = File.read(File.dirname(__FILE__) + "/responses/invalid_bad_data.txt").strip
+    socket = TCPSocket.stub_instance(:print => true, :close => true, :gets => data)
+    TCPSocket.stub_method(:new => socket)
+
+    pos = GBIP::POS.new(@valid_username, @invalid_password)
+    lambda { pos.find(:first, @isbn10) }.should raise_error(GBIP::InvalidRequestError)
+  end
+
+  specify "should raise an exception when an invalid request version is used" do
+    # Mock TCPSocket to return an invalid request version error code
+    data = File.read(File.dirname(__FILE__) + "/responses/invalid_request.txt").strip
+    socket = TCPSocket.stub_instance(:print => true, :close => true, :gets => data)
+    TCPSocket.stub_method(:new => socket)
+
+    pos = GBIP::POS.new(@valid_username, @invalid_password)
+    lambda { pos.find(:first, @isbn10) }.should raise_error(GBIP::InvalidRequestError)
+  end
+
+  specify "should raise an exception when a the GBIP API system is unavailable" do
+    # Mock TCPSocket to return a system unavailable error code
+    data = File.read(File.dirname(__FILE__) + "/responses/invalid_system_unavailable.txt").strip
+    socket = TCPSocket.stub_instance(:print => true, :close => true, :gets => data)
+    TCPSocket.stub_method(:new => socket)
+
+    pos = GBIP::POS.new(@valid_username, @invalid_password)
+    lambda { pos.find(:first, @isbn10) }.should raise_error(GBIP::SystemUnavailableError)
   end
 
   specify "should return a GBIP::Title object when queried for a single valid ISBN10" do
-    pos = GBIP::POS.new(@valid_username, @valid_password, MockTCPSocket)
-    result = pos.find(:first, @valid_isbn10)
+    # Mock TCPSocket to return a single matching title
+    data = File.read(File.dirname(__FILE__) + "/responses/single_result.txt").strip
+    socket = TCPSocket.stub_instance(:print => true, :close => true, :gets => data)
+    TCPSocket.stub_method(:new => socket)
+
+    pos = GBIP::POS.new(@username, @password)
+    result = pos.find(:first, @isbn10)
+
+    # check that a singlular result is returned, not an array
     result.should be_a_kind_of(GBIP::Title)
+
+    # TODO: check that our request was for an isbn13
+    socket.should have_received(:print)
   end
 
   specify "should return a GBIP::Title object when queried for a single valid ISBN13" do
-    pos = GBIP::POS.new(@valid_username, @valid_password, MockTCPSocket)
-    result = pos.find(:first, @valid_isbn13)
+    # Mock TCPSocket to return a single matching title
+    data = File.read(File.dirname(__FILE__) + "/responses/single_result.txt").strip
+    socket = TCPSocket.stub_instance(:print => true, :close => true, :gets => data)
+    TCPSocket.stub_method(:new => socket)
+
+    pos = GBIP::POS.new(@valid_username, @valid_password)
+    result = pos.find(:first, @isbn13)
     result.should be_a_kind_of(GBIP::Title)
+
+    # TODO: check that our request was for an isbn13
+    socket.should have_received(:print)
   end
 
   specify "should return a GBIP::Title object when the response contains an extra #" do
-    pos = GBIP::POS.new(@valid_username, @valid_password, MockTCPSocket)
-    result = pos.find(:first, @valid_isbn13_hash)
+    # Mock TCPSocket to return a single matching title that uses a # for its currency
+    # sign, as well as a record seperator
+    data = File.read(File.dirname(__FILE__) + "/responses/single_result2.txt").strip
+    socket = TCPSocket.stub_instance(:print => true, :close => true, :gets => data)
+    TCPSocket.stub_method(:new => socket)
+
+    pos = GBIP::POS.new(@username, @password)
+    result = pos.find(:first, @isbn13)
     result.should be_a_kind_of(GBIP::Title)
     result.title.should eql("Pro EDI in BizTalk Server 2006 R2:Electronic Document Interchange Solutions")
   end
 
   specify "should return a GBIP::Title object when querying for a single valid ISBN10 that has no warehouse data" do
-    pos = GBIP::POS.new(@valid_username, @valid_password, MockTCPSocket)
-    result = pos.find(:first, @valid_isbn10_with_no_warehouses)
-    result.should be_a_kind_of(GBIP::Title)
-    result.warehouses.should be_empty
-  end
+    # Mock TCPSocket to return a single matching title that lists no warehouses 
+    data = File.read(File.dirname(__FILE__) + "/responses/no_warehouses.txt").strip
+    socket = TCPSocket.stub_instance(:print => true, :close => true, :gets => data)
+    TCPSocket.stub_method(:new => socket)
 
-  specify "should return a GBIP::Title object when querying for a single valid ISBN10 that has no warehouse data" do
-    pos = GBIP::POS.new(@valid_username, @valid_password, MockTCPSocket)
-    result = pos.find(:first, @valid_isbn10_with_no_warehouses)
+    pos = GBIP::POS.new(@username, @password)
+    result = pos.find(:first, @isbn10)
     result.should be_a_kind_of(GBIP::Title)
     result.warehouses.should be_empty
   end
 
   specify "should return nil when a single ISBN10 not recognised by GBIP is requested" do
-    pos = GBIP::POS.new(@valid_username, @valid_password, MockTCPSocket)
-    result = pos.find(:first, @notfound_isbn10)
+    # Mock TCPSocket to return a valid response with no matching titles
+    data = File.read(File.dirname(__FILE__) + "/responses/no_result.txt").strip
+    socket = TCPSocket.stub_instance(:print => true, :close => true, :gets => data)
+    TCPSocket.stub_method(:new => socket)
+
+    pos = GBIP::POS.new(@username, @password)
+    result = pos.find(:first, @isbn10)
     result.should eql(nil)
   end
 
   specify "should return nil when a single ISBN13 not recognised by GBIP is requested" do
-    pos = GBIP::POS.new(@valid_username, @valid_password, MockTCPSocket)
-    result = pos.find(:first, @notfound_isbn13)
+    # Mock TCPSocket to return a valid response with no matching titles
+    data = File.read(File.dirname(__FILE__) + "/responses/no_result.txt").strip
+    socket = TCPSocket.stub_instance(:print => true, :close => true, :gets => data)
+    TCPSocket.stub_method(:new => socket)
+
+    pos = GBIP::POS.new(@username, @password)
+    result = pos.find(:first, @isbn13)
     result.should eql(nil)
   end
 
   specify "should return nil when any object is supplied as an ISBN when searching for :first" do
-    pos = GBIP::POS.new(@valid_username, @valid_password, MockTCPSocket)
+    pos = GBIP::POS.new(@username, @password)
     result = pos.find(:first, nil)
     result.should eql(nil)
 
@@ -84,49 +157,81 @@ context "A new POS object" do
   end
 
   specify "should perform a successful query if the ISBN is provided as a number" do
-    pos = GBIP::POS.new(@valid_username, @valid_password, MockTCPSocket)
-    result = pos.find(:first, @valid_isbn13)
+    # Mock TCPSocket to return a valid response with no matching titles
+    data = File.read(File.dirname(__FILE__) + "/responses/single_result.txt").strip
+    socket = TCPSocket.stub_instance(:print => true, :close => true, :gets => data)
+    TCPSocket.stub_method(:new => socket)
+
+    pos = GBIP::POS.new(@username, @password)
+    result = pos.find(:first, @isbn13.to_i)
     result.should be_a_kind_of(GBIP::Title)
   end
 
   specify "should raise an exception if no reponse is received in a certain amount of time" do
-    pos = GBIP::POS.new(@valid_username, @valid_password, TimeoutTCPSocket)
-    lambda { pos.find(:first, @valid_isbn13, :timeout => 2) }.should raise_error(Timeout::Error)
+    # Mock TCPSocket to take 5 seconds to generate a response
+    socket = TCPSocket.stub_instance(:print => true, :close => true)
+    socket.stub_method(:gets) do
+      sleep 5
+    end
+    TCPSocket.stub_method(:new => socket)
+
+    pos = GBIP::POS.new(@username, @password)
+    lambda { pos.find(:first, @isbn13, :timeout => 2) }.should raise_error(Timeout::Error)
   end
 
   #####################
   #  :all searches
   #####################
   specify "should return a non-empty Array when queried for a single valid ISBN10" do
-    pos = GBIP::POS.new(@valid_username, @valid_password, MockTCPSocket)
-    result = pos.find(:all, @valid_isbn10)
+    # Mock TCPSocket to return a valid response with a single result 
+    data = File.read(File.dirname(__FILE__) + "/responses/single_result.txt").strip
+    socket = TCPSocket.stub_instance(:print => true, :close => true, :gets => data)
+    TCPSocket.stub_method(:new => socket)
+
+    pos = GBIP::POS.new(@username, @password)
+    result = pos.find(:all, @isbn10)
     result.should be_a_kind_of(Array)
     result.should_not be_empty
   end
 
   specify "should return a non-empty Array when queried for a single valid ISBN13" do
-    pos = GBIP::POS.new(@valid_username, @valid_password, MockTCPSocket)
-    result = pos.find(:all, @valid_isbn13)
+    # Mock TCPSocket to return a valid response with a single result 
+    data = File.read(File.dirname(__FILE__) + "/responses/single_result.txt").strip
+    socket = TCPSocket.stub_instance(:print => true, :close => true, :gets => data)
+    TCPSocket.stub_method(:new => socket)
+
+    pos = GBIP::POS.new(@valid_username, @valid_password)
+    result = pos.find(:all, @isbn13)
     result.should be_a_kind_of(Array)
     result.should_not be_empty
   end
 
   specify "should return an empty Array when a single ISBN10 not recognised by GBIP is requested" do
-    pos = GBIP::POS.new(@valid_username, @valid_password, MockTCPSocket)
-    result = pos.find(:all, @notfound_isbn10)
+    # Mock TCPSocket to return a valid response with no matches
+    data = File.read(File.dirname(__FILE__) + "/responses/no_result.txt").strip
+    socket = TCPSocket.stub_instance(:print => true, :close => true, :gets => data)
+    TCPSocket.stub_method(:new => socket)
+
+    pos = GBIP::POS.new(@username, @password)
+    result = pos.find(:all, @isbn10)
     result.should be_a_kind_of(Array)
     result.should be_empty
   end
 
   specify "should return an empty Array when a single ISBN13 not recognised by GBIP is requested" do
-    pos = GBIP::POS.new(@valid_username, @valid_password, MockTCPSocket)
-    result = pos.find(:all, @notfound_isbn13)
+    # Mock TCPSocket to return a valid response with no matches
+    data = File.read(File.dirname(__FILE__) + "/responses/no_result.txt").strip
+    socket = TCPSocket.stub_instance(:print => true, :close => true, :gets => data)
+    TCPSocket.stub_method(:new => socket)
+
+    pos = GBIP::POS.new(@username, @password)
+    result = pos.find(:all, @isbn13)
     result.should be_a_kind_of(Array)
     result.should be_empty
   end
 
   specify "should return an empty array when any object is supplied as an ISBN when searching for :all" do
-    pos = GBIP::POS.new(@valid_username, @valid_password, MockTCPSocket)
+    pos = GBIP::POS.new(@username, @password)
     result = pos.find(:all, nil)
     result.should be_a_kind_of(Array)
     result.should be_empty
@@ -141,8 +246,13 @@ context "A new POS object" do
   end
 
   specify "should perform a successful query if the ISBN is provided as a number to an :all search" do
-    pos = GBIP::POS.new(@valid_username, @valid_password, MockTCPSocket)
-    result = pos.find(:all, 1741146712)
+    # Mock TCPSocket to return a valid response with a single result 
+    data = File.read(File.dirname(__FILE__) + "/responses/single_result.txt").strip
+    socket = TCPSocket.stub_instance(:print => true, :close => true, :gets => data)
+    TCPSocket.stub_method(:new => socket)
+
+    pos = GBIP::POS.new(@username, @password)
+    result = pos.find(:all, @isbn13.to_i)
     result.should be_a_kind_of(Array)
     result.should_not be_empty
   end
@@ -151,10 +261,10 @@ context "A new POS object" do
   #  invalid searches
   #####################
   specify "should raise an exception when an invalid search type is supplied" do
-    pos = GBIP::POS.new(@valid_username, @invalid_password, MockTCPSocket)
-    lambda { pos.find(nil, @valid_isbn10) }.should raise_error(ArgumentError)
-    lambda { pos.find(:last, @valid_isbn10) }.should raise_error(ArgumentError)
-    lambda { pos.find(123456, @valid_isbn10) }.should raise_error(ArgumentError)
+    pos = GBIP::POS.new(@username, @password)
+    lambda { pos.find(nil, @isbn10) }.should raise_error(ArgumentError)
+    lambda { pos.find(:last, @isbn10) }.should raise_error(ArgumentError)
+    lambda { pos.find(123456, @isbn10) }.should raise_error(ArgumentError)
   end
 
 end

data/specs/responses/invalid_account.txt

@@ -0,0 +1 @@
+5

data/specs/responses/invalid_bad_data.txt

@@ -0,0 +1 @@
+7

data/specs/responses/invalid_request.txt

@@ -0,0 +1 @@
+8

data/specs/responses/invalid_system_unavailable.txt

@@ -0,0 +1 @@
+9

data/specs/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'not_a_mock'
+
+Spec::Runner.configure do |config|
+  config.mock_with NotAMock::RspecMockFrameworkAdapter
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: gbip
 version: !ruby/object:Gem::Version 
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors: 
 - James Healy
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-14 00:00:00 +11:00
+date: 2008-11-07 00:00:00 +11:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,7 +40,6 @@ files:
 - lib/gbip/pos.rb
 - lib/gbip/title.rb
 - lib/gbip/warehouse.rb
-- specs/mock_tcpsocket.rb
 - specs/pos_class_spec.rb
 - specs/responses
 - specs/responses/invalid_login.txt
@@ -48,7 +47,11 @@ files:
 - specs/responses/no_warehouses.txt
 - specs/responses/single_result.txt
 - specs/responses/single_result2.txt
-- specs/timeout_tcpsocket.rb
+- specs/responses/invalid_account.txt
+- specs/responses/invalid_bad_data.txt
+- specs/responses/invalid_request.txt
+- specs/responses/invalid_system_unavailable.txt
+- specs/spec_helper.rb
 - Rakefile
 - CHANGELOG
 - README
@@ -85,6 +88,5 @@ signing_key:
 specification_version: 2
 summary: A library for access the globalbooksinprint.com API
 test_files: 
-- specs/mock_tcpsocket.rb
 - specs/pos_class_spec.rb
-- specs/timeout_tcpsocket.rb
+- specs/spec_helper.rb

data/specs/mock_tcpsocket.rb

@@ -1,44 +0,0 @@
-class MockTCPSocket
-
-  def initialize(host,port)
-    # do nothing
-  end
-
-  def print(query)
-    query = query.to_s.split("\t")
-    @username = query[3]
-    @password = query[4]
-    m, @isbn = *query[7].match(/bn=(\d\d\d\d\d\d\d\d\d\d\d\d\d)/)
-  end
-
-  def gets(placeholder)
-   
-    # if incorrect login details are supplied
-    unless @username.eql?("user") && @password.eql?("pass")
-     return File.read(File.dirname(__FILE__) + "/responses/invalid_login.txt").strip
-    end
-
-    # if the requested isbn isn't an isbn10
-    unless RBook::ISBN.valid_isbn13?(@isbn)
-      return File.read(File.dirname(__FILE__) + "/responses/no_result.txt").strip
-    end
-
-    # if the isbn10 is one we have available
-    if @isbn.eql?("9781741146714")
-      return File.read(File.dirname(__FILE__) + "/responses/single_result.txt").strip
-    elsif @isbn.eql?("9781590599358")
-      return File.read(File.dirname(__FILE__) + "/responses/single_result2.txt").strip
-    elsif @isbn.eql?("9780732282721")
-      return File.read(File.dirname(__FILE__) + "/responses/no_warehouses.txt").strip
-    else
-      return File.read(File.dirname(__FILE__) + "/responses/no_result.txt").strip
-    end
-    @username = nil
-    @password = nil
-    isbn = nil
-  end
-
-  def close
-
-  end
-end

data/specs/timeout_tcpsocket.rb

@@ -1,19 +0,0 @@
-class TimeoutTCPSocket
-
-  def initialize(host,port)
-    # do nothing
-  end
-
-  def print(query)
-    # do nothing
-  end
-
-  def gets(placeholder)
-    sleep 5
-    ""
-  end
-
-  def close
-    # do nothing
-  end
-end