quicktravel_client 1.1.2 → 2.0.0

data/lib/quick_travel/status.rb

@@ -0,0 +1,23 @@
+module QuickTravel
+  class Status
+    def self.key
+      # NOTE: This is not pretty, but we need to use a unique key per server
+      @key ||= "status-check##{SecureRandom.hex}"
+    end
+
+    def self.check!
+      # Test Cache
+      QuickTravel::Cache.delete(key)
+      QuickTravel::Cache.cache(key) { 'start' }
+      unless QuickTravel::Cache.cache(key) == 'start'
+        fail RuntimeError, 'Failed to cache status-check'
+      end
+
+      QuickTravel::Cache.delete(key)
+      QuickTravel::Cache.cache(key) { nil }
+      unless QuickTravel::Cache.cache(key) == nil
+        fail RuntimeError, 'Failed to clear status-check cache'
+      end
+    end
+  end
+end

data/lib/quick_travel/trip.rb

@@ -3,6 +3,5 @@ require 'quick_travel/adapter'
 module QuickTravel
   class Trip < Adapter
     self.api_base = '/api/trips'
-    attr_accessor :route_id
   end
 end

data/lib/quick_travel/vehicle.rb

@@ -2,16 +2,14 @@ require 'quick_travel/adapter'
 
 module QuickTravel
   class Vehicle < Adapter
-    attr_accessor :id, :vehicle_type_id, :registration, :length, :linked_to, :vehicle_type_name, :details
-
     def self.create(booking_id, vehicle_types = {})
       options = { booking_id: booking_id, vehicle_types: vehicle_types }
       response = post_and_validate("#{Booking.front_office_base}/#{booking_id}/vehicles.json", options)
-      fail AdapterException.new(response) unless response.key?('booking_id')
+      fail AdapterError.new(response) unless response.key?('booking_id')
     end
 
     def vehicle_type
-      VehicleType.all.detect { |vt| vt.id == vehicle_type_id }
+      VehicleType.find(vehicle_type_id)
     end
   end
 end

data/lib/quick_travel/vehicle_type.rb

@@ -2,9 +2,6 @@ require 'quick_travel/adapter'
 
 module QuickTravel
   class VehicleType < Adapter
-    attr_accessor :id, :name, :position, :code, :default_weight, :description, :detail_prompt, :double_length, :fixed_length, :fixed_weight
-    attr_accessor :has_cargo,	:default, :maximum_length, :minimum_length, :trailer
-
     self.api_base = '/vehicle_types'
     self.lookup = true
   end

data/lib/quick_travel/version.rb

@@ -1,3 +1,3 @@
 module QuickTravel
-  VERSION = '1.1.2'
+  VERSION = '2.0.0'
 end

data/quicktravel_client.gemspec

@@ -16,10 +16,9 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'httparty', '0.13.5'
+  spec.add_dependency 'httparty'
   spec.add_dependency 'geokit', '~> 1.8.3' # used in address model
   spec.add_dependency 'activesupport', '>= 2.0.0'
-  spec.add_dependency 'money_extensions'
   spec.add_dependency 'facets'
   spec.add_dependency 'money', '>= 3.0', '< 6.0' # 6.0 starts to deprecate/split
 
@@ -31,7 +30,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'simplecov-rcov'
   spec.add_development_dependency 'coveralls'
   spec.add_development_dependency 'stamp' # Used to send appropriate dates to API's
-  spec.add_development_dependency 'vcr', '2.9.3'
-  spec.add_development_dependency 'fakeweb'
+  spec.add_development_dependency 'vcr'
+  spec.add_development_dependency 'webmock'
   spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'travis'
 end

data/spec/booking_spec.rb

@@ -77,11 +77,35 @@ end
 
 describe QuickTravel::Booking do
   let(:booking) { QuickTravel::Booking.find(1) }
+
   it 'should have booking documents' do
     VCR.use_cassette('booking_with_documents') do
       expect(booking.documents.size).to eq 1
     end
   end
+
+  it 'should not have associated client objects' do
+    VCR.use_cassette('booking_with_documents') do
+      expect(booking.client).to be nil
+      expect(booking.client_party).to be nil
+      expect(booking.client_contact).to be nil
+      expect(booking.client_address).to be nil
+    end
+  end
+
+  let(:accom_product_type_id) { 2 }
+
+  it '#include_reservation_of?' do
+    VCR.use_cassette('booking_with_documents') do
+      expect(booking.include_reservation_of?(accom_product_type_id)).to be true
+    end
+  end
+
+  it '#includes_resource_class?' do
+    VCR.use_cassette('booking_with_documents') do
+      expect(booking.includes_resource_class?('Accommodation')).to be true
+    end
+  end
 end
 
 describe QuickTravel::Booking do

data/spec/discounts_spec.rb

@@ -2,9 +2,9 @@ require 'spec_helper'
 require 'quick_travel/reservation'
 require 'quick_travel/booking'
 
-describe 'Booking discounts' do
+describe 'Booking price_changes' do
   let(:booking) do
-    VCR.use_cassette('booking_with_discounts') do
+    VCR.use_cassette('booking_with_price_changes') do
       QuickTravel::Booking.find_by_reference('222223')
     end
   end
@@ -13,109 +13,109 @@ describe 'Booking discounts' do
     QuickTravel.config.version = 4
   end
 
-  context 'when the booking has a discount' do
-    let(:reservation)                 { booking.reservations.first }
-    let(:extra_pick_without_discount) { reservation.sub_reservations.first }
-    let(:extra_pick_with_discount)    { reservation.sub_reservations.second }
+  context 'when the booking has a price_change' do
+    let(:reservation)                     { booking.reservations.first }
+    let(:extra_pick_without_price_change) { reservation.sub_reservations.first }
+    let(:extra_pick_with_price_change)    { reservation.sub_reservations.second }
 
-    let(:discount) do
-      VCR.use_cassette('booking_discounts') do
-        booking.discount
+    let(:price_change) do
+      VCR.use_cassette('booking_price_changes') do
+        booking.price_change
       end
     end
 
-    specify { expect(discount.target.type).to eq 'Booking' }
-    specify { expect(discount.target.id).to eq booking.id }
-    specify { expect(discount.original_price).to eq 640.00 }
-    specify { expect(discount.discounted_price).to eq 380.00 }
-    specify { expect(discount.discount).to eq(-260.00) }
+    specify { expect(price_change.target.type).to eq 'Booking' }
+    specify { expect(price_change.target.id).to eq booking.id }
+    specify { expect(price_change.original_price).to eq 640.00 }
+    specify { expect(price_change.changed_price).to eq 380.00 }
+    specify { expect(price_change.price_change).to eq(-260.00) }
     specify do
-      expect(discount.reservation_discounts.count).to(
+      expect(price_change.reservation_price_changes.count).to(
         eq booking.reservations.count)
     end
 
-    context 'the discount applied on the top level reservation' do
-      let(:discount) do
-        VCR.use_cassette('booking_discounts') do
-          booking.discount_on(reservation)
+    context 'the price_change applied on the top level reservation' do
+      let(:price_change) do
+        VCR.use_cassette('booking_price_changes') do
+          booking.price_change_on(reservation)
         end
       end
 
-      specify { expect(discount.target.type).to eq 'Reservation' }
-      specify { expect(discount.target.id).to eq reservation.id }
-      specify { expect(discount.original_price).to eq 400.00 }
-      specify { expect(discount.discounted_price).to eq 200.00 }
-      specify { expect(discount.discount).to eq(-200) }
+      specify { expect(price_change.target.type).to eq 'Reservation' }
+      specify { expect(price_change.target.id).to eq reservation.id }
+      specify { expect(price_change.original_price).to eq 400.00 }
+      specify { expect(price_change.changed_price).to eq 200.00 }
+      specify { expect(price_change.price_change).to eq(-200) }
     end
 
-    context 'the total discount applied on the top level reservation' do
-      subject(:discount) do
-        VCR.use_cassette('booking_discounts') do
-          booking.total_discount_on(reservation)
+    context 'the total price_change applied on the top level reservation' do
+      subject(:price_change) do
+        VCR.use_cassette('booking_price_changes') do
+          booking.total_price_change_on(reservation)
         end
       end
 
-      specify { expect(discount.target.type).to eq 'Reservation' }
-      specify { expect(discount.target.id).to eq reservation.id }
-      specify { expect(discount.original_price).to eq 640.00 }
-      specify { expect(discount.discounted_price).to eq 380.00 }
-      specify { expect(discount.discount).to eq(-260.00) }
+      specify { expect(price_change.target.type).to eq 'Reservation' }
+      specify { expect(price_change.target.id).to eq reservation.id }
+      specify { expect(price_change.original_price).to eq 640.00 }
+      specify { expect(price_change.changed_price).to eq 380.00 }
+      specify { expect(price_change.price_change).to eq(-260.00) }
     end
 
-    context 'the discount applied on the first extra pick' do
-      let(:discount) do
-        VCR.use_cassette('booking_discounts') do
-          booking.discount_on(extra_pick_without_discount)
+    context 'the price_change applied on the first extra pick' do
+      let(:price_change) do
+        VCR.use_cassette('booking_price_changes') do
+          booking.price_change_on(extra_pick_without_price_change)
         end
       end
 
-      specify { expect(discount.target.type).to eq 'Reservation' }
-      specify { expect(discount.target.id).to eq extra_pick_without_discount.id }
-      specify { expect(discount.original_price).to eq 120 }
-      specify { expect(discount.discounted_price).to eq 120 }
-      specify { expect(discount.discount).to eq 0 }
+      specify { expect(price_change.target.type).to eq 'Reservation' }
+      specify { expect(price_change.target.id).to eq extra_pick_without_price_change.id }
+      specify { expect(price_change.original_price).to eq 120 }
+      specify { expect(price_change.changed_price).to eq 120 }
+      specify { expect(price_change.price_change).to eq 0 }
     end
 
-    context 'the total discount applied on the first extra pick' do
-      let(:discount) do
-        VCR.use_cassette('booking_discounts') do
-          booking.total_discount_on(extra_pick_without_discount)
+    context 'the total price_change applied on the first extra pick' do
+      let(:price_change) do
+        VCR.use_cassette('booking_price_changes') do
+          booking.total_price_change_on(extra_pick_without_price_change)
         end
       end
 
-      specify { expect(discount.target.type).to eq 'Reservation' }
-      specify { expect(discount.target.id).to eq extra_pick_without_discount.id }
-      specify { expect(discount.original_price).to eq 120 }
-      specify { expect(discount.discounted_price).to eq 120 }
-      specify { expect(discount.discount).to eq 0 }
+      specify { expect(price_change.target.type).to eq 'Reservation' }
+      specify { expect(price_change.target.id).to eq extra_pick_without_price_change.id }
+      specify { expect(price_change.original_price).to eq 120 }
+      specify { expect(price_change.changed_price).to eq 120 }
+      specify { expect(price_change.price_change).to eq 0 }
     end
 
-    context 'the discount applied on second extra pick' do
-      let(:discount) do
-        VCR.use_cassette('booking_discounts') do
-          booking.discount_on(extra_pick_with_discount)
+    context 'the price_change applied on second extra pick' do
+      let(:price_change) do
+        VCR.use_cassette('booking_price_changes') do
+          booking.price_change_on(extra_pick_with_price_change)
         end
       end
 
-      specify { expect(discount.target.type).to eq 'Reservation' }
-      specify { expect(discount.target.id).to eq extra_pick_with_discount.id }
-      specify { expect(discount.original_price).to eq 120.00 }
-      specify { expect(discount.discounted_price).to eq 60.00 }
-      specify { expect(discount.discount).to eq(-60.00) }
+      specify { expect(price_change.target.type).to eq 'Reservation' }
+      specify { expect(price_change.target.id).to eq extra_pick_with_price_change.id }
+      specify { expect(price_change.original_price).to eq 120.00 }
+      specify { expect(price_change.changed_price).to eq 60.00 }
+      specify { expect(price_change.price_change).to eq(-60.00) }
     end
 
-    context 'the total discount applied on second extra pick' do
-      let(:discount) do
-        VCR.use_cassette('booking_discounts') do
-          booking.total_discount_on(extra_pick_with_discount)
+    context 'the total price_change applied on second extra pick' do
+      let(:price_change) do
+        VCR.use_cassette('booking_price_changes') do
+          booking.total_price_change_on(extra_pick_with_price_change)
         end
       end
 
-      specify { expect(discount.target.type).to eq 'Reservation' }
-      specify { expect(discount.target.id).to eq extra_pick_with_discount.id }
-      specify { expect(discount.original_price).to eq 120.00 }
-      specify { expect(discount.discounted_price).to eq 60.00 }
-      specify { expect(discount.discount).to eq(-60.00) }
+      specify { expect(price_change.target.type).to eq 'Reservation' }
+      specify { expect(price_change.target.id).to eq extra_pick_with_price_change.id }
+      specify { expect(price_change.original_price).to eq 120.00 }
+      specify { expect(price_change.changed_price).to eq 60.00 }
+      specify { expect(price_change.price_change).to eq(-60.00) }
     end
   end
 end

data/spec/passenger_type_spec.rb

@@ -29,4 +29,34 @@ describe QuickTravel::PassengerType do
       it { should eq ['2 Adults'] }
     end
   end
+
+  context 'caching of collection' do
+    subject(:all) do
+      VCR.use_cassette('passenger_all') { QuickTravel::PassengerType.all }
+    end
+
+    let(:api) { double }
+
+    before do
+      stub_const('QuickTravel::Api', api)
+      allow(api).to receive(:call_and_validate) { [{id: 1}, {id: 2}] }
+    end
+    
+    context 'when called the first time' do
+      before do
+        QuickTravel::Cache.cache_store.clear
+        all
+      end
+      
+      specify { expect(api).to have_received(:call_and_validate).once }
+      
+      context 'when called again' do
+        before do
+          QuickTravel::PassengerType.all
+        end
+        
+        specify { expect(api).to have_received(:call_and_validate).once } # not called again
+      end
+    end
+  end
 end

data/spec/payment_type_spec.rb

@@ -15,4 +15,14 @@ describe QuickTravel::PaymentType do
     let(:brand) { 'American Express' }
     its(:code) { should eq 'american_express' }
   end
+
+  context 'payment info' do
+    it 'should fetch payment info' do
+      VCR.use_cassette 'payment_info' do
+        expect(QuickTravel::PaymentType.information).to eq(
+          'poli_pay' => { 'login' => 'S1234567' }
+        )
+      end
+    end
+  end
 end

data/spec/product_spec.rb

@@ -2,9 +2,18 @@ require 'spec_helper'
 require 'quick_travel/product'
 
 describe QuickTravel::Product do
+  let(:today) { '2016-03-01'.to_date }
+  let(:options) {
+    {
+      first_travel_date: today,
+      passenger_type_numbers: {'1' => 1},
+      rack_price_requested: true,
+      date_range: {start_date: today, end_date: today + 1}
+    }
+  }
+
   before do
     VCR.use_cassette('product_show') do
-      today = '2016-03-01'.to_date
       @product = QuickTravel::Product.find(6, # Executive Room
                                            first_travel_date: today,
                                            passenger_type_numbers: { '1' => 1 },
@@ -15,32 +24,52 @@ describe QuickTravel::Product do
 
   it 'should create a useful product object' do
     expect(@product.pricing_details.minimum_price).to eq 400.to_money
-    # @product.pricing_details_for_rack_rate.should_not be_present # TODO: Record new VCRs with new QT code
+    expect(@product.pricing_details_for_rack_rate).to_not be_present
+  end
+
+  it 'should return a rack minimum price when requested due to agent being logged in' do
+    VCR.use_cassette('product_show_as_agent') do
+      @product = QuickTravel::Product.find(6, options)
+    end
+
+    expect(@product.pricing_details_for_rack_rate).to be_present
+  end
+
+  it 'should ensure id is passed in correctly before calling' do
+    expect {
+      QuickTravel::Product.find(nil, options)
+    }.to raise_error(
+      ArgumentError,
+      'id must be an integer'
+    )
   end
 
-  # TODO: Record new VCRs with new QT code
-  # it 'should return a rack minimum price when requested due to agent being logged in' do
-  #   VCR.use_cassette('product_show_as_agent') do
-  #     today = '2013-02-14'.to_date
-  #     @product = QuickTravel::Product.find(195,
-  #       first_travel_date: today,
-  #       passenger_type_numbers: {'1' => 1},
-  #       rack_price_requested: true,
-  #       date_range: {start_date: today, end_date: today + 1}
-  #      )
-  #   end
-  #
-  #   @product.pricing_details_for_rack_rate.should be_present
-  # end
+  it 'shouldnt allow other strings' do
+    expect {
+      QuickTravel::Product.find('six', options)
+    }.to raise_error(
+      ArgumentError,
+      'id must be an integer'
+    )
+  end
+
+  it 'should allow string integers' do
+    expect {
+      VCR.use_cassette('product_show_as_agent') do
+        QuickTravel::Product.find('6', options)
+      end
+    }.not_to raise_error
+  end
 end
 
 describe QuickTravel::Product do
+  let(:today) { '2016-03-01'.to_date }
+
   before do
     VCR.use_cassette('product_date_range_bookability') do
-      @today = '2016-03-01'.to_date
       @products = QuickTravel::Product.fetch_and_arrange_by_resource_id_and_date(
         [3, 4, 6],
-        travel_date: @today,
+        travel_date: today,
         duration: 7,
         default_pax_type_numbers: { '1' => 1 },
         passenger_type_numbers: { '1' => 2, '2' => 1 }
@@ -48,8 +77,10 @@ describe QuickTravel::Product do
     end
   end
 
+  let(:expected_price) { 250.to_money }
+
   context 'accommodation product today' do
-    subject(:product) { @products[6][@today.to_s] }
+    subject(:product) { @products[6][today.to_s] }
     it { should be_an_instance_of QuickTravel::Product }
 
     context 'pricing details' do
@@ -59,13 +90,13 @@ describe QuickTravel::Product do
       context 'price per pax type' do
         let(:price_if_no_breakdown) { pricing_details.price_per_pax_type[0] }
         it 'should breakdown prices even if just a total' do
-          expect(price_if_no_breakdown).to eq 300.to_money
+          expect(price_if_no_breakdown).to eq expected_price
         end
       end
 
       context 'minimum price' do
         subject(:minimum_price) { pricing_details.minimum_price }
-        it { should eq 300.to_money } # $200 for 2 pax, $100 for extra passenger
+        it { should eq expected_price } # $200 for 2 pax, $50 for extra passenger
       end
 
       context 'adjustments' do