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

data/spec/unit/entities/page_spec.rb

@@ -1,50 +1,56 @@
 require 'spec_helper'
 
-describe 'Locomotive::Steam::Entities::Page' do
+describe Locomotive::Steam::Page do
 
-  it 'builds an empty page' do
-    build_page.should_not be_nil
-  end
+  let(:attributes) { {} }
+  let(:page) { described_class.new(attributes) }
 
   describe '#index?' do
-    it { build_page(fullpath: {en: 'index'}).should be_index }
-    it { build_page(fullpath: {en: 'about'}).should_not be_index }
-    it { build_page(fullpath: {en: 'products/index'}).should_not be_index }
-  end
 
-  describe '#index_or_404?' do
-    it { build_page(fullpath: {en: 'index'}).should be_index_or_404 }
-    it { build_page(fullpath: {en: 'about'}).should_not be_index_or_404 }
-    it { build_page(fullpath: {en: 'products/index'}).should_not be_index_or_404 }
-    it { build_page(fullpath: {en: 'products/404'}).should_not be_index_or_404 }
-    it { build_page(fullpath: {en: '404'}).should be_index_or_404 }
-  end
+    let(:attributes) { { fullpath: { en: 'foo/index' } } }
 
-  describe '#depth' do
-    it { build_page(fullpath: {en: 'index'}).depth.should eq 0 }
-    it { build_page(fullpath: {en: '404'}).depth.should eq 0 }
-    it { build_page(fullpath: {en: 'about'}).depth.should eq 1 }
-    it { build_page(fullpath: {en: 'about/me'}).depth.should eq 2 }
-    it { build_page(fullpath: {en: 'about/index'}).depth.should eq 2 }
-    it { build_page(fullpath: {en: 'about/the/team'}).depth.should eq 3 }
-  end
+    subject { page.index? }
+    it { is_expected.to eq false }
 
-  describe '#fullpath=' do
-    context 'when the page has no slug yet' do
-      it 'also sets the slug' do
-        build_page(fullpath: {en: 'this/is/the/page_full_path'}).slug[:en].should eq 'page_full_path'
-      end
+    context 'true' do
+      let(:attributes) { { fullpath: { en: 'index' } } }
+      it { is_expected.to eq true }
     end
 
-    context 'when the slug is already set' do
-      it 'keeps the original slug' do
-        build_page(fullpath: {en: 'this/is/the/page_full_path'}, slug: {en: 'the_slug'}).slug[:en].should eq 'the_slug'
-      end
+  end
+
+  describe '#not_found?' do
+
+    let(:attributes) { { fullpath: { en: 'index' } } }
+
+    subject { page.not_found? }
+    it { is_expected.to eq false }
+
+    context 'true' do
+      let(:attributes) { { fullpath: { en: '404' } } }
+      it { is_expected.to eq true }
     end
+
+  end
+
+  describe '#valid?' do
+
+    subject { page.valid? }
+    it { is_expected.to eq true }
+
   end
 
-  def build_page(attributes = {})
-    Locomotive::Steam::Entities::Page.new(attributes)
+  describe '#content_type_id' do
+
+    let(:attributes) { { target_klass_name: '42' } }
+    subject { page.content_type_id }
+
+    it { is_expected.to eq '42' }
+
+    context 'with a Locomotive Engine class name like' do
+      let(:attributes) { { target_klass_name: 'Locomotive::ContentEntryBigNumber' } }
+      it { is_expected.to eq 'BigNumber' }
+    end
   end
 
 end

data/spec/unit/entities/site_spec.rb

@@ -1,12 +1,63 @@
 require 'spec_helper'
 
-describe 'Locomotive::Steam::Entities::Site' do
+describe Locomotive::Steam::Site do
+
+  let(:attributes) { {} }
+  let(:site) { described_class.new(attributes) }
+
+  describe '#handle' do
+
+    let(:attributes) { { handle: 'acme' } }
+
+    subject { site.handle }
+    it { is_expected.to eq 'acme' }
+
+    context 'from a subdomain if the handle property is nil' do
+
+      let(:attributes) { { subdomain: 'acme' } }
+      it { is_expected.to eq 'acme' }
+
+    end
+
+  end
+
+  describe '#locales' do
+
+    let(:attributes) { { locales: %w(en fr) } }
+
+    subject { site.locales }
+    it { is_expected.to eq [:en, :fr] }
+
+  end
 
   describe '#default_locale' do
-    subject { Locomotive::Steam::Entities::Site.new attributes }
-    let(:attributes) { { locales: [:wk, :fr, :es] } }
-    it 'uses the first locale as default locale' do
-      expect(subject.default_locale).to eq :wk
+
+    let(:attributes) { { locales: %w(en fr) } }
+
+    subject { site.default_locale }
+    it { is_expected.to eq :en }
+
+  end
+
+  describe '#timezone_name' do
+
+    subject { site.timezone_name }
+    it { is_expected.to eq 'UTC' }
+
+    context 'not blank' do
+
+      let(:attributes) { { timezone: 'CDT' } }
+      it { is_expected.to eq 'CDT' }
+
     end
+
+    context 'from the timezone_name attribute itself' do
+
+      let(:attributes) { { timezone_name: 'CDT' } }
+      it { is_expected.to eq 'CDT' }
+
+    end
+
   end
+
 end

data/spec/unit/initializers/dragonfly_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Initializers::Dragonfly do
+
+  let(:initializer) { Locomotive::Steam::Initializers::Dragonfly.new }
+
+  subject { ::Dragonfly.app(:steam).plugins[:imagemagick] }
+
+  describe 'with ImagickMagick' do
+
+    before { initializer.run }
+    it { is_expected.not_to eq nil }
+
+  end
+
+  describe 'missing ImagickMagick' do
+
+    before do
+      ::Dragonfly::App.destroy_apps
+      expect(File).to receive(:exists?).and_return(false)
+      initializer.run
+    end
+    it { is_expected.to eq nil }
+
+    after(:all) do
+      Locomotive::Steam::Initializers::Dragonfly.new.run
+    end
+
+  end
+
+end

data/spec/unit/liquid/drops/content_entry_collection_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Liquid::Drops::ContentEntryCollection do
+
+  let(:assigns)       { {} }
+  let(:content_type)  { instance_double('ContentType', slug: 'articles') }
+  let(:services)      { Locomotive::Steam::Services.build_instance }
+  let(:context)       { ::Liquid::Context.new(assigns, {}, { services: services }) }
+  let(:drop)          { described_class.new(content_type).tap { |d| d.context = context } }
+
+  describe '#public_submission_url' do
+    it { expect(drop.public_submission_url).to eq '/entry_submissions/articles' }
+  end
+
+  describe '#api' do
+    it { expect(drop.api).to eq({ 'create' => '/entry_submissions/articles' }) }
+  end
+
+  describe 'acts as a collection' do
+
+    before do
+      allow(services.repositories.content_entry).to receive(:all).with(nil).and_return(['a', 'b'])
+    end
+
+    describe '#first' do
+      it { expect(drop.first).to eq('a') }
+    end
+
+    describe '#last' do
+      it { expect(drop.last).to eq('b') }
+    end
+
+    context 'with a scope' do
+
+      let(:assigns) { { 'with_scope' => { 'visible' => true } } }
+
+      describe '#first' do
+        before do
+          expect(services.repositories.content_entry).to receive(:all).with({ 'visible' => true }).and_return(['a', 'b'])
+        end
+        it { expect(drop.first).to eq('a') }
+      end
+
+      describe '#count' do
+        before do
+          expect(services.repositories.content_entry).to receive(:count).with({ 'visible' => true }).and_return(2)
+        end
+        it { expect(drop.count).to eq 2 }
+      end
+
+    end
+
+  end
+
+  describe 'get options of a select field' do
+
+    before do
+      expect(services.repositories.content_type).to receive(:select_options).with(content_type, 'category').and_return(['a', 'b'])
+    end
+
+    it { expect(drop.before_method(:category_options)).to eq ['a', 'b'] }
+
+  end
+
+  describe 'group entries by a select/belongs_to field' do
+
+    before do
+      expect(services.repositories.content_entry).to receive(:group_by_select_option).with(content_type, 'category').and_return([['a', [1, 2]]])
+    end
+
+    it { expect(drop.before_method(:group_by_category)).to eq [['a', [1, 2]]] }
+
+  end
+
+  describe 'unknown method' do
+
+    it { expect(drop.before_method(:foo)).to eq nil }
+
+  end
+
+end

data/spec/unit/liquid/drops/content_entry_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Liquid::Drops::ContentEntry do
+
+  let(:site)      { instance_double('Site', default_locale: 'en') }
+  let(:type)      { instance_double('Type', fields_by_name: { title: instance_double('Field', type: :string ) }) }
+  let(:entry)     { instance_double('Article', _id: 42, localized_attributes: {}, content_type: type, title: 'Hello world', _label: 'Hello world', _slug: 'hello-world', _translated: false, seo_title: 'seo title', meta_keywords: 'keywords', meta_description: 'description') }
+  let(:assigns)   { {} }
+  let(:services)  { Locomotive::Steam::Services.build_instance }
+  let(:context)   { ::Liquid::Context.new(assigns, {}, { services: services, site: site, locale: 'en' }) }
+  let(:drop)      { described_class.new(entry).tap { |d| d.context = context } }
+
+  subject { drop }
+
+  it 'gives access to general attributes' do
+    expect(subject._id).to eq '42'
+    expect(subject._label).to eq 'Hello world'
+    expect(subject._slug).to eq 'hello-world'
+    expect(subject._permalink).to eq 'hello-world'
+    expect(subject.seo_title).to eq 'seo title'
+    expect(subject.meta_keywords).to eq 'keywords'
+    expect(subject.meta_description).to eq 'description'
+  end
+
+  describe '#before_method (dynamic attributes)' do
+
+    describe 'simple ones' do
+      it { expect(subject.before_method(:title)).to eq 'Hello world' }
+    end
+
+    describe 'relationship field' do
+
+      let(:authors) { instance_double('AuthorsRepository', first: 'john', local_conditions: {}) }
+      let(:type)    { instance_double('Type', fields_by_name: { authors: instance_double('Field', type: :has_many ) }) }
+      let(:entry)   { instance_double('Article', content_type: type, authors: authors, localized_attributes: {}) }
+
+      before { allow(authors).to receive(:dup).and_return(authors) }
+
+      it { expect(subject.before_method(:authors).first).to eq 'john' }
+
+    end
+
+  end
+
+  describe '#next' do
+
+    let(:next_entry) { instance_double('NextEntry', to_liquid: true) }
+
+    before do
+      expect(services.repositories.content_entry).to receive(:next).with(entry).and_return(next_entry)
+    end
+
+    it { expect(subject.next).to eq true }
+
+  end
+
+  describe '#previous' do
+
+    let(:previous_entry) { instance_double('PreviousEntry', to_liquid: true) }
+
+    before do
+      expect(services.repositories.content_entry).to receive(:previous).with(entry).and_return(previous_entry)
+    end
+
+    it { expect(subject.previous).to eq true }
+
+  end
+
+  describe '#errors' do
+
+    let(:errors) { instance_double('Errors', messages: { title: ['not_blank'] }) }
+
+    before do
+      expect(entry).to receive(:errors).and_return(errors)
+    end
+
+    it { expect(subject.errors).to eq('title' => ['not_blank']) }
+
+  end
+
+  describe 'i18n' do
+
+    let(:entry) { instance_double('Article', content_type: type, localized_attributes: { title: true }, title: { en: 'Hello world', fr: 'Bonjour monde' }) }
+    let(:drop)  { described_class.new(entry).tap { |d| d.context = context } }
+
+    subject { drop.before_method(:title) }
+
+    it { is_expected.to eq 'Hello world' }
+
+    context 'change the current locale of the context' do
+
+      let(:context) { ::Liquid::Context.new(assigns, {}, { services: services, locale: 'fr', site: site }) }
+      it { is_expected.to eq 'Bonjour monde' }
+
+    end
+
+  end
+
+end

data/spec/unit/liquid/drops/content_types_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Liquid::Drops::ContentTypes do
+
+  let(:services)  { Locomotive::Steam::Services.build_instance }
+  let(:context)   { ::Liquid::Context.new({}, {}, { services: services }) }
+  let(:drop)      { described_class.new.tap { |d| d.context = context } }
+
+  before do
+    allow(services.repositories.content_type).to receive(:by_slug).with('articles').and_return(true)
+  end
+
+  it { expect(drop.before_method('articles')).not_to eq nil }
+
+  context 'content type not found' do
+
+    before do
+      allow(services.repositories.content_type).to receive(:by_slug).with('articles').and_return(nil)
+    end
+
+    it { expect(drop.before_method('articles')).to eq nil }
+
+  end
+
+end

data/spec/unit/liquid/drops/current_user_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Liquid::Drops::CurrentUser do
+
+  let(:drop) { described_class.new(user) }
+
+  subject { drop }
+
+  context 'not logged in' do
+
+    let(:user) { nil }
+
+    describe '#logged_in?' do
+      it { expect(subject.logged_in?).to eq false }
+    end
+
+    describe '#name' do
+      it { expect(subject.name).to eq nil }
+    end
+
+    describe '#email' do
+      it { expect(subject.email).to eq nil }
+    end
+
+  end
+
+  context 'logged in' do
+
+    let(:user) { instance_double('User', name: 'John', email: 'john@doe.net') }
+
+    describe '#logged_in?' do
+      it { expect(subject.logged_in?).to eq true }
+    end
+
+    describe '#name' do
+      it { expect(subject.name).to eq 'John' }
+    end
+
+    describe '#email' do
+      it { expect(subject.email).to eq 'john@doe.net' }
+    end
+
+  end
+
+end