alchemy_cms 2.9.1 → 3.0.0.rc5

data/spec/controllers/base_controller_spec.rb

@@ -1,119 +1,27 @@
 require 'spec_helper'
 
-# Here's a tiny custom matcher making it a bit easier to check the
-# current session for a language configuration.
-#
-RSpec::Matchers.define :include_language_information_for do |expected|
-  match do |actual|
-    actual[:language_id] == expected.id && actual[:language_code] == expected.code
-  end
-end
-
 module Alchemy
   describe BaseController do
 
-    let(:default_language) { Language.get_default }
-    let(:klingonian) { FactoryGirl.create(:klingonian) }
-
-    describe "#set_language" do
-
-      context "with a Language argument" do
-        it "should set the language to the passed Language instance" do
-          controller.send :set_language, klingonian
-          assigns(:language).should == klingonian
-        end
-      end
-
-      context "with a language id argument" do
-        it "should set the language to the language specified by the passed id" do
-          controller.send :set_language, klingonian.id
-          assigns(:language).should == klingonian
-        end
-      end
+    describe '#set_locale' do
+      context 'with Language.current set' do
+        let(:language) { create(:klingonian) }
 
-      context "with a language code argument" do
-        it "should set the language to the language specified by the passed code" do
-          controller.send :set_language, klingonian.code
-          assigns(:language).should == klingonian
-        end
-      end
-
-      context "with no lang param" do
-
-        it "should set the default language" do
-          controller.stub(:params).and_return({})
-          controller.send :set_language
-          assigns(:language).should == default_language
-          controller.session.should include_language_information_for(default_language)
-        end
-
-      end
-
-      context "with language set in the session" do
-        before do
-          controller.stub(:session).and_return(language_id: klingonian.id, language_code: klingonian.code)
-        end
+        before { Alchemy::Language.current = language }
 
-        it "should use the language set in the session cookie" do
-          controller.send :set_language
-          assigns(:language).should == klingonian
+        it "sets the ::I18n.locale to current language code" do
+          controller.send(:set_locale)
+          expect(::I18n.locale).to eq(language.code.to_sym)
         end
       end
 
-      context "with lang param" do
+      context 'without Language.current set' do
+        before { Alchemy::Language.current = nil }
 
-        it "should set the language" do
-          controller.stub(:params).and_return(:lang => klingonian.code)
-          controller.send :set_language
-          assigns(:language).should == klingonian
-          controller.session.should include_language_information_for(klingonian)
+        it "sets the ::I18n.locale to default language code" do
+          controller.send(:set_locale)
+          expect(::I18n.locale).to eq(Language.default.code.to_sym)
         end
-
-        context "for language that does not exist" do
-
-          before do
-            controller.stub(:params).and_return(:lang => 'fo')
-            controller.send :set_language
-          end
-
-          it "should set the language to default" do
-            assigns(:language).should == default_language
-            controller.session.should include_language_information_for(default_language)
-          end
-
-          it "should set the rails locale to default language code" do
-            ::I18n.locale.should == default_language.code.to_sym
-          end
-
-          it "should not set the rails locale to requested locale" do
-            ::I18n.locale.should_not == :fo
-          end
-
-        end
-
-      end
-
-    end
-
-    describe "#layout_for_page" do
-      it "should return false if params[:layout] is set to false" do
-        controller.stub(:params).and_return(layout: 'false')
-        expect(controller.send(:layout_for_page)).to be_false
-      end
-
-      it "should return false if params[:layout] is set to none" do
-        controller.stub(:params).and_return(layout: 'none')
-        expect(controller.send(:layout_for_page)).to be_false
-      end
-
-      it "should return the layout name set through params[:layout]" do
-        controller.stub(:params).and_return(layout: 'my_layout')
-        expect(controller.send(:layout_for_page)).to eq('my_layout')
-      end
-
-      it "should return 'application' if params[:layout] is not set" do
-        controller.stub(:params).and_return({})
-        expect(controller.send(:layout_for_page)).to eq('application')
       end
     end
 

data/spec/controllers/elements_controller_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 
 module Alchemy
   describe ElementsController do
-
     let(:public_page)         { FactoryGirl.create(:public_page) }
     let(:element)             { FactoryGirl.create(:element, :page => public_page, :name => 'download') }
     let(:restricted_page)     { FactoryGirl.create(:public_page, :restricted => true) }
@@ -31,10 +30,8 @@ module Alchemy
         end
       end
 
-      context "for registered user" do
-        before do
-          sign_in(registered_user)
-        end
+      context "for member user" do
+        before { sign_in(member_user) }
 
         it "should render elements of restricted pages" do
           get :show, :id => restricted_element.id

data/spec/controllers/messages_controller_spec.rb

@@ -5,11 +5,10 @@ module Alchemy
 
     before do
       controller.instance_variable_set(:@page, page)
-      controller.stub!(:get_page).and_return(page)
+      controller.stub(:get_page).and_return(page)
     end
 
     describe "#index" do
-
       let(:page) { mock_model('Page', {urlname: 'contact', page_layout: 'contact'}) }
 
       it "should redirect to @page" do
@@ -18,46 +17,44 @@ module Alchemy
     end
 
     describe "#new" do
-
       it "should render the alchemy/pages/show template" do
         get :new
         expect(get :new).to render_template('alchemy/pages/show')
       end
-
-      it "should call #layout_for_page to render the correct layout" do
-        controller.should_receive(:layout_for_page)
-        get :new
-      end
     end
 
     describe "#create" do
+      before do
+        controller.stub(:params).and_return({message: {email: ''}})
+      end
 
-      before { controller.stub!(:params).and_return({message: {email: ''}}) }
-
-      let(:page) { mock_model('Page', get_language_root: mock_model('Page')) }
+      let(:page)    { mock_model('Page', get_language_root: mock_model('Page')) }
       let(:element) { mock_model('Element', page: page, ingredient: '') }
       let(:message) { Message.new }
 
       it "should raise ActiveRecord::RecordNotFound if element of contactform could not be found" do
-        expect { get :create }.to raise_error(ActiveRecord::RecordNotFound)
+        expect { post :create }.to raise_error(ActiveRecord::RecordNotFound)
       end
 
       context "if validation of message" do
 
         before do
-          Element.stub!(:find_by_id).and_return(element)
+          Element.stub(:find_by).and_return(element)
+          element.stub(:ingredient).with(:success_page).and_return('thank-you')
           Message.any_instance.stub(:contact_form_id).and_return(1)
         end
 
-        context "is false" do
-          before { Message.any_instance.stub(:valid?).and_return(false) }
+        context "failed" do
+          before do
+            Message.any_instance.stub(:valid?).and_return(false)
+          end
 
           it "should render 'alchemy/pages/show' template" do
-            expect(get :create).to render_template('alchemy/pages/show')
+            expect(post :create).to render_template('alchemy/pages/show')
           end
         end
 
-        context "is true" do
+        context "succeeded" do
           before do
             Message.any_instance.stub(:valid?).and_return(true)
             Messages.stub_chain(:contact_form_mail, :deliver).and_return(true)
@@ -65,136 +62,137 @@ module Alchemy
 
           it "Messages should call Messages#contact_form_mail to send the email" do
             Messages.should_receive(:contact_form_mail)
-            get :create
+            post :create
           end
 
           describe '#mail_to' do
             context "with element having mail_to ingredient" do
-              before {
+              before do
                 element.stub(:ingredient).with(:mail_to).and_return('peter@schroeder.de')
                 message
                 Message.stub(:new).and_return(message)
-              }
+              end
 
               it "returns the ingredient" do
                 Messages.should_receive(:contact_form_mail).with(message, 'peter@schroeder.de', '', '')
-                get :create
+                post :create
               end
             end
 
             context "with element having no mail_to ingredient" do
-              before {
+              before do
                 element.stub(:ingredient).with(:mail_to).and_return(nil)
                 message
                 Message.stub(:new).and_return(message)
-              }
+              end
 
               it "returns the config value" do
                 Messages.should_receive(:contact_form_mail).with(message, 'your.mail@your-domain.com', '', '')
-                get :create
+                post :create
               end
             end
           end
 
           describe '#mail_from' do
             context "with element having mail_from ingredient" do
-              before {
+              before do
                 element.stub(:ingredient).with(:mail_from).and_return('peter@schroeder.de')
                 message
                 Message.stub(:new).and_return(message)
-              }
+              end
 
               it "returns the ingredient" do
                 Messages.should_receive(:contact_form_mail).with(message, '', 'peter@schroeder.de', '')
-                get :create
+                post :create
               end
             end
 
             context "with element having no mail_from ingredient" do
-              before {
+              before do
                 element.stub(:ingredient).with(:mail_from).and_return(nil)
                 message
                 Message.stub(:new).and_return(message)
-              }
+              end
 
               it "returns the config value" do
                 Messages.should_receive(:contact_form_mail).with(message, '', 'your.mail@your-domain.com', '')
-                get :create
+                post :create
               end
             end
           end
 
           describe '#subject' do
             context "with element having subject ingredient" do
-              before {
+              before do
                 element.stub(:ingredient).with(:subject).and_return('A new message')
                 message
                 Message.stub(:new).and_return(message)
-              }
+              end
 
               it "returns the ingredient" do
                 Messages.should_receive(:contact_form_mail).with(message, '', '', 'A new message')
-                get :create
+                post :create
               end
             end
 
             context "with element having no subject ingredient" do
-              before {
+              before do
                 element.stub(:ingredient).with(:subject).and_return(nil)
                 message
                 Message.stub(:new).and_return(message)
-              }
+              end
 
               it "returns the config value" do
                 Messages.should_receive(:contact_form_mail).with(message, '', '', 'A new contact form message')
-                get :create
+                post :create
               end
             end
           end
 
           describe "#redirect_to_success_page" do
-
             context "if 'success_page' ingredient of element is set with urlname" do
-              before { element.stub!(:ingredient).with('success_page').and_return('success-page') }
+              before do
+                element.stub(:ingredient).with(:success_page).and_return('success-page')
+              end
 
               it "should redirect to the given urlname" do
-                expect(get :create).to redirect_to(show_page_path(urlname: 'success-page'))
+                expect(post :create).to redirect_to(show_page_path(urlname: 'success-page'))
               end
             end
 
             context "if 'success_page' ingredient of element is not set" do
-              before { element.stub!(:ingredient).with('success_page').and_return(nil) }
+              before do
+                element.stub(:ingredient).with(:success_page).and_return(nil)
+              end
 
               context "but mailer_config['forward_to_page'] is true and mailer_config['mail_success_page'] is set" do
                 before do
-                  controller.stub!(:mailer_config).and_return({'forward_to_page' => true, 'mail_success_page' => 'mailer-config-success-page'})
-                  Page.stub_chain(:find_by_urlname, :urlname).and_return('mailer-config-success-page')
+                  controller.stub(:mailer_config).and_return({'forward_to_page' => true, 'mail_success_page' => 'mailer-config-success-page'})
+                  Page.stub_chain(:find_by, :urlname).and_return('mailer-config-success-page')
                 end
 
                 it "redirect to the given success page" do
-                  expect(get :create).to redirect_to(show_page_path(urlname: 'mailer-config-success-page'))
+                  expect(post :create).to redirect_to(show_page_path(urlname: 'mailer-config-success-page'))
                 end
               end
 
               context "and mailer_config has no instructions for success_page" do
+                let(:language) { mock_model('Language', code: 'en', pages: double(find_by: build_stubbed(:page))) }
+
                 before do
-                  controller.stub!(:mailer_config).and_return({})
+                  controller.stub(:mailer_config).and_return({})
+                  Language.stub_chain(:current_root_page, :urlname).and_return('lang-root')
                 end
 
                 it "should redirect to the language root page" do
-                  Page.stub_chain(:language_root_for, :urlname).and_return('lang-root')
-                  expect(get :create).to redirect_to(show_page_path(urlname: 'lang-root'))
+                  Language.stub(current: language)
+                  expect(post :create).to redirect_to(show_page_path(urlname: 'lang-root'))
                 end
               end
-
             end
-
           end
         end
-
       end
-
     end
-
   end
 end

data/spec/controllers/pages_controller_spec.rb

@@ -3,89 +3,61 @@ require 'spec_helper'
 
 module Alchemy
   describe PagesController do
-
-    let(:default_language)      { Language.get_default }
-    let(:default_language_root) { FactoryGirl.create(:language_root_page, :language => default_language, :name => 'Home', :public => true) }
-    let(:page) { FactoryGirl.create(:public_page, :parent_id => default_language_root.id, :page_layout => 'news', :name => 'News', :language => default_language, :do_not_autogenerate => false) }
+    let(:default_language)      { Language.default }
+    let(:default_language_root) { FactoryGirl.create(:language_root_page, language: default_language, name: 'Home', public: true) }
+    let(:page) { FactoryGirl.create(:public_page, parent_id: default_language_root.id, page_layout: 'news', name: 'News', urlname: 'news', language: default_language, do_not_autogenerate: false) }
 
     before { controller.stub(:signup_required?).and_return(false) }
 
+    context 'an author' do
+      let(:unpublic) { create(:page, parent: default_language_root) }
+
+      before { controller.stub(current_alchemy_user: author_user) }
+
+      it "should not be able to visit a unpublic page" do
+        get :show, urlname: unpublic.urlname
+        response.status.should == 404
+      end
+    end
+
     context "requested for a page containing a feed" do
       render_views
 
       it "should render a rss feed" do
-        get :show, :urlname => page.urlname, :format => :rss
+        get :show, urlname: page.urlname, format: :rss
         response.content_type.should == 'application/rss+xml'
       end
 
       it "should include content" do
-        page.elements.first.content_by_name('news_headline').essence.update_attributes({:body => 'Peters Petshop'})
-        get :show, :urlname => 'news', :format => :rss
+        page.elements.first.content_by_name('news_headline').essence.update_attributes({body: 'Peters Petshop'})
+        get :show, urlname: 'news', format: :rss
         response.body.should match /Peters Petshop/
       end
-
     end
 
     context "requested for a page that does not contain a feed" do
-
       it "should render xml 404 error" do
-        get :show, :urlname => default_language_root.urlname, :format => :rss
+        get :show, urlname: default_language_root.urlname, format: :rss
         response.status.should == 404
       end
-
     end
 
     describe "Layout rendering" do
-      context "with param layout set to none" do
-        it "should not render a layout" do
-          get :show, :urlname => page.urlname, :layout => 'none'
-          response.body.should_not match /<head>/
-        end
-      end
-
-      context "with param layout set to false" do
+      context "with ajax request" do
         it "should not render a layout" do
-          get :show, :urlname => page.urlname, :layout => 'false'
-          response.body.should_not match /<head>/
-        end
-      end
-
-      context "with params layout set to not existing layout" do
-        it "should raise ActionView::MissingTemplate" do
-          expect {
-            get :show, :urlname => default_language_root.urlname, :layout => 'lkuiuk'
-          }.to raise_error(ActionView::MissingTemplate)
+          xhr :get, :show, urlname: page.urlname
+          response.should render_template(:show)
+          response.should_not render_template(layout: 'application')
         end
       end
-
-      context "with param layout set to a custom layout" do
-        render_views
-
-        before do
-          @custom_layout = Rails.root.join('app/views/layouts', 'custom.html.erb')
-          File.open(@custom_layout, 'w') do |custom_layout|
-            custom_layout.puts "<html>I am a custom layout</html>"
-          end
-        end
-
-        it "should render the custom layout" do
-          get :show, :urlname => default_language_root.urlname, :layout => 'custom'
-          response.body.should have_content('I am a custom layout')
-        end
-
-        after do
-          FileUtils.rm(@custom_layout)
-        end
-
-      end
     end
 
     describe "url nesting" do
       render_views
 
-      let(:catalog)  { FactoryGirl.create(:public_page, :name => "Catalog", :parent_id => default_language_root.id, :language => default_language, :visible => true) }
-      let(:products) { FactoryGirl.create(:public_page, :name => "Products", :parent_id => catalog.id, :language => default_language, :visible => true) }
-      let(:product)  { FactoryGirl.create(:public_page, :name => "Screwdriver", :parent_id => products.id, :language => default_language, :do_not_autogenerate => false, :visible => true) }
+      let(:catalog)  { FactoryGirl.create(:public_page, name: "Catalog", urlname: 'catalog', parent: default_language_root, language: default_language, visible: true) }
+      let(:products) { FactoryGirl.create(:public_page, name: "Products", urlname: 'products', parent: catalog, language: default_language, visible: true) }
+      let(:product)  { FactoryGirl.create(:public_page, name: "Screwdriver", urlname: 'screwdriver', parent: products, language: default_language, do_not_autogenerate: false, visible: true) }
 
       before do
         Alchemy.user_class.stub(:admins).and_return(OpenStruct.new(count: 1))
@@ -94,130 +66,138 @@ module Alchemy
       end
 
       context "with correct levelnames in params" do
-
         it "should show the requested page" do
-          get :show, {:urlname => 'catalog/products/screwdriver'}
+          get :show, {urlname: 'catalog/products/screwdriver'}
           response.status.should == 200
           response.body.should have_content("screwdriver")
         end
-
       end
 
       context "with incorrect levelnames in params" do
-
         it "should render a 404 page" do
-          get :show, {:urlname => 'catalog/faqs/screwdriver'}
+          get :show, {urlname: 'catalog/faqs/screwdriver'}
           response.status.should == 404
           response.body.should have_content('The page you were looking for doesn\'t exist')
         end
-
       end
-
     end
 
     context "when a non-existent page is requested" do
       it "should rescue a RoutingError with rendering a 404 page." do
-        get :show, {:urlname => 'doesntexist'}
+        get :show, {urlname: 'doesntexist'}
         response.status.should == 404
         response.body.should have_content('The page you were looking for doesn\'t exist')
       end
     end
 
     describe '#redirect_to_public_child' do
-
-      let(:root_page)    { FactoryGirl.create(:language_root_page, :public => false) }
-      let(:page)         { FactoryGirl.create(:page, :parent_id => root_page.id) }
-      let(:public_page)  { FactoryGirl.create(:public_page, :parent_id => page.id) }
+      let(:root_page)    { FactoryGirl.create(:language_root_page, public: false) }
+      let(:page)         { FactoryGirl.create(:page, parent_id: root_page.id) }
+      let(:public_page)  { FactoryGirl.create(:public_page, parent_id: page.id) }
 
       before { controller.instance_variable_set("@page", root_page) }
 
-      context "with unpublished and published pages in page tree" do
-
-        before do
-          public_page
-          root_page.reload
-        end
+      context 'as guest user' do
+        context "with unpublished and published pages in page tree" do
+          before do
+            public_page
+            root_page.reload
+          end
 
-        it "should redirect to first public child" do
-          controller.should_receive(:redirect_page)
-          controller.send(:redirect_to_public_child)
-          controller.instance_variable_get('@page').should == public_page
+          it "should redirect to first public child" do
+            controller.should_receive(:redirect_page)
+            controller.send(:redirect_to_public_child)
+            controller.instance_variable_get('@page').should == public_page
+          end
         end
 
-      end
-
-      context "with only unpublished pages in page tree" do
-
-        before do
-          page
-          root_page.reload
-        end
+        context "with only unpublished pages in page tree" do
+          before do
+            page
+            root_page.reload
+          end
 
-        it "should raise not found error" do
-          expect {
-            controller.send(:redirect_to_public_child)
-          }.to raise_error(ActionController::RoutingError)
+          it "should raise not found error" do
+            expect {
+              controller.send(:redirect_to_public_child)
+            }.to raise_error(ActionController::RoutingError)
+          end
         end
-
       end
     end
 
     describe 'Redirecting to legacy page urls' do
       context 'Request a page with legacy url' do
-
-        let(:page)        { FactoryGirl.create(:public_page, :name => 'New page name') }
-        let(:second_page) { FactoryGirl.create(:public_page, :name => 'Second Page') }
-        let(:legacy_page) { FactoryGirl.create(:public_page, :name => 'Legacy Url') }
-        let(:legacy_url)  { LegacyPageUrl.create(:urlname => 'legacy-url', :page => page) }
-        let(:legacy_url2) { LegacyPageUrl.create(:urlname => 'legacy-url', :page => second_page) }
+        let(:page)        { FactoryGirl.create(:public_page, name: 'New page name') }
+        let(:second_page) { FactoryGirl.create(:public_page, name: 'Second Page') }
+        let(:legacy_page) { FactoryGirl.create(:public_page, name: 'Legacy Url') }
+        let(:legacy_url)  { LegacyPageUrl.create(urlname: 'legacy-url', page: page) }
+        let(:legacy_url2) { LegacyPageUrl.create(urlname: 'legacy-url', page: second_page) }
 
         it "should redirect permanently to page that belongs to legacy page url." do
-          get :show, :urlname => legacy_url.urlname
+          get :show, urlname: legacy_url.urlname
           response.status.should == 301
-          response.should redirect_to('/new-page-name')
+          response.should redirect_to("/#{page.urlname}")
         end
 
         it "should only redirect to legacy url if no page was found for urlname" do
           legacy_url
-          get :show, :urlname => legacy_page.urlname
+          get :show, urlname: legacy_page.urlname
           response.status.should == 200
-          response.should_not redirect_to('/new-page-name')
+          response.should_not redirect_to("/#{page.urlname}")
         end
 
         it "should redirect to last page that has that legacy url" do
           legacy_url
-          get :show, :urlname => legacy_url2.urlname
-          response.should redirect_to('/second-page')
+          get :show, urlname: legacy_url2.urlname
+          response.should redirect_to("/#{second_page.urlname}")
         end
-
       end
     end
 
     describe "while redirecting" do
-
       context "not in multi language mode" do
-
         before do
           PagesController.any_instance.stub(:multi_language?).and_return(false)
         end
 
         context "with no lang parameter present" do
-
           it "should store defaults language id in the session." do
-            get :show, :urlname => 'a-public-page'
-            controller.session[:language_id].should == Language.get_default.id
+            get :show, urlname: 'a-public-page'
+            controller.session[:alchemy_language_id].should == Language.default.id
           end
 
-          it "should store defaults language code in the session." do
-            get :show, :urlname => 'a-public-page'
-            controller.session[:language_code].should == Language.get_default.code
+          it "should store default language as class var." do
+            get :show, urlname: 'a-public-page'
+            Language.current.should == Language.default
           end
-
         end
+      end
+    end
+
+    describe '#page_etag' do
+      subject { controller.send(:page_etag) }
 
+      before do
+        page.stub(cache_key: 'aaa')
+        controller.instance_variable_set('@page', page)
       end
 
-    end
+      it "returns the etag for response headers" do
+        expect(subject).to eq('aaa')
+      end
+
+      context 'with user logged in' do
+        let(:author_user) { mock_model(Alchemy.user_class, cache_key: 'bbb') }
+
+        before do
+          sign_in(author_user)
+        end
 
+        it "returns another etag for response headers" do
+          expect(subject).to eq('aaabbb')
+        end
+      end
+    end
   end
 end