contentful 2.16.0 → 2.16.1

data/spec/asset_spec.rb

@@ -1,220 +0,0 @@
-require 'spec_helper'
-
-describe Contentful::Asset do
-  let(:asset) { vcr('asset') { create_client.asset('nyancat') } }
-
-  describe 'SystemProperties' do
-    it 'has a #sys getter returning a hash with symbol keys' do
-      expect(asset.sys).to be_a Hash
-      expect(asset.sys.keys.sample).to be_a Symbol
-    end
-
-    it 'has #id' do
-      expect(asset.id).to eq 'nyancat'
-    end
-
-    it 'has #type' do
-      expect(asset.type).to eq 'Asset'
-    end
-
-    it 'has #space' do
-      expect(asset.space).to be_a Contentful::Link
-    end
-
-    it 'has #created_at' do
-      expect(asset.created_at).to be_a DateTime
-    end
-
-    it 'has #updated_at' do
-      expect(asset.updated_at).to be_a DateTime
-    end
-
-    it 'has #revision' do
-      expect(asset.revision).to eq 1
-    end
-  end
-
-  describe 'Fields' do
-    it 'has #title' do
-      expect(asset.title).to eq 'Nyan Cat'
-    end
-
-    it 'could have #description' do
-      expect(asset).to respond_to :description
-    end
-
-    it 'has #file' do
-      expect(asset.file).to be_a Contentful::File
-    end
-  end
-
-  describe '#image_url' do
-    it 'returns #url of #file without parameter' do
-      expect(asset.image_url).to eq asset.file.url
-    end
-
-    it 'adds image options if given' do
-      url = asset.image_url(width: 100, format: 'jpg', quality: 50, focus: 'top_right', fit: 'thumb', fl: 'progressive', background: 'rgb:ff0000')
-      expect(url).to include asset.file.url
-      expect(url).to include '?w=100&fm=jpg&q=50&f=top_right&bg=rgb%3Aff0000&fit=thumb&fl=progressive'
-    end
-  end
-
-  describe '#url' do
-    it 'returns #url of #file without parameter' do
-      expect(asset.url).to eq asset.file.url
-    end
-
-    it 'adds image options if given' do
-      url = asset.url(width: 100, format: 'jpg', quality: 50, focus: 'top_right', fit: 'thumb', fl: 'progressive', background: 'rgb:ff0000')
-      expect(url).to include asset.file.url
-      expect(url).to include '?w=100&fm=jpg&q=50&f=top_right&bg=rgb%3Aff0000&fit=thumb&fl=progressive'
-    end
-  end
-
-  it 'can be marshalled' do
-    marshalled = Marshal.dump(asset)
-    unmarshalled = Marshal.load(marshalled)
-
-    expect(unmarshalled.title).to eq 'Nyan Cat'
-    expect(unmarshalled.file).to be_a Contentful::File
-  end
-
-
-  describe 'incoming links' do
-    let(:client) { create_client }
-
-    it 'will fetch entries referencing the asset using a query' do
-      vcr('entry/search_link_to_asset') {
-        entries = client.entries(links_to_asset: 'nyancat')
-        expect(entries).not_to be_empty
-        expect(entries.count).to eq 1
-        expect(entries.first.id).to eq 'nyancat'
-      }
-    end
-
-    it 'will fetch entries referencing the entry using instance method' do
-      vcr('entry/search_link_to_asset') {
-        entries = asset.incoming_references client
-        expect(entries).not_to be_empty
-        expect(entries.count).to eq 1
-        expect(entries.first.id).to eq 'nyancat'
-      }
-    end
-
-  end
-
-  describe 'select operator' do
-    let(:client) { create_client }
-
-    context 'with sys sent' do
-      it 'properly creates an entry' do
-        vcr('asset/select_only_sys') {
-          asset = client.assets(select: ['sys']).first
-          expect(asset.fields).to be_empty
-          expect(asset.sys).not_to be_empty
-        }
-      end
-
-      it 'can contain only one field' do
-        vcr('asset/select_one_field') {
-          asset = client.assets(select: ['sys', 'fields.file']).first
-          expect(asset.fields.keys).to eq([:file])
-        }
-      end
-    end
-
-    context 'without sys sent' do
-      it 'will enforce sys anyway' do
-        vcr('asset/select_no_sys') {
-          asset = client.assets(select: ['fields'], 'sys.id' => 'nyancat').first
-
-          expect(asset.id).to eq 'nyancat'
-          expect(asset.sys).not_to be_empty
-        }
-      end
-
-      it 'works with empty array as well, as sys is enforced' do
-        vcr('asset/select_empty_array') {
-          asset = client.assets(select: [], 'sys.id' => 'nyancat').first
-
-          expect(asset.id).to eq 'nyancat'
-          expect(asset.sys).not_to be_empty
-        }
-      end
-    end
-  end
-
-  describe 'issues' do
-    it 'serializes files correctly for every locale - #129' do
-      vcr('assets/issues_129') {
-        client = create_client(
-          space: 'bht13amj0fva',
-          access_token: 'bb703a05e107148bed6ee246a9f6b3678c63fed7335632eb68fe1b689c801534'
-        )
-
-        asset = client.assets('sys.id' => '14bZJKTr6AoaGyeg4kYiWq', locale: '*').first
-
-        expect(asset.file).to be_a ::Contentful::File
-        expect(asset.file.file_name).to eq 'Flag_of_the_United_States.svg'
-
-        expect(asset.fields[:file]).to be_a ::Contentful::File
-        expect(asset.fields[:file].file_name).to eq 'Flag_of_the_United_States.svg'
-
-        expect(asset.fields('es')[:file]).to be_a ::Contentful::File
-        expect(asset.fields('es')[:file].file_name).to eq 'Flag_of_Spain.svg'
-      }
-    end
-
-    it 'properly serializes files for non-default locales on localized requests - jekyll-contentful-data-import #46' do
-      vcr('assets/issues_jekyll_46') {
-        client = create_client(
-          space: 'bht13amj0fva',
-          access_token: 'bb703a05e107148bed6ee246a9f6b3678c63fed7335632eb68fe1b689c801534',
-        )
-
-        asset = client.assets('sys.id' => '14bZJKTr6AoaGyeg4kYiWq', locale: 'es').first
-
-        expect(asset.file).to be_a ::Contentful::File
-        expect(asset.file.file_name).to eq 'Flag_of_Spain.svg'
-      }
-    end
-  end
-
-  describe 'camelCase' do
-    it 'properties now are accessed with camelcase' do
-      vcr('asset') {
-        asset = create_client(use_camel_case: true).asset('nyancat')
-        expect(asset.file.fileName).to eq 'Nyan_cat_250px_frame.png'
-      }
-    end
-  end
-
-  describe 'tags metadata' do
-    let(:asset_id) { '686aLBcjj1f47uFWxrepj6' }
-
-    it 'can load an asset with tags' do
-      vcr('asset/with_tags') {
-        expect {
-          asset = create_client.asset(asset_id)
-        }.not_to raise_error
-      }
-    end
-
-    it 'hydrates tags' do
-      vcr('asset/with_tags') {
-        asset = create_client.asset(asset_id)
-        expect(asset._metadata[:tags].first).to be_a Contentful::Link
-      }
-    end
-
-    it 'loads tag links with their proper attributes' do
-      vcr('asset/with_tags') {
-        asset = create_client.asset(asset_id)
-        tag = asset._metadata[:tags].first
-        expect(tag.id).to eq 'mobQa'
-        expect(tag.link_type).to eq 'Tag'
-      }
-    end
-  end
-end

data/spec/auto_includes_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-describe 'Auto-include resources' do
-  let(:entries) { vcr('entries') { create_client.entries } } # entries come with asset includes
-
-  it 'replaces Contentful::Links which are actually included with the resource' do
-    asset = entries.items[1].fields[:image]
-
-    expect(asset).not_to be_a Contentful::Link
-    expect(asset).to be_a Contentful::Asset
-  end
-end

data/spec/client_class_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-describe Contentful::Client do
-  describe '#get' do
-    let(:client) { create_client() }
-    let(:proxy_client) { create_client(proxy_host: '183.207.232.194',
-                                       proxy_port: 8080,
-                                       secure: false) }
-    let(:timeout_client) { create_client(timeout_connect: 1, timeout_read: 2, timeout_write: 3) }
-    let(:request) { Contentful::Request.new(nil, client.environment_url('/content_types'), nil, 'cat') }
-
-    it 'uses #base_url' do
-      expect(client).to receive(:base_url).and_call_original
-
-      vcr('content_type') {
-        client.get(request)
-      }
-    end
-
-    it 'uses #request_headers' do
-      expect(client).to receive(:request_headers).and_call_original
-      vcr('content_type') { client.get(request) }
-    end
-
-    it 'uses Request#url' do
-      expect(request).to receive(:url).and_call_original
-      vcr('content_type') { client.get(request) }
-    end
-
-    it 'uses Request#query' do
-      expect(request).to receive(:query).thrice.and_call_original
-      vcr('content_type') { client.get(request) }
-    end
-
-    it 'calls #get_http' do
-      expect(client.class).to receive(:get_http).with(client.base_url + request.url, request.query, client.request_headers, client.proxy_params, client.timeout_params) { raw_fixture('content_type') }
-      client.get(request)
-    end
-
-    it 'calls #get_http via proxy' do
-      expect(proxy_client.class).to receive(:get_http).with(proxy_client.base_url + request.url, request.query, proxy_client.request_headers, proxy_client.proxy_params, client.timeout_params) { raw_fixture('content_type') }
-      proxy_client.get(request)
-      expect(proxy_client.proxy_params[:host]).to eq '183.207.232.194'
-      expect(proxy_client.proxy_params[:port]).to eq 8080
-    end
-
-    describe 'timeout params' do
-      context 'with timeouts configured' do
-        it 'calls #get_http with timeouts' do
-          expect(timeout_client.class).to receive(:get_http).with(timeout_client.base_url + request.url, request.query, timeout_client.request_headers, timeout_client.proxy_params, timeout_client.timeout_params) { raw_fixture('content_type') }
-          timeout_client.get(request)
-          expect(timeout_client.timeout_params[:connect]).to eq 1
-          expect(timeout_client.timeout_params[:read]).to eq 2
-          expect(timeout_client.timeout_params[:write]).to eq 3
-        end
-      end
-
-      context 'without timeouts' do
-        it 'calls #get_http with timeouts' do
-          expect(client.class).to receive(:get_http).with(client.base_url + request.url, request.query, client.request_headers, client.proxy_params, client.timeout_params) { raw_fixture('content_type') }
-          client.get(request)
-          expect(client.timeout_params).to eq({})
-        end
-      end
-    end
-
-    describe 'build_resources parameter' do
-      it 'returns Contentful::Resource object if second parameter is true [default]' do
-        res = vcr('content_type') { client.get(request) }
-        expect(res).to be_a Contentful::BaseResource
-      end
-
-      it 'returns a Contentful::Response object if second parameter is not true' do
-        res = vcr('content_type') { client.get(request, false) }
-        expect(res).to be_a Contentful::Response
-      end
-    end
-
-  end
-
-  describe '#sync' do
-    it 'creates a new Sync object' do
-      expect(create_client.sync).to be_a Contentful::Sync
-    end
-  end
-end

data/spec/client_configuration_spec.rb

@@ -1,394 +0,0 @@
-require 'spec_helper'
-
-describe 'Client Configuration Options' do
-  describe ':space' do
-    it 'is required' do
-      expect do
-        Contentful::Client.new(access_token: 'b4c0n73n7fu1')
-      end.to raise_error(ArgumentError)
-    end
-  end
-
-  describe ':access_token' do
-    it 'is required' do
-      expect do
-        Contentful::Client.new(space: 'cfexampleapi')
-      end.to raise_error(ArgumentError)
-    end
-  end
-
-  describe ':secure' do
-    it 'will use https [default]' do
-      expect(
-        create_client.base_url
-      ).to start_with 'https://'
-    end
-
-    it 'will use http when secure set to false' do
-      expect(
-        create_client(secure: false).base_url
-      ).to start_with 'http://'
-    end
-  end
-
-  describe ':raise_errors' do
-    it 'will raise response errors if set to true [default]' do
-      expect_vcr('not found')do
-        create_client.content_type 'not found'
-      end.to raise_error Contentful::NotFound
-    end
-
-    it 'will not raise response errors if set to false' do
-      res = nil
-
-      expect_vcr('not found')do
-        res = create_client(raise_errors: false).content_type 'not found'
-      end.not_to raise_error
-      expect(res).to be_instance_of Contentful::NotFound
-    end
-  end
-
-  describe ':log_level' do
-
-    let(:logger) { Logger.new(STDOUT) }
-
-    it 'changes the level of the logger instance when given' do
-      expect do
-        create_client(logger: logger, log_level: ::Logger::WARN)
-      end.to change { logger.level }.from(::Logger::DEBUG).to(::Logger::WARN)
-    end
-
-    it 'does not change the level of the logger instance when not given' do
-      expect do
-        create_client(logger: logger)
-      end.not_to change { logger.level }
-    end
-  end
-
-  describe ':dynamic_entries' do
-    before :each do
-      Contentful::ContentTypeCache.clear!
-    end
-
-    it 'will create dynamic entries if dynamic_entry_cache is not empty' do
-      client = create_client(dynamic_entries: :manual)
-      vcr('entry_cache') { client.update_dynamic_entry_cache! }
-      entry = vcr('nyancat') { client.entry('nyancat') }
-
-      expect(entry).to be_a Contentful::Entry
-    end
-
-    context ':auto' do
-      it 'will call update dynamic_entry_cache on start-up' do
-        vcr('entry_cache') do
-          create_client(dynamic_entries: :auto)
-        end
-        expect(Contentful::ContentTypeCache.cache).not_to be_empty
-      end
-    end
-
-    context ':manual' do
-      it 'will not call #update_dynamic_entry_cache! on start-up' do
-        create_client(dynamic_entries: :manual)
-        expect(Contentful::ContentTypeCache.cache).to be_empty
-      end
-    end
-
-    describe '#update_dynamic_entry_cache!' do
-      let(:client) { create_client(dynamic_entries: :manual) }
-
-      it 'will fetch all content_types' do
-        expect(client).to receive(:content_types).with(limit: 1000) { {} }
-        client.update_dynamic_entry_cache!
-      end
-
-      it 'will save dynamic entries in @dynamic_entry_cache' do
-        vcr('entry_cache')do
-          client.update_dynamic_entry_cache!
-        end
-        expect(Contentful::ContentTypeCache.cache).not_to be_empty
-      end
-    end
-
-    describe '#register_dynamic_entry' do
-      let(:client) { create_client(dynamic_entries: :manual) }
-
-      it 'can be used to register a dynamic entry manually' do
-        cat = vcr('content_type') { client.content_type 'cat' }
-        client.register_dynamic_entry 'cat', cat
-
-        expect(Contentful::ContentTypeCache.cache).not_to be_empty
-      end
-    end
-  end
-
-  describe ':api_url' do
-    it 'is "cdn.contentful.com" [default]' do
-      expect(
-        create_client.configuration[:api_url]
-      ).to eq 'cdn.contentful.com'
-    end
-
-    it 'will be used as base url' do
-      expect(
-        create_client(api_url: 'cdn2.contentful.com').base_url
-      ).to start_with 'https://cdn2.contentful.com'
-    end
-  end
-
-  describe ':api_version' do
-    it 'is 1 [default]' do
-      expect(
-        create_client.configuration[:api_version]
-      ).to eq 1
-    end
-
-    it 'will used for the http content type request header' do
-      expect(
-        create_client(api_version: 2).request_headers['Content-Type']
-      ).to eq 'application/vnd.contentful.delivery.v2+json'
-    end
-  end
-
-  describe ':authentication_mechanism' do
-    describe ':header [default]' do
-      it 'will add the :access_token as authorization bearer token request header' do
-        expect(
-          create_client.request_headers['Authorization']
-        ).to eq 'Bearer b4c0n73n7fu1'
-      end
-
-      it 'will not add :access_token to query' do
-        expect(
-          create_client.request_query({})['access_token']
-        ).to be_nil
-      end
-    end
-
-    describe ':query_string' do
-      it 'will add the :access_token to query' do
-        expect(
-          create_client(authentication_mechanism: :query_string).
-              request_query({})['access_token']
-        ).to eq 'b4c0n73n7fu1'
-      end
-
-      it 'will not add the :access_token as authorization bearer token request header' do
-        expect(
-          create_client(authentication_mechanism: :query_string).
-              request_headers['Authorization']
-        ).to be_nil
-      end
-    end
-  end
-
-  describe ':resource_mapping' do
-    it 'lets you register your own resource classes for certain response types' do
-      class MyBetterAsset < Contentful::Asset
-        def https_image_url
-          image_url.sub %r{\A//}, 'https://'
-        end
-      end
-
-      client = create_client(
-        resource_mapping: {
-          'Asset' => MyBetterAsset,
-        }
-      )
-
-      nyancat = vcr('asset') { client.asset 'nyancat' }
-      expect(nyancat).to be_a MyBetterAsset
-      expect(nyancat.https_image_url).to start_with 'https'
-    end
-  end
-
-  describe ':entry_mapping' do
-    it 'lets you register your own entry classes for certain entry types' do
-      class Cat < Contentful::Entry
-      end
-
-      client = create_client(
-        entry_mapping: {
-          'cat' => Cat
-        }
-      )
-
-      nyancat = vcr('entry') { client.entry 'nyancat' }
-      finn    = vcr('human') { client.entry 'finn' }
-      expect(nyancat).to be_a Cat
-      expect(finn).to be_a Contentful::Entry
-    end
-  end
-
-  describe 'X-Contentful-User-Agent headers' do
-    it 'default values' do
-      expected = [
-        "sdk contentful.rb/#{Contentful::VERSION};",
-        "platform ruby/#{RUBY_VERSION};",
-      ]
-
-      client = create_client
-      expected.each do |h|
-        expect(client.contentful_user_agent).to include(h)
-      end
-
-      expect(client.contentful_user_agent).to match(/os (Windows|macOS|Linux)(\/.*)?;/i)
-
-      ['integration', 'app'].each do |h|
-        expect(client.contentful_user_agent).not_to include(h)
-      end
-    end
-
-    it 'with integration name only' do
-      expected = [
-        "sdk contentful.rb/#{Contentful::VERSION};",
-        "platform ruby/#{RUBY_VERSION};",
-        "integration foobar;"
-      ]
-
-      client = create_client(integration_name: 'foobar')
-      expected.each do |h|
-        expect(client.contentful_user_agent).to include(h)
-      end
-
-      expect(client.contentful_user_agent).to match(/os (Windows|macOS|Linux)(\/.*)?;/i)
-
-      ['app'].each do |h|
-        expect(client.contentful_user_agent).not_to include(h)
-      end
-    end
-
-    it 'with integration' do
-      expected = [
-        "sdk contentful.rb/#{Contentful::VERSION};",
-        "platform ruby/#{RUBY_VERSION};",
-        "integration foobar/0.1.0;"
-      ]
-
-      client = create_client(integration_name: 'foobar', integration_version: '0.1.0')
-      expected.each do |h|
-        expect(client.contentful_user_agent).to include(h)
-      end
-
-      expect(client.contentful_user_agent).to match(/os (Windows|macOS|Linux)(\/.*)?;/i)
-
-      ['app'].each do |h|
-        expect(client.contentful_user_agent).not_to include(h)
-      end
-    end
-
-    it 'with application name only' do
-      expected = [
-        "sdk contentful.rb/#{Contentful::VERSION};",
-        "platform ruby/#{RUBY_VERSION};",
-        "app fooapp;"
-      ]
-
-      client = create_client(application_name: 'fooapp')
-      expected.each do |h|
-        expect(client.contentful_user_agent).to include(h)
-      end
-
-      expect(client.contentful_user_agent).to match(/os (Windows|macOS|Linux)(\/.*)?;/i)
-
-      ['integration'].each do |h|
-        expect(client.contentful_user_agent).not_to include(h)
-      end
-    end
-
-    it 'with application' do
-      expected = [
-        "sdk contentful.rb/#{Contentful::VERSION};",
-        "platform ruby/#{RUBY_VERSION};",
-        "app fooapp/1.0.0;"
-      ]
-
-      client = create_client(application_name: 'fooapp', application_version: '1.0.0')
-      expected.each do |h|
-        expect(client.contentful_user_agent).to include(h)
-      end
-
-      expect(client.contentful_user_agent).to match(/os (Windows|macOS|Linux)(\/.*)?;/i)
-
-      ['integration'].each do |h|
-        expect(client.contentful_user_agent).not_to include(h)
-      end
-    end
-
-    it 'with all' do
-      expected = [
-        "sdk contentful.rb/#{Contentful::VERSION};",
-        "platform ruby/#{RUBY_VERSION};",
-        "integration foobar/0.1.0;",
-        "app fooapp/1.0.0;"
-      ]
-
-      client = create_client(
-        integration_name: 'foobar',
-        integration_version: '0.1.0',
-        application_name: 'fooapp',
-        application_version: '1.0.0'
-      )
-
-      expected.each do |h|
-        expect(client.contentful_user_agent).to include(h)
-      end
-
-      expect(client.contentful_user_agent).to match(/os (Windows|macOS|Linux)(\/.*)?;/i)
-    end
-
-    it 'when only version numbers, skips header' do
-      expected = [
-        "sdk contentful.rb/#{Contentful::VERSION};",
-        "platform ruby/#{RUBY_VERSION};"
-      ]
-
-      client = create_client(
-        integration_version: '0.1.0',
-        application_version: '1.0.0'
-      )
-
-      expected.each do |h|
-        expect(client.contentful_user_agent).to include(h)
-      end
-
-      expect(client.contentful_user_agent).to match(/os (Windows|macOS|Linux)(\/.*)?;/i)
-
-      ['integration', 'app'].each do |h|
-        expect(client.contentful_user_agent).not_to include(h)
-      end
-    end
-
-    it 'headers include X-Contentful-User-Agent' do
-      client = create_client
-      expect(client.request_headers['X-Contentful-User-Agent']).to eq client.contentful_user_agent
-    end
-  end
-
-  describe 'timeout options' do
-    let(:full_options) { { timeout_connect: 1, timeout_read: 2, timeout_write: 3 } }
-
-    it 'allows the three options to be present together' do
-      expect do
-        create_client(full_options)
-      end.not_to raise_error
-    end
-
-    it 'allows the three options to be omitted' do
-      expect do
-        create_client()
-      end.not_to raise_error
-    end
-
-    it 'does not allow only some options to be set' do
-      # Test that any combination of 1 or 2 keys is rejected
-      1.upto(2) do |options_count|
-        full_options.keys.combination(options_count).each do |option_keys|
-          expect do
-            create_client(full_options.select { |key, _| option_keys.include?(key) })
-          end.to raise_error(ArgumentError)
-        end
-      end
-    end
-  end
-end