bookingsync-api 0.0.6 → 0.0.7

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

@@ -5,16 +5,66 @@ describe BookingSync::API::Client::Rentals do
 
   describe ".rentals", :vcr do
     it "returns rentals" do
-      expect(client.rentals).not_to be_nil
+      expect(client.rentals).not_to be_empty
       assert_requested :get, bs_url("rentals")
     end
 
-    context "with specified fields in options" do
-      it "returns rentals with filtered fields" do
-        rentals = client.rentals(fields: :name)
-        expect(rentals).not_to be_nil
-        assert_requested :get, bs_url("rentals?fields=name")
+    describe "links" do
+      it "returns associated photos" do
+        rental = client.rentals.first
+        expect(rental.photos).not_to be_empty
       end
     end
   end
+
+  describe ".rental", :vcr do
+    it "returns a single rental" do
+      rental = client.rental(2)
+      expect(rental.name).to eql("0 est")
+    end
+  end
+
+  describe ".create_rental", :vcr do
+    let(:attributes) { {
+      name: "New rental",
+      sleeps: 2
+    } }
+
+    it "creates a new rental" do
+      client.create_rental(attributes)
+      assert_requested :post, bs_url("rentals"),
+        body: { rentals: [attributes] }.to_json
+    end
+
+    it "returns newly created rental" do
+      VCR.use_cassette('BookingSync_API_Client_Rentals/_create_rental/creates_a_new_rental') do
+        rental = client.create_rental(attributes)
+        expect(rental.name).to eql("New rental")
+        expect(rental.sleeps).to eql(2)
+      end
+    end
+  end
+
+  describe ".edit_rental", :vcr do
+    it "updates given rental by ID" do
+      client.edit_rental(2, name: 'Updated Rental name')
+      assert_requested :put, bs_url("rentals/2"),
+        body: { rentals: [{ name: 'Updated Rental name' }] }.to_json
+    end
+
+    it "returns updated rental" do
+      VCR.use_cassette('BookingSync_API_Client_Rentals/_edit_rental/updates_given_rental_by_ID') do
+        rental = client.edit_rental(2, name: 'Updated Rental name')
+        expect(rental).to be_kind_of(BookingSync::API::Resource)
+        expect(rental.name).to eq('Updated Rental name')
+      end
+    end
+  end
+
+  describe ".cancel_rental", :vcr do
+    it "cancels given rental" do
+      client.cancel_rental(4)
+      assert_requested :delete, bs_url("rentals/4")
+    end
+  end
 end

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

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe BookingSync::API::Client::Reviews do
+  let(:client) { BookingSync::API::Client.new(test_access_token) }
+
+  describe ".reviews", :vcr do
+    it "returns reviews" do
+      expect(client.reviews).not_to be_empty
+      assert_requested :get, bs_url("reviews")
+    end
+  end
+
+  describe ".create_review", :vcr do
+    let(:attributes) {{
+      comment: "Awesome place",
+      rating: 5
+    }}
+
+    it "creates a new review" do
+      client.create_review(1, attributes)
+      assert_requested :post, bs_url("reviews"),
+        body: { booking_id: 1, 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(1, attributes)
+        expect(review.comment).to eql(attributes[:comment])
+        expect(review.rating).to eql(attributes[:rating])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+require "spec_helper"
+
+describe BookingSync::API::Client::Seasons do
+
+  let(:client) { BookingSync::API::Client.new(test_access_token) }
+
+  describe ".seasons", :vcr do
+    it "returns seasons" do
+      expect(client.seasons).not_to be_empty
+      assert_requested :get, bs_url("seasons")
+    end
+  end
+
+  describe ".create_season", :vcr do
+    let(:attributes) {{
+      name: "New season",
+      ratio: 0.2,
+      minimum_stay: 4
+    }}
+
+    it "creates a new season" do
+      client.create_season(13, attributes)
+      assert_requested :post, bs_url("seasons"),
+        body: { rates_table_id: 13, 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(13, attributes)
+        expect(season.name).to eql(attributes[:name])
+        expect(season.minimum_stay).to eql(attributes[:minimum_stay])
+      end
+    end
+  end
+
+  describe ".edit_season", :vcr do
+    let(:attributes) {
+      { name: "Updated season" }
+    }
+    it "updates given season by ID" do
+      client.edit_season(6, attributes)
+      assert_requested :put, bs_url("seasons/6"),
+        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)
+        expect(season).to be_kind_of(BookingSync::API::Resource)
+        expect(season.name).to eq(attributes[:name])
+      end
+    end
+  end
+
+  describe ".delete_season", :vcr do
+    it "deletes given season" do
+      client.delete_season(10)
+      assert_requested :delete, bs_url("seasons/10")
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+describe BookingSync::API::Client::SpecialOffers do
+  let(:client) { BookingSync::API::Client.new(test_access_token) }
+
+  describe ".special_offers", :vcr do
+    it "returns special_offers" do
+      expect(client.special_offers).not_to be_empty
+      assert_requested :get, bs_url("special_offers")
+    end
+  end
+
+  describe ".create_special_offer", :vcr do
+    let(:attributes) {
+      {
+        name: "New special offer",
+        start_at: '2014-04-28',
+        end_at: '2014-05-28',
+        discount: 5
+      }
+    }
+
+    it "creates a new special_offer" do
+      client.create_special_offer(12, attributes)
+      assert_requested :post, bs_url("special_offers"),
+        body: { rental_id: 12, 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(12, attributes)
+        expect(special_offer.name).to eql(attributes[:name])
+      end
+    end
+  end
+
+  describe ".edit_special_offer", :vcr do
+    let(:attributes) {
+      { name: 'Updated special offer' }
+    }
+
+    it "updates given special_offer by ID" do
+      client.edit_special_offer(3, attributes)
+      assert_requested :put, bs_url("special_offers/3"),
+        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)
+        expect(special_offer).to be_kind_of(BookingSync::API::Resource)
+        expect(special_offer.name).to eq(attributes[:name])
+      end
+    end
+  end
+
+  describe ".delete_special_offer", :vcr do
+    it "deletes given special_offer" do
+      client.delete_special_offer(4)
+      assert_requested :delete, bs_url("special_offers/4")
+    end
+  end
+end

data/spec/bookingsync/api/client_spec.rb

@@ -62,34 +62,55 @@ describe BookingSync::API::Client do
   end
 
   describe "#request" do
+    context "on response which responds to :resources" do
+      it "returns an array of resources" do
+        stub_get("resource", body: {resources: [{name: "Megan"}]}.to_json)
+        resources = client.request(:get, "resource")
+        expect(resources).to be_kind_of(Array)
+        expect(resources.first.name).to eq("Megan")
+      end
+    end
+
+    context "on response which doesn't respond to :resources" do
+      it "returns response" do
+        stub_get("resource", status: 204)
+        response = double(BookingSync::API::Response)
+        allow(client).to receive(:call) { response }
+        resources = client.request(:get, "resource")
+        expect(resources).to eql(response)
+      end
+    end
+  end
+
+  describe "#call" do
     before { VCR.turn_off! }
     it "authenticates the request with OAuth token" do
       ENV["ACCESS_TOKEN"] = nil
       stub_get("resource")
-      client.get("resource")
+      client.call(:get, "resource")
       assert_requested :get, bs_url("resource"),
         headers: {"Authorization" => "Bearer fake-access-token"}
     end
 
     it "requests proper accept header for JSON API" do
       stub_get("resource")
-      client.get("resource")
+      client.call(:get, "resource")
       assert_requested :get, bs_url("resource"),
         headers: {"Accept" => "application/vnd.api+json"}
     end
 
     it "requests sends data with JSON API content type" do
       stub_post("resource")
-      client.post("resource")
+      client.call(:post, "resource")
       assert_requested :post, bs_url("resource"),
         headers: {"Content-Type" => "application/vnd.api+json"}
     end
 
-    it "returns Array of resources" do
-      stub_get("resource", body: {resources: [{name: "Megan"}]}.to_json)
-      resources = client.get("resource")
-      expect(resources.size).to eq(1)
-      expect(resources.first.name).to eq("Megan")
+    it "returns an Response object of resources" do
+      attributes = {resources: [{name: "Megan"}]}
+      stub_post("resource", body: attributes.to_json)
+      response = client.call(:post, "resource", attributes)
+      expect(response).to be_kind_of(BookingSync::API::Response)
     end
 
     context "API returns 401" do
@@ -109,9 +130,9 @@ describe BookingSync::API::Client do
     end
 
     context "API returns 204 No Content" do
-      it "returns an empty array" do
+      it "returns nil" do
         stub_get("resource", status: 204)
-        expect(client.get("resource")).to eql([])
+        expect(client.get("resource")).to be_nil
       end
     end
 

data/spec/bookingsync/api/relation_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe BookingSync::API::Relation do
+  before { VCR.turn_off! }
+  let(:client) { BookingSync::API::Client.new(test_access_token,
+    base_url: "http://example.com") }
+  let(:links) { {"foo.photos" => "http://example.com/photos/{foo.photos}"} }
+  let(:relation) { BookingSync::API::Relation.new(client, :"foo.photos",
+    "http://example.com/photos/{foo.photos}") }
+
+  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).to be_kind_of(Hash)
+      expect(relations["foo.photos"]).to be_kind_of(BookingSync::API::Relation)
+    end
+  end
+
+  describe ".from_link" do
+    it "returns a single relation" do
+      relation = BookingSync::API::Relation.from_link(client, :example,
+        href: "https://example.com/photos")
+      expect(relation).to be_kind_of(BookingSync::API::Relation)
+    end
+  end
+
+  describe "#call" do
+    let(:client) { double(BookingSync::API::Client) }
+
+    it "makes HTTP request using API client" do
+      url_template = Addressable::Template.new("http://example.com/photos/{foo.photos}")
+      expect(client).to receive(:call).with(:get, url_template, nil, {})
+      relation.call
+    end
+  end
+
+  describe "#get" do
+    it "makes a HTTP GET using call on relation" do
+      url_template = Addressable::Template.new("http://example.com/photos/{foo.photos}")
+      expect(relation).to receive(:call).with({fields: [:name, :description], method: :get})
+      relation.get(fields: [:name, :description])
+    end
+  end
+
+
+  describe "#name" do
+    it "returns relation name" do
+      expect(relation.name).to eq(:"foo.photos")
+    end
+  end
+
+  describe "#href_template" do
+    it "returns relation's URL template" do
+      url_template = Addressable::Template.new("http://example.com/photos/{foo.photos}")
+      expect(relation.href_template).to eq(url_template)
+    end
+  end
+
+  describe "#href" do
+    it "returns relation's URL" do
+      expect(relation.href).to eq("http://example.com/photos/")
+    end
+
+    context "when options given" do
+      it "returns relation's URL expanded" do
+        url = relation.href("foo.photos" => [1, 2, 100])
+        expect(url).to eq("http://example.com/photos/1,2,100")
+      end
+    end
+  end
+end

data/spec/bookingsync/api/resource_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe BookingSync::API::Resource do
+  let(:links) { {photos: [9, 10]} }
+  let(:resource) {
+    client = BookingSync::API::Client.new(test_access_token,
+      base_url: "http://foo.com")
+    BookingSync::API::Resource.new(client,
+      {
+        name: "foo", width: 700,
+        links: links,
+        details: {count: 1},
+        id: 10
+      },
+      {
+        :"foo.photos" => "http://foo.com/photos/{foo.photos}",
+        :"foo.bars" => "http://foo.com/bars/{foo.bars}"
+      },
+      "foo"
+    )
+  }
+
+  describe "processing values" do
+    it "makes data accessible" do
+      expect(resource.name).to eql("foo")
+      expect(resource.width).to eql(700)
+    end
+
+    it "makes nested data accessible" do
+      expect(resource.details.count).to eql(1)
+    end
+
+    describe "#_resources_key" do
+      it "returns resources_key" do
+        expect(resource._resources_key).to eql("foo")
+      end
+
+      context "for nested resource" do
+        it "returns nil" do
+          expect(resource.details._resources_key).to be_nil
+        end
+      end
+    end
+  end
+
+  describe "associations" do
+    before { VCR.turn_off! }
+    it "fetches an association based on links" do
+      stub_request(:get, "http://foo.com/photos/9,10")
+        .to_return(body: {photos: [{file: 'a.jpg'}]}.to_json)
+      expect(resource.photos).to eql([{:file => "a.jpg"}])
+    end
+
+    context "when there are not associated ids" do
+      let(:links) { {photos: []} }
+      it "returns an empty array" do
+        expect(resource.photos).to eql([])
+      end
+    end
+
+    context "association doesn't exist" do
+      it "raises NoMethodError" do
+        expect { resource.pphotos }.to raise_error(NoMethodError)
+      end
+    end
+
+    it "passes query option to request" do
+      stub_request(:get, "http://foo.com/photos/9,10?fields=description")
+        .to_return(body: {photos: [{file: 'a.jpg'}]}.to_json)
+      resource.photos(fields: :description)
+    end
+  end
+
+  describe "#to_s" do
+    it "returns resource id" do
+      expect("#{resource}").to eq("10")
+    end
+  end
+end