contentful_lite 1.0.2

data/spec/entries_array_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+RSpec.describe ContentfulLite::EntriesArray do
+  let(:response) { JSON.parse(File.read('fixtures/entries/all.json')) }
+  let(:instance) { ContentfulLite::EntriesArray.new(response) }
+
+  describe 'should create an array of entries' do
+    it { expect(instance.first).to be_an ContentfulLite::Entry }
+    it { expect(instance.last).to be_an ContentfulLite::Entry }
+    it { expect(instance.sample).to be_an ContentfulLite::Entry }
+
+    it 'should solve the linked assets' do
+      expect(instance[4].fields['image']).to be_an ContentfulLite::Asset
+      expect(instance[4].fields['image'].url).to eq '//images.ctfassets.net/cfexampleapi/4hlteQAXS8iS0YCMU6QMWg/2a4d826144f014109364ccf5c891d2dd/jake.png'
+    end
+
+    it 'should solve the nested mutually-related entries' do
+      expect(instance[5].fields['bestFriend']).to be_an ContentfulLite::Entry
+      expect(instance[5].fields['bestFriend'].fields['bestFriend']).to eq instance[5]
+    end
+
+    it 'should properly serialize the nested mutually-related entries' do
+      friend = instance[5].as_json['fields']['bestFriend']
+      expect(friend['sys']['type']).to eq('Entry')
+      expect(friend['sys']['id']).to eq('nyancat')
+      expect(friend['fields']['bestFriend']['sys']['type']).to eq('Link')
+      expect(friend['fields']['bestFriend']['sys']['id']).to eq('happycat')
+    end
+
+    context 'with an array of references' do
+      let(:response) { JSON.parse(File.read('fixtures/entries/all_with_reference_array.json')) }
+
+      it 'should solve the linked assets' do
+        expect(instance[4].fields['images'].first).to be_an ContentfulLite::Asset
+        expect(instance[4].fields['images'].first.url).to eq '//images.ctfassets.net/cfexampleapi/4hlteQAXS8iS0YCMU6QMWg/2a4d826144f014109364ccf5c891d2dd/jake.png'
+      end
+
+      it 'should solve the nested mutually-related entries' do
+        expect(instance[5].fields['friends'].first).to be_an ContentfulLite::Entry
+        expect(instance[5].fields['friends'].first.fields['friends'].first).to eq instance[5]
+      end
+
+      it 'should properly serialize the nested mutually-related entries' do
+        friend = instance[5].as_json['fields']['friends'].first
+        expect(friend['sys']['type']).to eq('Entry')
+        expect(friend['sys']['id']).to eq('nyancat')
+        expect(friend['fields']['friends'].first['sys']['type']).to eq('Link')
+        expect(friend['fields']['friends'].first['sys']['id']).to eq('happycat')
+      end
+    end
+
+    context 'with multiple locales' do
+      let(:response) { JSON.parse(File.read('fixtures/entries/all_with_locales.json')) }
+
+      it { expect(instance[5].fields(locale: 'tlh')['name']).to eq("Quch vIghro'") }
+
+      it 'should solve the linked assets' do
+        expect(instance[4].fields['image']).to be_an ContentfulLite::Asset
+        expect(instance[4].fields['image'].url).to eq '//images.ctfassets.net/cfexampleapi/4hlteQAXS8iS0YCMU6QMWg/2a4d826144f014109364ccf5c891d2dd/jake.png'
+      end
+
+      it 'should solve the nested mutually-related entries' do
+        expect(instance[5].fields['bestFriend']).to be_an ContentfulLite::Entry
+        expect(instance[5].fields['bestFriend'].fields['bestFriend']).to eq instance[5]
+      end
+    end
+
+    context 'when include nesting is not enough' do
+      let(:response) { JSON.parse(File.read('fixtures/entries/all_without_includes.json')) }
+
+      it { expect(instance.first).to be_an ContentfulLite::Entry }
+      it { expect(instance.last).to be_an ContentfulLite::Entry }
+      it { expect(instance.sample).to be_an ContentfulLite::Entry }
+
+      it 'should create links for the assets' do
+        expect(instance[4].fields['image']).to be_an ContentfulLite::Link
+        expect(instance[4].fields['image'].type).to eq :asset
+        expect(instance[4].fields['image'].id).to eq 'jake'
+      end
+
+      it 'should solve the nested mutually-related entries' do
+        expect(instance[5].fields['bestFriend']).to be_an ContentfulLite::Link
+        expect(instance[5].fields['bestFriend'].type).to eq :entry
+        expect(instance[5].fields['bestFriend'].id).to eq 'nyancat'
+      end
+    end
+
+    describe 'serializing' do
+      subject { Marshal.load(Marshal.dump(instance)) }
+
+      it { expect(subject.first.id).to eq(instance.first.id) }
+      it { expect(subject.first.fields).to eq(instance.first.fields) }
+      it { expect(subject.last.id).to eq(instance.last.id) }
+      it { expect(subject.last.fields).to eq(instance.last.fields) }
+
+      it 'should solve the nested mutually-related entries' do
+        expect(subject[5].fields['bestFriend']).to be_an ContentfulLite::Entry
+        expect(subject[5].fields['bestFriend'].fields['bestFriend']).to eq subject[5]
+      end
+    end
+  end
+end

data/spec/entry_mapping_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+RSpec.describe ContentfulLite::EntryMapping do
+  let(:base_class) { Class.new.include(described_class) }
+  let!(:inherited_class) { Class.new(base_class) { content_type_id 'inherited_type' } }
+
+  describe '#get_class' do
+    subject { base_class.get_class(content_type) }
+
+    context 'for an existing content_type_id' do
+      let(:content_type) { 'inherited_type' }
+      it { is_expected.to eq(inherited_class) }
+    end
+
+    context 'for an invalid content_type_id' do
+      let(:content_type) { 'invalid_type' }
+      it { is_expected.to eq(base_class) }
+    end
+  end
+end

data/spec/entry_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+RSpec.describe ContentfulLite::Entry do
+  let(:entry_hash) { JSON.parse(File.read('fixtures/entries/nyancat.json')) }
+  let(:instance) { ContentfulLite::Entry.new(entry_hash) }
+
+  describe '#attributes' do
+    it { expect(instance.content_type_id).to eq 'cat' }
+    it { expect(instance.fields).to be_a Hash }
+  end
+
+  describe '#contentful_link' do
+    subject { instance.contentful_link }
+
+    it { is_expected.to eq 'https://app.contentful.com/spaces/cfexampleapi/entries/nyancat' }
+  end
+
+  describe 'Class methods' do
+    describe '#field_reader' do
+      let(:entry_class) do
+        Class.new(ContentfulLite::Entry) do
+          field_reader :name, localizable: true
+          field_reader :color, :bestFriend, :friends
+          field_reader :spayed, default: true
+        end
+      end
+      subject { entry_class.new(entry_hash) }
+
+      it { expect(subject.color).to eq 'rainbow' }
+      it { expect(subject.bestFriend).to be_a ContentfulLite::Link }
+      it { expect(subject.bestFriend.id).to eq 'happycat' }
+      it { expect(subject.spayed).to eq true }
+
+      context 'when the spayed field is nil' do
+        before { entry_hash['fields']['spayed'] = nil }
+
+        it 'falls back to the provided default' do
+          expect(subject.spayed).to eq true
+        end
+      end
+
+      context 'when the spayed field is set to false' do
+        before { entry_hash['fields']['spayed'] = false }
+
+        it { expect(subject.spayed).to eq false }
+      end
+
+      context 'with multiple locales' do
+        let(:entry_hash) { JSON.parse(File.read('fixtures/entries/nyancat_with_locales.json')) }
+
+        it { expect(subject.name).to eq 'Nyan Cat' }
+        it { expect(subject.color).to eq 'rainbow' }
+        it { expect(subject.color(locale: 'tlh')).to eq 'rainbow' }
+        it { expect(subject.with_locale('tlh') { subject.color }).to eq 'rainbow' }
+        it { expect(subject.bestFriend).to be_a ContentfulLite::Link }
+        it { expect(subject.bestFriend.id).to eq 'happycat' }
+        it { expect(subject.name(locale: 'tlh')).to eq 'Nyan vIghro\'' }
+        it { expect(subject.with_locale('tlh') { subject.name }).to eq 'Nyan vIghro\'' }
+      end
+
+      context 'with an array of references' do
+        let(:entry_hash) { JSON.parse(File.read('fixtures/entries/reference_array.json')) }
+
+        it { expect(subject.friends.first).to be_a ContentfulLite::Link }
+        it { expect(subject.friends.last).to be_a ContentfulLite::Link }
+      end
+    end
+  end
+
+  describe 'serializing' do
+    subject { Marshal.load(Marshal.dump(instance)) }
+
+    it { expect(subject.id).to eq(instance.id) }
+    it { expect(subject.created_at).to eq(instance.created_at) }
+    it { expect(subject.updated_at).to eq(instance.updated_at) }
+    it { expect(subject.retrieved_at).to eq(instance.retrieved_at) }
+    it { expect(subject.locale).to eq(instance.locale) }
+    it { expect(subject.revision).to eq(instance.revision) }
+    it { expect(subject.space_id).to eq(instance.space_id) }
+    it { expect(subject.environment_id).to eq(instance.environment_id) }
+    it { expect(subject.content_type_id).to eq(instance.content_type_id) }
+    it { expect(subject.fields).to eq(instance.fields) }
+  end
+end

data/spec/link_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+RSpec.describe ContentfulLite::Link do
+  let(:entry_hash) { JSON.parse(File.read('fixtures/entries/nyancat.json')) }
+  subject { ContentfulLite::Link.new(entry_hash['fields']['bestFriend']) }
+
+  describe '#attributes' do
+    it { expect(subject.type).to eq :entry }
+    it { expect(subject.id).to eq 'happycat' }
+
+    context 'when converting from an Entry' do
+      let(:entry) { ContentfulLite::Entry.new(entry_hash) }
+      subject { ContentfulLite::Link.new(entry) }
+
+      it { expect(subject.type).to eq :entry }
+      it { expect(subject.id).to eq 'nyancat' }
+    end
+
+    context 'when converting from an Asset' do
+      let(:asset_hash) { JSON.parse(File.read('fixtures/assets/nyancat.json')) }
+      let(:asset) { ContentfulLite::Asset.new(asset_hash) }
+      subject { ContentfulLite::Link.new(asset) }
+
+      it { expect(subject.type).to eq :asset }
+      it { expect(subject.id).to eq 'nyancat' }
+    end
+  end
+
+  describe '#==' do
+    let(:other_id) { 'happycat' }
+    let(:other_type) { 'Entry' }
+    let(:comparison) { ContentfulLite::Link.new( 'sys' => { 'linkType' => other_type, 'id' => other_id } ) }
+
+    it { is_expected.to eq comparison }
+
+    context 'when the id is different' do
+      let(:other_id) { 'other' }
+
+      it { is_expected.not_to eq comparison }
+    end
+
+    context 'when the type is different' do
+      let(:other_id) { 'asset' }
+
+      it { is_expected.not_to eq comparison }
+    end
+
+    context 'when the class is different' do
+      let(:comparison) { OpenStruct.new(id: other_id, type: :entry) }
+
+      it { is_expected.not_to eq comparison }
+    end
+  end
+
+  describe '#as_json' do
+    it { expect(subject.as_json).to eq(entry_hash['fields']['bestFriend']) }
+
+    context 'when rails is passing some other parameters as hash' do
+      let(:hash) { { template: "something", status: 200 } }
+
+      it 'should not throw errors' do
+        expect(subject.as_json(hash)).to eq(entry_hash['fields']['bestFriend'])
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+if ENV['COVERAGE']
+  require 'simplecov'
+  SimpleCov.start
+end
+
+require 'webmock/rspec'
+require 'vcr'
+require 'contentful_lite'
+
+VCR.configure do |config|
+  config.cassette_library_dir = 'fixtures/vcr_cassettes'
+  config.hook_into :webmock
+
+  config.default_cassette_options = { record: :once }
+end
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = '.rspec_status'
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/validations_spec.rb

@@ -0,0 +1,366 @@
+require 'spec_helper'
+
+RSpec.describe ContentfulLite::Validations::Entry do
+  def create_validable_model(validation_method, options)
+    klass = Class.new do
+      include ContentfulLite::Validations::Entry
+      attr_reader :fake_field
+      attr_accessor :locale
+      send(validation_method, :fake_field, options)
+
+      def initialize(value)
+        @fake_field = value
+        @locale = :en
+      end
+
+      def with_locale(locale)
+        @locale = locale unless locale.nil?
+        yield
+      ensure
+        @locale = :en
+      end
+    end
+    allow(klass).to receive(:model_name).and_return ActiveModel::Name.new(klass, nil, 'FakeClasss')
+    allow(klass).to receive(:human_attribute_name).and_return 'fake_field'
+    klass
+  end
+
+  shared_context 'multiple locales support' do
+    before do # Mock Entry localization, as it is part of the entry class and not the validations module
+      allow(fake_model).to receive(:locales).and_return(%i[en es])
+      allow(fake_model).to receive(:fake_field) { value[fake_model.locale] }
+    end
+  end
+
+  let(:model_class) { create_validable_model(:validates_presence_of, {}) }
+  let(:fake_model) { model_class.new(value) }
+
+  describe '#valid?' do
+    include_context 'multiple locales support'
+    let(:value) { { en: 'valid', es: 'valid' } }
+    subject { fake_model.valid?(locale: :es) }
+
+    it { is_expected.to be_truthy }
+
+    context 'when the other locale has invalid content' do
+      let(:value) { { en: nil, es: 'valid' } }
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when that locale has invalid content' do
+      let(:value) { { en: 'valid', es: nil } }
+      it { is_expected.to be_falsey }
+    end
+
+    context 'when both locales have invalid content' do
+      let(:value) { { en: nil, es: nil } }
+      it { is_expected.to be_falsey }
+    end
+  end
+
+  describe '#valid_for_all_locales?' do
+    include_context 'multiple locales support'
+    let(:value) { { en: 'valid', es: 'valid' } }
+    subject { fake_model.valid_for_all_locales? }
+
+    it { is_expected.to be_truthy }
+
+    context 'when first locale has invalid content' do
+      let(:value) { { en: nil, es: 'valid' } }
+      it { is_expected.to be_falsey }
+    end
+
+    context 'when second locale has invalid content' do
+      let(:value) { { en: 'valid', es: nil } }
+      it { is_expected.to be_falsey }
+    end
+
+    context 'when both locales have invalid content' do
+      let(:value) { { en: nil, es: nil } }
+      it { is_expected.to be_falsey }
+    end
+  end
+
+  describe '#errors' do
+    include_context 'multiple locales support'
+    let(:value) { { en: 'valid', es: 'valid' } }
+    subject(:en) { fake_model.tap(&:valid_for_all_locales?).errors(locale: :en)[:fake_field] }
+    subject(:es) { fake_model.tap(&:valid_for_all_locales?).errors(locale: :es)[:fake_field] }
+
+    it { expect(en).to be_empty }
+    it { expect(es).to be_empty }
+
+    context 'when first locale has invalid content' do
+      let(:value) { { en: nil, es: 'valid' } }
+      it { expect(en).to eq ["can't be blank"] }
+      it { expect(es).to be_empty }
+    end
+
+    context 'when second locale has invalid content' do
+      let(:value) { { en: 'valid', es: nil } }
+
+      it { expect(en).to be_empty }
+      it { expect(es).to eq ["can't be blank"] }
+    end
+
+    context 'when both locales have invalid content' do
+      let(:value) { { en: nil, es: nil } }
+
+      it { expect(en).to eq ["can't be blank"] }
+      it { expect(es).to eq ["can't be blank"] }
+    end
+  end
+
+  describe '.validates_included_asset' do
+    subject { fake_model.tap(&:valid?).errors[:fake_field] }
+
+    let(:asset) { ContentfulLite::Asset.new(JSON.parse(File.read('fixtures/assets/nyancat.json'))) }
+    let(:model_class) do
+      create_validable_model(:validates_included_asset, options)
+    end
+    let(:value) { nil }
+    let(:options) { {} }
+
+    describe 'allow_blank' do
+      context 'when value is nil and blank is allowed' do
+        let(:options) { { allow_blank: true } }
+
+        it { is_expected.to be_empty }
+      end
+
+      context 'when value is nil and blank is not allowed' do
+        let(:options) { { allow_blank: false } }
+
+        it { is_expected.to eq ['value is blank'] }
+      end
+
+      context 'when value is [] and blank is allowed' do
+        let(:options) { { allow_blank: true } }
+        let(:value) { [] }
+
+        it { is_expected.to be_empty }
+      end
+
+      context 'when value is [] and blank is not allowed' do
+        let(:options) { { allow_blank: false } }
+        let(:value) { [] }
+
+        it { is_expected.to eq ['value is blank'] }
+      end
+
+      context 'when value exists and blank is not allowed' do
+        let(:value) { asset }
+
+        it { is_expected.to be_empty }
+      end
+    end
+
+    describe 'array' do
+      context 'when value is not an array as expected' do
+        let(:value) { asset }
+        it { is_expected.to be_empty }
+      end
+
+      context 'when value is an array as expected' do
+        let(:value) { [asset] }
+        let(:options) { { array: true } }
+        it { is_expected.to be_empty }
+      end
+
+      context 'when value is not an asset or array' do
+        let(:value) { Object.new }
+        it { is_expected.to eq ['value is not a published asset'] }
+      end
+
+      context 'when value is an array with other objects' do
+        let(:value) { [asset, Object.new] }
+        let(:options) { { array: true } }
+        it { is_expected.to eq ['value[1] is not a published asset'] }
+      end
+
+      context 'when expects and array and has single value' do
+        let(:value) { asset }
+        let(:options) { { array: true } }
+        it { is_expected.to eq ['value is not an array'] }
+      end
+
+      context 'when expects a single value and has an array' do
+        let(:value) { [asset] }
+        it { is_expected.to eq ['value is not a published asset'] }
+      end
+    end
+
+    describe 'type' do
+      context 'when value is an image as expected' do
+        let(:options) { { type: :image } }
+        let(:value) { asset }
+        it { is_expected.to be_empty }
+      end
+
+      context 'when value is an image and expects a video' do
+        let(:options) { { type: :video } }
+        let(:value) { asset }
+        it { is_expected.to eq ['value has an invalid asset type. Expecting video'] }
+      end
+
+      context 'when values array has an image and expects only videos' do
+        let(:options) { { type: :video, array: true } }
+        let(:value) { [asset] }
+        it { is_expected.to eq ['value[0] has an invalid asset type. Expecting video'] }
+      end
+    end
+  end
+
+  describe '.validates_included_entry' do
+    subject { fake_model.tap(&:valid?).errors[:fake_field] }
+
+    let(:entry) { ContentfulLite::Entry.new(JSON.parse(File.read('fixtures/entries/nyancat.json'))) }
+    let(:model_class) do
+      create_validable_model(:validates_included_entry, options)
+    end
+    let(:value) { nil }
+    let(:options) { {} }
+
+    describe 'allow_blank' do
+      context 'when value is nil and blank is allowed' do
+        let(:options) { { allow_blank: true } }
+
+        it { is_expected.to be_empty }
+      end
+
+      context 'when value is nil and blank is not allowed' do
+        let(:options) { { allow_blank: false } }
+
+        it { is_expected.to eq ['value is blank'] }
+      end
+
+      context 'when value is [] and blank is allowed' do
+        let(:options) { { allow_blank: true } }
+        let(:value) { [] }
+
+        it { is_expected.to be_empty }
+      end
+
+      context 'when value is [] and blank is not allowed' do
+        let(:options) { { allow_blank: false } }
+        let(:value) { [] }
+
+        it { is_expected.to eq ['value is blank'] }
+      end
+
+      context 'when value exists and blank is not allowed' do
+        let(:value) { entry }
+
+        it { is_expected.to be_empty }
+      end
+    end
+
+    describe 'array' do
+      context 'when value is not an array as expected' do
+        let(:value) { entry }
+        it { is_expected.to be_empty }
+      end
+
+      context 'when value is an array as expected' do
+        let(:value) { [entry] }
+        let(:options) { { array: true } }
+        it { is_expected.to be_empty }
+      end
+
+      context 'when value is not an entry or array' do
+        let(:value) { Object.new }
+        it { is_expected.to eq ['value is not a published entry'] }
+      end
+
+      context 'when value is an array with other objects' do
+        let(:value) { [entry, Object.new] }
+        let(:options) { { array: true } }
+        it { is_expected.to eq ['value[1] is not a published entry'] }
+      end
+
+      context 'when expects and array and has single value' do
+        let(:value) { entry }
+        let(:options) { { array: true } }
+        it { is_expected.to eq ['value is not an array'] }
+      end
+
+      context 'when expects a single value and has an array' do
+        let(:value) { [entry] }
+        it { is_expected.to eq ['value is not a published entry'] }
+      end
+    end
+
+    describe 'invalid child' do
+      before { expect(entry).to receive(:valid?).and_return false }
+
+      context 'when the entry is invalid' do
+        let(:value) { entry }
+
+        it { is_expected.to eq ['value has invalid child entry nyancat'] }
+      end
+
+      context 'when is array and one of the entries is invalid' do
+        let(:value) { [entry] }
+        let(:options) { { array: true } }
+
+        it { is_expected.to eq ['value has invalid child entry nyancat'] }
+      end
+    end
+
+    context 'child is invalid only for a different locale' do
+      before do
+        allow(entry).to receive(:valid?).and_return true
+        allow(entry).to receive(:valid?).with(locale: :es).and_return false
+      end
+      let(:value) { entry }
+      it { is_expected.to be_empty }
+
+      context 'when calling validation and checking errors for that locale' do
+        subject { fake_model.tap{ |_| fake_model.valid?(locale: :es) }.errors(locale: :es)[:fake_field] }
+        it { is_expected.to eq ['value has invalid child entry nyancat'] }
+      end
+    end
+
+    context 'child is invalid only for the current locale' do
+      before do
+        allow(entry).to receive(:valid?).and_return true
+        allow(entry).to receive(:valid?).with(locale: :en).and_return false
+      end
+      let(:value) { entry }
+      it { is_expected.to eq ['value has invalid child entry nyancat'] }
+    end
+
+    describe 'allowed_models' do
+      let(:cat_entry) { cat_class.new(JSON.parse(File.read('fixtures/entries/nyancat.json'))) }
+      let(:cat_class) { Class.new(ContentfulLite::Entry) }
+
+      context 'when the entry is an allowed_model' do
+        let(:value) { cat_entry }
+        let(:options) { { allowed_models: [cat_class] } }
+
+        it { is_expected.to be_empty }
+      end
+
+      context 'when the entry is not an allowed_model' do
+        let(:value) { entry }
+        let(:options) { { allowed_models: [cat_class] } }
+
+        it { is_expected.to eq ["value has an invalid entry model. Expecting #{options[:allowed_models]}"] }
+      end
+
+      context 'when is array and all entries are allowed_models' do
+        let(:value) { [cat_entry] }
+        let(:options) { { allowed_models: [cat_class], array: true } }
+
+        it { is_expected.to be_empty }
+      end
+
+      context 'when is array and one entry is not an allowed_model' do
+        let(:value) { [cat_entry, entry] }
+        let(:options) { { allowed_models: [cat_class], array: true } }
+
+        it { is_expected.to eq ["value[1] has an invalid entry model. Expecting #{options[:allowed_models]}"] }
+      end
+    end
+  end
+end