suitcase 1.3.1 → 1.4.0

data/README.md

@@ -1,12 +1,12 @@
 Suitcase
 ========
 
-Ruby library that utilizes the EAN (Expedia.com) API for locating available hotels (and maybe rental cars and flights someday, too).
+Ruby library that utilizes the EAN (Expedia.com) API for locating available hotels through their version 3 API. It also uses the Hotwire API to search for rental cars.
 
 Installation
 ------------
 
-Suitcase is a Ruby gem, meaning it can be installed via a simple `gem install suitcase`. It can also be added to a project's `Gemfile` with the following line: `gem 'suitcase'` (or `gem 'suitcase', git: "git://github.com/thoughtfusion/suitcase.git", branch: "development"` for the latest updates).
+Suitcase is a Ruby gem, meaning it can be installed via a simple `gem install suitcase`. It can also be added to a project's `Gemfile` with the following line: `gem 'suitcase'` (or `gem 'suitcase', git: "git://github.com/thoughtfusion/suitcase.git", branch: "develop"` for the latest updates).
 
 Usage
 -----

data/Rakefile

@@ -1,12 +1,13 @@
 require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require "rake/testtask"
 
-task :default => :spec
-
-RSpec::Core::RakeTask.new(:spec) do |t|
-  t.rspec_opts = %w(-c --fail-fast --format d)
+Rake::TestTask.new do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.libs.push 'test'
 end
 
+task :default => :test
+
 task :install_nodoc => [:build] do
   system "gem install pkg/suitcase-#{Suitcase::VERSION}.gem --no-ri --no-rdoc"
 end

data/lib/suitcase/cache.rb

@@ -40,10 +40,10 @@ module Suitcase
     private
 
     def keys_to_strings(hash)
-      hash.inject({}) {|memo, (k, v)| 
+      hash.inject({}) do |memo, (k, v)| 
         memo[k.to_s] = v
         memo
-      }
+      end
     end
   end
 end

data/lib/suitcase/hotel/amenity.rb

@@ -37,7 +37,7 @@ module Suitcase
     def self.parse_mask(bitmask)
       return nil unless bitmask
 
-      BITS.select {|amenity, bit| (bitmask & bit) > 0 }.keys
+      BITS.select { |amenity, bit| (bitmask & bit) > 0 }.keys
     end
   end
 end

data/lib/suitcase/hotel/hotel.rb

@@ -1,27 +1,63 @@
-module Suitcase
+ module Suitcase
+  # Public: An Exception to be raised from all EAN API-related errors.
   class EANException < Exception
-    def initialize(message)
+    # Internal: Setter for the recovery information.
+    attr_writer :recovery
+
+    # Public: Getter for the recovery information.
+    attr_reader :recovery
+
+    # Internal: Setter for the error type.
+    attr_writer :type
+
+    # Public: Getter for the error type..
+    attr_reader :type
+
+    # Internal: Create a new EAN exception.
+    #
+    # message - The String error message returned by the API.
+    # type    - The Symbol type of the error.
+    def initialize(message, type = nil)
+      @type = type
       super(message)
     end
+
+    # Public: Check if the error is recoverable. If it is, recovery information
+    #         is in the attribute recovery.
+    #
+    # Returns a Boolean based on whether the error is recoverable.
+    def recoverable?
+      @recovery.is_a?(Hash)
+    end
   end
 
-  # Used for organizing Bed options
+  # Public: A BedType represents a bed configuration for a Room.
   class BedType
-    attr_accessor :id, :description
+    # Internal: The ID of the BedType.
+    attr_accessor :id
 
+    # Internal: The description of the BedType.
+    attr_accessor :description
+
+    # Internal: Create a new BedType.
+    #
+    # info  - A Hash from the parsed API response with the following keys:
+    #         :id           - The ID of the BedType.
+    #         :description  3- The description of the BedType.
     def initialize(info)
       @id, @description = info[:id], info[:description]
     end
   end
 
-  # A Class representing a Hotel that stores information
-  # about the hotel. It provides methods for checking
-  # room availability, fetching images and just general
-  # information providing.
+  # Public: A Class representing a single Hotel. It provides methods for
+  #         all Hotel EAN-related queries in the gem.
   class Hotel
     extend Suitcase::Helpers
 
-    AMENITIES = { pool: 1,
+    # Public: The Amenities that can be passed in to searches, and are returned
+    #         from many queries.
+    AMENITIES = { 
+      pool: 1,
       fitness_center: 2,
       restaurant: 3,
       children_activities: 4,
@@ -29,13 +65,22 @@ module Suitcase
       meeting_facilities: 6,
       pets: 7,
       wheelchair_accessible: 8,
-      kitchen: 9 }
+      kitchen: 9
+    }
     
-    attr_accessor :id, :name, :address, :city, :province, :amenities, :masked_amenities, :country_code, :high_rate, :low_rate, :longitude, :latitude, :rating, :postal_code, :supplier_type, :images, :nightly_rate_total, :airport_code, :property_category, :confidence_rating, :amenity_mask, :location_description, :short_description, :hotel_in_destination, :proximity_distance, :property_description, :number_of_floors, :number_of_rooms, :deep_link, :tripadvisor_rating
+    attr_accessor :id, :name, :address, :city, :province, :amenities,
+                  :masked_amenities, :country_code, :high_rate, :low_rate,
+                  :longitude, :latitude, :rating, :postal_code, :supplier_type,
+                  :images, :nightly_rate_total, :airport_code,
+                  :property_category, :confidence_rating, :amenity_mask,
+                  :location_description, :short_description,
+                  :hotel_in_destination, :proximity_distance,
+                  :property_description, :number_of_floors, :number_of_rooms,
+                  :deep_link, :tripadvisor_rating
 
-    # Public: Initialize a new hotel
+    # Internal: Initialize a new Hotel.
     #
-    # info - a Hash of the options listed in attr_accesor.
+    # info - A Hash of the options listed in attr_accessor.
     #
     # Returns a new Hotel object with the passed-in attributes.
     def initialize(info)
@@ -44,12 +89,16 @@ module Suitcase
       end
     end
 
-    # Public: Find a Hotel based on known information
+    # Public: Find a Hotel based on ID, IDs, or location (and other options).
     #
-    # info - a Hash of known information
+    # info  - A Hash of known information about the query. Depending on the
+    #         type of query being done, you can pass in three possible keys:
+    #         :ids  - An Array of unique IDs as assigned by the EAN API.
+    #         :id   - A single ID as assigned by the EAN API.
+    #         other - Any other Hash keys will be sent to the generic
+    #                 find_by_info method.
     #
-    # Returns a single Hotel if an id is passed in, otherwise
-    # an Array of Hotels.
+    # Returns a single Hotel if an ID is passed in, or an Array of Hotels.
     def self.find(info)
       if info[:ids]
         find_by_ids(info[:ids], info[:session])
@@ -60,43 +109,55 @@ module Suitcase
       end
     end
 
-    # Public: Find a Hotel by it's id.
+    # Interal: Find a Hotel by its ID.
     #
-    # id - an Integer or String representation of the Hotel's
-    #      id.
+    # id      - The Integer or String Hotel ID.
+    # session - A Session with session data.
     #
-    # Returns a single Hotel object.
+    # Returns a single Hotel.
     def self.find_by_id(id, session)
       params = { hotelId: id }
+
       if Configuration.cache? and Configuration.cache.cached?(:info, params)
         raw = Configuration.cache.get_query(:info, params)
       else
-        url = url(:method => "info", :params => params, :session => session)
+        url = url(method: "info", params: params, session: session)
         raw = parse_response(url)
         handle_errors(raw)
-        Configuration.cache.save_query(:info, params, raw) if Configuration.cache?
+        if Configuration.cache?
+          Configuration.cache.save_query(:info, params, raw)
+        end
       end
       hotel_data = parse_information(raw)
       update_session(raw, session)
+
       Hotel.new(hotel_data)
     end
 
+    # Internal: Find multiple Hotels based on multiple IDs.
+    #
+    # ids     - An Array of String or Integer Hotel IDs to be found.
+    # session - A Session with session data stored in it.
+    #
+    # Returns an Array of Hotels.
     def self.find_by_ids(ids, session)
       params = { hotelIdList: ids.join(",") }
+
       if Configuration.cache? and Configuration.cache.cached?(:list, params)
         raw = Configuration.cache.get_query(:list, params)
       else
-        url = url(:method => "list", :params => params, :session => session)
+        url = url(method: "list", params: params, session: session)
         raw = parse_response(url)
         handle_errors(raw)
-        Configuration.cache.save_query(:list, params, raw) if Configuration.cache?
-      end
-      hotels = []
-      [split(raw)].flatten.each do |hotel_data|
-        hotels.push Hotel.new(parse_information(hotel_data))
+        if Configuration.cache?
+          Configuration.cache.save_query(:list, params, raw)
+        end
       end
       update_session(raw, session)
-      hotels
+
+      [split(raw)].flatten.map do |hotel_data|
+        Hotel.new(parse_information(hotel_data))
+      end
     end
 
     # Public: Find a hotel by info other than it's id.
@@ -119,67 +180,128 @@ module Suitcase
 
       params["minRate"] = params[:min_rate] if params[:min_rate]
       params["maxRate"] = params[:max_rate] if params[:max_rate]
-      hotels = []
+
       if Configuration.cache? and Configuration.cache.cached?(:list, params)
         parsed = Configuration.cache.get_query(:list, params)
       else
-        parsed = parse_response(url(:method => "list", :params => params, :session => info[:session]))
+        url = url(method: "list", params: params, session: info[:session])
+        parsed = parse_response(url)
         handle_errors(parsed)
-        Configuration.cache.save_query(:list, params, parsed) if Configuration.cache?
+        if Configuration.cache?
+          Configuration.cache.save_query(:list, params, parsed)
+        end
       end
-      [split(parsed)].flatten.each do |hotel_data|
-        hotels.push Hotel.new(parse_information(hotel_data))
+      hotels = [split(parsed)].flatten.map do |hotel_data|
+        Hotel.new(parse_information(hotel_data))
       end
       update_session(parsed, info[:session])
+
       info[:results] ? hotels[0..(info[:results]-1)] : hotels
     end
 
-    # Public: Parse the information returned by a search request
+    # Public: Parse the information returned by a search request.
     #
-    # parsed - a Hash representing the parsed JSON
+    # parsed - A Hash representing the parsed JSON.
     #
     # Returns a reformatted Hash with the specified accessors.
     def self.parse_information(parsed)
       handle_errors(parsed)
-      summary = parsed["hotelId"] ? parsed : parsed["HotelInformationResponse"]["HotelSummary"]
-      parsed_info = { id: summary["hotelId"], name: summary["name"], address: summary["address1"], city: summary["city"], postal_code: summary["postalCode"], country_code: summary["countryCode"], rating: summary["hotelRating"], high_rate: summary["highRate"], low_rate: summary["lowRate"], latitude: summary["latitude"].to_f, longitude: summary["longitude"].to_f, province: summary["stateProvinceCode"], airport_code: summary["airportCode"], property_category: summary["propertyCategory"].to_i, proximity_distance: summary["proximityDistance"].to_s + summary["proximityUnit"].to_s, tripadvisor_rating: summary["tripAdvisorRating"], deep_link: summary["deepLink"] }
-      parsed_info[:amenities] = parsed["HotelInformationResponse"]["PropertyAmenities"]["PropertyAmenity"].map { |x| Amenity.new(id: x["amenityId"], description: x["amenity"]) } if parsed["HotelInformationResponse"]
+
+      summary = if parsed["hotelId"]
+                  parsed
+                else
+                  parsed["HotelInformationResponse"]["HotelSummary"]
+                end
+      proximity_distance = summary["proximityDistance"].to_s
+      proximity_distance << summary["proximityUnit"].to_s
+      parsed_info = {
+        id: summary["hotelId"],
+        name: summary["name"],
+        address: summary["address1"],
+        city: summary["city"],
+        postal_code: summary["postalCode"],
+        country_code: summary["countryCode"],
+        rating: summary["hotelRating"],
+        high_rate: summary["highRate"],
+        low_rate: summary["lowRate"],
+        latitude: summary["latitude"].to_f,
+        longitude: summary["longitude"].to_f,
+        province: summary["stateProvinceCode"],
+        airport_code: summary["airportCode"],
+        property_category: summary["propertyCategory"].to_i,
+        proximity_distance: proximity_distance,
+        tripadvisor_rating: summary["tripAdvisorRating"],
+        deep_link: summary["deepLink"]
+      }
+      parsed_info[:amenities] = parsed["HotelInformationResponse"]["PropertyAmenities"]["PropertyAmenity"].map do |x|
+        Amenity.new(id: x["amenityId"], description: x["amenity"])
+      end if parsed["HotelInformationResponse"]
       parsed_info[:images] = images(parsed) if images(parsed)
-      parsed_info[:property_description] = parsed["HotelInformationResponse"]["HotelDetails"]["propertyDescription"] if parsed["HotelInformationResponse"]
-      parsed_info[:location_description] = summary["locationDescription"]
-      parsed_info[:number_of_rooms] = parsed["HotelInformationResponse"]["HotelDetails"]["numberOfRooms"] if parsed["HotelInformationResponse"]
-      parsed_info[:number_of_floors] = parsed["HotelInformationResponse"]["HotelDetails"]["numberOfFloors"] if parsed["HotelInformationResponse"]
+      if parsed["HotelInformationResponse"]
+        parsed_info[:property_description] = parsed["HotelInformationResponse"]["HotelDetails"]["propertyDescription"]
+        parsed_info[:number_of_rooms] = parsed["HotelInformationResponse"]["HotelDetails"]["numberOfRooms"]
+        parsed_info[:number_of_floors] = parsed["HotelInformationResponse"]["HotelDetails"]["numberOfFloors"]
+      end
+      if parsed["locationDescription"]
+        parsed_info[:location_description] = summary["locationDescription"]
+      end
       parsed_info[:short_description] = summary["shortDescription"]
       parsed_info[:amenity_mask] = summary["amenityMask"]
       parsed_info[:masked_amenities] = Amenity.parse_mask(parsed_info[:amenity_mask])
+
       parsed_info
     end
 
-    # Public: Get images from a parsed object
+    # Internal: Get images from the parsed JSON.
     #
-    # parsed - a Hash representing the parsed JSON
+    # parsed - A Hash representing the parsed JSON.
     #
-    # Returns an Array of Suitcase::Images.
+    # Returns an Array of Image.
     def self.images(parsed)
-      images = parsed["HotelInformationResponse"]["HotelImages"]["HotelImage"].map { |image_data| Suitcase::Image.new(image_data) } if parsed["HotelInformationResponse"] && parsed["HotelInformationResponse"]["HotelImages"] && parsed["HotelInformationResponse"]["HotelImages"]["HotelImage"]
-      images = [Suitcase::Image.new("thumbnailURL" => "http://images.travelnow.com" + parsed["thumbNailUrl"])] unless parsed["thumbNailUrl"].nil? or parsed["thumbNailUrl"].empty?
-      return images ? images : []
+      images = parsed["HotelInformationResponse"]["HotelImages"]["HotelImage"].map do |image_data|
+        Suitcase::Image.new(image_data)
+      end if parsed["HotelInformationResponse"] && parsed["HotelInformationResponse"]["HotelImages"] && parsed["HotelInformationResponse"]["HotelImages"]["HotelImage"]
+      unless parsed["thumbNailUrl"].nil? or parsed["thumbNailUrl"].empty?
+        images = [Suitcase::Image.new("thumbnailURL" => "http://images.travelnow.com" + parsed["thumbNailUrl"])]
+      end
+      
+      images || []
     end
 
-    # Handle the errors from the response.
+    # Internal: Raise the errors returned from the response.
+    #
+    # info - The parsed JSON to get the errors from.
+    #
+    # Returns nothing.
     def self.handle_errors(info)
       key = info.keys.first
       if info[key] && info[key]["EanWsError"]
         message = info[key]["EanWsError"]["presentationMessage"]
+        exception = EANException.new(message)
+        if message =~ /Multiple locations/ && (info = info[key]["LocationInfos"])
+          exception.type = :multiple_locations
+          exception.recovery = {
+            alternate_locations: info["LocationInfo"].map { |h| h["code"] }
+          }
+        end
+
+        raise exception
       end
-      raise EANException.new(message) if message
     end
 
+    # Internal: Split an Array of multiple Hotels.
+    #
+    # parsed - The parsed JSON of the Hotels.
+    #
+    # Returns an Array of Hashes representing Hotels.
     def self.split(parsed)
       hotels = parsed["HotelListResponse"]["HotelList"]
       hotels["HotelSummary"]
     end
 
+    # Public: Get the thumbnail URL of the image.
+    #
+    # Returns a String URL to the image thumbnail.
     def thumbnail_url
       first_image = images.find { |img| img.thumbnail_url != nil }
       first_image.thumbnail_url if first_image
@@ -187,10 +309,9 @@ module Suitcase
 
     # Public: Fetch possible rooms from a Hotel.
     #
-    # info - a Hash of options described as the accessors in
-    #        the Suitcase::Room class
+    # info - A Hash of options that are the accessors in Rooms.
     #
-    # Returns an Array of Suitcase::Rooms.
+    # Returns an Array of Rooms.
     def rooms(info)
       params = { rooms: [{adults: 1, children_ages: []}] }.merge(info)
       params[:rooms].each_with_index do |room, n|
@@ -202,24 +323,30 @@ module Suitcase
       params.delete(:arrival)
       params.delete(:departure)
       params["hotelId"] = @id
+      
       if Configuration.cache? and Configuration.cache.cached?(:avail, params)
         parsed = Configuration.cache.get_query(:avail, params)
       else
-        parsed = Hotel.parse_response(Hotel.url(:method => "avail", :params => params, :session => info[:session]))
+        parsed = Hotel.parse_response(Hotel.url(method: "avail", params: params, session: info[:session]))
         Hotel.handle_errors(parsed)
-        Configuration.cache.save_query(:avail, params, parsed) if Configuration.cache?
+        if Configuration.cache?
+          Configuration.cache.save_query(:avail, params, parsed)
+        end
       end
       hotel_id = parsed["HotelRoomAvailabilityResponse"]["hotelId"]
       rate_key = parsed["HotelRoomAvailabilityResponse"]["rateKey"]
       supplier_type = parsed["HotelRoomAvailabilityResponse"]["HotelRoomResponse"][0]["supplierType"]
       Hotel.update_session(parsed, info[:session])
-      rooms = parsed["HotelRoomAvailabilityResponse"]["HotelRoomResponse"].map do |raw_data|
+      
+      parsed["HotelRoomAvailabilityResponse"]["HotelRoomResponse"].map do |raw_data|
         room_data = {}
         room_data[:rate_code] = raw_data["rateCode"]
         room_data[:room_type_code] = raw_data["roomTypeCode"]
         room_data[:room_type_description] = raw_data["roomTypeDescription"]
         room_data[:promo] = raw_data["RateInfo"]["@promo"].to_b
-        room_data[:price_breakdown] = raw_data["RateInfo"]["ChargeableRateInfo"]["NightlyRatesPerRoom"]["NightlyRate"].map { |raw| NightlyRate.new(raw) } if raw_data["RateInfo"]["ChargeableRateInfo"] && raw_data["RateInfo"]["ChargeableRateInfo"]["NightlyRatesPerRoom"] && raw_data["RateInfo"]["ChargeableRateInfo"]["NightlyRatesPerRoom"]["NightlyRate"].is_a?(Array)
+        room_data[:price_breakdown] = raw_data["RateInfo"]["ChargeableRateInfo"]["NightlyRatesPerRoom"]["NightlyRate"].map do |raw|
+          NightlyRate.new(raw)
+        end if raw_data["RateInfo"]["ChargeableRateInfo"] && raw_data["RateInfo"]["ChargeableRateInfo"]["NightlyRatesPerRoom"] && raw_data["RateInfo"]["ChargeableRateInfo"]["NightlyRatesPerRoom"]["NightlyRate"].is_a?(Array)
         room_data[:total_price] = raw_data["RateInfo"]["ChargeableRateInfo"]["@total"]
         room_data[:nightly_rate_total] = raw_data["RateInfo"]["ChargeableRateInfo"]["@nightlyRateTotal"]
         room_data[:average_nightly_rate] = raw_data["RateInfo"]["ChargeableRateInfo"]["@averageRate"]
@@ -229,7 +356,9 @@ module Suitcase
         room_data[:hotel_id] = hotel_id
         room_data[:supplier_type] = supplier_type
         room_data[:rooms] = params[:rooms]
-        room_data[:bed_types] = [raw_data["BedTypes"]["BedType"]].flatten.map { |x| BedType.new(id: x["@id"], description: x["description"]) } if raw_data["BedTypes"] && raw_data["BedTypes"]["BedType"]
+        room_data[:bed_types] = [raw_data["BedTypes"]["BedType"]].flatten.map do |x|
+          BedType.new(id: x["@id"], description: x["description"])
+        end if raw_data["BedTypes"] && raw_data["BedTypes"]["BedType"]
         Room.new(room_data)
       end
     end

data/lib/suitcase/hotel/room.rb

@@ -1,6 +1,14 @@
 module Suitcase
   class Room
-    attr_accessor :rate_key, :hotel_id, :supplier_type, :rate_code, :room_type_code, :supplier_type, :tax_rate, :non_refundable, :occupancy, :quoted_occupancy, :min_guest_age, :total, :surcharge_total, :nightly_rate_total, :average_base_rate, :average_rate, :max_nightly_rate, :currency_code, :value_adds, :room_type_description, :price_breakdown, :total_price, :average_nightly_rate, :promo, :arrival, :departure, :rooms, :bed_types
+    attr_accessor :rate_key, :hotel_id, :supplier_type, :rate_code,
+                  :room_type_code, :supplier_type, :tax_rate, :non_refundable,
+                  :occupancy, :quoted_occupancy, :min_guest_age, :total,
+                  :surcharge_total, :nightly_rate_total, :average_base_rate,
+                  :average_rate, :max_nightly_rate, :currency_code, :value_adds,
+                  :room_type_description, :price_breakdown, :total_price,
+                  :average_nightly_rate, :promo, :arrival, :departure, :rooms,
+                  :bed_types
+
     extend Suitcase::Helpers
 
     def initialize(info)

data/lib/suitcase/version.rb

@@ -1,3 +1,3 @@
 module Suitcase
-  VERSION = "1.3.1"
+  VERSION = "1.4.0"
 end

data/suitcase.gemspec

@@ -16,9 +16,11 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_development_dependency "rspec"
+  s.add_development_dependency "minitest"
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "turn"
+  
   s.add_development_dependency "rake"
-  s.add_development_dependency "factory_girl"
   s.add_development_dependency "pry"
 
   s.add_runtime_dependency "json"

data/test/car_rentals/car_rental_test.rb

@@ -0,0 +1,30 @@
+require "minitest_helper"
+
+describe Suitcase::CarRental do
+  before :each do
+    info = {
+      destination: "Seattle",
+      start_date: "07/04/2012",
+      end_date: "07/11/2012",
+      pickup_time: "07:30",
+      dropoff_time: "11:30"
+    }
+    @rentals = Suitcase::CarRental.find(info)
+    @rental = @rentals.first
+  end
+  
+  [:seating, :type_name, :type_code, :possible_features,
+  :possible_models].each do |accessor|
+    it "has an accessor #{accessor}" do
+      @rental.must_respond_to(accessor)
+      @rental.must_respond_to((accessor.to_s + "=").to_sym)
+    end
+  end
+  
+  describe ".find" do
+    it "returns an Array of CarRental's" do
+      @rentals.must_be_kind_of(Array)
+      @rental.must_be_kind_of(Suitcase::CarRental)
+    end
+  end
+end

data/test/hotels/amenity_test.rb

@@ -0,0 +1,23 @@
+require "minitest_helper"
+
+describe Suitcase::Amenity do
+  describe ".parse_mask" do
+    describe "when provided bitmask is not nil or 0" do
+      it "returns an Array of Symbols representing given Amenities" do
+        Suitcase::Amenity.parse_mask(5).must_equal [:business_services, :hot_tub]
+      end
+    end
+
+    describe "when bitmask is 0" do
+      it "returns an empty Array" do
+        Suitcase::Amenity.parse_mask(0).must_equal []
+      end
+    end
+
+    describe "when provided bitmask is nil" do
+      it "returns nil" do
+        Suitcase::Amenity.parse_mask(nil).must_equal nil
+      end
+    end
+  end  
+end

data/test/hotels/caching_test.rb

@@ -0,0 +1,42 @@
+require "minitest_helper"
+
+describe Suitcase do
+  before :each do
+    Suitcase::Configuration.cache = {}
+  end
+
+  it "caches all non-secure queries" do
+    # Query 1
+    hotel = Suitcase::Hotel.find(id: 123904)
+    
+    # Query 2
+    Suitcase::Hotel.find(location: "Boston, US")
+    
+    # Query 3
+    room = hotel.rooms(arrival: "6/23/2012", departure: "6/30/2012").first
+    
+    # Query 4
+    Suitcase::PaymentOption.find currency_code: "USD"
+    
+    # Query 5, don't cache though
+    room.rooms[0][:bed_type] = room.bed_types[0]
+    room.rooms[0][:smoking_preference] = "NS"
+    room.reserve!(Keys::VALID_RESERVATION_INFO)
+
+    Suitcase::Configuration.cache.keys.count.must_equal 4
+  end
+
+  it "retrieves from the cache if it's there" do
+    hotel = Suitcase::Hotel.find(id: 123904)
+    Suitcase::Hotel.find(location: "Boston, US")
+    hotel.rooms(arrival: "6/23/2012", departure: "6/30/2012")
+    Suitcase::PaymentOption.find currency_code: "USD"
+    
+    # Disable API access
+    Net::HTTP.expects(:get_response).never
+    hotel = Suitcase::Hotel.find(id: 123904)
+    Suitcase::Hotel.find(location: "Boston, US")
+    hotel.rooms(arrival: "6/23/2012", departure: "6/30/2012")
+    Suitcase::PaymentOption.find currency_code: "USD"
+  end
+end

data/test/hotels/ean_exception_test.rb

@@ -0,0 +1,24 @@
+require "minitest_helper"
+
+describe Suitcase::EANException do
+  before :each do
+    @exception = Suitcase::EANException.new(nil)
+  end
+
+  it "has an accessor recovery" do
+    @exception.must_respond_to(:recovery)
+    @exception.must_respond_to(:recovery=)
+  end
+
+  describe "#recoverable" do
+    it "returns true if the recovery attribute is set" do
+      @exception.recovery = { locations: ["London", "New London"] }
+      @exception.recoverable?.must_equal(true)
+    end
+
+    it "returns false if the recovery attribute is not set" do
+      @exception.recovery = nil
+      @exception.recoverable?.must_equal(false)
+    end
+  end
+end

data/test/hotels/helpers_test.rb

@@ -0,0 +1,44 @@
+require "minitest_helper"
+
+describe Suitcase::Helpers do
+  before :each do
+    class Dummy; extend Suitcase::Helpers; end
+  end
+
+  describe "#url" do
+    it "returns a URI with the proper base URL" do
+      url = Dummy.url(method: "action", params: {})
+      url.must_be_kind_of(URI)
+      url.host.must_match(/api.ean.com/)
+    end
+
+    describe "when using digital signature authorization" do
+      it "adds a 'sig' parameter" do
+        Suitcase::Configuration.expects(:use_signature_auth?).returns(true)
+        Dummy.expects(:generate_signature).returns("test")
+
+        url = Dummy.url(method: "action", params: {})
+        url.query.must_match(/sig=test/)
+      end
+    end
+  end
+
+  describe "#parse_response" do
+    it "raises an exception when passed an invalid URI" do
+      proc do
+        Dummy.parse_response(URI.parse("http://google.com"))
+      end.must_raise JSON::ParserError
+    end
+  end
+
+  describe "#generate_signature" do
+    it "returns the encrypted API key, shared secret, and timestamp" do
+      Suitcase::Configuration.expects(:hotel_api_key).returns("abc")
+      Suitcase::Configuration.expects(:hotel_shared_secret).returns("123")
+      Time.expects(:now).returns("10")
+
+      signature = Dummy.generate_signature
+      signature.must_equal(Digest::MD5.hexdigest("abc12310"))
+    end
+  end
+end