locomotivecms_steam 1.5.0.rc0 → 1.5.0.rc1

data/spec/unit/liquid/tags/redirect_to_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Liquid::Tags::RedirectTo do
+
+  let(:prefix_default)  { false }
+  let(:assigns)         { {} }
+  let(:current_locale)  { 'en' }
+  let(:locales)         { ['en'] }
+  let(:services)        { Locomotive::Steam::Services.build_instance }
+  let(:site)            { instance_double('Site', locales: locales, default_locale: 'en', prefix_default_locale: prefix_default) }
+  let(:context)         { ::Liquid::Context.new(assigns, {}, { services: services, site: site, locale: current_locale }) }
+
+  subject { render_template(source, context) }
+
+  before { allow(services).to receive(:current_site).and_return(site) }
+
+  describe 'parsing' do
+
+    let(:source) { '{% redirect_to %}' }
+    it { expect { subject }.to raise_error('Valid syntax: redirect_to <page|page_handle|content_entry|external_url>(, locale: [fr|de|...], with: <page_handle>, permanent: [true|false]') }
+
+  end
+
+  describe 'external url' do
+
+    let(:source) { '{% redirect_to "https://www.locomotivecms.com" %}' }
+
+    it { expect { subject }.to raise_error(Locomotive::Steam::RedirectionException, 'Redirect to https://www.locomotivecms.com (301)') }
+
+    context 'non permanent redirection' do
+
+      let(:source) { '{% redirect_to "https://www.locomotivecms.com", permanent: false %}' }
+
+      it { expect { subject }.to raise_error(Locomotive::Steam::RedirectionException, 'Redirect to https://www.locomotivecms.com (302)') }
+
+    end
+
+  end
+
+  describe 'unknown page' do
+
+    let(:source) { '{% redirect_to index %}' }
+
+    before do
+      expect(services.page_finder).to receive(:by_handle).with('index').and_return(nil)
+    end
+
+    it { is_expected.to eq '' }
+
+  end
+
+  describe 'from a handle of a page' do
+
+    let(:drop)      { Locomotive::Steam::Liquid::Drops::Page.new(page) }
+    let(:page)      { liquid_instance_double('Index', title: 'Index', handle: 'index', fullpath: fullpath, localized_attributes: { fullpath: true }, templatized?: false) }
+    let(:fullpath)  { { en: 'index', fr: 'index' } }
+    let(:source)    { '{% redirect_to index %}' }
+
+    before do
+      expect(services.page_finder).to receive(:by_handle).with('index').and_return(page)
+      allow(page).to receive(:to_liquid).and_return(drop)
+    end
+
+    it { expect { subject }.to raise_error(Locomotive::Steam::RedirectionException, 'Redirect to / (301)') }
+
+    context 'and a different locale' do
+
+      let(:source) { "{% redirect_to index, locale: 'fr' %}" }
+      it { expect { subject }.to raise_error(Locomotive::Steam::RedirectionException, 'Redirect to /fr (301)') }
+
+    end
+
+    context 'the current locale in session is different from the requested locale' do
+
+      let(:current_locale)  { 'fr' }
+      let(:locales)         { ['en', 'fr'] }
+      let(:source)          { "{% redirect_to index, locale: 'en' %}" }
+
+      before do
+        services.url_builder.current_locale = current_locale
+      end
+
+      it { expect { subject }.to raise_error(Locomotive::Steam::RedirectionException, 'Redirect to /en (301)') }
+
+      context 'prefix_default_locale is true' do
+
+        let(:prefix_default) { true }
+        it { expect { subject }.to raise_error(Locomotive::Steam::RedirectionException, 'Redirect to /en (301)') }
+
+      end
+
+    end
+
+    context 'prefix_default_locale is true' do
+
+      let(:prefix_default) { true }
+      it { expect { subject }.to raise_error(Locomotive::Steam::RedirectionException, 'Redirect to /en (301)') }
+
+    end
+
+  end
+
+  describe 'from a page (drop) itself' do
+
+    let(:assigns)   { { 'about_us' => drop } }
+    let(:drop)      { Locomotive::Steam::Liquid::Drops::Page.new(page) }
+    let(:page)      { liquid_instance_double('AboutUs', title: 'About us', handle: 'index', localized_attributes: { fullpath: true }, fullpath: fullpath, templatized?: false) }
+    let(:fullpath)  { { en: 'about-us', fr: 'a-notre-sujet' } }
+    let(:source)    { '{% redirect_to about_us %}' }
+
+    it { expect { subject }.to raise_error(Locomotive::Steam::RedirectionException, 'Redirect to /about-us (301)') }
+
+    context 'and a different locale' do
+
+      let(:source) { "{% redirect_to about_us, locale: 'fr' %}" }
+      it { expect { subject }.to raise_error(Locomotive::Steam::RedirectionException, 'Redirect to /fr/a-notre-sujet (301)') }
+
+      context 'locale is a variable' do
+
+        let(:assigns) { { 'about_us' => drop, 'language' => 'fr' } }
+        let(:source) { "{% redirect_to about_us, locale: language %}" }
+
+        it { expect { subject }.to raise_error(Locomotive::Steam::RedirectionException, 'Redirect to /fr/a-notre-sujet (301)') }
+
+      end
+
+    end
+
+  end
+
+  describe 'from a content entry (drop)' do
+
+    let(:assigns)     { { 'article' => entry_drop } }
+    let(:entry_drop)  { Locomotive::Steam::Liquid::Drops::ContentEntry.new(entry) }
+    let(:entry)       { liquid_instance_double('Article', localized_attributes: { _slug: true }, _slug: { en: 'hello-world', fr: 'bonjour-monde' }) }
+    let(:drop)        { Locomotive::Steam::Liquid::Drops::Page.new(page) }
+    let(:page)        { liquid_instance_double('ArticleTemplate', title: 'Template of an article', handle: 'article', localized_attributes: { fullpath: true }, fullpath: { en: 'my-articles/content_type_template', fr: 'mes-articles/content_type_template' }, content_entry: entry_drop.send(:_source), templatized?: true) }
+    let(:source)      { '{% redirect_to article %}' }
+
+    before do
+      allow(services.repositories.page).to receive(:template_for).with(entry, nil).and_return(page)
+      allow(page).to receive(:to_liquid).and_return(drop)
+    end
+
+    it { expect { subject }.to raise_error(Locomotive::Steam::RedirectionException, 'Redirect to /my-articles/hello-world (301)') }
+
+    context 'and a different locale' do
+
+      let(:source) { "{% redirect_to article, locale: 'fr' %}" }
+      it { expect { subject }.to raise_error(Locomotive::Steam::RedirectionException, 'Redirect to /fr/mes-articles/bonjour-monde (301)') }
+
+    end
+
+    context 'and a different template' do
+
+      let(:archive) { liquid_instance_double('ArticleTemplate', title: 'Template of an article', handle: 'article', localized_attributes: { fullpath: true }, fullpath: { en: 'my-archives/content_type_template', fr: 'mes-archives/content_type_template' }, content_entry: entry_drop.send(:_source), templatized?: true) }
+      let(:drop)    { Locomotive::Steam::Liquid::Drops::Page.new(archive) }
+
+      before do
+        allow(services.repositories.page).to receive(:template_for).with(entry, 'archives').and_return(archive)
+        allow(archive).to receive(:to_liquid).and_return(drop)
+      end
+
+      let(:source) { "{% redirect_to article, with: archives, locale: fr %}" }
+      it { expect { subject }.to raise_error(Locomotive::Steam::RedirectionException, 'Redirect to /fr/mes-archives/bonjour-monde (301)') }
+
+    end
+
+  end
+
+end

data/spec/unit/liquid/tags/section_spec.rb

@@ -9,9 +9,10 @@ describe Locomotive::Steam::Liquid::Tags::Section do
   let(:live_editing)  { true }
   let(:content)       { {} }
   let(:alt_content)   { nil }
+  let(:file_system)   { Locomotive::Steam::Liquid::FileSystem.new(section_finder: finder) }
   let(:page)          { liquid_instance_double('Page', sections_content: content)}
   let(:assigns)       { { 'page' => page } }
-  let(:context)       { ::Liquid::Context.new(assigns, {}, { services: services, live_editing: live_editing, _section_content: alt_content }) }
+  let(:context)       { ::Liquid::Context.new(assigns, {}, { services: services, live_editing: live_editing, _section_content: alt_content, file_system: file_system }, rethrow_errors: true) }
 
   describe 'parsing' do
 
@@ -98,6 +99,22 @@ describe Locomotive::Steam::Liquid::Tags::Section do
 
       end
 
+      context 'including the link_to liquid tag' do
+
+        let(:liquid_source) { 'go to {% link_to home %}' }
+
+        before { expect_any_instance_of(Locomotive::Steam::Liquid::Tags::LinkTo).to receive(:render) { 'HOME' } }
+
+        it { is_expected.to eq 'Locomotive'\
+          ' <div id="locomotive-section-page-header"'\
+          ' class="locomotive-section my-awesome-header"'\
+          ' data-locomotive-section-type="header">'\
+            '<span id="page-header-section"></span>'\
+            'go to HOME'\
+          '</div>' }
+
+      end
+
       context 'without the live editing feature enabled' do
 
         let(:live_editing) { false }
@@ -112,6 +129,20 @@ describe Locomotive::Steam::Liquid::Tags::Section do
 
       end
 
+      context 'the developer wants to wrap herself/himself the section' do
+
+        let(:liquid_source) { '<section class="section-header" id="{{ section.anchor_id }}" {{ section.locomotive_attributes }}>Hello world</section>' }
+
+        it { is_expected.to eq 'Locomotive '\
+          '<section class="section-header"'\
+          ' id="page-header-section"'\
+          ' data-locomotive-section-id="page-header"'\
+          ' data-locomotive-section-type="header">'\
+            'Hello world'\
+          '</section>' }
+
+      end
+
     end
 
     context 'with blocks' do
@@ -219,6 +250,15 @@ describe Locomotive::Steam::Liquid::Tags::Section do
       end
     end
 
+    context 'the section has a syntax error inside its liquid template' do
+
+      let(:liquid_source) { %(built by <a>\n\t<strong>{{ section.settings.brand }}{% if %}</strong></a>) }
+
+      it 'raises a LiquidError' do
+        expect { subject }.to raise_exception(Locomotive::Steam::LiquidError)
+      end
+
+    end
 
     context 'rendering error (action) found in the section' do
 
@@ -230,8 +270,8 @@ describe Locomotive::Steam::Liquid::Tags::Section do
         definition:     { settings: [], blocks: [] }
       )}
 
-      it 'raises ParsingRenderingError' do
-        expect { subject }.to raise_exception(Locomotive::Steam::ParsingRenderingError)
+      it 'raises a TemplateError' do
+        expect { subject }.to raise_exception(Locomotive::Steam::TemplateError)
       end
     end
 

data/spec/unit/liquid/tags/sections_dropzone_spec.rb

@@ -68,7 +68,6 @@ describe Locomotive::Steam::Liquid::Tags::SectionsDropzone do
       end
 
       it 'renders the list of sections' do
-        puts is_expected.inspect
         is_expected.to eq <<-HTML
           <div class="locomotive-sections">
             <div id="locomotive-section-dropzone-0" class="locomotive-section" data-locomotive-section-type="hero">

data/spec/unit/liquid/tags/snippet_spec.rb

@@ -2,11 +2,12 @@ require 'spec_helper'
 
 describe Locomotive::Steam::Liquid::Tags::Snippet do
 
-  let(:request)   { instance_double('Request', env: {}) }
-  let(:services)  { Locomotive::Steam::Services.build_instance(request) }
-  let(:finder)    { services.snippet_finder }
-  let(:snippet)   { instance_double('Snippet', template: nil, :template= => nil, liquid_source: 'built by NoCoffee') }
-  let(:source)    { 'Locomotive {% include footer %}' }
+  let(:request)     { instance_double('Request', env: {}) }
+  let(:services)    { Locomotive::Steam::Services.build_instance(request) }
+  let(:finder)      { services.snippet_finder }
+  let(:file_system) { Locomotive::Steam::Liquid::FileSystem.new(snippet_finder: finder) }
+  let(:snippet)     { instance_double('Snippet', template: nil, :template= => nil, liquid_source: 'built by NoCoffee') }
+  let(:source)      { 'Locomotive {% include footer %}' }
 
   before { allow(finder).to receive(:find).and_return(snippet) }
 
@@ -32,7 +33,7 @@ describe Locomotive::Steam::Liquid::Tags::Snippet do
 
   describe 'rendering' do
 
-    let(:context) { ::Liquid::Context.new({}, {}, { services: services }) }
+    let(:context) { ::Liquid::Context.new({}, {}, { services: services, file_system: file_system }) }
 
     subject { render_template(source, context) }
 
@@ -42,8 +43,8 @@ describe Locomotive::Steam::Liquid::Tags::Snippet do
 
       let(:snippet) { instance_double('Snippet', template: nil, :template= => nil, liquid_source: '{% action "Hello world" %}a.b(+}{% endaction %}') }
 
-      it 'raises ParsingRenderingError' do
-        expect { subject }.to raise_exception(Locomotive::Steam::ParsingRenderingError)
+      it 'raises a TemplateError' do
+        expect { subject }.to raise_exception(Locomotive::Steam::TemplateError)
       end
 
     end

data/spec/unit/liquid/tags/with_scope_spec.rb

@@ -1,110 +1,130 @@
 require 'spec_helper'
+require 'origin'
 
 describe Locomotive::Steam::Liquid::Tags::WithScope do
 
   let(:assigns)     { {} }
   let(:context)     { ::Liquid::Context.new(assigns, {}, {}) }
-  let!(:output)     { render_template(source, context) }
+  let(:output)      { render_template(source, context) }
   let(:conditions)  { context['conditions'] }
 
-  describe 'store the conditions in the context' do
+  describe 'no attributes' do
 
-    let(:source) { "{% with_scope active: true, price: 42, title: 'foo', hidden: false %}{% assign conditions = with_scope %}{% assign content_type = with_scope_content_type %}{% endwith_scope %}" }
-
-    it { expect(context['conditions'].keys).to eq(%w(active price title hidden)) }
-    it { expect(context['content_type']).to eq false }
+    let(:source)  { '{% with_scope %}42{% endwith_scope %}'}
+    it { expect { output }.to raise_error("Liquid syntax error (line 1): Syntax Error in 'with_scope' - Valid syntax: with_scope <name_1>: <value_1>, ..., <name_n>: <value_n>") }
 
   end
 
-  describe 'decode basic options (boolean, integer, ...)' do
+  describe 'valid syntax' do
 
-    let(:source) { "{% with_scope active: true, price: 42, title: 'foo', hidden: false %}{% assign conditions = with_scope %}{% endwith_scope %}" }
+    before { output }
 
-    it { expect(conditions['active']).to eq true }
-    it { expect(conditions['price']).to eq 42 }
-    it { expect(conditions['title']).to eq 'foo' }
-    it { expect(conditions['hidden']).to eq false }
+    describe 'renders basic stuff' do
+      let(:source) { '{% with_scope a: 1 %}42{% endwith_scope %}' }
+      it { expect(output).to eq '42' }
+    end
 
-  end
+    describe 'store the conditions in the context' do
 
-  describe 'decode regexps' do
+      let(:source) { "{% with_scope active: true, price: 42, title: 'foo', hidden: false %}{% assign conditions = with_scope %}{% assign content_type = with_scope_content_type %}{% endwith_scope %}" }
 
-    let(:source) { "{% with_scope title: /Like this one|or this one/ %}{% assign conditions = with_scope %}{% endwith_scope %}" }
-    it { expect(conditions['title']).to eq(/Like this one|or this one/) }
+      it { expect(context['conditions'].keys).to eq(%w(active price title hidden)) }
+      it { expect(context['content_type']).to eq false }
 
-  end
+    end
 
-  describe 'decode regexps with case-insensitive' do
+    describe 'decode basic options (boolean, integer, ...)' do
 
-    let(:source) { "{% with_scope title: /like this/ix %}{% assign conditions = with_scope %}{% endwith_scope %}" }
-    it { expect(conditions['title']).to eq(/like this/ix) }
+      let(:source) { "{% with_scope active: true, price: 42, title: 'foo', hidden: false %}{% assign conditions = with_scope %}{% endwith_scope %}" }
 
-  end
+      it { expect(conditions['active']).to eq true }
+      it { expect(conditions['price']).to eq 42 }
+      it { expect(conditions['title']).to eq 'foo' }
+      it { expect(conditions['hidden']).to eq false }
 
-  describe 'decode content entry' do
+    end
 
-    let(:entry) {
-      instance_double('ContentEntry', _id: 1, _source: 'entity').tap do |_entry|
-        allow(_entry).to receive(:to_liquid).and_return(_entry)
-      end }
-    let(:assigns) { { 'my_project' => entry } }
-    let(:source)  { "{% with_scope project: my_project %}{% assign conditions = with_scope %}{% endwith_scope %}" }
+    describe 'decode regexps' do
 
-    it { expect(conditions['project']).to eq 'entity' }
+      let(:source) { "{% with_scope title: /Like this one|or this one/ %}{% assign conditions = with_scope %}{% endwith_scope %}" }
+      it { expect(conditions['title']).to eq(/Like this one|or this one/) }
 
-    context 'an array of content entries' do
+    end
 
-      let(:source) { "{% with_scope project: [my_project, my_project, my_project] %}{% assign conditions = with_scope %}{% endwith_scope %}" }
+    describe 'decode regexps with case-insensitive' do
 
-      it { expect(conditions['project']).to eq ['entity', 'entity', 'entity'] }
+      let(:source) { "{% with_scope title: /like this/ix %}{% assign conditions = with_scope %}{% endwith_scope %}" }
+      it { expect(conditions['title']).to eq(/like this/ix) }
 
     end
 
-  end
+    describe 'decode content entry' do
 
-  describe 'decode context variable' do
+      let(:entry) {
+        instance_double('ContentEntry', _id: 1, _source: 'entity').tap do |_entry|
+          allow(_entry).to receive(:to_liquid).and_return(_entry)
+        end }
+      let(:assigns) { { 'my_project' => entry } }
+      let(:source)  { "{% with_scope project: my_project %}{% assign conditions = with_scope %}{% endwith_scope %}" }
 
-    let(:assigns) { { 'params' => { 'type' => 'posts' } } }
-    let(:source) { "{% with_scope category: params.type %}{% assign conditions = with_scope %}{% endwith_scope %}" }
-    it { expect(conditions['category']).to eq 'posts' }
+      it { expect(conditions['project']).to eq 'entity' }
 
-  end
+      context 'an array of content entries' do
 
-  describe 'decode a regexp stored in a context variable' do
+        let(:source) { "{% with_scope project: [my_project, my_project, my_project] %}{% assign conditions = with_scope %}{% endwith_scope %}" }
 
-    let(:assigns) { { 'my_regexp' => '/^Hello World/' } }
-    let(:source) { "{% with_scope title: my_regexp %}{% assign conditions = with_scope %}{% endwith_scope %}" }
-    it { expect(conditions['title']).to eq(/^Hello World/) }
+        it { expect(conditions['project']).to eq ['entity', 'entity', 'entity'] }
 
-  end
+      end
 
-  describe 'decode a regexp stored in a context variable, with case-insensitive' do
+    end
 
-    let(:assigns) { { 'my_regexp' => '/^hello world/ix' } }
-    let(:source) { "{% with_scope title: my_regexp %}{% assign conditions = with_scope %}{% endwith_scope %}" }
-    it { expect(conditions['title']).to eq(/^hello world/ix) }
+    describe 'decode context variable' do
 
-  end
+      let(:assigns) { { 'params' => { 'type' => 'posts' } } }
+      let(:source) { "{% with_scope category: params.type %}{% assign conditions = with_scope %}{% endwith_scope %}" }
+      it { expect(conditions['category']).to eq 'posts' }
 
-  describe 'allow order_by option' do
+    end
 
-    let(:source) { "{% with_scope order_by:\'name DESC\' %}{% assign conditions = with_scope %}{% endwith_scope %}" }
-    it { expect(conditions['order_by']).to eq 'name DESC' }
+    describe 'decode a regexp stored in a context variable' do
 
-  end
+      let(:assigns) { { 'my_regexp' => '/^Hello World/' } }
+      let(:source) { "{% with_scope title: my_regexp %}{% assign conditions = with_scope %}{% endwith_scope %}" }
+      it { expect(conditions['title']).to eq(/^Hello World/) }
 
-  describe 'replace _permalink by _slug' do
+    end
 
-    let(:source) { "{% with_scope _permalink: 'foo' %}{% assign conditions = with_scope %}{% endwith_scope %}" }
-    it { expect(conditions['_slug']).to eq 'foo' }
+    describe 'decode a regexp stored in a context variable, with case-insensitive' do
 
-  end
+      let(:assigns) { { 'my_regexp' => '/^hello world/ix' } }
+      let(:source) { "{% with_scope title: my_regexp %}{% assign conditions = with_scope %}{% endwith_scope %}" }
+      it { expect(conditions['title']).to eq(/^hello world/ix) }
+
+    end
+
+    describe 'allow order_by option' do
+
+      let(:source) { "{% with_scope order_by:\'name DESC\' %}{% assign conditions = with_scope %}{% endwith_scope %}" }
+      it { expect(conditions['order_by']).to eq 'name DESC' }
+
+    end
+
+    describe 'replace _permalink by _slug' do
 
-  describe 'decode criteria with gt and lt' do
+      let(:source) { "{% with_scope _permalink: 'foo' %}{% assign conditions = with_scope %}{% endwith_scope %}" }
+      it { expect(conditions['_slug']).to eq 'foo' }
+
+    end
 
-    let(:source) { "{% with_scope price.gt:42.0, price.lt:50 %}{% assign conditions = with_scope %}{% endwith_scope %}" }
-    it { expect(conditions['price.gt']).to eq 42.0 }
-    it { expect(conditions['price.lt']).to eq 50 }
+    describe 'decode criteria with gt and lt' do
+
+      let(:source) { "{% with_scope price.gt:42.0, price.lt:50, published_at.lte: '2019-09-10 00:00:00' %}{% assign conditions = with_scope %}{% endwith_scope %}" }
+      it { expect(conditions['price.gt']).to eq 42.0 }
+      it { expect(conditions['price.lt']).to eq 50 }
+      it { expect(conditions['published_at.lte']).to eq '2019-09-10 00:00:00' }
+
+    end
 
   end