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

data/spec/unit/liquid/filters/misc_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Liquid::Filters::Misc do
+
+  include ::Liquid::StandardFilters
+  include Locomotive::Steam::Liquid::Filters::Base
+  include Locomotive::Steam::Liquid::Filters::Misc
+
+  it 'returns the input string every n occurences' do
+    expect(str_modulo('foo', 0, 3)).to eq ''
+    expect(str_modulo('foo', 1, 3)).to eq ''
+    expect(str_modulo('foo', 2, 3)).to eq 'foo'
+    expect(str_modulo('foo', 3, 3)).to eq ''
+    expect(str_modulo('foo', 4, 3)).to eq ''
+    expect(str_modulo('foo', 5, 3)).to eq 'foo'
+  end
+
+  it 'returns default values if the input is empty' do
+    expect(default('foo', 42)).to eq 'foo'
+    expect(default('', 42)).to eq 42
+    expect(default(nil, 42)).to eq 42
+  end
+
+  describe 'index' do
+
+    let(:array)     { [1, 2, 3, 4] }
+    let(:position)  { 2 }
+    subject { index(array, position) }
+
+    it { is_expected.to eq 3 }
+
+  end
+
+  describe 'split' do
+
+    let(:string) { nil }
+    subject { split(string, ',') }
+
+    it { is_expected.to eq [] }
+
+    context 'a not nil value' do
+
+      let(:string) { 'foo,bar'}
+
+      it { is_expected.to eq %w(foo bar) }
+
+    end
+
+  end
+
+  describe 'random' do
+
+    context 'from an integer' do
+
+      subject { random(4) }
+      it { is_expected.to be_a_kind_of(Fixnum) }
+      it { is_expected.to satisfy { |n| n >=0 && n < 4 } }
+
+    end
+
+    context 'from a string' do
+
+      subject { random('4') }
+      it { is_expected.to be_a_kind_of(Fixnum) }
+      it { is_expected.to satisfy { |n| n >=0 && n < 4 } }
+
+    end
+
+  end
+
+  it 'returns a random number' do
+    random_number = random(4)
+    expect(random_number.class).to eq Fixnum
+  end
+
+  describe '#map' do
+
+    context 'to_liquid' do
+
+      subject { map(['4', '5'], 'to_liquid') }
+      it { is_expected.to eq(['4', '5']) }
+
+    end
+
+    context 'to_i' do
+
+      subject { map(['4', '5'], 'to_i') }
+      it { is_expected.to eq([4, 5]) }
+
+    end
+
+    context 'to_f' do
+
+      subject { map(['4.3', '5.2'], 'to_f') }
+      it { is_expected.to eq([4.3, 5.2]) }
+
+    end
+
+    context 'property' do
+
+      subject { map([{ 'title' => 'a' }, { 'title' => 'b' }], 'title') }
+      it { is_expected.to eq(['a', 'b']) }
+
+    end
+
+  end
+
+end

data/spec/unit/liquid/filters/pagination_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Liquid::Filters::Pagination do
+
+  include ::Liquid::StandardFilters
+  include Locomotive::Steam::Liquid::Filters::Base
+  include Locomotive::Steam::Liquid::Filters::Pagination
+
+  it 'returns a navigation block for the pagination' do
+    pagination = {
+      "previous"   => nil,
+      "parts"     => [
+        { 'title' => '1', 'is_link' => false },
+        { 'title' => '2', 'is_link' => true, 'url' => '/?page=2' },
+        { 'title' => '…', 'is_link' => false, 'hellip_break' => true },
+        { 'title' => '5', 'is_link' => true, 'url' => '/?page=5' }
+      ],
+      "next" => { 'title' => 'next', 'is_link' => true, 'url' => '/?page=2' }
+    }
+    html = default_pagination(pagination, 'css:flickr_pagination')
+    expect(html).to match(/<div class="pagination flickr_pagination">/)
+    expect(html).to match(/<span class="disabled prev_page">&laquo; Previous<\/span>/)
+    expect(html).to match(/<a href="\/\?page=2">2<\/a>/)
+    expect(html).to match(/<span class=\"gap\">\&hellip;<\/span>/)
+    expect(html).to match(/<a href="\/\?page=2" class="next_page">Next &raquo;<\/a>/)
+
+    pagination.merge!({
+      'previous' => { 'title' => 'previous', 'is_link' => true, 'url' => '/?page=4' },
+      'next'     => nil
+    })
+
+    html = default_pagination(pagination, 'css:flickr_pagination')
+    expect(html).to_not match(/<span class="disabled prev_page">&laquo; Previous<\/span>/)
+    expect(html).to match(/<a href="\/\?page=4" class="prev_page">&laquo; Previous<\/a>/)
+    expect(html).to match(/<span class="disabled next_page">Next &raquo;<\/span>/)
+
+    pagination.merge!({ 'parts' => [] })
+    html = default_pagination(pagination, 'css:flickr_pagination')
+    expect(html).to eq ''
+  end
+
+end

data/spec/unit/liquid/filters/resize_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Liquid::Filters::Resize do
+
+  include Locomotive::Steam::Liquid::Filters::Resize
+
+  let(:services)  { Locomotive::Steam::Services.build_instance }
+  let(:context)   { instance_double('Context', registers: { services: services }) }
+  let(:input)     { '' }
+  let(:geometry)  { nil }
+
+  subject { resize(input, geometry) }
+
+  before { @context = context }
+
+  it { is_expected.to eq '' }
+
+  describe 'with an url' do
+
+    let(:input) { 'http://upload.wikimedia.org/wikipedia/en/thumb/b/b5/Metropolitan_railway_steam_locomotive_2781022036.png/240px-Metropolitan_railway_steam_locomotive_2781022036.png' }
+
+    it 'returns the input' do
+      is_expected.to eq 'http://upload.wikimedia.org/wikipedia/en/thumb/b/b5/Metropolitan_railway_steam_locomotive_2781022036.png/240px-Metropolitan_railway_steam_locomotive_2781022036.png'
+    end
+
+    describe 'with a geometry' do
+
+      let(:geometry) { '30x40#' }
+
+      it { is_expected.to match /images\/dynamic\/.*\/240px-Metropolitan_railway_steam_locomotive_2781022036.png/ }
+
+    end
+
+  end
+
+end

data/spec/unit/liquid/filters/text_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Liquid::Filters::Text do
+
+  include Locomotive::Steam::Liquid::Filters::Text
+
+  let(:services)  { Locomotive::Steam::Services.build_instance }
+  let(:context)   { instance_double('Context', registers: { services: services }) }
+
+  before { @context = context }
+
+  it 'transforms a textile input into HTML' do
+    expect(textile('This is *my* text.')).to eq "<p>This is <strong>my</strong> text.</p>"
+  end
+
+  it 'transforms a markdown input into HTML' do
+    expect(markdown('# My title')).to eq "<h1>My title</h1>\n"
+  end
+
+  it 'underscores an input' do
+    expect(underscore('foo')).to eq 'foo'
+    expect(underscore('home page')).to eq 'home_page'
+    expect(underscore('My foo Bar')).to eq 'my_foo_bar'
+    expect(underscore('foo/bar')).to eq 'foo_bar'
+    expect(underscore('foo/bar/index')).to eq 'foo_bar_index'
+  end
+
+  it 'dasherizes an input' do
+    expect(dasherize('foo')).to eq 'foo'
+    expect(dasherize('foo_bar')).to eq 'foo-bar'
+    expect(dasherize('foo/bar')).to eq 'foo-bar'
+    expect(dasherize('foo/bar/index')).to eq 'foo-bar-index'
+  end
+
+  it 'concats strings' do
+    expect(concat('foo', 'bar')).to eq 'foobar'
+    expect(concat('hello', 'foo', 'bar')).to eq 'hellofoobar'
+  end
+
+  it 'encodes an input' do
+    expect(encode('http:://www.example.com?key=hello world')).to eq 'http%3A%3A%2F%2Fwww.example.com%3Fkey%3Dhello+world'
+  end
+
+  it 'replaces \n by <br/>' do
+    expect(multi_line("hello\nworld")).to eq 'hello<br/>world'
+  end
+
+  it 'right justifies and padds a string' do
+    expect(rjust('42', 4, '.')).to eq '..42'
+  end
+
+  it 'left justifies and padds a string' do
+    expect(ljust('42', 4, '.')).to eq '42..'
+  end
+
+end

data/spec/unit/liquid/filters/translate_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Liquid::Filters::Translate do
+
+  include Locomotive::Steam::Liquid::Filters::Translate
+
+  let(:services)      { Locomotive::Steam::Services.build_instance }
+  let(:translator)    { services.translator }
+  let(:context)       { instance_double('Context', registers: { services: services }) }
+
+  before { @context = context }
+
+  describe '#translate' do
+
+    before { allow(translator).to receive(:translate).and_return(translation) }
+
+    let(:input)       { 'example_text' }
+    let(:translation) { 'Example text' }
+
+    subject { translate(input) }
+
+    it { is_expected.to eq 'Example text' }
+
+    describe 'no translation found, displays the key itself' do
+
+      let(:translation) { nil }
+      it { is_expected.to eq 'example_text' }
+
+    end
+
+  end
+
+end

data/spec/unit/liquid/patches_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Liquid::StandardFilters do
+
+  describe '#to_number' do
+
+    subject { SimpleFilters.new.send(:to_number, obj) }
+
+    context 'Integer' do
+      let(:obj) { 42 }
+      it { is_expected.to eq 42 }
+    end
+
+    context 'String (Integer)' do
+      let(:obj) { '42' }
+      it { is_expected.to eq 42 }
+    end
+
+    context 'String (Float)' do
+      let(:obj) { '42.00' }
+      it { is_expected.to eq 42.0 }
+    end
+
+    context 'Date' do
+      let(:obj) { Date.parse('2007/06/29') }
+      it { is_expected.to be >= 1183068000 }
+    end
+
+    context 'Time' do
+      let(:obj) { Time.parse('2007/06/29 00:00:00') }
+      it { is_expected.to be >= 1183068000 }
+    end
+
+    context 'DateTime' do
+      let(:obj) { DateTime.parse('2007/06/29 00:00:00+0000') }
+      it { is_expected.to eq 1183075200 }
+    end
+
+    context 'Other object' do
+      let(:obj) { nil }
+      it { is_expected.to eq 0 }
+    end
+
+  end
+
+  class SimpleFilters
+    include Liquid::StandardFilters
+  end
+
+end

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

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Liquid::Tags::Consume do
+
+  let(:source)  { '{% consume blog from "http://blog.locomotiveapp.org" %}{% endconsume %}' }
+  let(:assigns)   { {} }
+  let(:services)  { Locomotive::Steam::Services.build_instance }
+  let(:context)   { ::Liquid::Context.new(assigns, {}, { services: services }) }
+
+  subject { render_template(source, context) }
+
+  describe 'validating syntax' do
+
+    let(:response)  { nil }
+    before { allow(services.external_api).to receive(:consume).and_return(response) }
+
+    describe 'validates a basic syntax' do
+      it { expect { subject }.not_to raise_exception }
+    end
+
+    describe 'validates more complex syntax with attributes' do
+      let(:source) { '{% consume blog from "http://www.locomotiveapp.org", username: "john", password: password_from_context %}{% endconsume %}' }
+      it { expect { subject }.not_to raise_exception }
+    end
+
+    describe 'should parse the correct url with complex syntax with attributes' do
+      let(:source) { '{% consume blog from "http://www.locomotiveapp.org" username: "john", password: "easyone" %}{% endconsume %}' }
+      it { expect { subject }.not_to raise_exception }
+    end
+
+    describe 'raises an error if the syntax is incorrect' do
+      let(:source) { '{% consume blog http://www.locomotiveapp.org %}{% endconsume %}' }
+      it { expect { subject }.to raise_exception }
+    end
+
+  end
+
+  describe 'rendering' do
+
+    let(:response) { { 'title' => 'Locomotive rocks!' } }
+    before { allow(services.external_api).to receive(:consume).and_return(response) }
+
+    describe 'assign the response into the liquid variable' do
+
+      let(:source) { "{% consume blog from \"http://blog.locomotiveapp.org/api/read\" %}{{ blog.title }}{% endconsume %}" }
+      it { is_expected.to eq 'Locomotive rocks!' }
+
+    end
+
+    describe 'assign the response into the liquid variable using a url from a variable' do
+
+      let(:assigns)   { { 'url' => 'http://blog.locomotiveapp.org/api/read' } }
+      let(:source)  { "{% consume blog from url %}{{ blog.title }}{% endconsume %}" }
+      it { is_expected.to eq 'Locomotive rocks!' }
+
+    end
+
+    describe 'accept options for the web service' do
+
+      let(:assigns)     { { 'secret_password' => 'bar' } }
+      let(:source) { "{% consume blog from \"http://blog.locomotiveapp.org/api/read\", username: 'foo', password: secret_password %}{{ blog.title }}{% endconsume %}" }
+      it { is_expected.to eq 'Locomotive rocks!' }
+
+    end
+
+  end
+
+  describe 'timeout' do
+
+    let(:response)  { { 'title' => 'first response' } }
+    let(:url)       { 'http://blog.locomotiveapp.org/api/read' }
+    let(:source)    { %{{% consume blog from "#{url}" timeout: 5.0 %}{{ blog.title }}{% endconsume %}} }
+
+    it 'should pass the timeout option to httparty' do
+      expect(services.external_api).to receive(:consume).with(url, timeout: 5.0).and_return(response)
+      subject
+    end
+
+    it 'should return the previous successful response if a timeout occurs' do
+      allow(services.cache).to receive(:read).and_return(response)
+      allow(services.external_api).to receive(:consume).and_raise(Timeout::Error)
+      expect(subject).to eq 'first response'
+    end
+
+  end
+
+end

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

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'rack/csrf'
+
+describe Locomotive::Steam::Liquid::Tags::Csrf do
+
+  before do
+    allow(Rack::Csrf).to receive(:field).and_return('token')
+    allow(Rack::Csrf).to receive(:token).and_return(42)
+  end
+
+  let(:request)   { instance_double('Request', env: {}) }
+  let(:services)  { Locomotive::Steam::Services.build_instance(request) }
+  let(:context)   { ::Liquid::Context.new({}, {}, { services: services }) }
+
+  subject { render_template(template, context) }
+
+  describe 'csrf_param' do
+
+    let(:template)  { '{% csrf_param %}' }
+    it { is_expected.to eq '<input type="hidden" name="token" value="42" />' }
+
+    context 'protection not enabled' do
+
+      before { allow(services.configuration).to receive(:csrf_protection).and_return(false) }
+      it { is_expected.to eq '' }
+
+    end
+
+  end
+
+  describe 'rendering the meta tag used by ajax requests' do
+
+    let(:template)  { '{% csrf_meta %}' }
+
+    it { is_expected.to match '<meta name="csrf-param" content="token" />' }
+    it { is_expected.to match '<meta name="csrf-token" content="42" />' }
+
+    context 'protection not enabled' do
+
+      before { allow(services.configuration).to receive(:csrf_protection).and_return(false) }
+      it { is_expected.to eq '' }
+
+    end
+
+  end
+
+end