alchemy_cms 3.2.1 → 3.3.0.rc1

data/spec/controllers/alchemy/on_page_layout_mixin_spec.rb

@@ -0,0 +1,330 @@
+require 'spec_helper'
+
+RSpec.describe Alchemy::PagesController, 'OnPageLayout mixin', type: :controller do
+  before(:all) do
+    ApplicationController.send(:extend, Alchemy::OnPageLayout)
+  end
+
+  let(:page) { create(:alchemy_page, :public, page_layout: 'standard') }
+
+  describe '.on_page_layout' do
+    context 'with :all as argument for page_layout' do
+      before do
+        ApplicationController.class_eval do
+          on_page_layout(:all) do
+            @on_all_layouts = @page.page_layout
+          end
+        end
+      end
+
+      context "for show action" do
+        %w(standard news).each do |page_layout|
+          it "runs callback on #{page_layout} layout" do
+            page = create(:alchemy_page, :public, page_layout: page_layout)
+            alchemy_get :show, urlname: page.urlname
+            expect(assigns(:on_all_layouts)).to eq(page_layout)
+          end
+        end
+      end
+
+      context "for index action" do
+        %w(standard news).each do |page_layout|
+          it "runs callback on #{page_layout} layout" do
+            create(:alchemy_page, :language_root, page_layout: page_layout)
+
+            alchemy_get :index
+            expect(assigns(:on_all_layouts)).to eq(page_layout)
+          end
+        end
+      end
+    end
+
+    context 'with :standard as argument for page_layout' do
+      before do
+        ApplicationController.class_eval do
+          on_page_layout(:standard) do
+            @successful_for_standard = true
+          end
+        end
+      end
+
+      context 'and page having standard layout' do
+        context "for show action" do
+          let(:page) { create(:alchemy_page, :public, page_layout: 'standard') }
+
+          it 'runs the callback' do
+            alchemy_get :show, urlname: page.urlname
+            expect(assigns(:successful_for_standard)).to eq(true)
+          end
+        end
+
+        context "for index action" do
+          let!(:page) { create(:alchemy_page, :language_root, page_layout: 'standard') }
+
+          it 'runs the callback' do
+            alchemy_get :index
+            expect(assigns(:successful_for_standard)).to eq(true)
+          end
+        end
+      end
+
+      context 'and page not having standard layout' do
+        let(:page) { create(:alchemy_page, :public, page_layout: 'news') }
+
+        context "for show action" do
+          it "doesn't run the callback" do
+            alchemy_get :show, urlname: page.urlname
+            expect(assigns(:successful_for_standard)).to eq(nil)
+          end
+        end
+
+        context "for index action" do
+          let!(:page) { create(:alchemy_page, :language_root, page_layout: 'news') }
+
+          it "doesn't run the callback" do
+            alchemy_get :index
+            expect(assigns(:successful_for_standard)).to eq(nil)
+          end
+        end
+      end
+    end
+
+    context 'when defining two callbacks for different page layouts' do
+      context "for show action" do
+        before do
+          ApplicationController.class_eval do
+            on_page_layout(:standard) do
+              @urlname = @page.urlname
+            end
+
+            on_page_layout(:news) do
+              @urlname = @page.urlname
+            end
+          end
+        end
+
+        %w(standard news).each do |page_layout|
+          it "runs both callbacks for #{page_layout} layout" do
+            page = create(:alchemy_page, :public, page_layout: page_layout)
+
+            alchemy_get :show, urlname: page.urlname
+            expect(assigns(:urlname)).to eq(page.urlname)
+          end
+        end
+      end
+
+      context "for index action" do
+        before do
+          ApplicationController.class_eval do
+            on_page_layout(:standard) do
+              @page_layout = @page.page_layout
+            end
+
+            on_page_layout(:news) do
+              @page_layout = @page.page_layout
+            end
+          end
+        end
+
+        %w(standard news).each do |page_layout|
+          it "runs both callbacks on #{page_layout} layout" do
+            create(:alchemy_page, :language_root, page_layout: page_layout)
+
+            alchemy_get :index
+            expect(assigns(:page_layout)).to eq(page_layout)
+          end
+        end
+      end
+    end
+
+    context 'when defining two callbacks for the same page_layout' do
+      before do
+        ApplicationController.class_eval do
+          on_page_layout(:standard) do
+            @successful_for_standard_first = true
+          end
+
+          on_page_layout(:standard) do
+            @successful_for_standard_second = true
+          end
+        end
+      end
+
+      context "for show action" do
+        it 'runs both callbacks' do
+          alchemy_get :show, urlname: page.urlname
+          expect(assigns(:successful_for_standard_first)).to eq(true)
+          expect(assigns(:successful_for_standard_second)).to eq(true)
+        end
+      end
+
+      context "for index action" do
+        let!(:page) { create(:alchemy_page, :language_root, page_layout: 'standard') }
+
+        it 'runs both callbacks' do
+          alchemy_get :index
+          expect(assigns(:successful_for_standard_first)).to eq(true)
+          expect(assigns(:successful_for_standard_second)).to eq(true)
+        end
+      end
+    end
+
+    context 'when block is given' do
+      before do
+        ApplicationController.class_eval do
+          on_page_layout :standard do
+            @successful_for_callback_method = true
+          end
+        end
+      end
+
+      context 'for show action' do
+        it 'evaluates the given block' do
+          alchemy_get :show, urlname: page.urlname
+          expect(assigns(:successful_for_callback_method)).to eq(true)
+        end
+      end
+
+      context 'for index action' do
+        let!(:page) { create(:alchemy_page, :language_root, page_layout: 'standard') }
+
+        it 'evaluates the given block' do
+          alchemy_get :index
+          expect(assigns(:successful_for_callback_method)).to eq(true)
+        end
+      end
+    end
+
+    context 'when callback method name is given' do
+      before do
+        ApplicationController.class_eval do
+          on_page_layout :standard, :run_method
+
+          def run_method
+            @successful_for_callback_method = true
+          end
+        end
+      end
+
+      context 'for show action' do
+        it 'runs the given callback method' do
+          alchemy_get :show, urlname: page.urlname
+          expect(assigns(:successful_for_callback_method)).to eq(true)
+        end
+      end
+
+      context 'for index action' do
+        let!(:page) { create(:alchemy_page, :language_root, page_layout: 'standard') }
+
+        it 'runs the given callback method' do
+          alchemy_get :index
+          expect(assigns(:successful_for_callback_method)).to eq(true)
+        end
+      end
+    end
+
+    context 'when neither callback method name nor block given' do
+      it 'raises an ArgumentError' do
+        expect do
+          ApplicationController.class_eval do
+            on_page_layout :standard
+          end
+        end.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when passing two page_layouts for a callback' do
+      before do
+        ApplicationController.class_eval do
+          on_page_layout([:standard, :news]) do
+            @successful = @page.page_layout
+          end
+        end
+      end
+
+      %w(standard news).each do |page_layout|
+        it 'evaluates the given callback on both page_layouts for show action' do
+          page = create(:alchemy_page, :public, page_layout: page_layout)
+
+          alchemy_get :show, urlname: page.urlname
+          expect(assigns(:successful)).to eq(page_layout)
+        end
+      end
+
+      %w(standard news).each do |page_layout|
+        it 'evaluates the given callback on both page_layouts for index action' do
+          create(:alchemy_page, :language_root, page_layout: page_layout)
+
+          alchemy_get :index
+          expect(assigns(:successful)).to eq(page_layout)
+        end
+      end
+    end
+  end
+end
+
+RSpec.describe ApplicationController, 'OnPageLayout mixin', type: :controller do
+  before(:all) do
+    ApplicationController.send(:extend, Alchemy::OnPageLayout)
+  end
+
+  controller do
+    def index
+      @another_controller = true
+      render nothing: true
+    end
+  end
+
+  context 'in another controller' do
+    before do
+      ApplicationController.class_eval do
+        on_page_layout(:standard) do
+          @successful_for_another_controller = true
+        end
+      end
+    end
+
+    it 'callback does not run' do
+      get :index
+      expect(assigns(:another_controller)).to eq(true)
+      expect(assigns(:successful_for_another_controller)).to eq(nil)
+    end
+  end
+end
+
+RSpec.describe Alchemy::Admin::PagesController, 'OnPageLayout mixin', type: :controller do
+  before(:all) do
+    ApplicationController.send(:extend, Alchemy::OnPageLayout)
+  end
+
+  context 'in admin/pages_controller' do
+    before do
+      ApplicationController.class_eval do
+        on_page_layout(:standard) do
+          @successful_for_alchemy_admin_pages_controller = true
+        end
+      end
+      authorize_user(:as_admin)
+    end
+
+    context "for show action" do
+      let(:page) { create(:alchemy_page, page_layout: 'standard') }
+
+      it 'callback also runs' do
+        alchemy_get :show, id: page.id
+        expect(assigns(:successful_for_alchemy_admin_pages_controller)).to be(true)
+      end
+    end
+
+    context "for index action" do
+      it 'does not run callback' do
+        alchemy_get :index
+        expect(assigns(:successful_for_alchemy_admin_pages_controller)).to be(nil)
+      end
+    end
+  end
+
+  after(:all) do
+    Alchemy::OnPageLayout.instance_variable_set(:@callbacks, nil)
+  end
+end

data/spec/controllers/{pages_controller_spec.rb → alchemy/pages_controller_spec.rb}

@@ -3,14 +3,149 @@ require 'spec_helper'
 
 module Alchemy
   describe PagesController do
-    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) }
+    let(:default_language) { Language.default }
 
-    before { allow(controller).to receive(:signup_required?).and_return(false) }
+    let(:default_language_root) do
+      create :alchemy_page, :language_root,
+        language: default_language,
+        name: 'Home',
+        public: true
+    end
+
+    let(:page) do
+      create :alchemy_page, :public,
+        parent_id: default_language_root.id,
+        page_layout: 'news',
+        name: 'News',
+        urlname: 'news',
+        language: default_language,
+        do_not_autogenerate: false
+    end
+
+    before do
+      allow(controller).to receive(:signup_required?).and_return(false)
+    end
+
+    describe "#index" do
+      before do
+        default_language_root
+        allow(Config).to receive(:get) do |arg|
+          arg == :redirect_index ? false : Config.parameter(arg)
+        end
+      end
+
+      it 'renders :show template' do
+        expect(alchemy_get(:index)).to render_template(:show)
+      end
+
+      context 'requesting nothing' do
+        it 'loads default language root page' do
+          alchemy_get :index
+          expect(assigns(:page)).to eq(default_language_root)
+        end
+
+        it 'sets @root_page to default language root' do
+          alchemy_get(:index)
+          expect(assigns(:root_page)).to eq(default_language_root)
+        end
+
+        context 'and the root page is not public' do
+          before do
+            default_language_root.update!(public: false)
+          end
+
+          context 'and redirect_to_public_child is set to false' do
+            before do
+              allow(Config).to receive(:get) do |arg|
+                arg == :redirect_to_public_child ? false : Config.parameter(arg)
+              end
+            end
+
+            it 'raises routing error (404)' do
+              expect {
+                alchemy_get :index
+              }.to raise_error(ActionController::RoutingError)
+            end
+          end
+
+          context 'and redirect_to_public_child is set to true' do
+            before do
+              allow(Config).to receive(:get) do |arg|
+                arg == :redirect_to_public_child ? true : Config.parameter(arg)
+              end
+            end
+
+            context 'that has a public child' do
+              let!(:public_child) do
+                create(:alchemy_page, :public, parent: default_language_root)
+              end
+
+              it 'loads this page' do
+                alchemy_get :index
+                expect(assigns(:page)).to eq(public_child)
+              end
+            end
+
+            context 'that has a non public child' do
+              let!(:non_public_child) do
+                create(:alchemy_page, parent: default_language_root)
+              end
+
+              context 'that has a public child' do
+                let!(:public_child) do
+                  create(:alchemy_page, :public, parent: non_public_child)
+                end
+
+                it 'loads this page' do
+                  alchemy_get :index
+                  expect(assigns(:page)).to eq(public_child)
+                end
+              end
+
+              context 'that has a non public child' do
+                before do
+                  create(:alchemy_page, parent: non_public_child)
+                end
+
+                it 'raises routing error (404)' do
+                  expect {
+                    alchemy_get :index
+                  }.to raise_error(ActionController::RoutingError)
+                end
+              end
+            end
+          end
+        end
+      end
+
+      context 'requesting non default locale' do
+        let!(:deutsch) do
+          create(:alchemy_language, name: 'Deutsch', code: 'de', default: false)
+        end
+
+        let!(:startseite) do
+          create :alchemy_page, :language_root,
+            language: deutsch, public: true, name: 'Startseite'
+        end
+
+        before do
+          allow(::I18n).to receive(:default_locale) { 'en' }
+        end
+
+        it 'loads the root page of that language' do
+          alchemy_get :index, locale: 'de'
+          expect(assigns(:page)).to eq(startseite)
+        end
+
+        it 'sets @root_page to root page of that language' do
+          alchemy_get :index, locale: 'de'
+          expect(assigns(:root_page)).to eq(startseite)
+        end
+      end
+    end
 
     context 'an author' do
-      let(:unpublic) { create(:page, parent: default_language_root) }
+      let(:unpublic) { create(:alchemy_page, parent: default_language_root) }
 
       before { authorize_user(:as_author) }
 
@@ -56,9 +191,9 @@ module Alchemy
     describe "url nesting" do
       render_views
 
-      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) }
+      let(:catalog)  { create(:alchemy_page, :public, name: "Catalog", urlname: 'catalog', parent: default_language_root, language: default_language, visible: true) }
+      let(:products) { create(:alchemy_page, :public, name: "Products", urlname: 'products', parent: catalog, language: default_language, visible: true) }
+      let(:product)  { create(:alchemy_page, :public, name: "Screwdriver", urlname: 'screwdriver', parent: products, language: default_language, do_not_autogenerate: false, visible: true) }
 
       before do
         allow(Alchemy.user_class).to receive(:admins).and_return(OpenStruct.new(count: 1))
@@ -91,47 +226,11 @@ module Alchemy
       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) }
-
-      before { controller.instance_variable_set("@page", root_page) }
-
-      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
-            expect(controller).to receive(:redirect_page)
-            controller.send(:redirect_to_public_child)
-            expect(controller.instance_variable_get('@page')).to eq(public_page)
-          end
-        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)
-          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(:page)        { create(:alchemy_page, :public, name: 'New page name') }
+        let(:second_page) { create(:alchemy_page, :public, name: 'Second Page') }
+        let(:legacy_page) { create(:alchemy_page, :public, 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(:legacy_url3) { LegacyPageUrl.create(urlname: 'index.php?id=2', page: second_page) }
@@ -197,6 +296,27 @@ module Alchemy
       end
     end
 
+    context 'in an environment with multiple languages' do
+      let(:klingon) { create(:alchemy_language, :klingon) }
+
+      context 'having two pages with the same url names in different languages' do
+        render_views
+
+        let!(:klingon_page) { create(:alchemy_page, :public, language: klingon, name: "same-name", do_not_autogenerate: false) }
+        let!(:english_page) { create(:alchemy_page, :public, language: default_language, name: "same-name") }
+
+        before do
+          # Set a text in an essence rendered on the page so we can match against that
+          klingon_page.essence_texts.first.update_column(:body, 'klingon page')
+        end
+
+        it 'renders the page related to its language' do
+          alchemy_get :show, {urlname: "same-name", locale: klingon_page.language_code}
+          expect(response.body).to have_content("klingon page")
+        end
+      end
+    end
+
     describe '#page_etag' do
       subject { controller.send(:page_etag) }
 
@@ -219,47 +339,5 @@ module Alchemy
         end
       end
     end
-
-    describe '#cache_page?' do
-      subject { controller.send(:cache_page?) }
-
-      before do
-        Rails.application.config.action_controller.perform_caching = true
-        controller.instance_variable_set('@page', page)
-      end
-
-      it 'returns true when everthing is alright' do
-        expect(subject).to be true
-      end
-
-      it 'returns false when the Rails app does not perform caching' do
-        Rails.application.config.action_controller.perform_caching = false
-        expect(subject).to be false
-      end
-
-      it 'returns false when there is no page' do
-        controller.instance_variable_set('@page', nil)
-        expect(subject).to be false
-      end
-
-      it 'returns false when caching is deactivated in the Alchemy config' do
-        allow(Alchemy::Config).to receive(:get).with(:cache_pages).and_return(false)
-        expect(subject).to be false
-      end
-
-      it 'returns false when the page layout is set to cache = false' do
-        page_layout = PageLayout.get('news')
-        page_layout['cache'] = false
-        allow(PageLayout).to receive(:get).with('news').and_return(page_layout)
-        expect(subject).to be false
-      end
-
-      it 'returns false when the page layout is set to searchresults = true' do
-        page_layout = PageLayout.get('news')
-        page_layout['searchresults'] = true
-        allow(PageLayout).to receive(:get).with('news').and_return(page_layout)
-        expect(subject).to be false
-      end
-    end
   end
 end