locomotivecms_steam 1.1.2 → 1.2.0.beta1

data/spec/unit/middlewares/site_spec.rb

@@ -42,38 +42,91 @@ describe Locomotive::Steam::Middlewares::Site do
 
   end
 
-  describe 'redirection to the first domain' do
+  describe 'redirection' do
 
-    let(:redirect_to_first_domain) { false }
+    let(:redirect_to_first_domain)  { false }
+    let(:redirect_to_https)         { false }
     let(:url)  { 'http://acme.com' }
-    let(:site) { instance_double('SiteWithDomains', name: 'Acme', domains: ['www.acme.com', 'acme.com'], redirect_to_first_domain: redirect_to_first_domain) }
+    let(:site) { instance_double('SiteWithDomains', name: 'Acme', domains: ['www.acme.com', 'acme.com'], redirect_to_first_domain: redirect_to_first_domain, redirect_to_https: redirect_to_https) }
 
     before { expect(services).to receive(:current_site).and_return(site) }
 
-    it { is_expected.to eq [200, nil] }
+    describe 'redirection to https' do
 
-    describe 'option enabled' do
+      it { is_expected.to eq [200, nil] }
 
-      let(:redirect_to_first_domain) { true }
+      describe 'option enabled' do
 
-      it { is_expected.to eq [301, 'http://www.acme.com/'] }
+        let(:redirect_to_https) { true }
 
-      context 'first domain requested' do
+        it { is_expected.to eq [301, 'https://www.acme.com/'] }
 
-        let(:url) { 'http://www.acme.com' }
-        it { is_expected.to eq [200, nil] }
+        context 'https requested' do
+
+          let(:url) { 'https://www.acme.com' }
+          it { is_expected.to eq [200, nil] }
+
+        end
+
+        context 'requesting the default host' do
+
+          let(:is_default_host) { true }
+          it { is_expected.to eq [200, nil] }
+
+        end
 
       end
 
-      context 'requesting the default host' do
+    end
+
+    describe 'redirection to the first domain' do
+
+      it { is_expected.to eq [200, nil] }
+
+      describe 'option enabled' do
+
+        let(:redirect_to_first_domain) { true }
+
+        it { is_expected.to eq [301, 'http://www.acme.com/'] }
+
+        context 'first domain requested' do
+
+          let(:url) { 'http://www.acme.com' }
+          it { is_expected.to eq [200, nil] }
 
-        let(:is_default_host) { true }
-        it { is_expected.to eq [200, nil] }
+        end
+
+        context 'requesting the default host' do
+
+          let(:is_default_host) { true }
+          it { is_expected.to eq [200, nil] }
+
+        end
 
       end
 
     end
 
+    describe 'redirection to both https and the first domain' do
+
+      let(:redirect_to_https)         { true }
+      let(:redirect_to_first_domain)  { true }
+      let(:url) { 'http://acme.com/foo/bar' }
+
+      it { is_expected.to eq [301, 'https://www.acme.com/foo/bar'] }
+
+    end
+
+    describe 'redirection to the first domain' do
+
+      let(:redirect_to_https)         { true }
+      let(:redirect_to_first_domain)  { true }
+      let(:url) { 'https://acme.com/foo/bar' }
+
+      it { is_expected.to eq [301, 'https://www.acme.com/foo/bar'] }
+
+    end
+
   end
 
 end

data/spec/unit/middlewares/sitemap_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+require_relative '../../../lib/locomotive/steam/middlewares/thread_safe'
+require_relative '../../../lib/locomotive/steam/middlewares/helpers'
+require_relative '../../../lib/locomotive/steam/middlewares/sitemap'
+
+describe Locomotive::Steam::Middlewares::Sitemap do
+
+  let(:pages)           { [] }
+  let(:page_repository) { instance_double('PageRepository', published: pages) }
+  let(:app)             { ->(env) { [200, env, 'app'] }}
+  let(:middleware)      { described_class.new(app) }
+
+  before do
+    allow_any_instance_of(described_class).to receive(:base_url).and_return('http://localhost/')
+    allow_any_instance_of(described_class).to receive(:page_repository).and_return(page_repository)
+  end
+
+  describe '#call' do
+
+    let(:env) { { 'PATH_INFO' => '/sitemap.xml', 'steam.page' => nil } }
+    subject { middleware.call(env) }
+
+    describe 'no pages' do
+
+      it 'renders a blank sitemap' do
+        is_expected.to eq [200, { "Content-Type"=>"text/plain" }, ["<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">\n  <url>\n    <loc>http://localhost/</loc>\n    <priority>1.0</priority>\n  </url>\n\n</urlset>\n"]]
+      end
+
+    end
+
+    describe 'only layouts' do
+
+      let(:pages) { [instance_double('Page', index?: false, not_found?: false, layout?: true)] }
+
+      it 'renders a blank sitemap' do
+        is_expected.to eq [200, { "Content-Type"=>"text/plain" }, ["<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">\n  <url>\n    <loc>http://localhost/</loc>\n    <priority>1.0</priority>\n  </url>\n\n</urlset>\n"]]
+      end
+
+    end
+
+  end
+
+end

data/spec/unit/models/i18n_field_spec.rb

@@ -22,4 +22,27 @@ describe Locomotive::Steam::Models::I18nField do
 
   end
 
+  describe '#dup' do
+
+    let(:translations) { { en: 'Hello world', fr: nil } }
+
+    subject { field.dup }
+
+    it 'gets a fresh copy of the translations' do
+      expect(subject[:en]).to eq 'Hello world'
+      expect(subject.translations.object_id).not_to eq field.translations.object_id
+    end
+
+  end
+
+  describe '#to_json' do
+
+    let(:translations) { { en: 'Hello world', fr: nil } }
+
+    subject { field.to_json }
+
+    it { is_expected.to eq("{\"en\":\"Hello world\",\"fr\":null}") }
+
+  end
+
 end

data/spec/unit/repositories/content_entry_repository_spec.rb

@@ -4,7 +4,7 @@ require_relative '../../../lib/locomotive/steam/adapters/filesystem.rb'
 
 describe Locomotive::Steam::ContentEntryRepository do
 
-  let(:_fields) { instance_double('Fields', selects: [], belongs_to: [], many_to_many: []) }
+  let(:_fields) { instance_double('Fields', selects: [], belongs_to: [], many_to_many: [], dates_and_date_times: []) }
   let(:type)    { build_content_type('Articles', label_field_name: :title, localized_names: [:title], fields: _fields, fields_by_name: { title: instance_double('Field', name: :title, type: :string) }, fields_with_default: []) }
   let(:entries) { [{ content_type_id: 1, _position: 0, _label: 'Update #1', title: { fr: 'Mise a jour #1' }, text: { en: 'added some free stuff', fr: 'phrase FR' }, date: '2009/05/12', category: 'General' }] }
   let(:locale)  { :en }
@@ -274,7 +274,7 @@ describe Locomotive::Steam::ContentEntryRepository do
     let(:other_type)    { build_content_type('Authors', _id: 2, label_field_name: :name, fields: _fields, fields_by_name: { name: instance_double('Field', name: :name, type: :string) }, fields_with_default: []) }
     let(:other_entries) { [{ content_type_id: 2, _id: 'john-doe', name: 'John Doe' }] }
 
-    let(:type_repository) { instance_double('ArticleBelongsToRepository', selects: [], belongs_to: [], many_to_many: []) }
+    let(:type_repository) { instance_double('ArticleBelongsToRepository', selects: [], belongs_to: [], many_to_many: [], dates_and_date_times: []) }
 
     before do
       allow(type).to receive(:fields).and_return(type_repository)
@@ -307,7 +307,7 @@ describe Locomotive::Steam::ContentEntryRepository do
         ]
       }
 
-    let(:type_repository) { instance_double('AuthorRepository', selects: [], belongs_to: [], many_to_many: []) }
+    let(:type_repository) { instance_double('AuthorRepository', selects: [], belongs_to: [], many_to_many: [], dates_and_date_times: []) }
 
     before do
       allow(type).to receive(:fields).and_return(type_repository)
@@ -340,7 +340,7 @@ describe Locomotive::Steam::ContentEntryRepository do
         ]
       }
 
-    let(:type_repository) { instance_double('AuthorRepository', selects: [], belongs_to: [], many_to_many: []) }
+    let(:type_repository) { instance_double('AuthorRepository', selects: [], belongs_to: [], many_to_many: [], dates_and_date_times: []) }
 
     before do
       allow(type).to receive(:fields).and_return(type_repository)
@@ -373,18 +373,42 @@ describe Locomotive::Steam::ContentEntryRepository do
       let(:option)      { instance_double('Option', _id: 42)}
       let(:options)     { instance_double('OptionRepository', by_name: option) }
       let(:field)       { instance_double('SelectField', name: 'category', persisted_name: 'category_id', select_options: options) }
-      let(:_fields)     { instance_double('Fields', selects: [field], belongs_to: [], many_to_many: []) }
+      let(:_fields)     { instance_double('Fields', selects: [field], belongs_to: [], many_to_many: [], dates_and_date_times: []) }
       let(:conditions)  { { 'category' => value } }
 
       it { is_expected.to eq([{ _visible: true, content_type_id: 1, 'category_id' => 42 }, nil]) }
 
     end
 
+    context 'date fields' do
+
+      let(:value)       { '2009/09/10' }
+      let(:field)       { instance_double('DateField', name: 'launched_at', persisted_name: 'launched_at', type: :date) }
+      let(:_fields)     { instance_double('Fields', selects: [], belongs_to: [], many_to_many: [], dates_and_date_times: [field]) }
+      let(:conditions)  { { 'launched_at' => value } }
+
+      it { is_expected.to eq([{ _visible: true, content_type_id: 1, 'launched_at' => Date.parse('2009/09/10') }, nil]) }
+
+    end
+
+    context 'date time fields' do
+
+      before { Time.zone = 'Paris' }
+
+      let(:value)       { '2007/06/29 21:15:00' }
+      let(:field)       { instance_double('DateField', name: 'launched_at', persisted_name: 'launched_at', type: :date_time) }
+      let(:_fields)     { instance_double('Fields', selects: [], belongs_to: [], many_to_many: [], dates_and_date_times: [field]) }
+      let(:conditions)  { { 'launched_at' => value } }
+
+      it { is_expected.to eq([{ _visible: true, content_type_id: 1, 'launched_at' => Time.zone.parse('2007/06/29 21:15:00').to_datetime }, nil]) }
+
+    end
+
     context 'belongs_to fields' do
 
       let(:value)       { 42 }
       let(:field)       { instance_double('BelongsToField', name: 'person', persisted_name: 'person_id') }
-      let(:_fields)     { instance_double('Fields', selects: [], belongs_to: [field], many_to_many: []) }
+      let(:_fields)     { instance_double('Fields', selects: [], belongs_to: [field], many_to_many: [], dates_and_date_times: []) }
       let(:conditions)  { { 'person' => value } }
 
       it { is_expected.to eq([{ _visible: true, content_type_id: 1, 'person_id' => 42 }, nil]) }
@@ -397,6 +421,14 @@ describe Locomotive::Steam::ContentEntryRepository do
 
       end
 
+      context 'the target is a hash' do
+
+        let(:value) { { '_id' => 42 } }
+
+        it { is_expected.to eq([{ _visible: true, content_type_id: 1, 'person_id' => 42 }, nil]) }
+
+      end
+
       context 'the target value is an arry of content entry' do
 
         let(:value) { [instance_double('TargetContentEntry', _id: 1), instance_double('TargetContentEntry', _id: 2)] }
@@ -419,7 +451,7 @@ describe Locomotive::Steam::ContentEntryRepository do
 
       let(:value)       { 42 }
       let(:field)       { instance_double('ManyToManyField', name: 'tags', persisted_name: 'tag_ids') }
-      let(:_fields)     { instance_double('Fields', selects: [], belongs_to: [], many_to_many: [field]) }
+      let(:_fields)     { instance_double('Fields', selects: [], belongs_to: [], many_to_many: [field], dates_and_date_times: []) }
       let(:conditions)  { { 'tags.in' => value } }
 
       it { is_expected.to eq([{ _visible: true, content_type_id: 1, 'tag_ids.in' => [42] }, nil]) }

data/spec/unit/repositories/content_type_field_repository_spec.rb

@@ -70,4 +70,14 @@ describe Locomotive::Steam::ContentTypeFieldRepository do
 
   end
 
+  describe '#dates_and_date_times' do
+
+    let(:collection)  { [{ name: 'name', type: 'string' }, { name: 'launched_at', type: 'date' }, { name: 'updated_at', type: 'date_time' }] }
+
+    subject { repository.dates_and_date_times }
+
+    it { expect(subject.map(&:name)).to eq(['launched_at', 'updated_at']) }
+
+  end
+
 end

data/spec/unit/services/action_service_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::ActionService do
+
+  let(:site_hash)     { { 'name' => 'Acme Corp' } }
+  let(:site)          { instance_double('Site', as_json: site_hash ) }
+  let(:email_service) { instance_double('EmailService') }
+  let(:entry_service) { instance_double('ContentService') }
+  let(:service)       { described_class.new(site, email_service, entry_service) }
+
+  describe '#run' do
+
+    let(:script)  { 'return 1 + 1;' }
+    let(:params)  { {} }
+    let(:assigns) { {} }
+    let(:session) { {} }
+    let(:context) { ::Liquid::Context.new(assigns, {}, { session: session }) }
+
+    subject { service.run(script, params, context) }
+
+    it { is_expected.to eq 2.0 }
+
+    describe 'with params' do
+
+      let(:params)  { { 'foo' => 'hello' } }
+      let(:script)  { "return params.foo + ' world';" }
+
+      it { is_expected.to eq 'hello world' }
+
+      describe "messing with params" do
+
+        let(:script)  { "params.foo += ' world!';" }
+
+        it { is_expected.to eq nil }
+
+        it "can't change a param value" do
+          subject
+          expect(params['foo']).to eq 'hello'
+        end
+
+      end
+
+    end
+
+    describe 'built-in functions / getters / setters' do
+
+      describe 'site' do
+
+        let(:script) { 'return "Name: " + site.name;' }
+
+        it { is_expected.to eq 'Name: Acme Corp' }
+
+      end
+
+      describe 'getProp' do
+
+        let(:assigns) { { 'name' => 'John' } }
+        let(:script) { "return getProp('name');" }
+
+        it { is_expected.to eq 'John' }
+
+      end
+
+      describe 'setProp' do
+
+        let(:script) { "return setProp('done', true);" }
+
+        it { subject; expect(context['done']).to eq true }
+
+      end
+
+      describe 'getSessionProp' do
+
+        let(:session) { { name: 'John' } }
+        let(:script) { "return getSessionProp('name');" }
+
+        it { is_expected.to eq 'John' }
+
+      end
+
+      describe 'sendSessionProp' do
+
+        let(:script) { "return setSessionProp('done', true);" }
+
+        it { subject; expect(session[:done]).to eq true }
+
+      end
+
+      describe 'allEntries' do
+
+        let(:now)     { Time.use_zone('America/Chicago') { Time.zone.local(2015, 'mar', 25, 10, 0) } }
+        let(:assigns) { { 'now' => now } }
+        let(:script) {
+          <<-JS
+            var entries = allEntries('bands', { 'created_at.lte': getProp('now'), published: true });
+            var names = []
+
+            for (var i = 0; i < entries.length; i++) {
+              names.push(entries[i].name)
+            }
+
+            return names.join(', ')
+          JS
+        }
+
+        before do
+          expect(entry_service).to receive(:all).with('bands', { "created_at.lte" => "2015-03-25T10:00:00.000-05:00", "published" => true }, true).and_return([
+            { 'name' => 'Pearl Jam' },
+            { 'name' => 'Nirvana' },
+            { 'name' => 'Soundgarden' }
+          ])
+        end
+
+        it { is_expected.to eq('Pearl Jam, Nirvana, Soundgarden') }
+
+      end
+
+      describe 'findEntry' do
+
+        let(:script) { "return findEntry('bands', '42').name;" }
+
+        before do
+          expect(entry_service).to receive(:find).with('bands', '42', true).and_return('name' => 'Pearl Jam')
+        end
+
+        it { is_expected.to eq('Pearl Jam') }
+
+      end
+
+      describe 'createEntry' do
+
+        let(:script) { "return createEntry('bands', { name: 'Pearl Jam'}).name;" }
+
+        before do
+          expect(entry_service).to receive(:create).with('bands', { 'name' => 'Pearl Jam' }, true).and_return('name' => 'Pearl Jam')
+        end
+
+        it { is_expected.to eq('Pearl Jam') }
+
+      end
+
+      describe 'updateEntry' do
+
+        let(:script) { "return updateEntry('bands', 'pearl-jam', { name: 'Pearl Jam'}).name;" }
+
+        before do
+          expect(entry_service).to receive(:update).with('bands', 'pearl-jam', { 'name' => 'Pearl Jam' }, true).and_return('name' => 'Pearl Jam')
+        end
+
+        it { is_expected.to eq('Pearl Jam') }
+
+      end
+
+      describe 'sendEmail' do
+
+        let(:params) { { 'to' => 'estelle@locomotivecms.com' } }
+        let(:script) { "sendEmail({ to: params.to, from: 'did@locomotivecms.com', subject: 'Happy Easter' })" }
+
+        it 'forwards the action to the email service' do
+          expect(email_service).to receive(:send_email).with({
+            'to'      => 'estelle@locomotivecms.com',
+            'from'    => 'did@locomotivecms.com',
+            'subject' => 'Happy Easter' }, context)
+          subject
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/unit/services/content_entry_service_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::ContentEntryService do
+
+  let(:site)              { instance_double('Site', default_locale: 'en') }
+  let(:locale)            { 'en' }
+  let(:type_repository)   { instance_double('ContentTypeRepository') }
+  let(:entry_repository)  { instance_double('Repository', site: site, locale: locale, content_type_repository: type_repository) }
+  let(:service)           { described_class.new(type_repository, entry_repository, locale) }
+
+  before { allow(entry_repository).to receive(:with).and_return(entry_repository) }
+
+  describe '#validate' do
+
+    let(:attributes)        { { title: 'Hello world' } }
+    let(:unique_fields)     { {} }
+    let(:first_validation)  { false }
+    let(:errors)            { [:title] }
+    let(:type)              { instance_double('Comments') }
+    let(:entry)             { instance_double('Entry', title: 'Hello world', content_type: type, valid?: first_validation, errors: errors, attributes: { title: 'Hello world' }, localized_attributes: []) }
+
+    before do
+      allow(type_repository).to receive(:by_slug).and_return(type)
+      allow(type_repository).to receive(:look_for_unique_fields).and_return(unique_fields)
+      allow(entry_repository).to receive(:build).with(attributes).and_return(entry)
+    end
+
+    subject { service.send(:validate, entry_repository, entry) }
+
+    context 'valid' do
+
+      let(:first_validation) { true }
+      let(:errors) { {} }
+
+      it { is_expected.to eq true }
+      it { subject; expect(entry.errors.empty?).to eq true }
+
+    end
+
+    context 'not valid' do
+
+      it { is_expected.to eq false }
+      it { subject; expect(entry.errors).to eq([:title]) }
+
+      context 'with unique fields' do
+
+        let(:unique_fields) { { title: instance_double('Field', name: 'title') } }
+
+        before do
+          allow(entry_repository).to receive(:exists?).with(title: 'Hello world').and_return(true)
+          expect(entry.errors).to receive(:add).with(:title, :unique).and_return(true)
+        end
+
+        it { is_expected.to eq false }
+        it { subject; expect(entry.errors).to eq([:title]) }
+
+      end
+
+    end
+
+  end
+
+end