contentful 0.3.4 → 0.3.5

data/spec/resource_building_spec.rb

@@ -1,21 +1,20 @@
 require 'spec_helper'
 
-
 describe 'Resource Building Examples' do
   it 'can deal with arrays' do
     response = Contentful::Response.new raw_fixture('link_array')
     resource = Contentful::ResourceBuilder.new(create_client, response).run
 
-    expect( resource.fields[:links] ).to be_a Array
-    expect( resource.fields[:links].first ).to be_a Contentful::Link
+    expect(resource.fields[:links]).to be_a Array
+    expect(resource.fields[:links].first).to be_a Contentful::Link
   end
 
   it 'replaces links with included versions if present' do
     response = Contentful::Response.new raw_fixture('includes')
     resource = Contentful::ResourceBuilder.new(create_client, response).run.first
 
-    expect( resource.fields[:links] ).to be_a Array
-    expect( resource.fields[:links].first ).to be_a Contentful::Entry
+    expect(resource.fields[:links]).to be_a Array
+    expect(resource.fields[:links].first).to be_a Contentful::Entry
   end
 
   it 'can also reference itself' do
@@ -23,7 +22,7 @@ describe 'Resource Building Examples' do
     resource = Contentful::ResourceBuilder.new(create_client, response).run.first
 
     other_resource = resource.fields[:e]
-    expect( other_resource ).to be_a Contentful::Entry
-    expect( other_resource.fields[:e] ).to be resource
+    expect(other_resource).to be_a Contentful::Entry
+    expect(other_resource.fields[:e]).to be resource
   end
-end
+end

data/spec/resource_spec.rb

@@ -4,20 +4,20 @@ describe Contentful::Resource do
   it 'must be included to get functionality' do
     c = Class.new
     c.send :include, Contentful::Resource
-    expect( c ).to respond_to :property_coercions
+    expect(c).to respond_to :property_coercions
   end
 
   describe 'creation' do
     it 'must be initialized with a (hash) object' do
-      expect{
+      expect do
         Contentful::ContentType.new json_fixture('nyancat')
-      }.not_to raise_error
+      end.not_to raise_error
     end
 
     it 'can deal with invalid objects' do
-      expect{
+      expect do
         Contentful::ContentType.new({})
-      }.not_to raise_error
+      end.not_to raise_error
     end
   end
 
@@ -25,28 +25,28 @@ describe Contentful::Resource do
     it 'will return a request object, if it has been initialized with one' do
       request  = Contentful::Request.new(nil, 'content_types')
       resource = Contentful::ContentType.new({}, request)
-      expect( resource.request ).to eq request
+      expect(resource.request).to eq request
     end
   end
 
   describe '#reload' do
-    let(:client){ create_client }
-    let(:entry){ vcr('entry'){ client.entry 'nyancat' } }
+    let(:client) { create_client }
+    let(:entry) { vcr('entry') { client.entry 'nyancat' } }
 
     it 'triggers the request connected to the resource (again)' do
       stub(entry.request).get
       entry.reload
-      expect( entry.request ).to have_received.get
+      expect(entry.request).to have_received.get
     end
 
     it 'the reloaded resource is different from the original one' do
-      reloaded_entry = vcr('reloaded_entry'){ entry.reload }
-      expect( reloaded_entry ).to be_a Contentful::Entry
-      expect( reloaded_entry ).not_to be entry
+      reloaded_entry = vcr('reloaded_entry') { entry.reload }
+      expect(reloaded_entry).to be_a Contentful::Entry
+      expect(reloaded_entry).not_to be entry
     end
 
     it 'will return false if #request not available' do
-      expect( Contentful::ContentType.new({}).reload ).to be_false
+      expect(Contentful::ContentType.new({}).reload).to be_false
     end
   end
-end
+end

data/spec/response_spec.rb

@@ -1,61 +1,62 @@
 require 'spec_helper'
 
 describe Contentful::Response do
-  let(:successful_response){ Contentful::Response.new raw_fixture('nyancat'), Contentful::Request.new(nil, '/entries', nil, 'nyancat') }
-  let(:error_response){ Contentful::Response.new raw_fixture('not_found') }
-  let(:unparsable_response){ Contentful::Response.new raw_fixture('unparsable') }
+  let(:successful_response) { Contentful::Response.new raw_fixture('nyancat'), Contentful::Request.new(nil, '/entries', nil, 'nyancat') }
+  let(:error_response) { Contentful::Response.new raw_fixture('not_found', 404) }
+  let(:unparsable_response) { Contentful::Response.new raw_fixture('unparsable') }
 
-  describe "#raw" do
-    it "returns the raw response it has been initalized with" do
-      expect( successful_response.raw.to_s ).to eql raw_fixture('nyancat').to_s
+  describe '#raw' do
+    it 'returns the raw response it has been initalized with' do
+      expect(successful_response.raw.to_s).to eql raw_fixture('nyancat').to_s
     end
   end
 
-  describe "#object" do
+  describe '#object' do
     it "returns the repsonse's parsed json" do
-      expect( successful_response.object ).to eq json_fixture('nyancat')
+      expect(successful_response.object).to eq json_fixture('nyancat')
     end
   end
 
-  describe "#request" do
-    it "returns the request the response has been initalized with" do
-      expect( successful_response.request ).to be_a Contentful::Request
+  describe '#request' do
+    it 'returns the request the response has been initalized with' do
+      expect(successful_response.request).to be_a Contentful::Request
     end
   end
 
-  describe "#status" do
+  describe '#status' do
     it 'returns :ok for normal responses' do
-      expect( successful_response.status ).to eq :ok
+      expect(successful_response.status).to eq :ok
     end
 
-    it 'returns :contentful_error for error responses' do
-      expect( error_response.status ).to eq :contentful_error
+    it 'returns :error for error responses' do
+      expect(error_response.status).to eq :error
     end
 
-    it 'returns :unparsable_json for unparsable json responses' do
-      expect( unparsable_response.status ).to eq :unparsable_json
+    it 'returns :error for unparsable json responses' do
+      expect(unparsable_response.status).to eq :error
     end
 
-    it 'returns :no_content for responses without content' do
+    it 'returns :error for responses without content' do
       raw_response = ''
-      stub(raw_response).status {204}
+      stub(raw_response).status { 204 }
       no_content_response = Contentful::Response.new raw_response
-      expect( no_content_response.status).to eq :no_content
+      expect(no_content_response.status).to eq :no_content
     end
   end
 
-  describe "#error_message" do
+  describe '#error_message' do
     it 'returns contentful error message for contentful errors' do
-      expect( error_response.error_message ).to eq "The resource could not be found."
+      expect(error_response.error_message).to eq 'The resource could not be found.'
     end
 
     it 'returns json parser error message for json parse errors' do
-      expect( unparsable_response.error_message ).to include "unexpected token"
+      expect(unparsable_response.error_message).to include 'unexpected token'
     end
 
     it 'returns a ServiceUnavailable error on a 503' do
       error_response = Contentful::Response.new raw_fixture('not_found', 503)
-      expect(error_response.status).to eql :service_unavailable
+      expect(error_response.status).to eql :error
+      expect(error_response.object).to be_kind_of Contentful::ServiceUnavailable
     end
   end
 end

data/spec/space_spec.rb

@@ -1,36 +1,36 @@
 require 'spec_helper'
 
 describe Contentful::Space do
-  let(:space){ vcr('space'){ create_client.space } }
+  let(:space) { vcr('space') { create_client.space } }
 
   describe 'SystemProperties' do
     it 'has a #sys getter returning a hash with symbol keys' do
-      expect( space.sys ).to be_a Hash
-      expect( space.sys.keys.sample ).to be_a Symbol
+      expect(space.sys).to be_a Hash
+      expect(space.sys.keys.sample).to be_a Symbol
     end
 
     it 'has #id' do
-      expect( space.id ).to eq "cfexampleapi"
+      expect(space.id).to eq 'cfexampleapi'
     end
 
     it 'has #type' do
-      expect( space.type ).to eq "Space"
+      expect(space.type).to eq 'Space'
     end
   end
 
   describe 'Properties' do
     it 'has a #properties getter returning a hash with symbol keys' do
-      expect( space.properties ).to be_a Hash
-      expect( space.properties.keys.sample ).to be_a Symbol
+      expect(space.properties).to be_a Hash
+      expect(space.properties.keys.sample).to be_a Symbol
     end
 
     it 'has #name' do
-      expect( space.name ).to eq "Contentful Example API"
+      expect(space.name).to eq 'Contentful Example API'
     end
 
     it 'has #locales' do
-      expect( space.locales ).to be_a Array
-      expect( space.locales.first ).to be_a Contentful::Locale
+      expect(space.locales).to be_a Array
+      expect(space.locales.first).to be_a Contentful::Locale
     end
   end
 end

data/spec/spec_helper.rb

@@ -3,5 +3,4 @@ require 'contentful'
 require 'securerandom'
 require 'rr'
 
-
-Dir[File.dirname(__FILE__) + '/support/**/*.rb'].each{ |f| require f }
+Dir[File.dirname(__FILE__) + '/support/**/*.rb'].each { |f| require f }

data/spec/support/json_responses.rb

@@ -1,6 +1,6 @@
 require 'multi_json'
 
-def raw_fixture(which,status = 200, as_json = false)
+def raw_fixture(which, status = 200, _as_json = false)
   object = Object.new
   stub(object).status { status }
   stub(object).headers { {} }
@@ -9,7 +9,7 @@ def raw_fixture(which,status = 200, as_json = false)
   object
 end
 
-def json_fixture(which, as_json = false)
+def json_fixture(which, _as_json = false)
   MultiJson.load(
     File.read File.dirname(__FILE__) + "/../fixtures/json_responses/#{which}.json"
   )

data/spec/support/vcr.rb

@@ -4,7 +4,7 @@ VCR.configure do |c|
   c.cassette_library_dir = 'spec/fixtures/vcr_cassettes'
   c.ignore_localhost = true
   c.hook_into :webmock
-  c.default_cassette_options = { :record => :once }
+  c.default_cassette_options = { record: :once }
 end
 
 def vcr(name, &block)
@@ -12,5 +12,5 @@ def vcr(name, &block)
 end
 
 def expect_vcr(name, &block)
-  expect{ VCR.use_cassette(name, &block) }
-end
+  expect { VCR.use_cassette(name, &block) }
+end

data/spec/sync_page_spec.rb

@@ -1,109 +1,108 @@
 require 'spec_helper'
 
-
 describe Contentful::SyncPage do
-  let(:page_with_more){ vcr('sync_page'){ create_client.sync(initial: true).first_page } }
-  let(:page){ vcr('sync_page_2'){ create_client.sync.get("https://cdn.contentful.com/spaces/cfexampleapi/sync?sync_token=w5ZGw6JFwqZmVcKsE8Kow4grw45QdybCr8Okw6AYwqbDksO3ehvDpUPCgcKsKXbCiAwPC8K2w4LDvsOkw6nCjhPDpcOQADElWsOoU8KGR3HCtsOAwqd6wp_Dulp8w6LDsF_CtsK7Kk05wrMvwrLClMOgG2_Dn2sGPg") } }
+  let(:page_with_more) { vcr('sync_page') { create_client.sync(initial: true).first_page } }
+  let(:page) { vcr('sync_page_2') { create_client.sync.get('https://cdn.contentful.com/spaces/cfexampleapi/sync?sync_token=w5ZGw6JFwqZmVcKsE8Kow4grw45QdybCr8Okw6AYwqbDksO3ehvDpUPCgcKsKXbCiAwPC8K2w4LDvsOkw6nCjhPDpcOQADElWsOoU8KGR3HCtsOAwqd6wp_Dulp8w6LDsF_CtsK7Kk05wrMvwrLClMOgG2_Dn2sGPg') } }
 
   describe 'SystemProperties' do
     it 'has a #sys getter returning a hash with symbol keys' do
-      expect( page.sys ).to be_a Hash
-      expect( page.sys.keys.sample ).to be_a Symbol
+      expect(page.sys).to be_a Hash
+      expect(page.sys.keys.sample).to be_a Symbol
     end
 
     it 'has #type' do
-      expect( page.type ).to eq "Array"
+      expect(page.type).to eq 'Array'
     end
   end
 
   describe 'Properties' do
     it 'has a #properties getter returning a hash with symbol keys' do
-      expect( page.properties ).to be_a Hash
-      expect( page.properties.keys.sample ).to be_a Symbol
+      expect(page.properties).to be_a Hash
+      expect(page.properties.keys.sample).to be_a Symbol
     end
 
     it 'has #items which contain resources' do
-      expect( page_with_more.items ).to be_a Array
-      expect( page_with_more.items.sample ).to be_a Contentful::Resource
+      expect(page_with_more.items).to be_a Array
+      expect(page_with_more.items.sample).to be_a Contentful::Resource
     end
   end
 
   describe 'Fields' do
     it 'properly deals with nested locale fields' do
-      expect( page_with_more.items.first.fields[:name] ).to eq "London"
+      expect(page_with_more.items.first.fields[:name]).to eq 'London'
     end
   end
 
   describe '#each' do
     it 'is an Enumerator' do
-      expect( page.each ).to be_a Enumerator
+      expect(page.each).to be_a Enumerator
     end
 
     it 'iterates over items' do
-      expect( page.each.to_a ).to eq page.items
+      expect(page.each.to_a).to eq page.items
     end
 
     it 'includes Enumerable' do
-      expect( page.map{ |r| r.type } ).to eq page.items.map{ |r| r.type }
+      expect(page.map { |r| r.type }).to eq page.items.map { |r| r.type }
     end
   end
 
   describe '#next_sync_url' do
     it 'will return the next_sync_url if there is one' do
-      expect( page.next_sync_url ).to be_a String
+      expect(page.next_sync_url).to be_a String
     end
 
     it 'will return nil if note last page, yet' do
-      expect( page_with_more.next_sync_url ).to be_nil
+      expect(page_with_more.next_sync_url).to be_nil
     end
   end
 
   describe '#next_page_url' do
     it 'will return the next_page_url if there is one' do
-      expect( page_with_more.next_page_url ).to be_a String
+      expect(page_with_more.next_page_url).to be_a String
     end
 
     it 'will return nil if on last page' do
-      expect( page.next_page_url ).to be_nil
+      expect(page.next_page_url).to be_nil
     end
   end
 
   describe '#next_page' do
     it 'requests the next page' do
-      next_page = vcr('sync_page_2'){
+      next_page = vcr('sync_page_2')do
         page_with_more.next_page
-      }
-      expect( next_page ).to be_a Contentful::SyncPage
+      end
+      expect(next_page).to be_a Contentful::SyncPage
     end
 
     it 'will return nil if last page' do
-      expect( page.next_page_url ).to be_nil
+      expect(page.next_page_url).to be_nil
     end
   end
 
   describe '#next_page?' do
     it 'will return true if there is a next page' do
-      expect( page_with_more.next_page? ).to be_true
+      expect(page_with_more.next_page?).to be_true
     end
 
     it 'will return false if last page' do
-      expect( page.next_page? ).to be_false
+      expect(page.next_page?).to be_false
     end
   end
 
   describe '#last_page?' do
     it 'will return true if no more pages available' do
-      expect( page.last_page? ).to be_true
+      expect(page.last_page?).to be_true
     end
 
     it 'will return false if more pages available' do
-      expect( page_with_more.last_page? ).to be_false
+      expect(page_with_more.last_page?).to be_false
     end
   end
 
   describe '#sync' do
     it 'returns the sync that created the page' do
-      expect( page.sync ).to be_a Contentful::Sync
+      expect(page.sync).to be_a Contentful::Sync
     end
   end
 end

data/spec/sync_spec.rb

@@ -1,41 +1,39 @@
 require 'spec_helper'
 
-
 describe Contentful::Sync do
   let(:first_page) do
-    vcr('sync_page'){
+    vcr('sync_page')do
       create_client.sync(initial: true).first_page
-    }
+    end
   end
 
   let(:last_page) do
-    vcr('sync_page'){
-      vcr('sync_page_2'){
+    vcr('sync_page')do
+      vcr('sync_page_2')do
         create_client.sync(initial: true).first_page.next_page
-      }
-    }
+      end
+    end
   end
 
-
   describe '#initialize' do
     it 'takes an options hash on initialization' do
-      expect{
-        vcr('sync_deletion'){ create_client.sync(initial: true, type: 'Deletion').first_page }
-      }.not_to raise_exception
+      expect do
+        vcr('sync_deletion') { create_client.sync(initial: true, type: 'Deletion').first_page }
+      end.not_to raise_exception
     end
 
     it 'takes a next_sync_url on initialization' do
-      expect{
-        vcr('sync_page_2'){ create_client.sync("https://cdn.contentful.com/spaces/cfexampleapi/sync?sync_token=w5ZGw6JFwqZmVcKsE8Kow4grw45QdybCr8Okw6AYwqbDksO3ehvDpUPCgcKsKXbCiAwPC8K2w4LDvsOkw6nCjhPDpcOQADElWsOoU8KGR3HCtsOAwqd6wp_Dulp8w6LDsF_CtsK7Kk05wrMvwrLClMOgG2_Dn2sGPg").first_page }
-      }.not_to raise_exception
+      expect do
+        vcr('sync_page_2') { create_client.sync('https://cdn.contentful.com/spaces/cfexampleapi/sync?sync_token=w5ZGw6JFwqZmVcKsE8Kow4grw45QdybCr8Okw6AYwqbDksO3ehvDpUPCgcKsKXbCiAwPC8K2w4LDvsOkw6nCjhPDpcOQADElWsOoU8KGR3HCtsOAwqd6wp_Dulp8w6LDsF_CtsK7Kk05wrMvwrLClMOgG2_Dn2sGPg').first_page }
+      end.not_to raise_exception
     end
   end
 
   describe '#first_page' do
     it 'returns only the first page of a new sync' do
-      vcr('sync_page'){
-        expect( create_client.sync(initial: true).first_page ).to be_a Contentful::SyncPage
-      }
+      vcr('sync_page')do
+        expect(create_client.sync(initial: true).first_page).to be_a Contentful::SyncPage
+      end
     end
   end
 
@@ -45,31 +43,31 @@ describe Contentful::Sync do
       vcr('sync_page'){ vcr('sync_page_2'){
         count = 0
         sync.each_page do |page|
-          expect( page ).to be_a Contentful::SyncPage
+          expect(page).to be_a Contentful::SyncPage
           count += 1
         end
-        expect( count ).to eq 2
+        expect(count).to eq 2
       }}
     end
   end
 
   describe '#next_sync_url' do
     it 'is empty if there are still more pages to request in the current sync' do
-      expect( first_page.next_sync_url ).to be_nil
+      expect(first_page.next_sync_url).to be_nil
     end
 
     it 'returns the url to continue the sync next time' do
-      expect( last_page.next_sync_url ).to be_a String
+      expect(last_page.next_sync_url).to be_a String
     end
   end
 
   describe '#completed?' do
     it 'will return true if no more pages to request in the current sync' do
-      expect( first_page.next_sync_url ).to be_false
+      expect(first_page.next_sync_url).to be_false
     end
 
     it 'will return true if not all pages requested, yet' do
-      expect( last_page.next_sync_url ).to be_true
+      expect(last_page.next_sync_url).to be_true
     end
   end
 
@@ -78,7 +76,7 @@ describe Contentful::Sync do
       sync = create_client.sync(initial: true)
       vcr('sync_page'){ vcr('sync_page_2'){
         sync.each_item do |item|
-          expect( item ).to be_a Contentful::Resource
+          expect(item).to be_a Contentful::Resource
         end
       }}
     end