locomotivecms_steam 0.1.2.pre.beta → 1.0.0.pre.alpha

data/spec/unit/adapters/mongodb_adapter_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+require_relative '../../../lib/locomotive/steam/adapters/mongodb.rb'
+
+describe Locomotive::Steam::MongoDBAdapter do
+
+  let(:adapter) { described_class.new(nil) }
+
+  describe '#key' do
+
+    subject { adapter.key(:title, :in) }
+
+    it { is_expected.to eq :title.in }
+
+  end
+
+end

data/spec/unit/configuration_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Configuration do
+
+  subject { Locomotive::Steam::Configuration.new }
+
+  describe 'default values' do
+
+    it { expect(subject.mode).to eq(:production) }
+    it { expect(subject.serve_assets).to eq(true) }
+    it { expect(subject.asset_path).to eq(nil) }
+
+  end
+
+  describe 'assign a different value' do
+
+    before { subject.mode = :test }
+    it { expect(subject.mode).to eq(:test) }
+
+    context 'the initial value was true' do
+
+      before { subject.serve_assets = false }
+      it { expect(subject.serve_assets).to eq(false) }
+
+    end
+
+  end
+
+end

data/spec/unit/core_ext/string_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe String do
+
+  describe '#permalink!' do
+
+    let(:string) { 'foo bar' }
+
+    before { string.permalink! }
+
+    it { expect(string).to eq 'foo-bar' }
+
+  end
+
+  describe '#to_bool' do
+
+    subject { string.to_bool }
+
+    describe 'true values' do
+
+      %w(true t yes y 1).each do |val|
+        let(:string) { val }
+        it { is_expected.to eq true }
+      end
+
+    end
+
+    describe 'false values' do
+
+      (%w(false f no n 0) + ['']).each do |val|
+        let(:string) { val }
+        it { is_expected.to eq false }
+      end
+
+    end
+
+    describe 'no truthy or falsy' do
+      let(:string) { 'foo' }
+      it { expect { subject }.to raise_error(%(invalid value for Boolean: "foo")) }
+    end
+
+  end
+
+end

data/spec/unit/decorators/i18n_decorator_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Decorators::I18nDecorator do
+
+  let(:field)           { i18n_field(:title, { en: 'Hello world!', fr: 'Bonjour monde' }) }
+  let(:other_field)     { i18n_field(:slug, 'hello-world') }
+  let(:page)            { instance_double('Page', published?: true, title: field, slug: other_field, localized_attributes: { title: true, slug: true }) }
+  let(:locale)          { 'fr' }
+  let(:default_locale)  { nil }
+  let(:decorated)       { described_class.new(page, locale, default_locale) }
+
+  it 'uses the localized version of the title attribute' do
+    expect(decorated.title).to eq 'Bonjour monde'
+  end
+
+  it 'uses the same value for all the locales' do
+    expect(decorated.slug).to eq 'hello-world'
+  end
+
+  it 'allows access to the other methods of the model too' do
+    expect(decorated.published?).to eq true
+  end
+
+  it 'allows to set a new value' do
+    decorated.title = 'Bonjour le monde'
+    expect(decorated.title).to eq 'Bonjour le monde'
+  end
+
+  describe 'using a different locale' do
+
+    before { decorated.__locale__ = 'en' }
+    it { expect(decorated.title).to eq 'Hello world!' }
+    it { expect(decorated.published?).to eq true }
+
+  end
+
+  describe 'using the default locale' do
+
+    let(:locale)          { 'de' }
+    let(:default_locale)  { 'en' }
+    it { expect(decorated.title).to eq 'Hello world!' }
+
+  end
+
+  describe 'freeze locale' do
+
+    before { decorated.__freeze_locale__ }
+
+    it 'forbids the modification of the locale' do
+      decorated.__locale__ = 'en'
+      expect(decorated.title).to eq 'Bonjour monde'
+    end
+
+  end
+
+  # Note: it could have a been a case for the select field of a content entry
+  # but we found a nice work-around to avoid that specific case.
+  #
+  # describe 'inception' do
+
+  #   let(:inner_field) { i18n_field(:name, { en: 'Beef', fr: 'Boeuf' }) }
+  #   let(:field)       { i18n_field(:category, { en: inner_field, fr: inner_field }) }
+  #   let(:page)        { instance_double('Page', category: field, localized_attributes: { category: true }) }
+
+  #   it { expect(decorated.category).to eq 'Boeuf' }
+
+  # end
+
+  it 'uses another way to switch to a different locale' do
+    decorated.__with_locale__(:en) do
+      expect(decorated.title).to eq 'Hello world!'
+    end
+    expect(decorated.__locale__).to eq :fr
+  end
+
+  def i18n_field(name, translations)
+    Locomotive::Steam::Models::I18nField.new(name, translations)
+  end
+
+end

data/spec/unit/entities/content_entry_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::ContentEntry do
+
+  let(:fields)      { nil }
+  let(:repository)  { instance_double('FieldRepository', all: fields) }
+  let(:type)        { instance_double('ContentType', slug: 'articles', label_field_name: :title, fields: repository) }
+  let(:attributes)  { { title: 'Hello world', _slug: 'hello-world' } }
+  let(:content_entry) { described_class.new(attributes) }
+
+  before { content_entry.content_type = type }
+
+  describe '#valid?' do
+
+    let(:fields) { [instance_double('Field', name: :title, type: :string, required: true)] }
+
+    before do
+      allow(repository).to receive(:required).and_return(fields)
+      allow(type).to receive(:fields_by_name).and_return({ title: fields.first })
+    end
+
+    subject { content_entry.valid? }
+    it { is_expected.to eq true }
+
+    context 'missing attribute' do
+
+      let(:attributes) { {} }
+      it { is_expected.to eq false }
+      it { subject; expect(content_entry.errors[:title]).to eq(["can't not be blank"]) }
+      it { subject; expect(content_entry.errors.empty?).to eq false }
+
+    end
+
+    describe 'adding a custom error message' do
+
+      before { content_entry.errors.add(:title, 'is mandatory') }
+
+      it { expect(content_entry.errors[:title]).to eq(['is mandatory']) }
+
+    end
+
+  end
+
+  describe '#_label' do
+
+    subject { content_entry._label }
+    it { is_expected.to eq 'Hello world' }
+
+  end
+
+  describe '#content_type_slug' do
+
+    subject { content_entry.content_type_slug }
+    it { is_expected.to eq 'articles' }
+
+  end
+
+  describe 'dynamic attributes' do
+
+    let(:field_type)  { :string }
+    let(:attributes)  { { my_field: value } }
+    let(:field)       { instance_double('Field', name: :my_field, type: field_type) }
+
+    before { allow(type).to receive(:fields_by_name).and_return(my_field: field) }
+
+    subject { content_entry.my_field }
+
+    describe 'unable to cast it' do
+
+      let(:field_type)  { :float }
+      let(:value)       { [] }
+      it { is_expected.to eq nil }
+
+    end
+
+    context 'no provided value, should return nil' do
+
+      let(:attributes)  { {} }
+      it { is_expected.to eq nil }
+
+    end
+
+    context 'a string' do
+      let(:value) { 'Hello world' }
+      it { is_expected.to eq 'Hello world' }
+      context 'localized' do
+        let(:value) { build_i18n_field(en: 'Hello world', fr: 'Bonjour monde') }
+        it { expect(subject.translations).to eq('en' => 'Hello world', 'fr' => 'Bonjour monde') }
+      end
+    end
+
+    context 'an integer' do
+      let(:field_type)  { :integer }
+      let(:value)       { '42' }
+      it { is_expected.to eq 42 }
+      context 'localized' do
+        let(:value) { build_i18n_field(en: 42, fr: '42') }
+        it { expect(subject.translations).to eq('en' => 42, 'fr' => 42) }
+      end
+    end
+
+    context 'a float' do
+      let(:field_type)  { :float }
+      let(:value)       { '42.0' }
+      it { is_expected.to eq 42.0 }
+      context 'localized' do
+        let(:value) { build_i18n_field(en: 42.0, fr: '42.0') }
+        it { expect(subject.translations).to eq('en' => 42.0, 'fr' => 42.0) }
+      end
+    end
+
+    context 'a date' do
+      let(:field_type)  { :date }
+      let(:value)       { '2007/06/29' }
+      let(:date)        { Date.parse('2007/06/29') }
+      it { is_expected.to eq date }
+      context 'localized' do
+        let(:value) { build_i18n_field(en: '2007/06/29', fr: date) }
+        it { expect(subject.translations).to eq('en' => date, 'fr' => date) }
+      end
+    end
+
+    context 'a date time' do
+      let(:field_type)  { :date_time }
+      let(:value)       { '2007/06/29 00:00:00' }
+      let(:datetime)    { DateTime.parse('2007/06/29 00:00:00') }
+      it { is_expected.to eq datetime }
+      context 'localized' do
+        let(:value) { build_i18n_field(en: '2007/06/29 00:00:00', fr: datetime) }
+        it { expect(subject.translations).to eq('en' => datetime, 'fr' => datetime) }
+      end
+    end
+
+    context 'a file' do
+      let(:field_type)  { :file }
+      let(:value)       { 'foo.png' }
+      it { expect(subject.url).to eq('/foo.png') }
+      context 'localized' do
+        let(:value) { build_i18n_field(en: 'foo-en.png', fr: 'foo-fr.png') }
+        it { expect(subject.translations[:en].url).to eq('/foo-en.png') }
+        it { expect(subject.translations[:fr].url).to eq('/foo-fr.png') }
+      end
+    end
+
+    context 'a select' do
+      let(:option)      { instance_double('SelectOption', name: { en: 'Category #1', fr: 'Categorie #1' }) }
+      let(:field)       { instance_double('Field', name: :my_field, type: :select, select_options: instance_double('SelectOptions')) }
+      let(:attributes)  { { my_field_id: 42 } }
+      before { expect(field.select_options).to receive(:find).with(42).and_return(option) }
+      it { is_expected.to eq({ en: 'Category #1', fr: 'Categorie #1' }) }
+    end
+
+  end
+
+  def build_i18n_field(translations = {})
+    Locomotive::Steam::Models::I18nField.new(:my_field, translations)
+  end
+
+end

data/spec/unit/entities/content_type_field_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::ContentTypeField do
+
+  let(:attributes)    { { name: 'title', type: 'string' } }
+  let(:content_type)  { described_class.new(attributes) }
+
+  describe '#type' do
+
+    subject { content_type.type }
+    it { is_expected.to eq :string }
+
+  end
+
+  describe '#order_by' do
+
+    subject { content_type.order_by }
+    it { is_expected.to eq nil }
+
+    context 'has_many field' do
+
+      let(:attributes) { { name: 'articles', type: 'has_many', inverse_of: 'author' } }
+      it { is_expected.to eq(position_in_author: 'asc') }
+
+      context 'order_by is specified' do
+
+        let(:attributes) { { name: 'articles', type: 'has_many', inverse_of: 'author', order_by: 'name asc' } }
+        it { is_expected.to eq(name: 'asc') }
+
+      end
+
+    end
+
+  end
+
+  describe '#target_id' do
+
+    subject { content_type.target_id }
+    it { is_expected.to eq nil }
+
+    context 'slug' do
+
+      let(:attributes) { { name: 'articles', class_name: 'articles' } }
+      it { is_expected.to eq 'articles' }
+
+    end
+
+    context 'class name' do
+
+      let(:attributes) { { name: 'articles', class_name: 'Locomotive::ContentEntry42' } }
+      it { is_expected.to eq '42' }
+
+    end
+
+  end
+
+  describe '#association_options' do
+
+    let(:attributes) { { name: 'articles', class_name: 'articles', type: 'has_many', inverse_of: 'author' } }
+
+    subject { content_type.association_options }
+
+    it { is_expected.to eq(target_id: 'articles', inverse_of: 'author', order_by: { position_in_author: 'asc' }) }
+
+  end
+
+end

data/spec/unit/entities/content_type_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::ContentType do
+
+  let(:fields) { [instance_double('Field1', label: 'Title', name: :title, localized: false), instance_double('Field2', label: 'Author', name: :author, localized: true)] }
+  let(:repository) { instance_double('FieldRepository', all: fields, first: fields.first, find: nil) }
+  let(:content_type) { described_class.new(name: 'Articles') }
+
+  before { allow(content_type).to receive(:fields).and_return(repository) }
+
+  describe '#label_field_name' do
+
+    subject { content_type.label_field_name }
+    it { is_expected.to eq :title }
+
+    context 'defined within the content type itself' do
+
+      before { allow(content_type.attributes).to receive(:[]).with(:label_field_name).and_return('author') }
+      it { is_expected.to eq :author }
+
+    end
+
+  end
+
+  describe '#fields_by_name' do
+
+    subject { content_type.fields_by_name }
+    it { expect(subject.keys).to eq ['title', 'author'] }
+    it { expect(subject[:title]).to eq(subject['title']) }
+
+  end
+
+  describe '#order_by' do
+
+    subject { content_type.order_by }
+    it { is_expected.to eq(_position: 'asc') }
+
+    context 'specifying manually' do
+
+      before do
+        content_type.attributes[:order_by] = 'manually'
+        content_type.attributes[:order_direction] = 'desc'
+      end
+      it { is_expected.to eq(_position: 'desc') }
+
+    end
+
+    context 'order_by references an id of a field' do
+
+      let(:field) { instance_double('Field', name: 'title') }
+      let(:repository) { instance_double('FieldRepository', all: fields, first: fields.first, find: field) }
+
+      it { is_expected.to eq(title: 'asc') }
+
+    end
+
+  end
+
+end