contentful 2.16.0 → 2.16.1

data/spec/content_type_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-describe Contentful::ContentType do
-  let(:content_type) { vcr('content_type') { create_client.content_type 'cat' } }
-
-  describe 'SystemProperties' do
-    it 'has a #sys getter returning a hash with symbol keys' do
-      expect(content_type.sys).to be_a Hash
-      expect(content_type.sys.keys.sample).to be_a Symbol
-    end
-
-    it 'has #id' do
-      expect(content_type.id).to eq 'cat'
-    end
-
-    it 'has #type' do
-      expect(content_type.type).to eq 'ContentType'
-    end
-  end
-
-  describe 'Properties' do
-    it 'has #name' do
-      expect(content_type.name).to eq 'Cat'
-    end
-
-    it 'has #description' do
-      expect(content_type.description).to eq 'Meow.'
-    end
-
-    it 'has #fields' do
-      expect(content_type.fields).to be_a Array
-      expect(content_type.fields.first).to be_a Contentful::Field
-    end
-
-    it 'could have #display_field' do
-      expect(content_type).to respond_to :display_field
-    end
-  end
-
-  describe 'camel case' do
-    it 'supports camel case' do
-      vcr('content_type') {
-        content_type = create_client(use_camel_case: true).content_type 'cat'
-
-        expect(content_type.displayField).to eq 'name'
-      }
-    end
-  end
-end

data/spec/deleted_asset_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-describe 'DeletedAsset' do
-  let(:deleted_asset)do
-    vcr('sync_deleted_asset')do
-      create_client.sync(initial: true, type: 'DeletedAsset').first_page.items[0]
-    end
-  end
-
-  describe 'SystemProperties' do
-    it 'has a #sys getter returning a hash with symbol keys' do
-      expect(deleted_asset.sys).to be_a Hash
-      expect(deleted_asset.sys.keys.sample).to be_a Symbol
-    end
-
-    it 'has #id' do
-      expect(deleted_asset.id).to eq '5c6VY0gWg0gwaIeYkUUiqG'
-    end
-
-    it 'has #type' do
-      expect(deleted_asset.type).to eq 'DeletedAsset'
-    end
-
-    it 'has #deleted_at' do
-      expect(deleted_asset.created_at).to be_a DateTime
-    end
-  end
-
-  describe 'camel case' do
-    it 'supports camel case' do
-      vcr('sync_deleted_asset') {
-        deleted_asset = create_client(use_camel_case: true).sync(initial: true, type: 'DeletedAsset').first_page.items[0]
-
-        expect(deleted_asset.createdAt).to be_a DateTime
-      }
-    end
-  end
-end

data/spec/deleted_entry_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-describe 'DeletedEntry' do
-  let(:deleted_entry)do
-    vcr('sync_deleted_entry')do
-      create_client.sync(initial: true, type: 'DeletedEntry').first_page.items[0]
-    end
-  end
-
-  describe 'SystemProperties' do
-    it 'has a #sys getter returning a hash with symbol keys' do
-      expect(deleted_entry.sys).to be_a Hash
-      expect(deleted_entry.sys.keys.sample).to be_a Symbol
-    end
-
-    it 'has #id' do
-      expect(deleted_entry.id).to eq 'CVebBDcQsSsu6yKKIayy'
-    end
-
-    it 'has #type' do
-      expect(deleted_entry.type).to eq 'DeletedEntry'
-    end
-
-    it 'has #deleted_at' do
-      expect(deleted_entry.created_at).to be_a DateTime
-    end
-  end
-
-  describe 'camel case' do
-    it 'supports camel case' do
-      vcr('sync_deleted_entry') {
-        deleted_entry = create_client(use_camel_case: true).sync(initial: true, type: 'DeletedEntry').first_page.items[0]
-
-        expect(deleted_entry.createdAt).to be_a DateTime
-      }
-    end
-  end
-end

data/spec/entry_spec.rb

@@ -1,815 +0,0 @@
-require 'spec_helper'
-
-describe Contentful::Entry do
-  let(:entry) { vcr('entry') { create_client.entry 'nyancat' } }
-
-  let(:subclass) do
-    Class.new(described_class) do
-      # An overridden sys method:
-      def created_at; 'yesterday'; end
-
-      # An overridden field method:
-      def best_friend; 'octocat'; end
-    end
-  end
-
-  let(:raw) { entry.raw }
-  let(:subclassed_entry) { subclass.new(raw, create_client.configuration) }
-
-  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
-    end
-
-    it 'has #id' do
-      expect(entry.id).to eq 'nyancat'
-    end
-
-    it 'has #type' do
-      expect(entry.type).to eq 'Entry'
-    end
-
-    it 'has #space' do
-      expect(entry.space).to be_a Contentful::Link
-    end
-
-    it 'has #content_type' do
-      expect(entry.content_type).to be_a Contentful::Link
-    end
-
-    it 'has #created_at' do
-      expect(entry.created_at).to be_a DateTime
-    end
-
-    it 'has #updated_at' do
-      expect(entry.updated_at).to be_a DateTime
-    end
-
-    it 'has #revision' do
-      expect(entry.revision).to eq 5
-    end
-
-    context 'when subclassed' do
-      it 'does not redefine existing methods' do
-        expect(subclassed_entry.created_at).to eq 'yesterday'
-      end
-    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
-    end
-
-    it "contains the entry's fields" do
-      expect(entry.fields[:color]).to eq 'rainbow'
-      expect(entry.fields[:best_friend]).to be_a Contentful::Entry
-    end
-
-    context 'when subclassed' do
-      it 'does not redefine existing methods' do
-        expect(subclassed_entry.best_friend).to eq 'octocat'
-      end
-    end
-  end
-
-  describe 'multiple locales' do
-    it 'can handle multiple locales' do
-      vcr('entry_locales') {
-        nyancat = create_client.entries(locale: "*", 'sys.id' => 'nyancat').items.first
-        expect(nyancat.fields('en-US')[:name]).to eq "Nyan Cat"
-        expect(nyancat.fields('tlh')[:name]).to eq "Nyan vIghro'"
-
-
-        expect(nyancat.fields(:'en-US')[:name]).to eq "Nyan Cat"
-        expect(nyancat.fields(:tlh)[:name]).to eq "Nyan vIghro'"
-      }
-    end
-
-    describe '#fields_with_locales' do
-      it 'can handle entries with just 1 locale' do
-        vcr('entry') {
-          nyancat = create_client.entry('nyancat')
-          expect(nyancat.fields_with_locales[:name].size).to eq(1)
-          expect(nyancat.fields_with_locales[:name][:'en-US']).to eq("Nyan Cat")
-        }
-      end
-
-      it 'can handle entries with multiple locales' do
-        vcr('entry_locales') {
-          nyancat = create_client.entries(locale: "*", 'sys.id' => 'nyancat').items.first
-          expect(nyancat.fields_with_locales[:name].size).to eq(2)
-          expect(nyancat.fields_with_locales[:name][:'en-US']).to eq("Nyan Cat")
-          expect(nyancat.fields_with_locales[:name][:tlh]).to eq("Nyan vIghro'")
-        }
-      end
-
-      it 'can have references in multiple locales and they are properly solved' do
-        vcr('multi_locale_reference') {
-          client = create_client(
-            space: '1sjfpsn7l90g',
-            access_token: 'e451a3cdfced9000220be41ed9c899866e8d52aa430eaf7c35b09df8fc6326f9',
-            dynamic_entries: :auto
-          )
-
-          entry = client.entries(locale: '*').first
-
-          expect(entry.image).to be_a ::Contentful::Asset
-          expect(entry.fields('zh')[:image]).to be_a ::Contentful::Asset
-          expect(entry.fields('es')[:image]).to be_a ::Contentful::Asset
-
-          expect(entry.image.id).not_to eq entry.fields('zh')[:image].id
-        }
-      end
-
-      it 'can have references with arrays in multiple locales and have them properly solved' do
-        vcr('multi_locale_array_reference') {
-          client = create_client(
-            space: 'cma9f9g4dxvs',
-            access_token: '3e4560614990c9ac47343b9eea762bdaaebd845766f619660d7230787fd545e1',
-            dynamic_entries: :auto
-          )
-
-          entry = client.entries(content_type: 'test', locale: '*').first
-
-          expect(entry.files).to be_a ::Array
-          expect(entry.references).to be_a ::Array
-          expect(entry.files.first).to be_a ::Contentful::Asset
-          expect(entry.references.first.entry?).to be_truthy
-
-          expect(entry.fields('zh')[:files]).to be_a ::Array
-          expect(entry.fields('zh')[:references]).to be_a ::Array
-          expect(entry.fields('zh')[:files].first).to be_a ::Contentful::Asset
-          expect(entry.fields('zh')[:references].first.entry?).to be_truthy
-
-          expect(entry.files.first.id).not_to eq entry.fields('zh')[:files].first.id
-        }
-      end
-    end
-  end
-
-  it '#raw' do
-    vcr('entry/raw') {
-      nyancat = create_client.entry('nyancat')
-      expect(nyancat.raw).to eq(create_client(raw_mode: true).entry('nyancat').object['items'].first)
-    }
-  end
-
-  describe 'can be marshalled' do
-    def test_dump(nyancat)
-      dump = Marshal.dump(nyancat)
-      yield if block_given?
-      new_cat = Marshal.load(dump)
-
-      # Attributes
-      expect(new_cat).to be_a Contentful::Entry
-      expect(new_cat.name).to eq "Nyan Cat"
-      expect(new_cat.lives).to eq 1337
-
-      # Single linked objects
-      expect(new_cat.best_friend).to be_a Contentful::Entry
-      expect(new_cat.best_friend.name).to eq "Happy Cat"
-
-      # Array of linked objects
-      expect(new_cat.cat_pack.count).to eq 2
-      expect(new_cat.cat_pack[0].name).to eq "Happy Cat"
-      expect(new_cat.cat_pack[1].name).to eq "Worried Cat"
-
-      # Nested Links
-      expect(new_cat.best_friend.best_friend).to be_a Contentful::Entry
-      expect(new_cat.best_friend.best_friend.name).to eq "Nyan Cat"
-
-      # Asset
-      expect(new_cat.image.file.url).to eq "//images.contentful.com/cfexampleapi/4gp6taAwW4CmSgumq2ekUm/9da0cd1936871b8d72343e895a00d611/Nyan_cat_250px_frame.png"
-    end
-
-    it 'marshals properly when entry_mapping changed' do
-      vcr('entry/marshall') {
-        class TestEntryMapping; end
-        nyancat = create_client(gzip_encoded: false, max_include_resolution_depth: 2, entry_mapping: { 'irrelevant_model' => TestEntryMapping }).entries(include: 2, 'sys.id' => 'nyancat').first
-        test_dump(nyancat) { Object.send(:remove_const, :TestEntryMapping) }
-      }
-    end
-
-    it 'marshals properly' do
-      vcr('entry/marshall') {
-        nyancat = create_client(gzip_encoded: false, max_include_resolution_depth: 2).entries(include: 2, 'sys.id' => 'nyancat').first
-        test_dump(nyancat)
-      }
-    end
-
-    it 'marshals with a logger set but keeps the instance' do
-      logger = Logger.new(IO::NULL)
-      vcr('entry/marshall') {
-        nyancat = create_client(gzip_encoded: false, max_include_resolution_depth: 2, logger: logger).entries(include: 2, 'sys.id' => 'nyancat').first
-        expect(nyancat.instance_variable_get(:@configuration)[:logger]).to eq(logger)
-        test_dump(nyancat)
-        expect(nyancat.instance_variable_get(:@configuration)[:logger]).to eq(logger)
-      }
-    end
-
-    it 'can remarshall an unmarshalled object' do
-      vcr('entry/marshall') {
-        nyancat = create_client(max_include_resolution_depth: 2).entries(include: 2, 'sys.id' => 'nyancat').first
-
-        # The double load/dump is on purpose
-        test_dump(Marshal.load(Marshal.dump(nyancat)))
-      }
-    end
-
-    it 'can properly marshal multiple level nested resources - #138' do
-      vcr('entry/marshal_138') {
-        parent = create_client(
-          space: 'j8tb59fszch7',
-          access_token: '5f711401f965951eb724ac72ac905e13d892294ba209268f13a9b32e896c8694',
-          dynamic_entries: :auto,
-          max_include_resolution_depth: 5
-        ).entry('5aV3O0l5jU0cwQ2OkyYsyU')
-
-        rehydrated = Marshal.load(Marshal.dump(parent))
-
-        expect(rehydrated.childs.first.image1.url).to eq '//images.contentful.com/j8tb59fszch7/7FjliblAmAoGMwU62MeQ6k/62509df90ef4bed38c0701bb9aa8c74c/Funny-Cat-Pictures-with-Captions-25.jpg'
-        expect(rehydrated.childs.first.image2.url).to eq '//images.contentful.com/j8tb59fszch7/1pbGuWZ27O6GMO0OGemgcA/a4185036a3640ad4491f38d8926003ab/Funny-Cat-Pictures-with-Captions-1.jpg'
-        expect(rehydrated.childs.last.image1.url).to eq '//images.contentful.com/j8tb59fszch7/4SXVTr0KEUyWiMMCOaUeUU/c9fa2246d5529a9c8e1ec6f5387dc4f6/e0194eca1c8135636ce0e014341548c3.jpg'
-        expect(rehydrated.childs.last.image2.url).to eq '//images.contentful.com/j8tb59fszch7/1NU1YcNQJGIA22gAKmKqWo/56fa672bb17a7b7ae2773d08e101d059/57ee64921c25faa649fc79288197c313.jpg'
-      }
-    end
-
-    it 'filters out unpublished resources after rehydration' do
-      vcr('entry/marshal_unpublished') {
-        parent = create_client(
-          space: 'z3eix6mwjid2',
-          access_token: '9047c4394a2130dff8e9dc544a7a3ec299703fdac8e52575eb5a6678be06c468',
-          dynamic_entries: :auto
-        ).entry('5Etc0jWzIWwMeSu4W0SCi8')
-
-        rehydrated = Marshal.load(Marshal.dump(parent))
-
-        expect(rehydrated.children).to be_empty
-
-        preview_parent = create_client(
-          space: 'z3eix6mwjid2',
-          access_token: '38153b942011a70b5482fda61c6a3a9d22f5e8a512662dac00fcf7eb344b75f4',
-          dynamic_entries: :auto,
-          api_url: 'preview.contentful.com'
-        ).entry('5Etc0jWzIWwMeSu4W0SCi8')
-
-        preview_rehydrated = Marshal.load(Marshal.dump(preview_parent))
-
-        expect(preview_rehydrated.children).not_to be_empty
-        expect(preview_rehydrated.children.first.title).to eq 'Child'
-      }
-    end
-  end
-
-  describe 'incoming links' do
-    let(:client) { create_client }
-
-    it 'will fetch entries referencing the entry using a query' do
-      vcr('entry/search_link_to_entry') {
-        entries = client.entries(links_to_entry: 'nyancat')
-        expect(entries).not_to be_empty
-        expect(entries.count).to eq 1
-        expect(entries.first.id).to eq 'happycat'
-      }
-    end
-
-    it 'will fetch entries referencing the entry using instance method' do
-      vcr('entry/search_link_to_entry') {
-        entries = entry.incoming_references client
-        expect(entries).not_to be_empty
-        expect(entries.count).to eq 1
-        expect(entries.first.id).to eq 'happycat'
-      }
-    end
-
-    it 'will fetch entries referencing the entry using instance method + query' do
-      vcr('entry/search_link_to_entry_with_custom_query') {
-        entries = entry.incoming_references(client, { content_type: 'cat', select: ['fields.name'] })
-        expect(entries).not_to be_empty
-        expect(entries.count).to eq 1
-        expect(entries.first.id).to eq 'happycat'
-        expect(entries.first.fields.keys).to eq([:name])
-      }
-    end
-
-  end
-
-  describe 'select operator' do
-    let(:client) { create_client }
-
-    context 'with sys sent' do
-      it 'properly creates an entry' do
-        vcr('entry/select_only_sys') {
-          entry = client.entries(select: ['sys'], 'sys.id' => 'nyancat').first
-          expect(entry.fields).to be_empty
-          expect(entry.entry?).to be_truthy
-        }
-      end
-
-      describe 'can contain only one field' do
-        context 'with content_type sent' do
-          it 'will properly create the entry with one field' do
-            vcr('entry/select_one_field_proper') {
-              entry = client.entries(content_type: 'cat', select: ['sys', 'fields.name'], 'sys.id' => 'nyancat').first
-              expect(entry.fields).not_to be_empty
-              expect(entry.entry?).to be_truthy
-              expect(entry.fields[:name]).to eq 'Nyan Cat'
-              expect(entry.fields).to eq({name: 'Nyan Cat'})
-            }
-          end
-        end
-
-        context 'without content_type sent' do
-          it 'will raise an error' do
-            vcr('entry/select_one_field') {
-              expect { client.entries(select: ['sys', 'fields.name'], 'sys.id' => 'nyancat') }.to raise_error Contentful::BadRequest
-            }
-          end
-        end
-      end
-    end
-
-    context 'without sys sent' do
-      it 'will enforce sys anyway' do
-        vcr('entry/select_no_sys') {
-          entry = client.entries(select: ['fields'], 'sys.id' => 'nyancat').first
-
-          expect(entry.id).to eq 'nyancat'
-          expect(entry.sys).not_to be_empty
-        }
-      end
-
-      it 'works with empty array as well, as sys is enforced' do
-        vcr('entry/select_empty_array') {
-          entry = client.entries(select: [], 'sys.id' => 'nyancat').first
-
-          expect(entry.id).to eq 'nyancat'
-          expect(entry.sys).not_to be_empty
-        }
-      end
-    end
-  end
-
-  describe 'reuse objects' do
-    it 'should handle recursion as well as not reusing' do
-      vcr('entry/include_resolution') {
-        entry = create_client(reuse_objects: true).entry('nyancat', include: 2)
-
-        expect(entry.best_friend.name).to eq 'Happy Cat'
-        expect(entry
-              .best_friend.best_friend
-              .best_friend.best_friend
-              .best_friend.best_friend
-              .best_friend.best_friend
-              .best_friend.best_friend
-              .best_friend.best_friend
-              .best_friend.best_friend
-              .best_friend.best_friend
-              .best_friend.best_friend
-              .best_friend.best_friend.name).to eq 'Nyan Cat'
-      }
-    end
-    it 'should use the same object for the same entry' do
-      vcr('entry/include_resolution') {
-        entry = create_client(reuse_entries: true).entry('nyancat', include: 2)
-
-        expect(entry.best_friend.name).to eq 'Happy Cat'
-        expect(entry.best_friend.best_friend).to be(entry)
-      }
-    end
-    it 'works on nested structures with unique objects' do
-      vcr('entry/include_resolution_uniques') {
-        entry = create_client(
-          space: 'v7cxgyxt0w5x',
-          access_token: '96e5d256e9a5349ce30e84356597e409f8f1bb485cb4719285b555e0f78aa27e',
-          reuse_entries: true
-        ).entry('1nLXjjWvk4MEeWeQCWmymc', include: 10)
-
-        expect(entry.title).to eq '1'
-        expect(entry
-                 .child.child
-                 .child.child
-                 .child.child
-                 .child.child
-                 .child.title).to eq '10'
-        expect(entry
-                 .child.child
-                 .child.child
-                 .child.child
-                 .child.child
-                 .child.child.title).to eq '1'
-        expect(entry
-                 .child.child.child.child
-                 .child.child.child.child
-                 .child.child.child.child
-                 .child.child.child.child
-                 .child.child.child.child.title).to eq '1'
-      }
-    end
-  end
-
-  describe 'include resolution' do
-    it 'should not reuse objects by default' do
-      vcr('entry/include_resolution') {
-        entry = create_client.entry('nyancat', include: 2)
-
-        expect(entry.best_friend.name).to eq 'Happy Cat'
-        expect(entry.best_friend.best_friend).not_to be(entry)
-      }
-    end
-    it 'defaults to 20 depth' do
-      vcr('entry/include_resolution') {
-        entry = create_client.entry('nyancat', include: 2)
-
-        expect(entry.best_friend.name).to eq 'Happy Cat'
-        expect(entry
-               .best_friend.best_friend
-               .best_friend.best_friend
-               .best_friend.best_friend
-               .best_friend.best_friend
-               .best_friend.best_friend
-               .best_friend.best_friend
-               .best_friend.best_friend
-               .best_friend.best_friend
-               .best_friend.best_friend
-               .best_friend.best_friend.name).to eq 'Nyan Cat'
-
-        expect(entry
-               .best_friend.best_friend
-               .best_friend.best_friend
-               .best_friend.best_friend
-               .best_friend.best_friend
-               .best_friend.best_friend
-               .best_friend.best_friend
-               .best_friend.best_friend
-               .best_friend.best_friend
-               .best_friend.best_friend
-               .best_friend.best_friend
-               .best_friend).to be_a ::Contentful::Link
-      }
-    end
-
-    it 'can be configured arbitrarily' do
-      vcr('entry/include_resolution') {
-        entry = create_client(max_include_resolution_depth: 3).entry('nyancat', include: 2)
-
-        expect(entry.best_friend.name).to eq 'Happy Cat'
-        expect(entry
-               .best_friend.best_friend
-               .best_friend.name).to eq 'Happy Cat'
-        expect(entry
-               .best_friend.best_friend
-               .best_friend.best_friend).to be_a ::Contentful::Link
-      }
-    end
-    it 'works on nested structures with unique objects' do
-      vcr('entry/include_resolution_uniques') {
-        entry = create_client(
-          space: 'v7cxgyxt0w5x',
-          access_token: '96e5d256e9a5349ce30e84356597e409f8f1bb485cb4719285b555e0f78aa27e',
-        ).entry('1nLXjjWvk4MEeWeQCWmymc', include: 10)
-
-        expect(entry.title).to eq '1'
-        expect(entry
-                 .child.child
-                 .child.child
-                 .child.child
-                 .child.child
-                 .child.title).to eq '10'
-        expect(entry
-                 .child.child
-                 .child.child
-                 .child.child
-                 .child.child
-                 .child.child.title).to eq '1'
-        expect(entry
-                 .child.child.child.child
-                 .child.child.child.child
-                 .child.child.child.child
-                 .child.child.child.child
-                 .child.child.child.child.title).to eq '1'
-      }
-    end
-  end
-
-  describe 'issues' do
-    it 'filters out unresolvable assets' do
-      vcr('entries/unresolvable_assets') {
-        client = create_client(space: 'facgnwwgj5fe', access_token: '4d0f55d940975f78139daae5d965b463c0816e88ad16062d2c1ee3d6cb930521')
-        entry = client.entry('gLVzQlb09IeOeU181fwtz')
-
-        expect(entry.single_asset).to be_nil
-        expect(entry.multi_asset.size).to eq 1
-        expect(entry.raw["fields"]["multiAsset"].size).to eq 2
-      }
-    end
-
-    it 'Symbol/Text field with null values should be serialized as nil - #117' do
-      vcr('entries/issue_117') {
-        client = create_client(space: '8jbbayggj9gj', access_token: '4ce0108f04e55c76476ba84ab0e6149734db73d67cd1b429323ef67f00977e07')
-        entry = client.entries.first
-
-        expect(entry.nil).to be_nil
-        expect(entry.nil).not_to eq ''
-      }
-    end
-
-    describe 'JSON Fields should not be treated as locale data - #96' do
-      before do
-        vcr('entry/json_objects_client') {
-          @client = create_client(
-            space: 'h425t6gef30p',
-            access_token: '278f7aa72f2eb90c0e002d60f85bf2144c925acd2d37dd990d3ca274f25076cf',
-            dynamic_entries: :auto
-          )
-
-        }
-        vcr('entry/json_objects') {
-          @entry = @client.entries.first
-        }
-      end
-
-      it 'only has default locale' do
-        expect(@entry.locales).to eq ['en-US']
-      end
-
-      it 'can obtain all values properly' do
-        expect(@entry.name).to eq('Test')
-        expect(@entry.object_test).to eq({
-          null: nil,
-          text: 'some text',
-          array: [1, 2, 3],
-          number: 123,
-          boolean: true,
-          object: {
-            null: nil,
-            text: 'bar',
-            array: [1, 2, 3],
-            number: 123,
-            boolean: false,
-            object: {foo: 'bar'}
-          }
-        })
-      end
-    end
-
-    it 'Number (Integer and Decimal) values get properly serialized - #125' do
-      vcr('entries/issue_125') {
-        client = create_client(space: 'zui87wsu8q80', access_token: '64ff902c58cd14ea063d3ded810d1111a0266537e9aba283bad3319b1762c302', dynamic_entries: :auto)
-        entry = client.entries.first
-
-        expect(entry.integer).to eq 123
-        expect(entry.decimal).to eq 12.3
-      }
-    end
-
-    it 'unresolvable entries get filtered from results' do
-      vcr('entries/unresolvable_filter') {
-        client = create_client(space: '011npgaszg5o', access_token: '42c9d93410a7319e9a735671fc1e415348f65e94a99fc768b70a7c649859d4fd', dynamic_entries: :auto)
-        entry = client.entry('1HR1QvURo4MoSqO0eqmUeO')
-
-        expect(entry.modules.size).to eq 2
-      }
-    end
-
-    it 'unresolvable entries get filtered from results in deeply nested objects - #177' do
-      vcr('entries/unresolvable_filter_deeply_nested') {
-        client = create_client(space: 'z471hdso7l1a', access_token: '8a0e09fe71f1cb41e8788ace86a8c8d9d084599fe43a40070f232045014d2585', dynamic_entries: :auto)
-        entry = client.entry('1hb8sipClkQ8ggeGaeSQWm', include: 3)
-        expect(entry.should_published.first.should_unpublished.size).to eq 0
-      }
-    end
-  end
-
-  describe 'camel case' do
-    it 'supports camel case' do
-      vcr('entry') {
-        entry = create_client(use_camel_case: true).entry 'nyancat'
-
-        expect(entry.bestFriend.name).to eq 'Happy Cat'
-        expect(entry.createdAt).to be_a DateTime
-      }
-    end
-  end
-
-  describe 'empty fields' do
-    context 'when default configuration' do
-      it 'raises an exception by default' do
-        vcr('entries/empty_fields') {
-          entry = create_client(
-            space: 'z4ssexir3p93',
-            access_token: 'e157fdaf7b325b71d07a94b7502807d4cfbbb1a34e69b7856838e25b92777bc6',
-            dynamic_entries: :auto
-          ).entry('2t1x77MgUA4SM2gMiaUcsy')
-
-          expect { entry.title }.to raise_error Contentful::EmptyFieldError
-        }
-      end
-
-      it 'returns nil if raise_for_empty_fields is false' do
-        vcr('entries/empty_fields') {
-          entry = create_client(
-            space: 'z4ssexir3p93',
-            access_token: 'e157fdaf7b325b71d07a94b7502807d4cfbbb1a34e69b7856838e25b92777bc6',
-            dynamic_entries: :auto,
-            raise_for_empty_fields: false
-          ).entry('2t1x77MgUA4SM2gMiaUcsy')
-
-          expect(entry.title).to be_nil
-        }
-      end
-
-      it 'will properly raise NoMethodError for non-fields' do
-        vcr('entries/empty_fields') {
-          entry = create_client(
-            space: 'z4ssexir3p93',
-            access_token: 'e157fdaf7b325b71d07a94b7502807d4cfbbb1a34e69b7856838e25b92777bc6',
-            dynamic_entries: :auto
-          ).entry('2t1x77MgUA4SM2gMiaUcsy')
-
-          expect { entry.unexisting_field }.to raise_error NoMethodError
-        }
-      end
-    end
-
-    context 'when use_camel_case is true it should still work' do
-      it 'raises an exception by default' do
-        vcr('entries/empty_fields') {
-          entry = create_client(
-            space: 'z4ssexir3p93',
-            access_token: 'e157fdaf7b325b71d07a94b7502807d4cfbbb1a34e69b7856838e25b92777bc6',
-            dynamic_entries: :auto,
-            use_camel_case: true
-          ).entry('2t1x77MgUA4SM2gMiaUcsy')
-
-          expect { entry.title }.to raise_error Contentful::EmptyFieldError
-        }
-      end
-
-      it 'returns nil if raise_for_empty_fields is false' do
-        vcr('entries/empty_fields') {
-          entry = create_client(
-            space: 'z4ssexir3p93',
-            access_token: 'e157fdaf7b325b71d07a94b7502807d4cfbbb1a34e69b7856838e25b92777bc6',
-            dynamic_entries: :auto,
-            raise_for_empty_fields: false,
-            use_camel_case: true
-          ).entry('2t1x77MgUA4SM2gMiaUcsy')
-
-          expect(entry.title).to be_nil
-        }
-      end
-
-      it 'will properly raise NoMethodError for non-fields' do
-        vcr('entries/empty_fields') {
-          entry = create_client(
-            space: 'z4ssexir3p93',
-            access_token: 'e157fdaf7b325b71d07a94b7502807d4cfbbb1a34e69b7856838e25b92777bc6',
-            dynamic_entries: :auto,
-            use_camel_case: true
-          ).entry('2t1x77MgUA4SM2gMiaUcsy')
-
-          expect { entry.unexisting_field }.to raise_error NoMethodError
-        }
-      end
-    end
-  end
-
-  describe 'rich text support' do
-    it 'properly serializes and resolves includes' do
-      vcr('entries/rich_text') {
-        entry = create_client(
-          space: 'jd7yc4wnatx3',
-          access_token: '6256b8ef7d66805ca41f2728271daf27e8fa6055873b802a813941a0fe696248',
-          raise_errors: true,
-          dynamic_entries: :auto,
-          gzip_encoded: false
-        ).entry('4BupPSmi4M02m0U48AQCSM')
-
-        expected_entry_occurrances = 2
-        embedded_entry_index = 1
-        entry.body['content'].each do |content|
-          if content['nodeType'] == 'embedded-entry-block'
-            expect(content['data']['target']).to be_a Contentful::Entry
-            expect(content['data']['target'].body).to eq "Embedded #{embedded_entry_index}"
-            expected_entry_occurrances -= 1
-            embedded_entry_index += 1
-          end
-        end
-
-        expect(expected_entry_occurrances).to eq 0
-      }
-    end
-
-    it 'doesnt hydrate the same entry twice - #194' do
-      vcr('entries/rich_text_hydration_issue') {
-        entry = nil
-
-        expect {
-          entry = create_client(
-            space: 'fds721b88p6b',
-            access_token: '45ba81cc69423fcd2e3f0a4779de29481bb5c11495bc7e14649a996cf984e98e',
-            raise_errors: true,
-            dynamic_entries: :auto,
-            gzip_encoded: false
-          ).entry('1tBAu0wP9qAQEg6qCqMics')
-        }.not_to raise_error
-
-        expect(entry.children[0].id).to eq entry.children[1].id
-        expect(entry.children[0].body).to eq entry.children[1].body
-      }
-    end
-
-    it 'respects content in data attribute if its not a Link' do
-      vcr('entries/rich_text_nested_fields') {
-        entry = create_client(
-          space: 'jd7yc4wnatx3',
-          access_token: '6256b8ef7d66805ca41f2728271daf27e8fa6055873b802a813941a0fe696248',
-          raise_errors: true,
-          dynamic_entries: :auto,
-          gzip_encoded: false
-        ).entry('6NGLswCREsGA28kGouScyY')
-
-        expect(entry.body['content'][0]).to eq({
-            'data' => {},
-            'content' => [
-                {'marks' => [], 'value' => 'A link to ', 'nodeType' => 'text', 'nodeClass' => 'text'},
-                {
-                    'data' => {'uri' => 'https://google.com'},
-                    'content' => [{'marks' => [], 'value' => 'google', 'nodeType' => 'text', 'nodeClass' => 'text'}],
-                    'nodeType' => 'hyperlink',
-                    'nodeClass' => 'inline'
-                },
-                {'marks' => [], 'value' => '', 'nodeType' => 'text', 'nodeClass' => 'text'}
-            ],
-            'nodeType' => 'paragraph',
-            'nodeClass' => 'block'
-        })
-      }
-    end
-
-    it 'supports includes in nested fields' do
-      vcr('entries/rich_text_nested_fields') {
-        entry = create_client(
-          space: 'jd7yc4wnatx3',
-          access_token: '6256b8ef7d66805ca41f2728271daf27e8fa6055873b802a813941a0fe696248',
-          raise_errors: true,
-          dynamic_entries: :auto,
-          gzip_encoded: false
-        ).entry('6NGLswCREsGA28kGouScyY')
-
-        expect(entry.body['content'][3]['nodeType']).to eq('unordered-list')
-        expect(entry.body['content'][3]['content'][2]['content'][0]['data']['target'].is_a?(Contentful::Entry)).to be_truthy
-
-        expect(entry.body['content'][4]['nodeType']).to eq('ordered-list')
-        expect(entry.body['content'][4]['content'][2]['content'][0]['data']['target'].is_a?(Contentful::Entry)).to be_truthy
-      }
-    end
-
-    it 'returns a link when resource is valid but unreachable' do
-      vcr('entries/rich_text_unresolved_relationships') {
-        parent = create_client(
-          space: 'jd7yc4wnatx3',
-          access_token: '6256b8ef7d66805ca41f2728271daf27e8fa6055873b802a813941a0fe696248',
-          raise_errors: true,
-          dynamic_entries: :auto,
-          gzip_encoded: false
-        ).entry('4fvSwl5Ob6UEWKg6MQicuC')
-
-        entry = parent.rich_text_child
-        expect(entry.body['content'][19]['data']['target'].is_a?(Contentful::Link)).to be_truthy
-      }
-    end
-  end
-
-  describe 'tags metadata' do
-    let(:entry_id) { '52GcYcPOPhuhlaogl05DIh' }
-
-    it 'can load an entry with tags' do
-      vcr('entry/with_tags') {
-        expect {
-          entry = create_client.entry(entry_id)
-        }.not_to raise_error
-      }
-    end
-
-    it 'hydrates tags' do
-      vcr('entry/with_tags') {
-        entry = create_client.entry(entry_id)
-        expect(entry._metadata[:tags].first).to be_a Contentful::Link
-      }
-    end
-
-    it 'loads tag links with their proper attributes' do
-      vcr('entry/with_tags') {
-        entry = create_client.entry(entry_id)
-        tag = entry._metadata[:tags].first
-        expect(tag.id).to eq 'mobQa'
-        expect(tag.link_type).to eq 'Tag'
-      }
-    end
-  end
-end