bookingsync-api 0.1.3 → 0.1.4

data/spec/bookingsync/api/client/reviews_spec.rb

@@ -3,6 +3,8 @@ require "spec_helper"
 describe BookingSync::API::Client::Reviews do
   let(:client) { BookingSync::API::Client.new(test_access_token) }
 
+  before { |ex| @casette_base_path = casette_path(casette_dir, ex.metadata) }
+
   describe ".reviews", :vcr do
     it "returns reviews" do
       expect(client.reviews).not_to be_empty
@@ -11,27 +13,31 @@ describe BookingSync::API::Client::Reviews do
   end
 
   describe ".review", :vcr do
+    let(:prefetched_review_id) {
+      find_resource("#{@casette_base_path}_reviews/returns_reviews.yml", "reviews")[:id]
+    }
+
     it "returns a single review" do
-      review = client.review(34562)
-      expect(review.id).to eq 34562
+      review = client.review(prefetched_review_id)
+      expect(review.id).to eq prefetched_review_id
     end
   end
 
   describe ".create_review", :vcr do
     let(:attributes) { { comment: "Awesome place", rating: 5 } }
-    let(:booking) { BookingSync::API::Resource.new(client, id: 1) }
+    let(:booking) { BookingSync::API::Resource.new(client, id: 840059) }
 
     it "creates a new review" do
       client.create_review(booking, attributes)
-      assert_requested :post, bs_url("bookings/1/reviews"),
+      assert_requested :post, bs_url("bookings/#{booking}/reviews"),
         body: { reviews: [attributes] }.to_json
     end
 
     it "returns newly created review" do
       VCR.use_cassette("BookingSync_API_Client_Reviews/_create_review/creates_a_new_review") do
         review = client.create_review(booking, attributes)
-        expect(review.comment).to eql(attributes[:comment])
-        expect(review.rating).to eql(attributes[:rating])
+        expect(review.comment).to eq(attributes[:comment])
+        expect(review.rating).to eq(attributes[:rating])
       end
     end
   end

data/spec/bookingsync/api/client/seasons_spec.rb

@@ -3,6 +3,8 @@ require "spec_helper"
 describe BookingSync::API::Client::Seasons do
   let(:client) { BookingSync::API::Client.new(test_access_token) }
 
+  before { |ex| @casette_base_path = casette_path(casette_dir, ex.metadata) }
+
   describe ".seasons", :vcr do
     it "returns seasons" do
       expect(client.seasons).not_to be_empty
@@ -11,54 +13,68 @@ describe BookingSync::API::Client::Seasons do
   end
 
   describe ".season", :vcr do
+    let(:prefetched_season_id) {
+      find_resource("#{@casette_base_path}_seasons/returns_seasons.yml", "seasons")[:id]
+    }
+
     it "returns a single season" do
-      season = client.season(1803)
-      expect(season.id).to eq 1803
+      season = client.season(prefetched_season_id)
+      expect(season.id).to eq prefetched_season_id
     end
   end
 
   describe ".create_season", :vcr do
-    let(:attributes) { { name: "New season", ratio: 0.2, minimum_stay: 4 } }
-    let(:rates_table) { BookingSync::API::Resource.new(client, id: 13) }
+    let(:attributes) { { name: "New season", ratio_percentage: 0.2, minimum_stay: 4 } }
+    let(:rates_table) do
+      find_resource("#{casette_dir}/BookingSync_API_Client_RatesTables/_rates_tables/returns_rates_tables.yml", "rates_tables")
+    end
 
     it "creates a new season" do
       client.create_season(rates_table, attributes)
-      assert_requested :post, bs_url("rates_tables/13/seasons"),
+      assert_requested :post, bs_url("rates_tables/#{rates_table}/seasons"),
         body: { seasons: [attributes] }.to_json
     end
 
     it "returns newly created season" do
       VCR.use_cassette("BookingSync_API_Client_Seasons/_create_season/creates_a_new_season") do
         season = client.create_season(rates_table, attributes)
-        expect(season.name).to eql(attributes[:name])
-        expect(season.minimum_stay).to eql(attributes[:minimum_stay])
+        expect(season.name).to eq(en: attributes[:name])
+        expect(season.minimum_stay).to eq(attributes[:minimum_stay])
       end
     end
   end
 
   describe ".edit_season", :vcr do
     let(:attributes) {
-      { name: "Updated season" }
+      { name: "Updated season name 2" }
     }
+    let(:created_season_id) {
+      find_resource("#{@casette_base_path}_create_season/creates_a_new_season.yml", "seasons")[:id]
+    }
+
     it "updates given season by ID" do
-      client.edit_season(6, attributes)
-      assert_requested :put, bs_url("seasons/6"),
+      client.edit_season(created_season_id, attributes)
+      assert_requested :put, bs_url("seasons/#{created_season_id}"),
         body: { seasons: [attributes] }.to_json
     end
 
     it "returns updated season" do
       VCR.use_cassette("BookingSync_API_Client_Seasons/_edit_season/updates_given_season_by_ID") do
-        season = client.edit_season(6, attributes)
+        season = client.edit_season(created_season_id, attributes)
         expect(season).to be_kind_of(BookingSync::API::Resource)
-        expect(season.name).to eq(attributes[:name])
+        expect(season.name).to eq(en: attributes[:name])
       end
     end
   end
 
   describe ".delete_season", :vcr do
+    let(:created_season_id) {
+      find_resource("#{@casette_base_path}_create_season/creates_a_new_season.yml", "seasons")[:id]
+    }
+
     it "deletes given season" do
-      client.delete_season(10)
-      assert_requested :delete, bs_url("seasons/10")
+      client.delete_season(created_season_id)
+      assert_requested :delete, bs_url("seasons/#{created_season_id}")
     end
   end
 end

data/spec/bookingsync/api/client/sources_spec.rb

@@ -3,6 +3,8 @@ require "spec_helper"
 describe BookingSync::API::Client::Sources do
   let(:client) { BookingSync::API::Client.new(test_access_token) }
 
+  before { |ex| @casette_base_path = casette_path(casette_dir, ex.metadata) }
+
   describe ".sources", :vcr do
     it "returns sources" do
       expect(client.sources).not_to be_empty
@@ -11,9 +13,13 @@ describe BookingSync::API::Client::Sources do
   end
 
   describe ".source", :vcr do
+    let(:prefetched_source_id) {
+      find_resource("#{@casette_base_path}_sources/returns_sources.yml", "sources")[:id]
+    }
+
     it "returns a single source" do
-      source = client.source(1874)
-      expect(source.id).to eq 1874
+      source = client.source(prefetched_source_id)
+      expect(source.id).to eq prefetched_source_id
     end
   end
 
@@ -31,27 +37,30 @@ describe BookingSync::API::Client::Sources do
     it "returns newly created source" do
       VCR.use_cassette("BookingSync_API_Client_Sources/_create_source/creates_a_new_source") do
         source = client.create_source(attributes)
-        expect(source.name).to eql(attributes[:name])
+        expect(source.name).to eq(attributes[:name])
       end
     end
   end
 
   describe ".edit_source", :vcr do
     let(:attributes) {
-      { name: "HomeAway.com" }
+      { name: "another test source" }
+    }
+    let(:created_source_id) {
+      find_resource("#{@casette_base_path}_create_source/creates_a_new_source.yml", "sources")[:id]
     }
 
     it "updates given source by ID" do
-      client.edit_source(4, attributes)
-      assert_requested :put, bs_url("sources/4"),
+      client.edit_source(created_source_id, attributes)
+      assert_requested :put, bs_url("sources/#{created_source_id}"),
         body: { sources: [attributes] }.to_json
     end
 
     it "returns updated source" do
       VCR.use_cassette("BookingSync_API_Client_Sources/_edit_source/updates_given_source_by_ID") do
-        source = client.edit_source(4, attributes)
+        source = client.edit_source(created_source_id, attributes)
         expect(source).to be_kind_of(BookingSync::API::Resource)
-        expect(source.name).to eql(attributes[:name])
+        expect(source.name).to eq(attributes[:name])
       end
     end
   end

data/spec/bookingsync/api/client/special_offers_spec.rb

@@ -3,6 +3,8 @@ require "spec_helper"
 describe BookingSync::API::Client::SpecialOffers do
   let(:client) { BookingSync::API::Client.new(test_access_token) }
 
+  before { |ex| @casette_base_path = casette_path(casette_dir, ex.metadata) }
+
   describe ".special_offers", :vcr do
     it "returns special_offers" do
       expect(client.special_offers).not_to be_empty
@@ -11,61 +13,74 @@ describe BookingSync::API::Client::SpecialOffers do
   end
 
   describe ".special_offer", :vcr do
+    let(:prefetched_special_offer_id) {
+      find_resource("#{@casette_base_path}_special_offers/returns_special_offers.yml", "special_offers")[:id]
+    }
+
     it "returns a single special_offer" do
-      special_offer = client.special_offer(86)
-      expect(special_offer.id).to eq 86
+      special_offer = client.special_offer(prefetched_special_offer_id)
+      expect(special_offer.id).to eq prefetched_special_offer_id
     end
   end
 
   describe ".create_special_offer", :vcr do
     let(:attributes) {
       {
-        name: "New special offer",
-        start_at: "2014-04-28",
-        end_at: "2014-05-28",
+        name_en: "New special offer",
+        start_date: "2017-04-28",
+        end_date: "2017-05-28",
         discount: 5
       }
     }
-    let(:rental) { BookingSync::API::Resource.new(client, id: 12) }
+    let(:rental) do
+      find_resource("#{casette_dir}/BookingSync_API_Client_Rentals/_rental/returns_a_single_rental.yml", "rentals")
+    end
 
     it "creates a new special_offer" do
       client.create_special_offer(rental, attributes)
-      assert_requested :post, bs_url("rentals/12/special_offers"),
+      assert_requested :post, bs_url("rentals/#{rental}/special_offers"),
         body: { special_offers: [attributes] }.to_json
     end
 
     it "returns newly created special_offer" do
       VCR.use_cassette("BookingSync_API_Client_SpecialOffers/_create_special_offer/creates_a_new_special_offer") do
         special_offer = client.create_special_offer(rental, attributes)
-        expect(special_offer.name).to eql(attributes[:name])
+        expect(special_offer.name).to eq(en: attributes[:name_en])
       end
     end
   end
 
   describe ".edit_special_offer", :vcr do
     let(:attributes) {
-      { name: "Updated special offer" }
+      { name_en: "Updated special offer" }
+    }
+    let(:created_special_offer_id) {
+      find_resource("#{@casette_base_path}_create_special_offer/creates_a_new_special_offer.yml", "special_offers")[:id]
     }
 
     it "updates given special_offer by ID" do
-      client.edit_special_offer(3, attributes)
-      assert_requested :put, bs_url("special_offers/3"),
+      client.edit_special_offer(created_special_offer_id, attributes)
+      assert_requested :put, bs_url("special_offers/#{created_special_offer_id}"),
         body: { special_offers: [attributes] }.to_json
     end
 
     it "returns updated special_offer" do
       VCR.use_cassette("BookingSync_API_Client_SpecialOffers/_edit_special_offer/updates_given_special_offer_by_ID") do
-        special_offer = client.edit_special_offer(3, attributes)
+        special_offer = client.edit_special_offer(created_special_offer_id, attributes)
         expect(special_offer).to be_kind_of(BookingSync::API::Resource)
-        expect(special_offer.name).to eq(attributes[:name])
+        expect(special_offer.name).to eq(en: attributes[:name_en])
       end
     end
   end
 
   describe ".delete_special_offer", :vcr do
+    let(:created_special_offer_id) {
+      find_resource("#{@casette_base_path}_create_special_offer/creates_a_new_special_offer.yml", "special_offers")[:id]
+    }
+
     it "deletes given special_offer" do
-      client.delete_special_offer(4)
-      assert_requested :delete, bs_url("special_offers/4")
+      client.delete_special_offer(created_special_offer_id)
+      assert_requested :delete, bs_url("special_offers/#{created_special_offer_id}")
     end
   end
 end

data/spec/bookingsync/api/client/strict_bookings_spec.rb

@@ -6,19 +6,15 @@ describe BookingSync::API::Client::StrictBookings do
   describe ".create_strict_booking", :vcr do
     let(:params) do
       {
-        "rental_id" => "1",
-        "start_at" => "2016-01-15 16:00:00",
-        "end_at" => "2016-01-23 10:00:00",
-        "adults" => "3",
-        "children" => "2",
-        "final_price" => "2125.42",
-        "price_to_pay_now" => "2125.42",
+        "rental_id" => 25938,
+        "start_at" => "2017-05-22 16:00:00",
+        "end_at" => "2017-05-29 10:00:00",
+        "adults" => 3,
+        "children" => 2,
+        "final_price" => "63",
+        "price_to_pay_now" => "18.9",
         "currency" => "EUR",
-        "source_id" => "1",
-        "bookings_fees" => [
-          { "rentals_fee_id" => "1", "times_booked" => "1" },
-          { "rentals_fee_id" => "3", "times_booked" => "1" }
-        ],
+        "source_id" => "4504",
         "client" => {
           "firstname" => "Lazar",
           "email" => "email@example.com",
@@ -41,8 +37,8 @@ describe BookingSync::API::Client::StrictBookings do
     it "returns newly created booking" do
      VCR.use_cassette("BookingSync_API_Client_StrictBookings/_create_strict_booking/creates_a_booking") do
        booking = client.create_strict_booking(params)
-       expect(booking.start_at).to eql(Time.parse("2016-01-15 16:00:00 UTC"))
-       expect(booking.end_at).to eql(Time.parse("2016-01-23 10:00:00 UTC"))
+       expect(booking.start_at).to eq(Time.parse("2017-05-22 16:00:00 UTC"))
+       expect(booking.end_at).to eq(Time.parse("2017-05-29 10:00:00 UTC"))
      end
    end
   end

data/spec/bookingsync/api/client/taxes_spec.rb

@@ -3,6 +3,8 @@ require "spec_helper"
 describe BookingSync::API::Client::Taxes do
   let(:client) { BookingSync::API::Client.new(test_access_token) }
 
+  before { |ex| @casette_base_path = casette_path(casette_dir, ex.metadata) }
+
   describe ".taxes", :vcr do
     it "returns taxes" do
       expect(client.taxes).not_to be_empty
@@ -11,9 +13,13 @@ describe BookingSync::API::Client::Taxes do
   end
 
   describe ".tax", :vcr do
+    let(:prefetched_tax_id) {
+      find_resource("#{@casette_base_path}_taxes/returns_taxes.yml", "taxes")[:id]
+    }
+
     it "returns a single tax" do
-      tax = client.tax(168)
-      expect(tax.id).to eq 168
+      tax = client.tax(prefetched_tax_id)
+      expect(tax.id).to eq prefetched_tax_id
     end
   end
 end

data/spec/bookingsync/api/client_spec.rb

@@ -6,7 +6,7 @@ describe BookingSync::API::Client do
   describe "#new" do
     it "initializes client object with given token" do
       client = BookingSync::API::Client.new("xyz")
-      expect(client.token).to eql("xyz")
+      expect(client.token).to eq("xyz")
     end
   end
 
@@ -80,7 +80,7 @@ describe BookingSync::API::Client do
         response = double(BookingSync::API::Response)
         allow(client).to receive(:call) { response }
         resources = client.request(:get, "resource")
-        expect(resources).to eql(response)
+        expect(resources).to eq(response)
       end
     end
   end
@@ -167,7 +167,7 @@ describe BookingSync::API::Client do
         expect {
           client.get("resource")
         }.to raise_error(BookingSync::API::UnsupportedResponse) { |error|
-          expect(error.status).to eql(405)
+          expect(error.status).to eq(405)
           expect(error.headers).to eq("content-type" => "application/vnd.api+json")
           expect(error.body).to eq("Whoops!")
           expect(error.message).to include("Received unsupported response from BookingSync API")
@@ -216,7 +216,7 @@ describe BookingSync::API::Client do
   describe "#api_endpoint" do
     it "returns URL to the API" do
       ENV["BOOKINGSYNC_URL"] = nil
-      expect(client.api_endpoint).to eql("https://www.bookingsync.com/api/v3")
+      expect(client.api_endpoint).to eq("https://www.bookingsync.com/api/v3")
     end
 
     context "user specifies base URL via BOOKINGSYNC_URL env" do
@@ -229,7 +229,7 @@ describe BookingSync::API::Client do
       end
 
       it "returns custom URL to the API" do
-        expect(client.api_endpoint).to eql("https://bookingsync.dev/api/v3")
+        expect(client.api_endpoint).to eq("https://bookingsync.dev/api/v3")
       end
     end
   end
@@ -275,7 +275,7 @@ describe BookingSync::API::Client do
     it "returns last response" do
       stub_get("resources", body: { meta: { count: 10 }, resources: [] }.to_json)
       client.get("resources")
-      expect(client.last_response.meta).to eql(count: 10)
+      expect(client.last_response.meta).to eq(count: 10)
     end
   end
 
@@ -288,7 +288,23 @@ describe BookingSync::API::Client do
     describe "#pagination_first_response" do
       it "returns first response of a paginated call" do
         client.paginate("resources", auto_paginate: true)
-        expect(client.pagination_first_response.meta).to eql(text: "first request")
+        expect(client.pagination_first_response.meta).to eq(text: "first request")
+      end
+    end
+
+    describe "with block" do
+      before do
+        stub_get("resources?per_page=50", headers: {}, body: { meta: { text: "first request" }, resources: [{ id: 1 }] }.to_json)
+      end
+
+      context "when there is only one page with results" do
+        it "invokes block" do
+          block = double("block")
+          expect(block).to receive(:do_stuff)
+          client.paginate("resources", per_page: 50) do |batch|
+            block.do_stuff
+          end
+        end
       end
     end
   end

data/spec/bookingsync/api/relation_spec.rb

@@ -13,7 +13,7 @@ describe BookingSync::API::Relation do
   describe ".from_links" do
     it "returns a hash of relations" do
       relations = BookingSync::API::Relation.from_links(client, links)
-      expect(relations.size).to eql(1)
+      expect(relations.size).to eq(1)
       expect(relations).to be_kind_of(Hash)
       expect(relations["foo.photos"]).to be_kind_of(BookingSync::API::Relation)
     end