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

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

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Liquid::Tags::Paginate do
+
+  let(:source) { <<-EOF
+{% paginate projects by 5 %}
+  {% for project in paginate.collection %}!{{ project }}{% endfor %}
+  {{ paginate.next.url }}
+{% endpaginate %}'
+EOF
+  }
+
+  let(:projects)  { ['RoR', 'MongoDB', 'Liquid', 'ReactJS', 'DCI', 'Bootstrap'] }
+  let(:page)      { 1 }
+  let(:assigns)   { { 'projects' => projects, 'current_page' => page, 'fullpath' => '/' } }
+  let(:context)   { ::Liquid::Context.new(assigns, {}, {}) }
+  let(:output)    { render_template(source, context) }
+
+  describe 'parsing' do
+
+    subject { parse_template(source) }
+
+    describe 'wrong syntax' do
+
+      let(:source) { '{% paginate projects %}{% endpaginate %}' }
+      it { expect { subject }.to raise_error(::Liquid::SyntaxError, 'Liquid syntax error: Valid syntax: paginate <collection> by <number>') }
+
+    end
+
+    describe 'with options for the pagination' do
+
+      let(:source)  { '{% paginate projects by 2, window_size: 4 %}{% endpaginate %}' }
+      let(:block)   { subject.root.nodelist.first }
+      it { expect(block.send(:window_size)).to eq 4 }
+
+    end
+
+  end
+
+  describe 'rendering' do
+
+    describe 'nil array' do
+
+      let(:projects) { nil }
+
+      subject { output }
+
+      it { expect { subject }.to raise_error(::Liquid::ArgumentError, "Liquid error: Cannot paginate 'projects'. Not found.") }
+
+    end
+
+    describe 'simple array' do
+
+      subject { output }
+
+      it { is_expected.to include '!RoR!MongoDB!Liquid!ReactJS!DCI' }
+      it { is_expected.not_to include '!Bootstrap' }
+
+      describe 'second page of results: display the last item' do
+
+        let(:page) { 2 }
+        it { is_expected.to include '!Bootstrap' }
+        it { is_expected.not_to include '!RoR!MongoDB!Liquid!ReactJS!DCI' }
+
+      end
+
+    end
+
+    describe 'array from a db collection' do
+
+      let(:projects) { KindaDBCollection.new(['RoR', 'MongoDB', 'Liquid', 'ReactJS', 'DCI', 'Bootstrap']) }
+
+      subject { output }
+
+      it { is_expected.to include '!RoR!MongoDB!Liquid!ReactJS!DCI' }
+      it { is_expected.not_to include '!Bootstrap' }
+
+    end
+
+    describe 'a very big collection' do
+
+      let(:projects)  { (1..100).to_a }
+      let(:page)      { 20 }
+      let(:source)    { '{% paginate projects by 2, window_size: 10 %}{% assign _pagination = paginate %}{% endpaginate %}' }
+
+      before  { output }
+      subject { context['_pagination']['parts'] }
+
+      it { expect(subject.first['title']).to eq 1 }
+      it { expect(subject[1]['title']).to eq '&hellip;' }
+      it { expect(subject[2]['title']).to eq 11 }
+      it { expect(subject[21]['title']).to eq '&hellip;' }
+      it { expect(subject.last['title']).to eq 50 }
+
+    end
+
+    describe ''
+
+  end
+
+  class KindaDBCollection < Struct.new(:collection)
+
+    def paginate(options = {})
+      total_pages = (collection.size.to_f / options[:per_page].to_f).to_f.ceil + 1
+      offset = (options[:page] - 1) * options[:per_page]
+
+      {
+        collection:     collection[offset..(offset + options[:per_page]) - 1],
+        current_page:   options[:page],
+        previous_page:  options[:page] == 1 ? 1 : options[:page] - 1,
+        next_page:      options[:page] == total_pages ? total_pages : options[:page] + 1,
+        total_entries:  collection.size,
+        total_pages:    total_pages,
+        per_page:       options[:per_page]
+      }
+    end
+
+    def each(&block)
+      collection.each(&block)
+    end
+
+    def method_missing(method, *args)
+      collection.send(method, *args)
+    end
+
+    def to_liquid
+      self
+    end
+  end
+
+end

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

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Liquid::Tags::PathTo do
+
+  let(:assigns)   { {} }
+  let(:services)  { Locomotive::Steam::Services.build_instance }
+  let(:site)      { instance_double('Site', default_locale: 'en') }
+  let(:context)   { ::Liquid::Context.new(assigns, {}, { services: services, site: site, locale: 'en' }) }
+
+  subject { render_template(source, context) }
+
+  before { allow(services).to receive(:current_site).and_return(site) }
+
+  describe 'parsing' do
+
+    let(:source) { '{% path_to %}' }
+    it { expect { subject }.to raise_error('Valid syntax: path_to <page|page_handle|content_entry>(, locale: [fr|de|...], with: <page_handle>') }
+
+  end
+
+  describe 'unknown page' do
+
+    let(:source) { '{% path_to index %}' }
+
+    before do
+      expect(services.repositories.page).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)    { '{% path_to index %}' }
+
+    before do
+      expect(services.repositories.page).to receive(:by_handle).with('index').and_return(page)
+      allow(page).to receive(:to_liquid).and_return(drop)
+    end
+
+    it { is_expected.to eq '/' }
+
+    context 'and a different locale' do
+
+      let(:source) { "{% path_to index, locale: 'fr' %}" }
+      it { is_expected.to eq '/fr' }
+
+    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, localized_attributes: [:fullpath], templatized?: false) }
+    let(:fullpath)  { { en: 'about-us', fr: 'a-notre-sujet' } }
+    let(:source)    { '{% path_to about_us %}' }
+
+    it { is_expected.to eq '/about-us' }
+
+    context 'and a different locale' do
+
+      let(:source) { "{% path_to about_us, locale: 'fr' %}" }
+      it { is_expected.to eq '/fr/a-notre-sujet' }
+
+    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)      { '{% path_to article %}' }
+
+    before do
+      expect(services.repositories.page).to receive(:template_for).with(entry, nil).and_return(page)
+      allow(page).to receive(:to_liquid).and_return(drop)
+    end
+
+    it { is_expected.to eq '/my-articles/hello-world' }
+
+    context 'and a different locale' do
+
+      let(:source) { "{% path_to article, locale: 'fr' %}" }
+      it { is_expected.to eq '/fr/mes-articles/bonjour-monde' }
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Liquid::Tags::SEO do
+
+  let(:page)          { nil }
+  let(:content_entry) { nil }
+
+  let(:site)      { instance_double('Site', name: 'Acme', seo_title: 'Acme (SEO)', meta_description: 'A short site description', meta_keywords: 'test only cat dog') }
+  let(:assigns)   { { 'page' => page, 'content_entry' => content_entry } }
+  let(:context)   { ::Liquid::Context.new(assigns, {}, { site: site }) }
+
+  subject { render_template(source, context).strip }
+
+  describe 'seo' do
+
+    let(:source) { '{% seo %}' }
+    it { is_expected.to include '<title>Acme (SEO)</title>' }
+    it { is_expected.to include %Q[<meta name="description" content="A short site description">] }
+    it { is_expected.to include %Q[<meta name="keywords" content="test only cat dog">] }
+
+  end
+
+  describe 'seo_title' do
+
+    let(:source) { '{% seo_title %}' }
+
+    describe 'no page' do
+
+      it { is_expected.to eq '<title>Acme (SEO)</title>' }
+
+      describe 'no seo_title site property' do
+
+        let(:site) { instance_double('Site', name: 'Acme', seo_title: nil, meta_description: 'A short site description', meta_keywords: 'test only cat dog') }
+        it { is_expected.to eq '<title>Acme</title>' }
+
+      end
+
+    end
+
+    describe 'with a page' do
+
+      let(:page) { liquid_instance_double('Page', seo_title: 'Snow!') }
+      it { is_expected.to eq '<title>Snow!</title>' }
+
+    end
+
+    describe 'with a content entry' do
+
+      let(:content_entry) { liquid_instance_double('Entry', seo_title: 'Snow!') }
+      it { is_expected.to eq '<title>Snow!</title>' }
+
+    end
+
+  end
+
+  describe 'seo_metadata' do
+
+    let(:source) { '{% seo_metadata %}' }
+
+    describe 'no page' do
+
+      it { is_expected.to include %Q[<meta name="description" content="A short site description">] }
+      it { is_expected.to include %Q[<meta name="keywords" content="test only cat dog">] }
+
+    end
+
+    describe 'with a page' do
+
+      let(:page) { liquid_instance_double('Page', meta_description: "It's snowing", meta_keywords: 'snow') }
+      it { is_expected.to include %Q[<meta name="description" content="It's snowing">] }
+      it { is_expected.to include %Q[<meta name="keywords" content="snow">] }
+
+    end
+
+    describe 'with a content entry' do
+
+      let(:content_entry) { liquid_instance_double('Entry', meta_description: "It's snowing", meta_keywords: 'snow') }
+      it { is_expected.to include %Q[<meta name="description" content="It's snowing">] }
+      it { is_expected.to include %Q[<meta name="keywords" content="snow">] }
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Liquid::Tags::SessionAssign do
+
+  let(:source)    { '{% session_assign title=42 %}' }
+  let(:session)   { Hash.new }
+  let(:request)   { instance_double('Request', session: session) }
+  let(:assigns)   { {} }
+  let(:context)   { ::Liquid::Context.new(assigns, {}, { request: request }) }
+
+  let(:output)    { render_template(source, context) }
+
+  subject { session[:title] }
+
+  it { expect(output).to eq '' }
+
+  describe 'parsing' do
+
+    context 'wrong syntax' do
+
+      let(:source) { '{% session_assign title %}' }
+      it { expect { output }.to raise_error(::Liquid::SyntaxError) }
+
+    end
+
+  end
+
+  describe 'store the object in the session' do
+
+    before { output }
+
+    it { is_expected.to eq 42 }
+
+    describe 'the object is a string' do
+
+      let(:source) { '{% session_assign title = "Hello world" %}' }
+      it { is_expected.to eq 'Hello world' }
+
+    end
+
+    describe 'the object is a variable' do
+
+      let(:assigns) { { 'product' => { 'name' => 'Snow!' } } }
+      let(:source)  { '{% session_assign title = product.name %}' }
+      it { is_expected.to eq 'Snow!' }
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Liquid::Tags::Snippet do
+
+  let(:services)  { Locomotive::Steam::Services.build_instance(nil) }
+  let(:finder)    { services.snippet_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) }
+
+  describe 'parsing' do
+
+    let(:page)      { instance_double('Page') }
+    let(:listener)  { Liquid::SimpleEventsListener.new }
+    let(:options)   { { events_listener: listener, page: page, snippet_finder: finder, parser: services.liquid_parser } }
+
+    let!(:template) { parse_template(source, options) }
+
+    it { expect(listener.event_names.first).to eq :include }
+
+    # describe 'with an editable_element inside', pending: true do
+
+    #   let(:snippet) { instance_double('Snippet', source: '{% editable_text company %}built by NoCoffee{% endeditable_text %}') }
+
+    #   it { expect(listener.events.size).to eq 2 }
+
+    # end
+
+  end
+
+  describe 'rendering' do
+
+    let(:context) { ::Liquid::Context.new({}, {}, { services: services }) }
+
+    subject { render_template(source, context) }
+
+    it { is_expected.to eq 'Locomotive built by NoCoffee' }
+
+  end
+
+end

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

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Liquid::Tags::WithScope do
+
+  let(:assigns)     { {} }
+  let(:context)     { ::Liquid::Context.new(assigns, {}, {}) }
+  let!(:output)     { render_template(source, context) }
+  let(:conditions)  { context['conditions'] }
+
+  describe 'decode basic options (boolean, integer, ...)' do
+
+    let(:source) { "{% with_scope active: true, price: 42, title: 'foo', hidden: false %}{% assign conditions = with_scope %}{% endwith_scope %}" }
+
+    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 }
+
+  end
+
+  describe 'decode regexps' do
+
+    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/) }
+
+  end
+
+  describe 'decode context variable' do
+
+    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' }
+
+  end
+
+  describe 'decode a regexp stored in a context variable' do
+
+    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/) }
+
+  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
+
+    let(:source) { "{% with_scope _permalink: 'foo' %}{% assign conditions = with_scope %}{% endwith_scope %}" }
+    it { expect(conditions['_slug']).to eq 'foo' }
+
+  end
+
+  describe 'decode criteria with gt and lt' do
+
+    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 }
+
+  end
+
+end