locomotivecms 3.0.0.pre.alpha

data/spec/models/locomotive/content_entry_spec.rb

@@ -0,0 +1,411 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Locomotive::ContentEntry do
+
+  before(:each) do
+    allow_any_instance_of(Locomotive::Site).to receive(:create_default_pages!).and_return(true)
+    @content_type = FactoryGirl.build(:content_type)
+    @content_type.entries_custom_fields.build label: 'Title', type: 'string'
+    @content_type.entries_custom_fields.build label: 'Description', type: 'text'
+    @content_type.entries_custom_fields.build label: 'Visible ?', type: 'boolean', name: 'visible'
+    @content_type.entries_custom_fields.build label: 'File', type: 'file'
+    @content_type.entries_custom_fields.build label: 'Published at', type: 'date'
+    @content_type.valid?
+    @content_type.send(:set_label_field)
+  end
+
+  describe '#validation' do
+
+    it 'is valid' do
+      expect(build_content_entry).to be_valid
+    end
+
+    ## Validations ##
+
+    it 'requires the presence of title' do
+      content_entry = build_content_entry title: nil
+      expect(content_entry).to_not be_valid
+      expect(content_entry.errors[:title]).to eq(["can't be blank"])
+    end
+
+    it 'requires the presence of the permalink (_slug)' do
+      content_entry = build_content_entry title: nil
+      expect(content_entry).to_not be_valid
+      expect(content_entry.errors[:_slug]).to eq(["can't be blank"])
+    end
+
+  end
+
+  describe '.slug' do
+
+    before :each do
+      build_content_entry(_slug: 'dogs').tap do |entry|
+        entry.save!
+        expect(entry._slug).to eq('dogs')
+      end
+    end
+
+    it 'accepts underscore instead of dashes' do
+      expect(build_content_entry(_slug: 'monkey_wrench').tap(&:save!)._slug).to eq('monkey_wrench')
+    end
+
+    it 'uses the given slug if it is unique' do
+      expect(build_content_entry(_slug: 'monkeys').tap(&:save!)._slug).to eq('monkeys')
+      expect(build_content_entry(_slug: 'cats-2').tap(&:save!)._slug).to eq('cats-2')
+    end
+
+    it 'appends a number to the end of the slug if it is not unique' do
+      expect(build_content_entry(_slug: 'dogs').tap(&:save!)._slug).to eq('dogs-1')
+      expect(build_content_entry(_slug: 'dogs').tap(&:save!)._slug).to eq('dogs-2')
+      expect(build_content_entry(_slug: 'dogs-2').tap(&:save!)._slug).to eq('dogs-3')
+      expect(build_content_entry(_slug: 'dogs-2').tap(&:save!)._slug).to eq('dogs-4')
+    end
+
+    it 'ignores the case of a slug' do
+      expect(build_content_entry(_slug: 'dogs').tap(&:save!)._slug).to eq('dogs-1')
+      expect(build_content_entry(_slug: 'DOGS').tap(&:save!)._slug).to eq('dogs-2')
+    end
+
+    it 'correctly handles slugs with multiple numbers' do
+      expect(build_content_entry(_slug: 'fish-1-2').tap(&:save!)._slug).to eq('fish-1-2')
+      expect(build_content_entry(_slug: 'fish-1-2').tap(&:save!)._slug).to eq('fish-1-3')
+
+      expect(build_content_entry(_slug: 'fish-1-hi').tap(&:save!)._slug).to eq('fish-1-hi')
+      expect(build_content_entry(_slug: 'fish-1-hi').tap(&:save!)._slug).to eq('fish-1-hi-1')
+    end
+
+    it 'correctly handles more than 13 slugs with the same name' do
+      (1..15).each do |i|
+        expect(build_content_entry(_slug: 'dogs').tap(&:save!)._slug).to eq("dogs-#{i}")
+      end
+    end
+
+    it 'copies the slug in ALL the locales of the site' do
+      allow_any_instance_of(Locomotive::Site).to receive(:locales).and_return(%w(en fr ru))
+      entry = build_content_entry(_slug: 'monkeys').tap(&:save!)
+      expect(entry._slug_translations).to eq({ 'en' => 'monkeys', 'fr' => 'monkeys', 'ru' => 'monkeys' })
+    end
+  end
+
+  describe '#I18n' do
+
+    before(:each) do
+      localize_content_type @content_type
+      ::Mongoid::Fields::I18n.locale = 'en'
+      @content_entry = build_content_entry(title: 'Hello world')
+      @content_entry.send(:set_slug)
+      ::Mongoid::Fields::I18n.locale = 'fr'
+    end
+
+    after(:all) do
+      ::Mongoid::Fields::I18n.locale = 'en'
+    end
+
+    it 'tells if an entry has been translated or not' do
+      expect(@content_entry.translated?).to eq(false)
+      @content_entry.title = 'Bonjour'
+      expect(@content_entry.translated?).to eq(true)
+    end
+
+    describe '.slug' do
+
+      it 'is not nil in the default locale' do
+        ::Mongoid::Fields::I18n.locale = 'en'
+        expect(@content_entry._slug).to eq('hello-world')
+      end
+
+      it 'is not translated by default in the other locale' do
+        expect(@content_entry._slug).to eq(nil) # French
+      end
+
+    end
+
+  end
+
+  describe 'csv' do
+
+    context 'entry itself' do
+
+      subject { build_content_entry }
+
+      it { is_expected.to respond_to(:to_values) }
+
+      describe '#to_values' do
+
+        subject { build_content_entry.to_values(host: 'example.com') }
+
+        it { expect(subject.size).to eq(6) }
+        it { expect(subject.first).to eq('Locomotive') }
+        it { expect(subject.last).to eq('July 05, 2013 00:00') }
+
+        context 'with a file' do
+
+          subject { build_content_entry(file: FixturedAsset.open('5k.png')).tap(&:save).to_values(host: 'example.com')[3] }
+
+          it { is_expected.to match(/^http:\/\/example.com\/sites\/[0-9a-f]+\/content_entry[0-9a-f]+\/[0-9a-f]+\/files\/5k.png$/) }
+
+        end
+
+      end
+
+    end
+
+    context 'set of entries' do
+
+      before(:each) do
+        @content_type.save
+        3.times { build_content_entry(file: FixturedAsset.open('5k.png')).save! }
+      end
+
+      subject { @content_type.ordered_entries.to_csv(host: 'example.com').split("\n") }
+
+      it { expect(subject.size).to eq(4) }
+      it { expect(subject.first).to eq("Title,Description,Visible ?,File,Published at,Created at") }
+      it { expect(subject.last).to match(/^Locomotive,Lorem ipsum....,false,http:\/\/example.com\/sites\/[0-9a-f]+\/content_entry[0-9a-f]+\/[0-9a-f]+\/files\/5k.png,\"\",\"July 05, 2013 00:00\"$/) }
+
+    end
+
+  end
+
+  describe "#navigation" do
+
+    before(:each) do
+      @content_type.update_attribute :order_by, '_position'
+
+      %w(first second third).each_with_index do |item, index|
+        content = build_content_entry(title: item.to_s, _position: index, published_at: (index + 2).days.ago, visible: true)
+        content.save!
+        instance_variable_set "@#{item}", content
+      end
+    end
+
+    it 'finds previous item when available' do
+      expect(@second.previous.title).to eq('first')
+      expect(@second.previous._position).to eq(0)
+    end
+
+    it 'finds next item when available' do
+      expect(@second.next.title).to eq('third')
+      expect(@second.next._position).to eq(2)
+    end
+
+    it 'returns nil when fetching previous item on first in list' do
+      expect(@first.previous).to eq(nil)
+    end
+
+    it 'returns nil when fetching next item on last in list' do
+      expect(@third.next).to eq(nil)
+    end
+
+    context "ordered by published at" do
+
+      before do
+        @content_type.update_attributes order_by: 'published_at', order_direction: 'asc'
+
+        @very_first = build_content_entry(title: 'very first', _position: 4, published_at: Time.now, visible: true)
+        @very_first.save!
+      end
+
+      it "finds previous item" do
+        expect(@second.previous.title).to eq('third')
+      end
+
+      it "finds next item" do
+        expect(@first.next.title).to eq('very first')
+      end
+
+      it 'returns nil when fetching previous item on first in list' do
+        expect(@third.previous).to eq(nil)
+      end
+
+      it 'returns nil when fetching next item on last in list' do
+        expect(@very_first.next).to eq(nil)
+      end
+
+      context 'with desc direction' do
+
+        before do
+          @content_type.update_attribute :order_direction, 'desc'
+        end
+
+        it "finds previous item" do
+          expect(@second.previous.title).to eq('first')
+        end
+
+        it "finds next item" do
+          expect(@first.next.title).to eq('second')
+        end
+
+        it 'returns nil when fetching previous item on first in list' do
+          expect(@very_first.previous).to eq(nil)
+        end
+
+        it 'returns nil when fetching next item on last in list' do
+          expect(@third.next).to eq(nil)
+        end
+
+      end
+
+    end
+  end
+
+  describe '#permalink' do
+
+    before(:each) do
+      @content_entry = build_content_entry
+    end
+
+    it 'has a default value based on the highlighted field' do
+      @content_entry.send(:set_slug)
+      expect(@content_entry._permalink).to eq('locomotive')
+    end
+
+    it 'is empty if no value for the highlighted field is provided' do
+      @content_entry.title = nil; @content_entry.send(:set_slug)
+      expect(@content_entry._permalink).to eq(nil)
+    end
+
+    it 'includes dashes instead of white spaces' do
+      @content_entry.title = 'my content instance'; @content_entry.send(:set_slug)
+      expect(@content_entry._permalink).to eq('my-content-instance')
+    end
+
+    it 'removes accentued characters' do
+      @content_entry.title = "une chèvre dans le pré"; @content_entry.send(:set_slug)
+      expect(@content_entry._permalink).to eq('une-chevre-dans-le-pre')
+    end
+
+    it 'removes dots' do
+      @content_entry.title = "my.test"; @content_entry.send(:set_slug)
+      expect(@content_entry._permalink).to eq('my-dot-test')
+    end
+
+    it 'accepts non-latin chars' do
+      @content_entry.title = "абракадабра"; @content_entry.send(:set_slug)
+      expect(@content_entry._permalink).to eq('abrakadabra')
+    end
+
+    it 'also accepts a file field as the highlighted field' do
+      allow(@content_entry).to receive(:_label_field_name).and_return('file')
+      @content_entry.file = FixturedAsset.open('5k.png'); @content_entry.send(:set_slug)
+      expect(@content_entry._permalink).to eq('5k')
+    end
+
+  end
+
+  describe '#visibility' do
+
+    before(:each) do
+      @content_entry = build_content_entry
+    end
+
+    it 'is not visible by default' do
+      @content_entry.send(:set_visibility)
+      expect(@content_entry.visible?).to eq(false)
+    end
+
+    it 'can be visible even if it is nil' do
+      @content_entry.visible = nil
+      @content_entry.send(:set_visibility)
+      expect(@content_entry.visible?).to eq(true)
+    end
+
+    it 'can not be visible' do
+      @content_entry.visible = false
+      @content_entry.send(:set_visibility)
+      expect(@content_entry.visible?).to eq(false)
+    end
+
+  end
+
+  describe '#label' do
+
+    it 'has a label based on the value of the first field' do
+      expect(build_content_entry._label).to eq('Locomotive')
+    end
+
+    it 'uses the to_label method if the value of the label field defined it' do
+      entry = build_content_entry(_label_field_name: 'with_to_label')
+      allow(entry).to receive(:with_to_label).and_return(instance_double('with_to_label', to_label: 'acme'))
+      expect(entry._label).to eq('acme')
+    end
+
+    it 'uses the to_s method at last if the label field did not define the to_label method' do
+      entry = build_content_entry(_label_field_name: 'not_a_string')
+      allow(entry).to receive(:not_a_string).and_return(instance_double('not_a_string', to_s: 'not_a_string'))
+      expect(entry._label).to eq('not_a_string')
+    end
+
+  end
+
+  describe '#file' do
+
+    let(:entry) { build_content_entry(title: 'Hello world', file: FixturedAsset.open('5k.png')) }
+
+    it 'writes the file to the filesystem' do
+      entry.save
+      expect(entry.file.url).to_not match(/content_content_entry/)
+    end
+
+  end
+
+  describe '#public_submission' do
+
+    before(:each) do
+      @account_1 = FactoryGirl.build('admin user', id: fake_bson_id('1'))
+      @account_2 = FactoryGirl.build('frenchy user', id: fake_bson_id('2'))
+
+      @content_type.public_submission_enabled = true
+      @content_type.public_submission_accounts = ['', @account_1._id, @account_2._id.to_s]
+
+      site = FactoryGirl.build(:site)
+      allow(site).to receive(:accounts).and_return([@account_1, @account_2])
+
+      @content_entry = build_content_entry(site: site)
+    end
+
+    it 'does not send email notifications if the api is disabled' do
+      @content_type.public_submission_enabled = false
+      expect(Locomotive::Notifications).to_not receive(:new_content_entry)
+      @content_entry.save
+    end
+
+    it 'does not send email notifications if no api accounts' do
+      @content_type.public_submission_accounts = nil
+      expect(Locomotive::Notifications).to_not receive(:new_content_entry)
+      @content_entry.save
+    end
+
+    it 'sends email notifications when a new instance is created' do
+      expect(Locomotive::Notifications).to receive(:new_content_entry).with(@account_1, @content_entry).and_return(instance_double('mailer', deliver: true))
+      expect(Locomotive::Notifications).to receive(:new_content_entry).with(@account_2, @content_entry).and_return(instance_double('mailer', deliver: true))
+      @content_entry.save
+    end
+
+  end
+
+  describe '#site' do
+
+    it 'assigns a site when saving the content entry' do
+      content_entry = build_content_entry
+      content_entry.save
+      expect(content_entry.site).to_not eq(nil)
+    end
+
+  end
+
+  def localize_content_type(content_type)
+    content_type.entries_custom_fields.first.localized = true
+    content_type.save
+  end
+
+  def build_content_entry(options = {})
+    @content_type.entries.build({ title: 'Locomotive', description: 'Lorem ipsum....', _label_field_name: 'title', created_at: Time.zone.parse('2013-07-05 00:00:00') }.merge(options))
+  end
+
+  def fake_bson_id(id)
+    BSON::ObjectId.from_string(id.to_s.rjust(24, '0'))
+  end
+end

data/spec/models/locomotive/content_type_spec.rb

@@ -0,0 +1,405 @@
+require 'spec_helper'
+
+describe Locomotive::ContentType do
+
+  before(:each) do
+    allow_any_instance_of(Locomotive::Site).to receive(:create_default_pages!).and_return(true)
+  end
+
+  context 'when validating' do
+
+    it 'haves a valid factory' do
+      content_type = FactoryGirl.build(:content_type)
+      content_type.entries_custom_fields.build label: 'anything', type: 'string'
+      expect(content_type).to be_valid
+    end
+
+    # Validations ##
+
+    %w{site name}.each do |field|
+      it "requires the presence of #{field}" do
+        content_type = FactoryGirl.build(:content_type, field.to_sym => nil)
+        expect(content_type).to_not be_valid
+        expect(content_type.errors[field.to_sym]).to eq(["can't be blank"])
+      end
+    end
+
+    it 'requires the presence of slug' do
+      content_type = FactoryGirl.build(:content_type, name: nil, slug: nil)
+      expect(content_type).to_not be_valid
+      expect(content_type.errors[:slug]).to eq(["can't be blank"])
+    end
+
+    it 'is not valid if slug is not unique' do
+      content_type = FactoryGirl.build(:content_type)
+      content_type.entries_custom_fields.build label: 'anything', type: 'string'
+      content_type.save
+      content_type = FactoryGirl.build(:content_type, site: content_type.site, slug: content_type.slug)
+      expect(content_type).to_not be_valid
+      expect(content_type.errors[:slug]).to eq(["is already taken"])
+    end
+
+    it 'is not valid if there is not at least one field' do
+      content_type = FactoryGirl.build(:content_type)
+      expect(content_type).to_not be_valid
+      expect(content_type.errors[:entries_custom_fields]).to eq({ base: ['At least, one custom field is required'] })
+    end
+
+    %w(created_at updated_at).each do |name|
+      it "does not allow #{name} as name" do
+        content_type = FactoryGirl.build(:content_type)
+        field = content_type.entries_custom_fields.build label: 'anything', type: 'string', name: name
+        expect(field.valid?).to eq(false)
+        expect(field.errors[:name]).to eq(['is reserved'])
+      end
+    end
+
+    it 'sets a slug from the name before the validation' do
+      content_type = FactoryGirl.build(:content_type, name: 'my content Type')
+      content_type.valid?
+      expect(content_type.slug).to match(/slug_of_content_type_/)
+    end
+
+    it 'make sure the slug is correctly set before the validation' do
+      content_type = FactoryGirl.build(:content_type, slug: 'my content-type')
+      content_type.valid?
+      expect(content_type.slug).to eq('my_content_type')
+    end
+
+  end
+
+  context '#ordered_entries' do
+
+    before(:each) do
+      (@content_type = build_content_type(order_by: 'created_at')).save
+      @content_2 = @content_type.entries.create name: 'Sacha'
+      @content_1 = @content_type.entries.create name: 'Did'
+    end
+
+    it 'orders with the ASC direction by default' do
+      expect(@content_type.order_direction).to eq('asc')
+    end
+
+    it 'has a getter for manual order' do
+      expect(@content_type.order_manually?).to eq(false)
+      @content_type.order_by = '_position'
+      expect(@content_type.order_manually?).to eq(true)
+    end
+
+    it 'returns a list of entries ordered manually' do
+      @content_type.order_by = '_position'
+      expect(@content_type.ordered_entries.collect(&:name)).to eq(%w(Sacha Did))
+    end
+
+    it 'returns a list of entries ordered by a column specified by order_by (ASC)' do
+      @content_type.order_by = @content_type.entries_custom_fields.where(name: 'name').first._id
+      expect(@content_type.ordered_entries.collect(&:name)).to eq(%w(Did Sacha))
+    end
+
+    it 'returns a list of entries ordered by a column specified by order_by (DESC)' do
+      @content_type.order_by = @content_type.entries_custom_fields.where(name: 'name').first._id
+      @content_type.order_direction = 'desc'
+      expect(@content_type.ordered_entries.collect(&:name)).to eq(%w(Sacha Did))
+    end
+
+    it 'returns a list of contents ordered through condition {order_by: "name asc"}' do
+      @content_type.order_by = @content_type.entries_custom_fields.where(name: 'name').first._id
+      @content_type.order_direction = 'desc'
+      expect(@content_type.ordered_entries(order_by: 'name asc').collect(&:name)).to eq(%w(Did Sacha))
+    end
+
+    it 'returns a list of entries ordered by a Date column when first instance is missing the value' do
+      @content_type.order_by = @content_type.entries_custom_fields.where(name: 'active_at').first._id
+      @content_2.update_attribute :active_at, Date.parse('01/01/2001')
+      content_3 = @content_type.entries.create name: 'Mario', active_at: Date.parse('02/02/2001')
+
+      expect(@content_type.ordered_entries.map(&:active_at)).to eq([nil, Date.parse('01/01/2001'), Date.parse('02/02/2001')])
+
+      @content_type.order_direction = 'desc'
+      expect(@content_type.ordered_entries.map(&:active_at)).to eq([Date.parse('02/02/2001'), Date.parse('01/01/2001'), nil])
+    end
+
+  end
+
+  describe 'belongs_to/has_many relationship' do
+
+    before(:each) do
+      build_belongs_to_has_many_relationship
+
+      @category_1 = @category_content_type.entries.create name: 'Gems'
+      @category_2 = @category_content_type.entries.create name: 'Service'
+
+      @content_1 = @content_type.entries.create name: 'Github',        category: @category_2
+      @content_2 = @content_type.entries.create name: 'LocomotiveCMS', category: @category_1, description: 'Lorem ipsum',  _position_in_category: 1
+      @content_3 = @content_type.entries.create name: 'RubyOnRails',   category: @category_1, description: 'Zzzzzz',       _position_in_category: 2
+    end
+
+    context '#ordering in a belongs_to/has_many relationship' do
+
+      it 'orders projects based on the default order of the Project content type' do
+        expect(@category_1.projects.relation_metadata.order).to eq(%w(name desc))
+        expect(@category_1.projects.sort.map(&:name)).to eq(%w(RubyOnRails LocomotiveCMS).sort)
+        expect(@category_1.projects.ordered.all.map(&:name)).to eq(%w(RubyOnRails LocomotiveCMS))
+      end
+
+      it 'updates the information about the order of a has_many relationship if the target class changes its order' do
+        @content_type.order_by = 'description'; @content_type.order_direction = 'ASC'; @content_type.save!
+        @category_1 = safe_find(@category_1.class, @category_1._id)
+
+        expect(@category_1.projects.relation_metadata.order).to eq(%w(description ASC))
+        expect(@category_1.projects.map(&:name)).to eq(%w(LocomotiveCMS RubyOnRails))
+      end
+
+      it 'uses the order by position if the UI option is enabled' do
+        field = @category_content_type.entries_custom_fields.where(name: 'projects').first
+        field.ui_enabled = true;
+
+        @category_content_type.save!; @category_1 = safe_find(@category_1.class, @category_1._id)
+
+        expect(@category_1.projects.relation_metadata.order.to_s).to eq('position_in_category')
+        expect(@category_1.projects.map(&:name)).to eq(%w(LocomotiveCMS RubyOnRails))
+      end
+
+    end
+
+    describe '#list_of_groups' do
+
+      subject { @content_type.send(:list_of_groups) }
+
+      it { expect(subject.size).to eq 2 }
+      it { expect(subject[0][:name]).to eq 'Gems' }
+      it { expect(subject[1][:name]).to eq 'Service' }
+
+    end
+
+  end
+
+  describe 'custom fields' do
+
+    before(:each) do
+      site = FactoryGirl.build(:site)
+      allow(Locomotive::Site).to receive(:find).and_return(site)
+
+      @content_type = build_content_type(site: site)
+      # Locomotive::ContentType.logger = Logger.new($stdout)
+      # Locomotive::ContentType.db.connection.instance_variable_set(:@logger, Logger.new($stdout))
+    end
+
+    context 'validation' do
+
+      %w{label type}.each do |key|
+        it "validates presence of #{key}" do
+          field = @content_type.entries_custom_fields.build({ label: 'Shortcut', type: 'string' }.merge(key.to_sym => nil))
+          expect(field).to_not be_valid
+          expect(field.errors[key.to_sym]).to eq(["can't be blank"])
+        end
+      end
+
+      it 'does not have unique label' do
+        field = @content_type.entries_custom_fields.build label: 'Active', type: 'boolean'
+        expect(field).to_not be_valid
+        expect(field.errors[:label]).to eq(["is already taken"])
+      end
+
+      it 'invalidates parent if custom field is not valid' do
+        field = @content_type.entries_custom_fields.build
+        expect(@content_type).to_not be_valid
+        expect(@content_type.entries_custom_fields.last.errors[:label]).to eq(["can't be blank"])
+      end
+
+    end
+
+    context 'define core attributes' do
+
+      it 'has an unique name' do
+        @content_type.valid?
+        expect(@content_type.entries_custom_fields.first.name).to eq('name')
+        expect(@content_type.entries_custom_fields.last.name).to eq('active_at')
+      end
+
+    end
+
+    context 'build and save' do
+
+      before(:each) do
+        @content_type.save
+      end
+
+      it 'builds asset' do
+        asset = @content_type.entries.build
+        expect {
+          asset.name
+          asset.description
+          asset.active
+        }.not_to raise_error
+      end
+
+      it 'assigns values to newly built asset' do
+        asset = build_content_entry(@content_type)
+        expect(asset.description).to eq('Lorem ipsum')
+        expect(asset.active).to eq(true)
+      end
+
+      it 'saves asset' do
+        asset = build_content_entry(@content_type)
+        asset.save and @content_type.reload
+        asset = @content_type.entries.first
+        expect(asset.description).to eq('Lorem ipsum')
+        expect(asset.active).to eq(true)
+      end
+
+      it 'does not modify entries from another content type' do
+        asset = build_content_entry(@content_type)
+        asset.save and @content_type.reload
+        another_content_type = Locomotive::ContentType.new
+        expect { another_content_type.entries.build.description }.to raise_error
+      end
+
+    end
+
+    context 'modifying fields' do
+
+      before(:each) do
+        @content_type.save
+        @asset = build_content_entry(@content_type).save
+      end
+
+      it 'adds new field' do
+        @content_type.entries_custom_fields.build label: 'Author', name: 'author', type: 'string'
+        @content_type.save && @content_type.reload
+        asset = @content_type.entries.first
+        expect { asset.author }.to_not raise_error
+      end
+
+      it 'removes a field' do
+        @content_type.entries_custom_fields.destroy_all(name: 'active_at')
+        @content_type.save && @content_type.reload
+        asset = @content_type.entries.first
+        expect { asset.active_at }.to raise_error
+      end
+
+      it 'removes the field used as the label when setting the original label_field_name value before' do
+        @content_type.label_field_name = 'name'
+        @content_type.entries_custom_fields.destroy_all(name: @content_type.label_field_name)
+        @content_type.save
+        expect(@content_type.label_field_name).to eq('description')
+      end
+
+      it 'renames field label' do
+        @content_type.entries_custom_fields[1].label = 'Simple description'
+        @content_type.entries_custom_fields[1].name = nil
+        @content_type.save && @content_type.reload
+        asset = @content_type.entries.first
+        expect(asset.simple_description).to eq('Lorem ipsum')
+      end
+
+    end
+
+    context 'managing from hash' do
+
+      it 'adds new field' do
+        @content_type.entries_custom_fields.clear
+        field = @content_type.entries_custom_fields.build label: 'Title'
+        @content_type.entries_custom_fields_attributes = { 0 => { id: field.id.to_s, 'label' => 'A title', 'type' => 'string' }, 1 => { 'label' => 'Tagline', 'type' => 'sring' } }
+        expect(@content_type.entries_custom_fields.size).to eq(2)
+        expect(@content_type.entries_custom_fields.first.label).to eq('A title')
+        expect(@content_type.entries_custom_fields.last.label).to eq('Tagline')
+      end
+
+      it 'updates/removes fields' do
+        @content_type.save
+
+        field = @content_type.entries_custom_fields.build label: 'Title', type: 'string'
+        @content_type.save
+
+        @content_type.update_attributes(entries_custom_fields_attributes: {
+          '0' => { '_id' => lookup_field_id(1), 'label' => 'My Description', 'type' => 'text', '_destroy' => '1' },
+          '1' => { '_id' => lookup_field_id(2), 'label' => 'Active', 'type' => 'boolean', '_destroy' => '1' },
+          '2' => { '_id' => field._id, 'label' => 'My Title !' },
+          '3' => { 'label' => 'Published at', 'type' => 'string' }
+        })
+
+        @content_type = Locomotive::ContentType.find(@content_type.id)
+
+        expect(@content_type.entries_custom_fields.size).to eq(4)
+        expect(@content_type.entries_custom_fields.map(&:name)).to eq(%w(name active_at title published_at))
+        expect(@content_type.entries_custom_fields[2].label).to eq('My Title !')
+      end
+
+    end
+
+  end
+
+  describe 'finding by id or slug' do
+
+    let(:content_type) { build_content_type(slug: 'my_project') }
+    let(:id_or_slug) { 'unknown' }
+
+    subject { Locomotive::ContentType.by_id_or_slug(id_or_slug).first }
+
+    before { content_type.save }
+
+    describe 'unknown id' do
+
+      it { should eq nil }
+
+    end
+
+    describe 'existing id' do
+
+      let(:id_or_slug) { content_type._id.to_s }
+      it { expect(subject.name).to eq 'My project' }
+
+    end
+
+    describe 'existing slug' do
+
+      let(:id_or_slug) { 'my_project' }
+      it { expect(subject.name).to eq 'My project' }
+
+    end
+
+  end
+
+  def build_content_type(options = {}, &block)
+    FactoryGirl.build(:content_type, options).tap do |content_type|
+      content_type.entries_custom_fields.build label: 'Name',        type: 'string'
+      content_type.entries_custom_fields.build label: 'Description', type: 'text'
+      content_type.entries_custom_fields.build label: 'Active',      type: 'boolean'
+      content_type.entries_custom_fields.build label: 'Active at',   type: 'date'
+      block.call(content_type) if block_given?
+    end
+  end
+
+  def safe_find(klass, id)
+    # Mongoid::IdentityMap.clear
+    # Rails.logger.debug "---> reload #{klass}, #{id}!!!!!"
+    klass.find(id)
+  end
+
+  def build_content_entry(content_type)
+    content_type.entries.build(name: 'Asset on steroids', description: 'Lorem ipsum', active: true)
+  end
+
+  def build_belongs_to_has_many_relationship
+    (@category_content_type = build_content_type(name: 'Categories')).save!
+    category_klass = @category_content_type.klass_with_custom_fields(:entries).name
+
+    @content_type = build_content_type.tap do |content_type|
+      field = content_type.entries_custom_fields.build label: 'Category', type: 'belongs_to', class_name: category_klass
+      content_type.order_by           = 'name'
+      content_type.order_direction    = 'desc'
+      content_type.group_by_field_id  = field._id
+      content_type.save!
+    end
+    project_klass = @content_type.klass_with_custom_fields(:entries).name
+
+    field = @category_content_type.entries_custom_fields.build label: 'Projects', type: 'has_many', class_name: project_klass, inverse_of: :category, ui_enabled: false
+    @category_content_type.save!
+  end
+
+  def lookup_field_id(index)
+    @content_type.entries_custom_fields.all[index].id.to_s
+  end
+
+end