contentful_model 0.2.0 → 1.0.0

data/spec/associations/has_many_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+class HasManyTestModel < ContentfulModel::Base
+  self.content_type_id = 'hasManyTestModel'
+
+  has_many :test_models
+end
+
+describe ContentfulModel::Associations::HasOne do
+  before :each do
+    ContentfulModel.configure do |c|
+      c.space = 'a22o2qgm356c'
+      c.access_token = '60229df5876f14f499870d0d26f37b1323764ed637289353a5f74a5ea190c214'
+      c.entry_mapping = {}
+    end
+
+    HasManyTestModel.add_entry_mapping
+    TestModel.add_entry_mapping
+  end
+
+  it 'resolves children references' do
+    vcr('association/has_many') {
+      parent = HasManyTestModel.first
+
+      expect(parent).to be_a HasManyTestModel
+      expect(parent.name).to eq 'Has Many - Parent 1'
+
+      expect(parent.test_models).to be_a ::Array
+      expect(parent.test_models.size).to eq 2
+      expect(parent.test_models.first.name).to eq 'Has Many - Child 1'
+    }
+  end
+end

data/spec/associations/has_one_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+class HasOneTestModel < ContentfulModel::Base
+  self.content_type_id = 'hasOneTestModel'
+
+  has_one :test_model
+end
+
+describe ContentfulModel::Associations::HasOne do
+  before :each do
+    ContentfulModel.configure do |c|
+      c.space = 'a22o2qgm356c'
+      c.access_token = '60229df5876f14f499870d0d26f37b1323764ed637289353a5f74a5ea190c214'
+      c.entry_mapping = {}
+    end
+
+    HasOneTestModel.add_entry_mapping
+    TestModel.add_entry_mapping
+  end
+
+  it 'resolves children references' do
+    vcr('association/has_one') {
+      parent = HasOneTestModel.first
+
+      expect(parent).to be_a HasOneTestModel
+      expect(parent.name).to eq 'Has One - Parent 1'
+
+      expect(parent.test_model).to be_a TestModel
+      expect(parent.test_model.name).to eq 'Has One - Child'
+    }
+  end
+end

data/spec/base_spec.rb

@@ -0,0 +1,199 @@
+require 'spec_helper'
+
+class HumanWithMethods < ContentfulModel::Base
+  self.content_type_id = 'human'
+
+  def foo
+    'bar'
+  end
+
+  def profile
+    [
+      "Name: #{name}",
+      "Description: #{description}",
+      "Likes: #{likes.join(', ')}"
+    ].join("\n")
+  end
+end
+
+module Models
+  class NestedDog < ContentfulModel::Base
+    self.content_type_id = 'dog'
+  end
+end
+
+class ModelWithEmptyFields < ContentfulModel::Base
+  self.content_type_id = 'modelWithEmpty'
+
+  return_nil_for_empty :empty
+end
+
+describe ContentfulModel::Base do
+  subject { vcr('nyancat') { Cat.find('nyancat') } }
+
+  before :each do
+    ContentfulModel.configure do |config|
+      config.space = 'cfexampleapi'
+      config.access_token = 'b4c0n73n7fu1'
+      config.entry_mapping = {}
+    end
+  end
+
+  describe 'class methods' do
+    it '::client' do
+      vcr('client') {
+        expect(Cat.client).to be_a ContentfulModel::Client
+      }
+    end
+
+    it '::content_type' do
+      vcr('base/content_type') {
+        content_type = Cat.content_type
+        expect(content_type.id).to eq 'cat'
+        expect(content_type).to be_a Contentful::ContentType
+      }
+    end
+
+    it '::descendents' do
+      child_classes = ContentfulModel::Base.descendents
+      expect(child_classes).to be_a ::Array
+      expect(child_classes).to include(Cat)
+    end
+
+    describe '::return_nil_for_empty' do
+      before :each do
+        ContentfulModel.configure do |config|
+          config.space = 'a22o2qgm356c'
+          config.access_token = '60229df5876f14f499870d0d26f37b1323764ed637289353a5f74a5ea190c214'
+          config.entry_mapping = {}
+        end
+        ModelWithEmptyFields.add_entry_mapping
+      end
+
+      it 'returns nil for undefined field' do
+        vcr('base/return_nil_for_empty') {
+          empty_entry = ModelWithEmptyFields.find('3QBNQLVctWIUMy4MEMUECK')
+          expect(empty_entry.empty).to be_nil
+        }
+      end
+
+      it 'returns value for defined field' do
+        vcr('base/return_nil_for_empty_with_value') {
+          empty_entry = ModelWithEmptyFields.find('JwGJyMyZQ44QWmWGS6sSy')
+          expect(empty_entry.empty).to eq 'foo'
+        }
+      end
+    end
+  end
+
+  describe 'initialization' do
+    it 'creates getters on initialize for each field' do
+      expect(subject.respond_to?(:foobar)).to be_falsey
+      expect(subject.respond_to?(:name)).to be_truthy
+      expect(subject.respond_to?(:lives)).to be_truthy
+    end
+  end
+
+  describe "coercion" do
+    it "applies to the getters created for each field" do
+      vcr('nyancat') {
+        nyancat = CoercedCat.find('nyancat')
+        expect(nyancat.name).to eq 'Fat Cat'
+        expect(nyancat.created_at).to eq '2013-06-27T22:46:19+00:00'
+      }
+    end
+  end
+
+  describe "#coerce_field" do
+    it "returns the value for fields that have no coercion" do
+      title = 'CMS of the future'
+      expect(CoercedCat.coerce_value(:title, title)).to eq title
+    end
+
+    context "the fields coercion is a Proc" do
+      it "call the proc with the value and returns the result" do
+        expect(CoercedCat.coerce_value(:name, 'Nyan man')).to eq 'Fat man'
+      end
+    end
+
+    context "the fields coercion is a Symbol" do
+      it "calls the builtin coercion with the value and returns the result" do
+        date = '2016-12-06T11:00+00:00'
+        expect(CoercedCat.coerce_value(:updated_at, date))
+          .to be_instance_of(DateTime)
+      end
+    end
+  end
+
+  describe "#cache_key" do
+    subject(:contentful_object) { vcr('nyancat') { Cat.find('nyancat') } }
+
+    it "can be found by #responds_to?" do
+      expect(contentful_object).to respond_to(:cache_key)
+    end
+
+    it "starts with the objects model name"do
+      expect(contentful_object.cache_key).to start_with("cat/")
+    end
+
+    it "contains the objects id" do
+      expect(contentful_object.cache_key).to include(contentful_object.id.to_s)
+    end
+
+    it "contains the objects updated timestamp" do
+      expect(contentful_object.cache_key)
+        .to include(contentful_object.updated_at.utc.to_s(:usec))
+    end
+  end
+
+  it '#hash' do
+    vcr('nyancat') {
+      nyancat = Cat.find('nyancat')
+      expect(nyancat.hash).to eq 'cat-nyancat'.hash
+    }
+  end
+
+  it '#eql?' do
+    nyancat = nil
+    other_nyan = nil
+
+    vcr('nyancat') { nyancat = Cat.find('nyancat') }
+    vcr('nyancat') { other_nyan = Cat.find('nyancat') }
+
+    expect(nyancat == other_nyan).to be_truthy
+  end
+
+  describe 'base children should be able to have user defined methods' do
+    it 'has a user defined method' do
+      vcr('human') {
+        human = HumanWithMethods.first
+        expect(human.foo).to eq 'bar'
+      }
+    end
+
+    it 'has a user defined method that uses some entry field' do
+      vcr('human') {
+        human = HumanWithMethods.first
+        profile = human.profile
+
+        expect(profile).to include("Name: Finn")
+        expect(profile).to include("Description: Fearless adventurer! Defender of pancakes.")
+        expect(profile).to include("Likes: adventure")
+      }
+    end
+  end
+
+  describe 'base children can be defined in nested modules' do
+    it 'does not fail to fetch entries' do
+      dog = nil
+      vcr('dog') {
+        expect {
+          dog = Models::NestedDog.first
+        }.not_to raise_error
+
+        expect(dog.name).to eq 'Jake'
+      }
+    end
+  end
+end
+

data/spec/chainable_queries_spec.rb

@@ -0,0 +1,199 @@
+require 'spec_helper'
+
+class MockChainQueriable
+  include ContentfulModel::Queries
+
+  class << self
+    attr_accessor :content_type_id
+  end
+end
+
+class MockChainQueriableEntry < MockChainQueriable
+  self.content_type_id = 'foo'
+
+  def self.client
+    @@client ||= MockClient.new
+  end
+
+  def invalid?
+    false
+  end
+end
+
+describe ContentfulModel::Base do
+  subject { MockChainQueriableEntry }
+
+  before do
+    subject.content_type_id = 'foo'
+  end
+
+  describe 'class methods' do
+    describe '::all' do
+      it 'fails if no content type is set' do
+        subject.content_type_id = nil
+        expect { subject.all }.to raise_error 'You need to set self.content_type in your model class'
+      end
+
+      it 'returns a query object' do
+        expect(subject.all).to be_a ContentfulModel::Query
+      end
+    end
+
+    it '::params' do
+      query = subject.params({'include' => 1})
+      expect(query.parameters).to include('include' => 1)
+    end
+
+    it '::first' do
+      expect_any_instance_of(ContentfulModel::Query).to receive(:load) { ['first'] }
+      expect(subject.first).to eq 'first'
+    end
+
+    it '::skip' do
+      query = subject.skip(2)
+      expect(query.parameters).to include('skip' => 2)
+    end
+
+    it '::offset' do
+      query = subject.offset(3)
+      expect(query.parameters).to include('skip' => 3)
+    end
+
+    it '::limit' do
+      query = subject.limit(4)
+      expect(query.parameters).to include('limit' => 4)
+    end
+
+    it '::locale' do
+      query = subject.locale('en-US')
+      expect(query.parameters).to include('locale' => 'en-US')
+    end
+
+    it '::load_children' do
+      query = subject.load_children(4)
+      expect(query.parameters).to include('include' => 4)
+    end
+
+    describe '::order' do
+      describe 'when parameter is a hash' do
+        it 'ascending' do
+          query = subject.order(foo: :asc)
+          expect(query.parameters).to include('order' => 'fields.foo')
+        end
+
+        it 'descending' do
+          query = subject.order(foo: :desc)
+          expect(query.parameters).to include('order' => '-fields.foo')
+        end
+      end
+
+      it 'when param is a symbol' do
+        query = subject.order(:foo)
+        expect(query.parameters).to include('order' => 'fields.foo')
+      end
+
+      it 'when param is a string' do
+        query = subject.order('foo')
+        expect(query.parameters).to include('order' => 'fields.foo')
+      end
+
+      it 'when param is a sys property' do
+        query = subject.order(:created_at)
+        expect(query.parameters).to include('order' => 'sys.createdAt')
+      end
+    end
+
+    describe '::find_by' do
+      it 'when value is an array' do
+        query = subject.find_by(foo: [1, 2, 3])
+        expect(query.parameters).to include('fields.foo[in]' => '1,2,3')
+      end
+
+      it 'when value is a string' do
+        query = subject.find_by(foo: 'bar')
+        expect(query.parameters).to include('fields.foo' => 'bar')
+      end
+
+      it 'when value is a number' do
+        query = subject.find_by(foo: 1)
+        expect(query.parameters).to include('fields.foo' => 1)
+      end
+
+      it 'when value is a boolean' do
+        query = subject.find_by(foo: true)
+        expect(query.parameters).to include('fields.foo' => true)
+      end
+
+      it 'when value is a hash' do
+        query = subject.find_by(foo: {gte: 123})
+        expect(query.parameters).to include('fields.foo[gte]' => 123)
+      end
+
+      it 'when multiple fields' do
+        query = subject.find_by(foo: true, bar: 123)
+        expect(query.parameters).to include('fields.foo' => true , 'fields.bar' => 123)
+      end
+
+      it 'supports sys fields' do
+        query = subject.find_by('sys.id': 'foo')
+        expect(query.parameters).to include('sys.id' => 'foo')
+      end
+
+      it 'support sys properties without prefix' do
+        query = subject.find_by('updatedAt' => 'foo')
+        expect(query.parameters).to include('sys.updatedAt' => 'foo')
+      end
+    end
+
+    describe '::paginate' do
+      it 'defaults to first page and 100 items and sort by updatedAt' do
+        query = subject.paginate
+        expect(query.parameters).to include('limit' => 100, 'skip' => 0, 'order' => 'sys.updatedAt')
+      end
+
+      it 'requesting second page will add page_size to skip' do
+        query = subject.paginate(2)
+        expect(query.parameters).to include('limit' => 100, 'skip' => 100)
+      end
+
+      it 'can change page_size' do
+        query = subject.paginate(1, 20)
+        expect(query.parameters).to include('limit' => 20, 'skip' => 0)
+      end
+
+      it 'can change page_size and select a different page' do
+        query = subject.paginate(3, 20)
+        expect(query.parameters).to include('limit' => 20, 'skip' => 40)
+      end
+
+      it 'outliers are changed to default values' do
+        query = subject.paginate(-1, 'foo')
+        expect(query.parameters).to include('limit' => 100, 'skip' => 0)
+      end
+
+      it 'can sort by a different field' do
+        query = subject.paginate(1, 100, 'sys.createdAt')
+        expect(query.parameters).to include('limit' => 100, 'skip' => 0, 'order' => 'sys.createdAt')
+      end
+    end
+
+    describe '::search' do
+      describe 'when parameter is a hash' do
+        it 'when value is a string performs "match"' do
+          query = subject.search(foo: 'bar')
+          expect(query.parameters).to include('fields.foo[match]' => 'bar')
+        end
+
+        it 'when value is a hash performs query based on hash key' do
+          query = subject.search(foo: {gte: 123})
+          expect(query.parameters).to include('fields.foo[gte]' => 123)
+        end
+      end
+
+      it 'when parameter is a string, performs full text search using "query"' do
+        query = subject.search('foobar')
+        expect(query.parameters).to include('query' => 'foobar')
+      end
+    end
+  end
+end