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

data/spec/unit/middlewares/dynamic_assets_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+require 'sprockets'
+require_relative '../../../lib/locomotive/steam/middlewares/dynamic_assets'
+
+describe Locomotive::Steam::Middlewares::DynamicAssets do
+
+  let(:app)     { ->(env) { [200, env, 'app'] }}
+  let(:options) { { root: File.dirname(__FILE__), minify: true } }
+
+  let(:middleware) { Locomotive::Steam::Middlewares::DynamicAssets.new(app, options) }
+
+  describe 'java not installed' do
+
+    let(:sprockets) { instance_double('Sprockets') }
+
+    before { allow(middleware).to receive(:is_java_installed?).and_return(false) }
+
+    subject { middleware.send(:install_yui_compressor, sprockets, options) }
+
+    it { is_expected.to eq(false) }
+
+  end
+
+end

data/spec/unit/middlewares/locale_redirection_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+require_relative '../../../lib/locomotive/steam/middlewares/threadsafe'
+require_relative '../../../lib/locomotive/steam/middlewares/helpers'
+require_relative '../../../lib/locomotive/steam/middlewares/locale_redirection'
+
+describe Locomotive::Steam::Middlewares::LocaleRedirection do
+
+  let(:prefixed)        { false }
+  let(:site)            { instance_double('Site', prefix_default_locale: prefixed, default_locale: :de, locales: %w(de fr)) }
+  let(:url)             { 'http://models.example.com' }
+  let(:app)             { ->(env) { [200, env, 'app'] } }
+  let(:middleware)      { Locomotive::Steam::Middlewares::LocaleRedirection.new(app) }
+  let(:locale)          { 'de' }
+  let(:locale_in_path)  { true }
+
+  subject do
+    env = env_for(url, 'steam.site' => site, 'steam.locale' => locale, 'steam.locale_in_path' => locale_in_path)
+    env['steam.request'] = Rack::Request.new(env)
+    code, env = middleware.call(env)
+    [code, env['Location']]
+  end
+
+  describe 'not prefixed by locale' do
+
+    describe 'strip default locale from root path' do
+      let(:url) { 'http://models.example.com/de' }
+      it { is_expected.to eq [301, '/'] }
+    end
+
+    describe 'strip default locale' do
+      let(:url) { 'http://models.example.com/de/hello' }
+      it { is_expected.to eq [301, '/hello'] }
+    end
+
+    describe 'strip default locale from root path with query' do
+      let(:url) { 'http://models.example.com/de?this=is_a_param' }
+      it { is_expected.to eq [301, '/?this=is_a_param'] }
+    end
+
+    describe 'strip default locale from path with query' do
+      let(:url) { 'http://models.example.com/de/hello?this=is_a_param' }
+      it { is_expected.to eq [301, '/hello?this=is_a_param'] }
+    end
+
+    describe 'dont strip a non-default locale' do
+      let(:locale)  { 'fr' }
+      let(:url)     { 'http://models.example.com/fr/hello' }
+      it { is_expected.to eq [200, nil] }
+    end
+
+    describe 'dont redirect URL without locale' do
+      let(:locale)          { :de }
+      let(:locale_in_path)  { false }
+      let(:url) { 'http://models.example.com/hello' }
+      it { is_expected.to eq [200, nil] }
+    end
+
+  end
+
+  describe 'prefixed by locale' do
+
+    let(:prefixed) { true }
+
+    describe 'without locale' do
+
+      let(:locale_in_path) { false }
+
+      describe 'add default locale to root path' do
+        let(:url) { 'http://models.example.com/' }
+        it { is_expected.to eq [301, '/de'] }
+      end
+
+      describe 'add default locale to long path' do
+        let(:url) { 'http://models.example.com/hello/world' }
+        it { is_expected.to eq [301, '/de/hello/world'] }
+      end
+
+      describe 'add default locale to url with path and query' do
+        let(:url) { 'http://models.example.com/hello/world?this=is_me' }
+        it { is_expected.to eq [301, '/de/hello/world?this=is_me'] }
+      end
+
+    end
+
+    describe 'with locale' do
+
+      let(:locale_in_path) { true }
+
+      describe 'dont add default locale if already present' do
+        let(:url)    { 'http://models.example.com/de/hello/world' }
+        it { is_expected.to eq [200, nil] }
+      end
+
+      describe 'dont add default locale to localized path' do
+        let(:locale) { 'fr' }
+        let(:url)    { 'http://models.example.com/fr/hello/world' }
+        it { is_expected.to eq [200, nil] }
+      end
+
+    end
+
+  end
+
+end

data/spec/unit/middlewares/renderer_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+require_relative '../../../lib/locomotive/steam/middlewares/threadsafe'
+require_relative '../../../lib/locomotive/steam/middlewares/helpers'
+require_relative '../../../lib/locomotive/steam/middlewares/renderer'
+
+describe Locomotive::Steam::Middlewares::Renderer do
+
+  let(:app) { ->(env) { [200, env, 'app'] }}
+
+  let :middleware do
+    Locomotive::Steam::Middlewares::Renderer.new(app)
+  end
+
+  describe 'missing 404 page' do
+
+    subject do
+      middleware.call env_for('http://www.example.com', { 'steam.page' => nil })
+    end
+
+    specify 'return 200' do
+      code, headers, response = subject
+      expect(code).to eq(404)
+      expect(response).to eq(['Missing 404 page'])
+    end
+
+  end
+
+end

data/spec/unit/middlewares/stack_proxy_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+require_relative '../../../lib/locomotive/steam/middlewares/stack_proxy'
+
+describe Locomotive::Steam::Middlewares::StackProxy do
+
+  let(:klass) { Locomotive::Steam::Middlewares::StackProxy }
+  let(:proxy) { klass.new }
+
+  describe '#initialize' do
+
+    let(:args) { DefaultMiddleware }
+    subject do
+      klass.new { use(DefaultMiddleware) }
+    end
+
+    it 'adds it to the list' do
+      expect(subject.list.size).to eq 1
+      expect(subject.list.first).to eq [[DefaultMiddleware], nil]
+    end
+
+  end
+
+  describe '#use' do
+
+    let(:args) { DefaultMiddleware }
+    before { proxy.use(*args) }
+
+    it 'adds it to the operations' do
+      expect(proxy.list.size).to eq 1
+      expect(proxy.list.first).to eq [[DefaultMiddleware], nil]
+    end
+
+  end
+
+  describe 'manipulating middlewares' do
+
+    before do
+      proxy.use DefaultMiddleware
+      proxy.use SimpleMiddleware
+
+      proxy.insert_before SimpleMiddleware, FooMiddleware
+      proxy.use BarMiddleware, { answer: 42 }
+      proxy.delete SimpleMiddleware
+      proxy.insert_after 1, FancyMiddleware
+    end
+
+    subject { proxy.list }
+
+    it do
+      is_expected.to eq([
+        [[DefaultMiddleware], nil],
+        [[FooMiddleware], nil],
+        [[FancyMiddleware], nil],
+        [[BarMiddleware, { answer: 42 }], nil]
+      ])
+    end
+
+  end
+
+  class SimpleMiddleware; end
+  class DefaultMiddleware; end
+  class FooMiddleware; end
+  class BarMiddleware; end
+  class FancyMiddleware; end
+
+end

data/spec/unit/models/mapper_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Models::Mapper do
+
+  let(:repository)  { instance_double('Repository', base_url: '') }
+  let(:name)        { 'pages' }
+  let(:options)     { { entity: MyPage } }
+  let(:block)       { nil }
+  let(:mapper)      { described_class.new(name, options, repository, &block) }
+
+  describe '#localized attributes' do
+
+    let(:block) { ->(_) { localized_attributes(:foo, :bar) } }
+
+    subject { mapper.localized_attributes }
+    it { is_expected.to eq [:foo, :bar] }
+
+  end
+
+  describe '#to_entity' do
+
+    subject { mapper.to_entity(attributes) }
+
+    describe 'default attributes' do
+
+      let(:attributes) { { title: 'Hello world' } }
+      let(:repository) { instance_double('Repository', my_site: 42, base_url: '') }
+      let(:block) { ->(_) { default_attribute(:site, -> (repository) { repository.my_site }) } }
+
+      it { expect(subject.site).to eq 42 }
+
+    end
+
+    describe 'association' do
+
+      let(:repository)  { instance_double('Repository', scope: 42, base_url: '') }
+      let(:attributes) { { parents: [instance_double('Page', title: 'Hello world')] } }
+      let(:klass) { instance_double('RepositoryKlass')}
+      let(:block) { ->(_) { embedded_association(:parents, BlankRepository) } }
+
+      it { expect(subject.parents).not_to eq nil }
+
+    end
+
+    describe 'localized attributes' do
+
+      let(:block) { ->(_) { localized_attributes(:title) } }
+      let(:attributes) { { title: { 'en' => 'Hello world' } } }
+
+      it { expect(subject.attributes[:title].class).to eq Locomotive::Steam::Models::I18nField }
+      it { expect(subject.attributes[:title][:en]).to eq('Hello world') }
+
+      context 'string value for the localized field' do
+
+        let(:attributes) { { title: 'Hello world' } }
+
+        it { expect(subject.attributes[:title][:en]).to eq('Hello world') }
+        it { expect(subject.attributes[:title][:fr]).to eq('Hello world') }
+
+      end
+
+    end
+
+  end
+
+  class MyPage
+    include Locomotive::Steam::Models::Entity
+    attr_accessor :site
+  end
+
+  class BlankRepository < Struct.new(:adapter)
+    attr_accessor :page, :scope
+  end
+
+end

data/spec/unit/models/pager_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Models::Pager do
+
+  let(:page)        { 1 }
+  let(:per_page)    { 2 }
+  let(:source)      { ['MongoDB', 'Rails', 'Liquid', 'Rack', 'Devise'] }
+  let(:pager)       { described_class.new(source, page, per_page) }
+
+  describe '#collection' do
+
+    subject { pager.collection }
+
+    it { is_expected.to eq ['MongoDB', 'Rails'] }
+
+    describe 'last page' do
+      let(:page) { 3 }
+      it { is_expected.to eq ['Devise'] }
+    end
+
+    describe 'per_page is 1' do
+      let(:per_page) { 1 }
+      it { is_expected.to eq ['MongoDB'] }
+    end
+
+    describe 'per_page is > to the number of total entries' do
+      let(:per_page) { 10 }
+      it { is_expected.to eq ['MongoDB', 'Rails', 'Liquid', 'Rack', 'Devise'] }
+    end
+
+    describe 'page is > to the total number of pages' do
+      let(:page) { 4 }
+      it { is_expected.to eq [] }
+    end
+
+  end
+
+  describe '#previous_page' do
+
+    subject { pager.previous_page }
+
+    it { is_expected.to eq nil }
+
+    describe 'another page' do
+      let(:page) { 2 }
+      it { is_expected.to eq 1 }
+    end
+
+  end
+
+  describe '#next_page' do
+
+    subject { pager.next_page }
+
+    it { is_expected.to eq 2 }
+
+    describe 'another page' do
+      let(:page) { 3 }
+      it { is_expected.to eq nil }
+    end
+
+  end
+
+  describe '#to_liquid' do
+
+    subject { pager.to_liquid }
+
+    it do
+      is_expected.to eq({
+        collection:       ['MongoDB', 'Rails'],
+        current_page:     1,
+        per_page:         2,
+        previous_page:    nil,
+        next_page:        2,
+        total_entries:    5,
+        total_pages:      3
+      })
+    end
+
+  end
+
+end

data/spec/unit/models/repository_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Models::Repository do
+
+  let(:adapter)     { nil }
+  let(:site)        { nil }
+  let(:locale)      { :en }
+  let(:repository)  { ArticleRepository.new(adapter, site, locale) }
+
+  describe '#locale' do
+
+    subject { repository.locale }
+
+    it { is_expected.to eq :en }
+
+    context 'change the locale' do
+
+      before { repository.locale = :fr }
+
+      it { is_expected.to eq :fr }
+
+    end
+
+  end
+
+  describe '#scope' do
+
+    subject { repository.scope }
+
+    it { expect(subject.locale).to eq :en }
+
+    context 'change the locale from the repository' do
+
+      before { subject; repository.locale = :fr }
+
+      it { expect(subject.locale).to eq :fr }
+
+    end
+
+  end
+
+  class ArticleRepository
+    include Locomotive::Steam::Models::Repository
+  end
+
+end

data/spec/unit/models/scope_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Models::Scope do
+
+  let(:site)    { instance_double('Site', _id: 1) }
+  let(:locale)  { :en }
+  let(:context) { nil }
+  let(:scope)   { described_class.new(site, locale, context) }
+
+  describe '#to_key' do
+
+    subject { scope.to_key }
+
+    it { is_expected.to eq 'site_1' }
+
+    context 'with a content type for instance' do
+
+      let(:content_type) { instance_double('ContentType', _id: 42) }
+      let(:context) { { content_type: content_type } }
+
+      it { is_expected.to eq 'site_1_content_type_42' }
+
+    end
+
+  end
+
+end