contentful 0.3.4 → 0.3.5

data/spec/dynamic_entry_spec.rb

@@ -1,34 +1,34 @@
 require 'spec_helper'
 
 describe Contentful::DynamicEntry do
-  let(:content_type){ vcr('content_type'){ create_client.content_type 'cat' } }
+  let(:content_type) { vcr('content_type') { create_client.content_type 'cat' } }
 
   it 'create as a class' do
-    expect( Contentful::DynamicEntry.create(content_type) ).to be_instance_of Class
+    expect(Contentful::DynamicEntry.create(content_type)).to be_instance_of Class
   end
 
   it 'also works with raw json object input as argument' do
-    expect( Contentful::DynamicEntry.create(json_fixture('content_type')) ).to be_instance_of Class
+    expect(Contentful::DynamicEntry.create(json_fixture('content_type'))).to be_instance_of Class
   end
 
   it 'should create Contentful::DynamicEntry instances' do
-    expect( Contentful::DynamicEntry.create(content_type).new(json_fixture('nyancat')) ).to \
+    expect(Contentful::DynamicEntry.create(content_type).new(json_fixture('nyancat'))).to \
         be_a Contentful::DynamicEntry
   end
 
   describe 'Example Entry Class' do
-    before{
+    before do
       NyanCatEntry = Contentful::DynamicEntry.create(content_type)
-    }
+    end
 
     it 'defines getters for entry fields' do
-      nyancat = NyanCatEntry.new json_fixture("nyancat")
-      expect( nyancat.color ).to eq "rainbow"
+      nyancat = NyanCatEntry.new json_fixture('nyancat')
+      expect(nyancat.color).to eq 'rainbow'
     end
 
     it 'automatically coerces types' do
-      nyancat = NyanCatEntry.new json_fixture("nyancat")
-      expect( nyancat.birthday ).to be_a DateTime
+      nyancat = NyanCatEntry.new json_fixture('nyancat')
+      expect(nyancat.birthday).to be_a DateTime
     end
   end
-end
+end

data/spec/entry_spec.rb

@@ -1,52 +1,52 @@
 require 'spec_helper'
 
 describe Contentful::ContentType do
-  let(:entry){ vcr('entry'){ create_client.entry 'nyancat' } }
+  let(:entry) { vcr('entry') { create_client.entry 'nyancat' } }
 
   describe 'SystemProperties' do
     it 'has a #sys getter returning a hash with symbol keys' do
-      expect( entry.sys ).to be_a Hash
-      expect( entry.sys.keys.sample ).to be_a Symbol
+      expect(entry.sys).to be_a Hash
+      expect(entry.sys.keys.sample).to be_a Symbol
     end
 
     it 'has #id' do
-      expect( entry.id ).to eq "nyancat"
+      expect(entry.id).to eq 'nyancat'
     end
 
     it 'has #type' do
-      expect( entry.type ).to eq "Entry"
+      expect(entry.type).to eq 'Entry'
     end
 
     it 'has #space' do
-      expect( entry.space ).to be_a Contentful::Link
+      expect(entry.space).to be_a Contentful::Link
     end
 
     it 'has #content_type' do
-      expect( entry.content_type ).to be_a Contentful::Link
+      expect(entry.content_type).to be_a Contentful::Link
     end
 
     it 'has #created_at' do
-      expect( entry.created_at ).to be_a DateTime
+      expect(entry.created_at).to be_a DateTime
     end
 
     it 'has #updated_at' do
-      expect( entry.updated_at ).to be_a DateTime
+      expect(entry.updated_at).to be_a DateTime
     end
 
     it 'has #revision' do
-      expect( entry.revision ).to eq 5
+      expect(entry.revision).to eq 5
     end
   end
 
   describe 'Fields' do
     it 'has a #fields getter returning a hash with symbol keys' do
-      expect( entry.sys ).to be_a Hash
-      expect( entry.sys.keys.sample ).to be_a Symbol
+      expect(entry.sys).to be_a Hash
+      expect(entry.sys.keys.sample).to be_a Symbol
     end
 
     it "contains the entry's fields" do
-      expect( entry.fields[:color] ).to eq "rainbow"
-      expect( entry.fields[:bestFriend] ).to be_a Contentful::Link
+      expect(entry.fields[:color]).to eq 'rainbow'
+      expect(entry.fields[:bestFriend]).to be_a Contentful::Link
     end
   end
 

data/spec/error_class_spec.rb

@@ -1,59 +1,56 @@
 require 'spec_helper'
 
 describe Contentful::Error do
-  let(:r){ Contentful::Response.new raw_fixture("not_found") }
-
+  let(:r) { Contentful::Response.new raw_fixture('not_found',404) }
 
   describe '#response' do
     it 'returns the response the error has been initialized with' do
-      expect( Contentful::Error.new(r).response ).to be r
+      expect(Contentful::Error.new(r).response).to be r
     end
   end
 
   describe '#message' do
     it 'returns the message found in the response json' do
-      expect( Contentful::Error.new(r).message ).not_to be_nil
-      expect( Contentful::Error.new(r).message ).to \
-          eq json_fixture("not_found")["message"]
+      expect(Contentful::Error.new(r).message).not_to be_nil
+      expect(Contentful::Error.new(r).message).to \
+          eq json_fixture('not_found')['message']
     end
   end
 
-
   describe Contentful::UnparsableJson do
     describe '#message' do
       it 'returns the json parser\'s message' do
-        uj = Contentful::Response.new raw_fixture("unparsable")
-        expect( Contentful::UnparsableJson.new(uj).message ).to \
-            include "unexpected token"
+        uj = Contentful::Response.new raw_fixture('unparsable')
+        expect(Contentful::UnparsableJson.new(uj).message).to \
+            include 'unexpected token'
       end
     end
   end
 
-
   describe '.[]' do
     it 'returns NotFound error class for 404' do
-      expect( Contentful::Error[404] ).to eq Contentful::NotFound
+      expect(Contentful::Error[404]).to eq Contentful::NotFound
     end
 
     it 'returns BadRequest error class for 400' do
-      expect( Contentful::Error[400] ).to eq Contentful::BadRequest
+      expect(Contentful::Error[400]).to eq Contentful::BadRequest
     end
 
     it 'returns AccessDenied error class for 403' do
-      expect( Contentful::Error[403] ).to eq Contentful::AccessDenied
+      expect(Contentful::Error[403]).to eq Contentful::AccessDenied
     end
 
     it 'returns Unauthorized error class for 401' do
-      expect( Contentful::Error[401] ).to eq Contentful::Unauthorized
+      expect(Contentful::Error[401]).to eq Contentful::Unauthorized
     end
 
     it 'returns ServerError error class for 500' do
-      expect( Contentful::Error[500] ).to eq Contentful::ServerError
+      expect(Contentful::Error[500]).to eq Contentful::ServerError
     end
 
     it 'returns generic error class for any other value' do
-      expect( Contentful::Error[nil] ).to eq Contentful::Error
-      expect( Contentful::Error[200] ).to eq Contentful::Error
+      expect(Contentful::Error[nil]).to eq Contentful::Error
+      expect(Contentful::Error[200]).to eq Contentful::Error
     end
   end
 

data/spec/error_requests_spec.rb

@@ -1,17 +1,16 @@
 require 'spec_helper'
 
-
 describe 'Error Requests' do
   it 'will return 404 (Unauthorized) if resource not found' do
-    expect_vcr("not found"){
+    expect_vcr('not found')do
       create_client.entry 'not found'
-    }.to raise_error(Contentful::NotFound)
+    end.to raise_error(Contentful::NotFound)
   end
 
   it 'will return 400 (BadRequest) if invalid parameters have been passed' do
-    expect_vcr("bad request"){
+    expect_vcr('bad request')do
       create_client.entries(some: 'parameter')
-    }.to raise_error(Contentful::BadRequest)
+    end.to raise_error(Contentful::BadRequest)
   end
 
   it 'will return 403 (AccessDenied) if ...' do
@@ -19,9 +18,9 @@ describe 'Error Requests' do
   end
 
   it 'will return 401 (Unauthorized) if wrong credentials given' do
-    client = Contentful::Client.new(space: "wrong", access_token: "credentials")
+    client = Contentful::Client.new(space: 'wrong', access_token: 'credentials')
 
-    expect_vcr("unauthorized"){
+    expect_vcr('unauthorized'){
       client.entry 'nyancat'
     }.to raise_error(Contentful::Unauthorized)
   end

data/spec/field_spec.rb

@@ -1,36 +1,36 @@
 require 'spec_helper'
 
 describe Contentful::Field do
-  let(:field){ vcr('field'){ create_client.content_type('cat').fields.first } }
+  let(:field) { vcr('field') { create_client.content_type('cat').fields.first } }
 
   describe 'Properties' do
     it 'has a #properties getter returning a hash with symbol keys' do
-      expect( field.properties ).to be_a Hash
-      expect( field.properties.keys.sample ).to be_a Symbol
+      expect(field.properties).to be_a Hash
+      expect(field.properties.keys.sample).to be_a Symbol
     end
 
     it 'has #id' do
-      expect( field.id ).to eq "name"
+      expect(field.id).to eq 'name'
     end
 
     it 'has #name' do
-      expect( field.name ).to eq "Name"
+      expect(field.name).to eq 'Name'
     end
 
     it 'has #type' do
-      expect( field.type ).to eq "Text"
+      expect(field.type).to eq 'Text'
     end
 
     it 'could have #items' do
-      expect( field ).to respond_to :items
+      expect(field).to respond_to :items
     end
 
     it 'has #required' do
-      expect( field.required ).to be_true
+      expect(field.required).to be_true
     end
 
     it 'has #localized' do
-      expect( field.required ).to be_true
+      expect(field.required).to be_true
     end
   end
 end

data/spec/file_spec.rb

@@ -1,28 +1,28 @@
 require 'spec_helper'
 
 describe Contentful::File do
-  let(:file){ vcr('asset'){ create_client.asset('nyancat').file } }
+  let(:file) { vcr('asset') { create_client.asset('nyancat').file } }
 
   describe 'Properties' do
     it 'has a #properties getter returning a hash with symbol keys' do
-      expect( file.properties ).to be_a Hash
-      expect( file.properties.keys.sample ).to be_a Symbol
+      expect(file.properties).to be_a Hash
+      expect(file.properties.keys.sample).to be_a Symbol
     end
 
     it 'has #file_name' do
-      expect( file.file_name ).to eq "Nyan_cat_250px_frame.png"
+      expect(file.file_name).to eq 'Nyan_cat_250px_frame.png'
     end
 
     it 'has #content_type' do
-      expect( file.content_type ).to eq "image/png"
+      expect(file.content_type).to eq 'image/png'
     end
 
     it 'has #url' do
-      expect( file.url ).to eq "//images.contentful.com/cfexampleapi/4gp6taAwW4CmSgumq2ekUm/9da0cd1936871b8d72343e895a00d611/Nyan_cat_250px_frame.png"
+      expect(file.url).to eq '//images.contentful.com/cfexampleapi/4gp6taAwW4CmSgumq2ekUm/9da0cd1936871b8d72343e895a00d611/Nyan_cat_250px_frame.png'
     end
 
     it 'has #details' do
-      expect( file.details ).to be_instance_of Hash
+      expect(file.details).to be_instance_of Hash
     end
   end
 end

data/spec/link_spec.rb

@@ -1,40 +1,40 @@
 require 'spec_helper'
 
 describe Contentful::Link do
-  let(:entry){ vcr('entry'){ create_client.entry('nyancat') } }
-  let(:link){ entry.space }
-  let(:content_type_link){ entry.content_type }
+  let(:entry) { vcr('entry') { create_client.entry('nyancat') } }
+  let(:link) { entry.space }
+  let(:content_type_link) { entry.content_type }
 
   describe 'SystemProperties' do
     it 'has a #sys getter returning a hash with symbol keys' do
-      expect( link.sys ).to be_a Hash
-      expect( link.sys.keys.sample ).to be_a Symbol
+      expect(link.sys).to be_a Hash
+      expect(link.sys.keys.sample).to be_a Symbol
     end
 
     it 'has #id' do
-      expect( link.id ).to eq "cfexampleapi"
+      expect(link.id).to eq 'cfexampleapi'
     end
 
     it 'has #type' do
-      expect( link.type ).to eq "Link"
+      expect(link.type).to eq 'Link'
     end
 
     it 'has #link_type' do
-      expect( link.link_type ).to eq "Space"
+      expect(link.link_type).to eq 'Space'
     end
   end
 
   describe '#resolve' do
     it 'queries the api for the resource' do
-      vcr('space'){
-        expect( link.resolve ).to be_a Contentful::Space
-      }
+      vcr('space')do
+        expect(link.resolve).to be_a Contentful::Space
+      end
     end
 
     it 'queries the api for the resource (different link object)' do
-      vcr('content_type'){
-        expect( content_type_link.resolve ).to be_a Contentful::ContentType
-      }
+      vcr('content_type')do
+        expect(content_type_link.resolve).to be_a Contentful::ContentType
+      end
     end
   end
 end

data/spec/locale_spec.rb

@@ -1,24 +1,24 @@
 require 'spec_helper'
 
 describe Contentful::Locale do
-  let(:locale){ vcr('locale'){ create_client.space.locales.first } }
+  let(:locale) { vcr('locale') { create_client.space.locales.first } }
 
   describe 'Properties' do
     it 'has a #properties getter returning a hash with symbol keys' do
-      expect( locale.properties ).to be_a Hash
-      expect( locale.properties.keys.sample ).to be_a Symbol
+      expect(locale.properties).to be_a Hash
+      expect(locale.properties.keys.sample).to be_a Symbol
     end
 
     it 'has #code' do
-      expect( locale.code ).to eq "en-US"
+      expect(locale.code).to eq 'en-US'
     end
 
     it 'has #name' do
-      expect( locale.name ).to eq "English"
+      expect(locale.name).to eq 'English'
     end
 
     it 'has #default' do
-      expect( locale.default ).to eq true
+      expect(locale.default).to eq true
     end
   end
 end

data/spec/location_spec.rb

@@ -1,30 +1,30 @@
 require 'spec_helper'
 
 describe Contentful::Location do
-  let(:location){
-    vcr('location'){
+  let(:location)do
+    vcr('location')do
       Contentful::Client.new(
         space: 'lzjz8hygvfgu',
         access_token: '0c6ef483524b5e46b3bafda1bf355f38f5f40b4830f7599f790a410860c7c271',
         dynamic_entries: :auto,
       ).entry('3f6fq5ylFCi4kIYAQKsAYG').location
-    }
-  }
+    end
+  end
 
   describe 'Properties' do
     it 'has a #properties getter returning a hash with symbol keys' do
-      expect( location.properties ).to be_a Hash
-      expect( location.properties.keys.sample ).to be_a Symbol
+      expect(location.properties).to be_a Hash
+      expect(location.properties.keys.sample).to be_a Symbol
     end
 
     it 'has #lat' do
-      expect( location.lat ).to be_a Float
-      expect( location.lat.to_i ).to eq 36
+      expect(location.lat).to be_a Float
+      expect(location.lat.to_i).to eq 36
     end
 
     it 'has #lon' do
-      expect( location.lon ).to be_a Float
-      expect( location.lon.to_i ).to eq -94
+      expect(location.lon).to be_a Float
+      expect(location.lon.to_i).to eq -94
     end
   end
 end

data/spec/request_spec.rb

@@ -7,49 +7,49 @@ describe Contentful::Request do
       stub(client).get
       request = Contentful::Request.new(client, '/content_types', nil, 'nyancat')
       request.get
-      expect( client ).to have_received.get(request)
+      expect(client).to have_received.get(request)
     end
   end
 
   describe '#query' do
     it 'converts arrays given in query to comma strings' do
       client = create_client
-      request = Contentful::Request.new(client, '/entries', {'fields.likes[in]' => ['jake', 'finn']})
-      expect( request.query[:'fields.likes[in]'] ).to eq 'jake,finn'
+      request = Contentful::Request.new(client, '/entries', 'fields.likes[in]' => %w(jake finn))
+      expect(request.query[:'fields.likes[in]']).to eq 'jake,finn'
     end
   end
 
   context '[single resource]' do
-    let(:request){
+    let(:request)do
       Contentful::Request.new(create_client, '/content_types', nil, 'nyancat')
-    }
+    end
 
     describe '#url' do
       it 'contais endpoint' do
-        expect( request.url ).to include 'content_types'
+        expect(request.url).to include 'content_types'
       end
 
       it 'contains id' do
-        expect( request.url ).to include 'nyancat'
+        expect(request.url).to include 'nyancat'
       end
     end
   end
 
   context '[multi resource]' do
-    let(:request){
-      Contentful::Request.new(create_client, '/content_types', {"something" => 'requested'})
-    }
+    let(:request)do
+      Contentful::Request.new(create_client, '/content_types', 'something' => 'requested')
+    end
 
     describe '#query' do
       it 'contains query' do
-        expect( request.query ).not_to be_empty
-        expect( request.query[:something] ).to eq 'requested'
+        expect(request.query).not_to be_empty
+        expect(request.query[:something]).to eq 'requested'
       end
     end
 
     describe '#url' do
       it 'contais endpoint' do
-        expect( request.url ).to include 'content_types'
+        expect(request.url).to include 'content_types'
       end
     end
   end