contentful_model 0.2.0 → 1.0.0

data/spec/queries_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+class NameValidation
+  def validate(entry)
+    return [] if entry.name == 'Nyan Cat'
+    ['Invalid Entry']
+  end
+end
+
+class InvalidatedCat < ContentfulModel::Base
+  self.content_type_id = 'cat'
+
+  validate_with NameValidation.new, on_load: true
+end
+
+describe ContentfulModel::Queries do
+  before :each do
+    ContentfulModel.configure do |config|
+      config.space = 'cfexampleapi'
+      config.access_token = 'b4c0n73n7fu1'
+      config.entry_mapping = {}
+    end
+
+    Cat.client = nil
+    Cat.instance_variable_set(:@query, ContentfulModel::Query.new(Cat))
+
+    InvalidatedCat.client = nil
+    InvalidatedCat.instance_variable_set(:@query, ContentfulModel::Query.new(InvalidatedCat))
+  end
+
+  describe 'class methods' do
+    describe '::load' do
+      it 'returns the base query "/entries"' do
+        vcr('query/load') {
+          response = Cat.load
+          expect(response).to be_a ::Contentful::Array
+          expect(response.items.size).to eq 3
+          expect(response.total).to eq 3
+        }
+      end
+
+      it 'filters out invalid elements' do
+        vcr('query/load') {
+          response = InvalidatedCat.load
+          expect(response).to be_a ::Contentful::Array
+          expect(response.items.size).to eq 1
+          expect(response.total).to eq 3
+        }
+      end
+    end
+
+    it '::find' do
+      vcr('nyancat') {
+        nyancat = Cat.find('nyancat')
+        expect(nyancat).to be_a Cat
+        expect(nyancat.name).to eq 'Nyan Cat'
+        expect(nyancat.id).to eq 'nyancat'
+      }
+    end
+
+    it '::paginate' do
+      vcr('query/manual_pagination') {
+        happy_cat = Cat.paginate(2, 2).load.first
+        expect(happy_cat.name).to eq 'Happy Cat'
+      }
+    end
+
+    it '::each_page' do
+      vcr('query/each_page') {
+        Cat.each_page(2) do |page|
+          expect(page).to be_a ::Contentful::Array
+          expect(page.first).to be_a Cat
+        end
+      }
+    end
+
+    it '::each_entry' do
+      vcr('query/each_entry') {
+        Cat.each_entry(2) do |cat|
+          expect(cat).to be_a Cat
+        end
+      }
+    end
+  end
+end

data/spec/query_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+class Foo < ContentfulModel::Base
+end
+
+class OneInclude < ContentfulModel::Base
+  has_one :foo
+end
+
+class MultiInclude < ContentfulModel::Base
+  has_one :one_include
+end
+
+class CircularInclude < ContentfulModel::Base
+  has_many :to_circulars
+end
+
+class ToCircular < ContentfulModel::Base
+  has_one :circular_include
+end
+
+class Bar < ContentfulModel::Base
+end
+
+class MultiIncludeWithVaryingReferenceDepth < ContentfulModel::Base
+  has_one :one_include
+  has_one :bar
+end
+
+describe ContentfulModel::Query do
+  let(:parameters) { { 'sys.id' => 'foo' } }
+  let(:entry) { vcr('nyancat') { Cat.find('nyancat') } }
+  subject { described_class.new(Cat, parameters) }
+
+  before :each do
+    ContentfulModel.configure do |config|
+      config.space = 'cfexampleapi'
+      config.access_token = 'b4c0n73n7fu1'
+      config.entry_mapping = {}
+    end
+  end
+
+  describe 'attributes' do
+    it ':parameters' do
+      expect(subject.parameters).to eq parameters
+    end
+  end
+
+  describe 'instance_methods' do
+    before :each do
+      Cat.client = nil
+    end
+
+    it '#<< updates parameters' do
+      expect(subject.parameters).to eq parameters
+
+      subject << {foo: 'bar'}
+
+      expect(subject.parameters).to eq parameters.merge(foo: 'bar')
+    end
+
+    it '#default_parameters' do
+      expect(subject.default_parameters).to eq('content_type' => 'cat')
+    end
+
+    it '#client' do
+      vcr('client') {
+        expect(subject.client).to eq Cat.client
+      }
+    end
+
+    it '#reset' do
+      subject << {'foo' => 'bar'}
+
+      subject.reset
+
+      expect(subject.parameters).to eq subject.default_parameters
+    end
+
+    describe '#execute' do
+      it 'when response is empty' do
+        vcr('query/empty') {
+          expect(subject.execute.items).to eq []
+        }
+      end
+
+      it 'when response contains items' do
+        query = described_class.new(Cat, 'sys.id' => 'nyancat')
+        vcr('nyancat') {
+          entries = query.execute
+          expect(entries.first.id).to eq 'nyancat'
+        }
+      end
+    end
+
+    describe '#discover_includes' do
+      it 'defaults to 1 for a class without associations' do
+        query = described_class.new(Cat)
+        expect(query.discover_includes).to eq 1
+      end
+
+      it 'adds an include level if it finds another nested item' do
+        query = described_class.new(OneInclude)
+        expect(query.discover_includes).to eq 2
+      end
+
+      it 'follows the include chain' do
+        query = described_class.new(MultiInclude)
+        expect(query.discover_includes).to eq 3
+      end
+
+      it 'can support circular references' do
+        query = described_class.new(CircularInclude)
+        expect(query.discover_includes).to eq 2
+
+        query = described_class.new(ToCircular)
+        expect(query.discover_includes).to eq 2
+      end
+
+      it 'when having multiple reference chains, include is set to the maximum chain legth' do
+        query = described_class.new(MultiIncludeWithVaryingReferenceDepth)
+        expect(query.discover_includes).to eq 3
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,58 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'contentful_model'
+require 'rspec'
+require 'vcr'
+
+RSpec.configure do |config|
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+end
+
+VCR.configure do |c|
+  c.cassette_library_dir = 'spec/fixtures/vcr_cassettes'
+  c.ignore_localhost = true
+  c.hook_into :webmock
+  c.default_cassette_options = { record: :once }
+end
+
+def vcr(name, &block)
+  VCR.use_cassette(name, &block)
+end
+
+class MockSpace
+  attr_reader :id
+
+  def initialize(id)
+    @id = id
+  end
+end
+
+class MockClient
+  attr_accessor :response
+
+  def initialize(response = [])
+    @response = response
+  end
+
+  def entries(query = {})
+    response
+  end
+end
+
+class Cat < ContentfulModel::Base
+  self.content_type_id = 'cat'
+end
+
+class CoercedCat < ContentfulModel::Base
+  self.content_type_id = 'cat'
+
+  coerce_field name: -> (name) { name.gsub('Nyan', 'Fat') }
+  coerce_field created_at: 'String'
+  coerce_field updated_at: 'Date'
+end
+
+class TestModel < ContentfulModel::Base
+  self.content_type_id = 'testModel'
+end

data/spec/validations/validations_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+class MockValidatableNoFields
+  include ContentfulModel::Validations
+end
+
+class MockValidatable
+  include ContentfulModel::Validations
+
+  attr_reader :fields
+
+  def initialize(fields = [])
+    @fields = fields
+    fields.each do |f|
+      define_singleton_method f do
+        "#{f}_value"
+      end
+    end
+  end
+end
+
+class MockValidatableWithAdditionalValidation < MockValidatable
+  validates_presence_of 'foo'
+end
+
+class BestFriendValidation
+  def validate(entry)
+    return ['Best Friend is not happycat'] unless entry.best_friend.try(:id) == 'happycat'
+    []
+  end
+end
+
+class LivesValidation
+  def initialize(lives)
+    @lives = lives
+  end
+
+  def validate(entry)
+    return ["Lives are not #{@lives}"] unless entry.lives == @lives
+    []
+  end
+end
+
+class ValidationsCat < ContentfulModel::Base
+  self.content_type_id = 'cat'
+
+  # validation lambda
+  validate :name, -> (e) { e.name == 'Nyan Cat' }, on_load: true
+
+  # validation block
+  validate :id, on_load: true do |e|
+    e.id == 'nyancat'
+  end
+
+  # validation class
+  validate_with BestFriendValidation, on_load: true
+
+  # validation object
+  validate_with LivesValidation.new(1337), on_load: true
+
+  # validation only on save
+  validate :name, -> (e) { e.name == 'foobar' }
+
+  # presence validation
+  validates_presence_of :likes
+end
+
+
+describe ContentfulModel::Validations do
+  let(:validatable) { MockValidatable.new }
+  let(:non_validatable) { MockValidatableNoFields.new }
+  let(:validatable_with_fields) { MockValidatable.new(['foo']) }
+  let(:validatable_with_validations) { MockValidatableWithAdditionalValidation.new }
+
+  describe 'class methods' do
+    describe '::validations' do
+      it 'is nil by default' do
+        expect(validatable.class.validations).to eq nil
+      end
+
+      it 'is an array of validations' do
+        expect(validatable_with_validations.class.validations).to be_a Array
+        expect(validatable_with_validations.class.validations.size).to eq 1
+      end
+    end
+  end
+
+  describe 'instance methods' do
+    describe '#validate' do
+      it 'returns false and sets error if its not an entry (aka. has no fields)' do
+        expect(non_validatable.validate).to be_falsey
+        expect(non_validatable.errors).to eq ["Entity doesn't respond to the fields() method"]
+        expect(non_validatable.valid?).to be_falsey
+        expect(non_validatable.invalid?).to be_truthy
+      end
+
+      it 'returns false and sets error if validation does not pass' do
+        expect(validatable_with_validations.validate).to be_falsey
+        expect(validatable_with_validations.errors).to eq ["foo is required"]
+        expect(validatable_with_validations.valid?).to be_falsey
+        expect(validatable_with_validations.invalid?).to be_truthy
+      end
+
+      it 'returns true if validations pass' do
+        ok_validatable = MockValidatableWithAdditionalValidation.new(['foo'])
+
+        expect(ok_validatable.validate).to be_truthy
+        expect(ok_validatable.errors).to be_empty
+        expect(ok_validatable.valid?).to be_truthy
+        expect(ok_validatable.invalid?).to be_falsey
+      end
+    end
+  end
+
+  describe 'integration' do
+    before :each do
+      ContentfulModel.configure do |config|
+        config.space = 'cfexampleapi'
+        config.access_token = 'b4c0n73n7fu1'
+        config.entry_mapping = {}
+      end
+
+      ValidationsCat.client = nil
+    end
+
+    it 'can have many kinds of validations' do
+      expect(ValidationsCat.validations.size).to eq 5
+      expect(ValidationsCat.save_validations.size).to eq 1
+    end
+
+    it 'can pass all validations' do
+      vcr('nyancat') {
+        nyancat = ValidationsCat.find('nyancat')
+        expect(nyancat.validate).to be_truthy
+        expect(nyancat.invalid?).to be_falsey
+        expect(nyancat.valid?).to be_truthy
+        expect(nyancat.errors).to be_empty
+      }
+    end
+
+    it 'can validate save validations' do
+      vcr('nyancat') {
+        nyancat = ValidationsCat.find('nyancat')
+
+        expect(nyancat.validate(true)).to be_falsey
+        expect(nyancat.invalid?(true)).to be_truthy
+        expect(nyancat.valid?(true)).to be_falsey
+        expect(nyancat.errors.size).to eq 1
+      }
+    end
+
+    it 'can fail a validation' do
+      vcr('nyancat') {
+        nyancat = ValidationsCat.find('nyancat')
+        nyancat.name = 'foobar'
+        expect(nyancat.validate).to be_falsey
+        expect(nyancat.invalid?).to be_truthy
+        expect(nyancat.errors).to eq ["name: validation not met"]
+      }
+    end
+
+    it 'can fail multiple validations' do
+      vcr('nyancat') {
+        nyancat = ValidationsCat.find('nyancat')
+        nyancat.name = 'foobar'
+        nyancat.lives = 1000
+        nyancat.best_friend = nil
+        nyancat.sys[:id] = 'foo'
+        nyancat.likes = nil
+
+        expect(nyancat.validate).to be_falsey
+        expect(nyancat.errors).to match_array [
+          "name: validation not met",
+          "Lives are not 1337",
+          "Best Friend is not happycat",
+          "id: validation not met",
+          "likes is required"
+        ]
+      }
+    end
+  end
+end