locomotivecms_steam 1.5.0.beta3 → 1.5.0.rc0

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

@@ -2,7 +2,8 @@ require 'spec_helper'
 
 describe Locomotive::Steam::Liquid::Tags::Section do
 
-  let(:services)      { Locomotive::Steam::Services.build_instance(nil) }
+  let(:request)       { instance_double('Request', env: {}) }
+  let(:services)      { Locomotive::Steam::Services.build_instance(request) }
   let(:finder)        { services.section_finder }
   let(:source)        { 'Locomotive {% section header %}' }
   let(:live_editing)  { true }

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

@@ -2,7 +2,8 @@ require 'spec_helper'
 
 describe Locomotive::Steam::Liquid::Tags::Snippet do
 
-  let(:services)  { Locomotive::Steam::Services.build_instance(nil) }
+  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 %}' }

data/spec/unit/middlewares/auth_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 
 require_relative '../../../lib/locomotive/steam/middlewares/thread_safe'
 require_relative '../../../lib/locomotive/steam/middlewares/concerns/helpers'
+require_relative '../../../lib/locomotive/steam/middlewares/concerns/recaptcha'
 require_relative '../../../lib/locomotive/steam/middlewares/auth'
 
 describe Locomotive::Steam::Middlewares::Auth::AuthOptions do

data/spec/unit/middlewares/entry_submission_spec.rb

@@ -2,38 +2,51 @@ require 'spec_helper'
 
 require_relative '../../../lib/locomotive/steam/middlewares/thread_safe'
 require_relative '../../../lib/locomotive/steam/middlewares/concerns/helpers'
+require_relative '../../../lib/locomotive/steam/middlewares/concerns/recaptcha'
 require_relative '../../../lib/locomotive/steam/middlewares/entry_submission'
 
 describe Locomotive::Steam::Middlewares::EntrySubmission do
 
-  let(:app)         { ->(env) { [200, env, ['app']] } }
-  let(:site)        { instance_double('Site', default_locale: 'en', locales: ['en']) }
-  let(:middleware)  { described_class.new(app) }
-  let(:service)     { instance_double('EntrySubmission') }
-  let(:services)    { instance_double('Services', entry_submission: service, :locale= => 'en') }
-  let(:session)     { {} }
-  let(:method)      { 'POST' }
+  let(:app)                 { ->(env) { [200, env, ['app']] } }
+  let(:site)                { instance_double('Site', default_locale: 'en', locales: ['en']) }
+  let(:middleware)          { described_class.new(app) }
+  let(:recaptcha_enabled)   { false }
+  let(:recaptcha_valid)     { false }
+  let(:content_type)        { instance_double('ContentType', :recaptcha_required? => recaptcha_enabled) }
+  let(:service)             { instance_double('EntrySubmissionService') }
+  let(:entry_service)       { instance_double('EntryService', get_type: content_type) }
+  let(:recaptcha_service)   { instance_double('RecaptchaService', verify: recaptcha_valid) }
+  let(:services)            { instance_double('Services', entry_submission: service, content_entry: entry_service, recaptcha: recaptcha_service, :locale= => 'en') }
+  let(:session)             { {} }
+  let(:method)              { 'POST' }
+  let(:errors)              { instance_double('Error', empty?: false) }
+  let(:entry)               { instance_double('Entry', errors: errors, content_type_slug: 'contacts') }
+  let(:form)                { { content_type_slug: 'contacts', :'g-recaptcha-response' => 'myrecaptchacode', content: { email: 'john@doe.net' } } }
+  let(:rack_env)            { build_env }
 
   before do
     allow_any_instance_of(described_class).to receive(:csrf_field).and_return('csrf_field')
+    allow(service).to receive(:submit).with('contacts', { email: 'john@doe.net' }).and_return(entry)
+    allow(entry_service).to receive(:build).with('contacts', { email: 'john@doe.net' }).and_return(entry)
   end
 
-  describe '#call' do
+  subject do
+    code, env = middleware.call(rack_env)
+    [code, env['steam.liquid_assigns']['contact']]
+  end
 
-    let(:rack_env) { build_env }
+  context 'recaptcha has not been enabled' do
 
-    before do
-      expect(service).to receive(:submit).with('contacts', { email: 'john@doe.net' }).and_return(entry)
+    it 'creates a new entry' do
+      expect(subject.first).to eq 200
+      expect(subject.last).to eq entry
     end
 
-    subject { middleware.call(rack_env) }
-
-    context 'the creation of a content entry returns nil' do
+    context 'the form has not been set up for public submission' do
 
-      let(:form)  { { content_type_slug: 'contacts', content: { email: 'john@doe.net' } } }
       let(:entry) { nil }
 
-      it 'raises an exception' do
+      it 'raises an exception with an explicit error message' do
         expect { subject }.to raise_exception('Unknown content type "contacts" or public_submission_enabled property not true')
       end
 
@@ -41,12 +54,43 @@ describe Locomotive::Steam::Middlewares::EntrySubmission do
 
   end
 
+  context 'recaptcha has been enabled' do
+
+    let(:recaptcha_enabled) { true }
+
+    context 'the recaptcha response is valid' do
+
+      let(:recaptcha_valid) { true }
+
+      it 'creates a new entry' do
+        expect(recaptcha_service).to receive(:verify).with('myrecaptchacode').and_return(true)
+        expect(subject.first).to eq 200
+        expect(subject.last).to eq entry
+      end
+
+    end
+
+    context 'the recaptcha response is invalid' do
+
+      let(:recaptcha_valid) { false }
+
+      it 'returns a 200 code with the invalid entry' do
+        expect(errors).to receive(:add).with(:recaptcha_invalid, true)
+        expect(subject.first).to eq 200
+        expect(subject.last).to eq entry
+      end
+
+    end
+
+  end
+
   def build_env
     env_for('http://example.com/contact-us', params: form, method: method).tap do |env|
-      env['steam.request']    = Rack::Request.new(env)
-      env['steam.site']       = site
-      env['steam.services']   = services
-      env['rack.session']     = session
+      env['steam.request']        = Rack::Request.new(env)
+      env['steam.site']           = site
+      env['steam.services']       = services
+      env['rack.session']         = session
+      env['steam.liquid_assigns'] = {}
     end
   end
 

data/spec/unit/middlewares/helpers_spec.rb

@@ -42,7 +42,11 @@ describe Locomotive::Steam::Middlewares::Concerns::Helpers do
 
     context 'mounted_on is not blank' do
 
-      before { allow(instance).to receive(:mounted_on).and_return('/my_app') }
+      before do
+        allow(instance).to receive(:mounted_on).and_return('/my_app')
+        allow(instance).to receive(:inject_cookies).and_return(nil)
+      end
+
 
       let(:location) { '/foo/bar' }
       it { is_expected.to eq '/my_app/foo/bar' }

data/spec/unit/middlewares/impersonated_entry_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+require_relative '../../../lib/locomotive/steam/middlewares/concerns/helpers'
+require_relative '../../../lib/locomotive/steam/middlewares/concerns/auth_helpers'
+require_relative '../../../lib/locomotive/steam/middlewares/thread_safe'
+require_relative '../../../lib/locomotive/steam/middlewares/impersonated_entry'
+
+describe Locomotive::Steam::Middlewares::ImpersonatedEntry do
+
+  let(:site)            { instance_double('Site', _id: 42) }
+  let(:url)             { 'http://models.example.com' }
+  let(:app)             { ->(env) { [200, env, ['<html><body></body></html>']] } }
+  let(:entry)           { nil }
+  let(:session)         { {} }
+  let(:params)          { {} }
+  let(:middleware)      { described_class.new(app) }
+
+  subject do
+    code, env, body = call
+    [env['steam.impersonating_authenticated_entry'], body.first]
+  end
+
+  describe 'no impersonation' do
+
+    it { is_expected.to eq [nil, '<html><body></body></html>'] }
+
+  end
+
+  describe 'impersonating is on' do
+
+    let(:session) { { authenticated_impersonation: '1', authenticated_entry_type: 'accounts' } }
+
+    context 'the account is not logged in' do
+
+      it { is_expected.to eq [nil, '<html><body></body></html>'] }
+
+    end
+
+    context 'the account is logged in' do
+
+      let(:entry) { instance_double('Account', _label: 'John') }
+
+      it { expect(subject.first).to eq true }
+      it { expect(subject.last.gsub(/\s*\n\s+/, ' ')).to include('<body><div class="locomotive-impersonating-banner" ') }
+
+    end
+
+    describe 'the administrator wants to leave the impersonating mode' do
+
+      let(:entry) { instance_double('Account', _label: 'John') }
+      let(:params) { { impersonating: 'stop' } }
+
+      subject do
+        code, env, body = call
+        [code, env['steam.impersonating_authenticated_entry'], env['Location']]
+      end
+
+      it { is_expected.to eq [302, nil, '/'] }
+
+      it "resets the session variable used to tell if we're in the impersonating mode" do
+        subject
+        expect(session[:authenticated_impersonation]).to eq '0'
+      end
+
+    end
+
+  end
+
+  def call
+    env = env_for(url, params: params)
+    env['rack.session']               = session
+    env['steam.site']                 = site
+    env['steam.path']                 = '/'
+    env['steam.request']              = Rack::Request.new(env)
+    env['steam.liquid_assigns']       = {}
+    env['steam.authenticated_entry']  = entry
+    middleware.call(env)
+  end
+
+end

data/spec/unit/middlewares/locale_spec.rb

@@ -9,94 +9,115 @@ describe Locomotive::Steam::Middlewares::Locale do
   let(:site)            { instance_double('Site', default_locale: :de, locales: [:de, :fr, :en]) }
   let(:url)             { 'http://models.example.com' }
   let(:app)             { ->(env) { [200, env, 'app'] } }
-  let(:services)        { instance_double('Services', :locale= => 'en') }
+  let(:cookie_lang)     { nil }
+  let(:cookie_service)  { instance_double('Cookie Service', :get => cookie_lang) }
+  let(:services)        { instance_double('Services', :locale= => 'en', :cookie => cookie_service) }
   let(:middleware)      { Locomotive::Steam::Middlewares::Locale.new(app) }
-  let(:session)         { {} }
   let(:accept_language) { '' }
 
   subject do
     env = env_for(
         url,
         'steam.site' => site,
-        'rack.session' => session,
         'HTTP_ACCEPT_LANGUAGE' => accept_language)
     env['steam.request']  = Rack::Request.new(env)
     env['steam.services'] = services
+    env['steam.locale']
     code, env = middleware.call(env)
-    [env['steam.locale'], session['steam-locale']&.to_sym, env['steam.path']]
+    [env['steam.locale'], env['steam.path']]
   end
 
-  describe 'locale defined in the path' do
+  describe 'whatever url' do
 
-    let(:url) { 'http://models.example.com/de/hello-de/foo' }
+    let(:url) { 'http://models.example.com/whatever' }
 
-    it { is_expected.to eq [:de, :de, '/hello-de/foo'] }
+    it 'should set the cookies' do
+       expect(cookie_service).to receive(:set).with('steam-locale', {
+           value: :de,
+           path: '/',
+           max_age: 1.year
+       }).and_return(nil)
+       is_expected.to eq [:de,  '/whatever']
+    end
 
   end
 
-  describe 'no locale defined in the path' do
+  describe 'browse site with' do
 
-    describe 'first connexion' do
+    before { allow(cookie_service).to receive(:set).and_return(nil) }
 
-      context 'without accept-language header' do
+    describe 'locale defined in the path' do
 
-        it { is_expected.to eq [:de, :de, '/'] }
+      let(:url) { 'http://models.example.com/de/hello-de/foo' }
 
-      end
+      it { is_expected.to eq [:de, '/hello-de/foo'] }
+
+    end
+
+    describe 'no locale defined in the path' do
+
+      describe 'first connexion' do
+
+        context 'without accept-language header' do
+
+          it { is_expected.to eq [:de, '/'] }
+
+        end
 
-      context 'with accept-language header' do
+        context 'with accept-language header' do
 
-        let(:accept_language) { 'fr-FR,fr;q=0.9,en-US;q=0.8,en;q=0.7' }
+          let(:accept_language) { 'fr-FR,fr;q=0.9,en-US;q=0.8,en;q=0.7' }
 
-        it { is_expected.to eq [:fr, :fr, '/'] }
+          it { is_expected.to eq [:fr,  '/'] }
 
-        context 'with url path' do
+          context 'with url path' do
 
-          let(:url) { 'http://models.example.com/werkzeug' }
+            let(:url) { 'http://models.example.com/werkzeug' }
 
-          it { is_expected.to eq [:de, :de, '/werkzeug'] }
+            it { is_expected.to eq [:de, '/werkzeug'] }
+
+          end
 
         end
 
       end
 
-    end
+      context 'user with cookie, use it' do
 
-    context 'user with session, use it' do
+        let(:cookie_lang) { 'en' }
 
-      let(:session) { {'steam-locale' => 'en'} }
+        it { is_expected.to eq [:en, '/'] }
 
-      it { is_expected.to eq [:en, :en, '/'] }
+      end
 
     end
 
-  end
+    describe 'locale asked in the request params' do
 
-  describe 'locale asked in the request params' do
+      context 'the locale is blank' do
 
-    context 'the locale is blank' do
+        let(:url) { 'http://models.example.com?locale=' }
 
-      let(:url) { 'http://models.example.com?locale=' }
+        it { is_expected.to eq [:de, '/'] }
 
-      it { is_expected.to eq [:de, :de, '/'] }
+      end
 
-    end
+      context 'the locale exists' do
 
-    context 'the locale exists' do
+        let(:url) { 'http://models.example.com?locale=en' }
 
-      let(:url) { 'http://models.example.com?locale=en' }
+        it { is_expected.to eq [:en, '/'] }
 
-      it { is_expected.to eq [:en, :en, '/'] }
+      end
 
-    end
+      context 'the locale is unknown' do
 
-    context 'the locale is unknown' do
+        let(:url) { 'http://models.example.com?locale=onload' }
 
-      let(:url) { 'http://models.example.com?locale=onload' }
+        it { is_expected.to eq [:de, '/'] }
 
-      it { is_expected.to eq [:de, :de, '/'] }
+      end
 
     end
-
   end
 end

data/spec/unit/middlewares/section_spec.rb

@@ -27,11 +27,12 @@ describe Locomotive::Steam::Middlewares::Section do
                         }
 
   before do
-    env['steam.page']           = page
-    env['steam.services']       = services
-    env['steam.locale']         = :en
-    env['steam.liquid_assigns'] = {}
-    env['steam.request']        = Rack::Request.new(env)
+    env['steam.page']             = page
+    env['steam.services']         = services
+    env['steam.locale']           = :en
+    env['steam.liquid_registers'] = {}
+    env['steam.liquid_assigns']   = {}
+    env['steam.request']          = Rack::Request.new(env)
     env['steam.request'].add_header('HTTP_LOCOMOTIVE_SECTION_TYPE', 'header')
     allow(section_finder).to receive(:find).with('header').and_return(section)
   end

data/spec/unit/middlewares/site_spec.rb

@@ -10,6 +10,7 @@ describe Locomotive::Steam::Middlewares::Site do
   let(:configuration)   { instance_double('SimpleConfiguration', render_404_if_no_site: render_404) }
   let(:services)        { instance_double('SimpleServices', configuration: configuration) }
   let(:url)             { 'http://models.example.com' }
+  let(:engine_site)     { nil }
   let(:app)             { ->(env) { [200, env, 'app'] } }
   let(:middleware)      { Locomotive::Steam::Middlewares::Site.new(app) }
   let(:is_default_host) { nil }
@@ -17,6 +18,7 @@ describe Locomotive::Steam::Middlewares::Site do
   subject do
     env = env_for(url, 'steam.services' => services)
     env['steam.request']          = Rack::Request.new(env)
+    env['steam.site']             = engine_site
     env['steam.is_default_host']  = is_default_host
     code, env = middleware.call(env)
     [code, env['Location']]
@@ -42,6 +44,17 @@ describe Locomotive::Steam::Middlewares::Site do
 
   end
 
+  describe 'the site has been set from the Engine' do
+
+    let(:engine_site) { instance_double('SiteWithDomains', name: 'Acme', domains: ['www.acme.com'], redirect_to_first_domain: false, redirect_to_https: false) }
+
+    it 'sets the site for all the services' do
+      expect(services).to receive(:set_site).with(engine_site).and_return(engine_site)
+      is_expected.to eq [200, nil]
+    end
+
+  end
+
   describe 'redirection' do
 
     let(:redirect_to_first_domain)  { false }

data/spec/unit/services/action_service_spec.rb

@@ -2,13 +2,14 @@ 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(:api_service)   { instance_double('ExternalAPIService') }
+  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(:api_service)    { instance_double('ExternalAPIService') }
   let(:redirection_service) { instance_double('PageRedirectionService') }
-  let(:service)       { described_class.new(site, email_service, content_entry: entry_service, api: api_service, redirection: redirection_service) }
+  let(:cookie_service) { instance_double('CookieService') }
+  let(:service)        { described_class.new(site, email_service, content_entry: entry_service, api: api_service, redirection: redirection_service, cookie: cookie_service) }
 
   describe '#run' do
 
@@ -115,18 +116,23 @@ describe Locomotive::Steam::ActionService do
 
       describe 'getCookiesProp' do
 
-        let(:cookies) { { 'name' => 'John' } }
         let(:script) { "return getCookiesProp('name');" }
 
-        it { is_expected.to eq 'John' }
+        it 'should read in the cookie name and return John' do
+          expect(cookie_service).to receive(:get).with('name').and_return('John')
+          is_expected.to eq('John')
+        end
 
       end
 
-      describe 'sendCookiesProp' do
+      describe 'setCookiesProp' do
 
-        let(:script) { "return setCookiesProp('done', true);" }
+        let(:script) { "return setCookiesProp('done', {'value': true});" }
 
-        it { subject; expect(cookies['done']).to eq 'true' }
+        it 'should set the cookie done with the value true' do
+          expect(cookie_service).to receive(:set).with('done', {'value' => true})
+          is_expected.to eq(nil)
+        end
 
       end