alchemy_cms 3.3.0.rc1 → 3.3.0.rc2

data/spec/controllers/alchemy/admin/essence_files_controller_spec.rb

@@ -1,76 +0,0 @@
-require "spec_helper"
-
-module Alchemy
-  describe Admin::EssenceFilesController do
-    before do
-      authorize_user(:as_admin)
-    end
-
-    let(:essence_file) { mock_model('EssenceFile', :attachment= => nil, content: content) }
-    let(:content)      { mock_model('Content') }
-    let(:attachment)   { mock_model('Attachment') }
-
-    describe '#edit' do
-      before do
-        expect(EssenceFile).to receive(:find)
-          .with(essence_file.id.to_s)
-          .and_return(essence_file)
-      end
-
-      it "assigns @essence_file with the EssenceFile found by id" do
-        alchemy_get :edit, id: essence_file.id
-        expect(assigns(:essence_file)).to eq(essence_file)
-      end
-
-      it "should assign @content with essence_file's content" do
-        alchemy_get :edit, id: essence_file.id
-        expect(assigns(:content)).to eq(content)
-      end
-    end
-
-    describe '#update' do
-      let(:essence_file) { create(:alchemy_essence_file) }
-
-      before do
-        expect(EssenceFile).to receive(:find).and_return(essence_file)
-      end
-
-      it "should update the attributes of essence_file" do
-        alchemy_xhr :put, :update, id: essence_file.id, essence_file: {
-          title: 'new title',
-          css_class: 'left',
-          link_text: 'Download this file'
-        }
-        expect(essence_file.title).to eq 'new title'
-        expect(essence_file.css_class).to eq 'left'
-        expect(essence_file.link_text).to eq 'Download this file'
-      end
-    end
-
-    describe '#assign' do
-      let(:content) { create(:alchemy_content) }
-
-      before do
-        expect(Content).to receive(:find_by).and_return(content)
-        expect(Attachment).to receive(:find_by).and_return(attachment)
-        allow(content).to receive(:essence).and_return(essence_file)
-      end
-
-      it "should assign @attachment with the Attachment found by attachment_id" do
-        alchemy_xhr :put, :assign, content_id: content.id, attachment_id: attachment.id
-        expect(assigns(:attachment)).to eq(attachment)
-      end
-
-      it "should assign @content.essence.attachment with the attachment found by id" do
-        expect(content.essence).to receive(:attachment=).with(attachment)
-        alchemy_xhr :put, :assign, content_id: content.id, attachment_id: attachment.id
-      end
-
-      it "updates the @content.updated_at column" do
-        expect {
-          alchemy_xhr :put, :assign, content_id: content.id, attachment_id: attachment.id
-        }.to change(content, :updated_at)
-      end
-    end
-  end
-end

data/spec/controllers/alchemy/admin/essence_pictures_controller_spec.rb

@@ -1,202 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe Admin::EssencePicturesController do
-    before { authorize_user(:as_admin) }
-
-    let(:essence) { EssencePicture.new }
-    let(:content) { Content.new }
-    let(:picture) { Picture.new }
-
-    describe '#edit' do
-      before do
-        expect(EssencePicture).to receive(:find).and_return(essence)
-        expect(Content).to receive(:find).and_return(content)
-      end
-
-      it 'should assign @essence_picture and @content instance variables' do
-        alchemy_post :edit, id: 1, content_id: 1
-        expect(assigns(:essence_picture)).to be_a(EssencePicture)
-        expect(assigns(:content)).to be_a(Content)
-      end
-    end
-
-    describe '#crop' do
-      before do
-        expect(EssencePicture).to receive(:find).and_return(essence)
-      end
-
-      context 'with no picture assigned' do
-        before do
-          expect(essence).to receive(:picture).at_least(:once).and_return(nil)
-        end
-
-        it "renders error message" do
-          alchemy_get :crop, id: 1
-          expect(assigns(:no_image_notice)).to eq(Alchemy.t(:no_image_for_cropper_found))
-        end
-      end
-
-      context 'with picture assigned' do
-        let(:default_mask) do
-          {
-            x1: 0,
-            y1: 0,
-            x2: 300,
-            y2: 250
-          }
-        end
-
-        before do
-          picture.image_file_width = 300
-          picture.image_file_height = 250
-          expect(essence).to receive(:picture).at_least(:once).and_return(picture)
-        end
-
-        context 'with no render_size present in essence' do
-          before do
-            expect(essence).to receive(:render_size).at_least(:once).and_return(nil)
-          end
-
-          context 'with sizes in params' do
-            it "sets sizes to given values" do
-              alchemy_get :crop, id: 1, options: {image_size: '300x250'}
-              expect(assigns(:min_size)).to eq({ width: 300, height: 250 })
-            end
-          end
-
-          context 'with no sizes in params' do
-            it "sets sizes to zero" do
-              alchemy_get :crop, id: 1
-              expect(assigns(:min_size)).to eq({ width: 0, height: 0 })
-            end
-          end
-        end
-
-        context 'with render_size present in essence' do
-          it "sets sizes from these values" do
-            expect(essence).to receive(:render_size).at_least(:once).and_return('30x25')
-
-            alchemy_get :crop, id: 1
-            expect(assigns(:min_size)).to eq({ width: 30, height: 25 })
-          end
-
-          context 'when width or height is not fixed' do
-            it 'infers the height from the image file preserving the aspect ratio' do
-              expect(essence).to receive(:render_size).at_least(:once).and_return('30x')
-
-              alchemy_get :crop, id: 1
-              expect(assigns(:min_size)).to eq({ width: 30, height: 0})
-            end
-
-            it 'does not infer the height from the image file preserving the aspect ratio' do
-              expect(essence).to receive(:render_size).at_least(:once).and_return('x25')
-
-              alchemy_get :crop, id: 1, options: { fixed_ratio: "2"}
-              expect(assigns(:min_size)).to eq({ width: 50, height: 25 })
-            end
-          end
-
-          context 'when width or height is not fixed and an aspect ratio is given' do
-            it 'width is given, it infers the height from width and ratio' do
-              expect(essence).to receive(:render_size).at_least(:once).and_return('30x')
-
-              alchemy_get :crop, id: 1, options: { fixed_ratio: "0.5" }
-              expect(assigns(:min_size)).to eq({ width: 30, height: 60 })
-            end
-
-            it 'infers the height from the image file preserving the aspect ratio' do
-              expect(essence).to receive(:render_size).at_least(:once).and_return('x25')
-
-              alchemy_get :crop, id: 1
-              expect(assigns(:min_size)).to eq({ width: 0, height: 25})
-            end
-          end
-        end
-
-        context 'no crop sizes present in essence' do
-          before do
-            expect(essence).to receive(:crop_from).and_return(nil)
-            allow(essence).to receive(:crop_size).and_return(nil)
-          end
-
-          it "assigns default mask boxes" do
-            alchemy_get :crop, id: 1
-            expect(assigns(:initial_box)).to eq(default_mask)
-            expect(assigns(:default_box)).to eq(default_mask)
-          end
-        end
-
-        context 'crop sizes present in essence' do
-          let(:mask) { {'x1' => '0', 'y1' => '0', 'x2' => '120', 'y2' => '160'} }
-
-          before do
-            allow(essence).to receive(:crop_from).and_return('0x0')
-            allow(essence).to receive(:crop_size).and_return('120x160')
-          end
-
-          it "assigns cropping boxes" do
-            expect(essence).to receive(:cropping_mask).and_return(mask)
-            alchemy_get :crop, id: 1
-            expect(assigns(:initial_box)).to eq(mask)
-            expect(assigns(:default_box)).to eq(default_mask)
-          end
-        end
-
-        context 'with fixed_ratio set to false' do
-          it "sets ratio to false" do
-            alchemy_get :crop, id: 1, options: {fixed_ratio: false}
-            expect(assigns(:ratio)).to eq(false)
-          end
-        end
-
-        context 'with no fixed_ratio set in params' do
-          it "sets a fixed ratio from sizes" do
-            alchemy_get :crop, id: 1, options: {image_size: '80x60'}
-            expect(assigns(:ratio)).to eq(80.0 / 60.0)
-          end
-        end
-      end
-    end
-
-    describe '#update' do
-      before do
-        expect(EssencePicture).to receive(:find).and_return(essence)
-        expect(Content).to receive(:find).and_return(content)
-      end
-
-      let(:attributes) { {render_size: '1x1', alt_tag: 'Alt Tag', caption: 'Caption', css_class: 'CSS Class', title: 'Title'} }
-
-      it "updates the essence attributes" do
-        expect(essence).to receive(:update).and_return(true)
-        alchemy_xhr :put, :update, id: 1, essence_picture: attributes
-      end
-
-      it "saves the cropping mask" do
-        expect(essence).to receive(:update).and_return(true)
-        alchemy_xhr :put, :update, id: 1, essence_picture: {render_size: '1x1', crop_from: '0x0', crop_size: '100x100'}
-      end
-    end
-
-    describe '#assign' do
-      let(:content) { create(:alchemy_content) }
-
-      before do
-        expect(Content).to receive(:find).and_return(content)
-        expect(content).to receive(:essence).at_least(:once).and_return(essence)
-        expect(Picture).to receive(:find_by).and_return(picture)
-      end
-
-      it "should assign a Picture" do
-        alchemy_xhr :put, :assign, content_id: '1', picture_id: '1'
-        expect(assigns(:content).essence.picture).to eq(picture)
-      end
-
-      it "updates the content timestamp" do
-        expect {
-          alchemy_xhr :put, :assign, content_id: '1', picture_id: '1'
-        }.to change(content, :updated_at)
-      end
-    end
-  end
-end

data/spec/controllers/alchemy/admin/languages_controller_spec.rb

@@ -1,73 +0,0 @@
-require 'spec_helper'
-
-describe Alchemy::Admin::LanguagesController do
-  before do
-    authorize_user(:as_admin)
-  end
-
-  describe "#new" do
-    context "when default_language.page_layout is set" do
-      before do
-        allow(Alchemy::Config).to receive(:get) do |arg|
-          if arg == :default_language
-            {'page_layout' => "new_standard"}
-          else
-            Alchemy::Config.show[arg.to_s]
-          end
-        end
-      end
-
-      it "uses it as page_layout-default for the new language" do
-        alchemy_get :new
-        expect(assigns(:language).page_layout).to eq("new_standard")
-      end
-    end
-
-    context "when default_language is not configured" do
-      before do
-        allow(Alchemy::Config).to receive(:get) do |arg|
-          if arg == :default_language
-            nil
-          else
-            Alchemy::Config.show[arg.to_s]
-          end
-        end
-      end
-
-      it "falls back to default database value." do
-        alchemy_get :new
-        expect(assigns(:language).page_layout).to eq("intro")
-      end
-    end
-
-    context "when default language page_layout is not configured" do
-      before do
-        allow(Alchemy::Config).to receive(:get) do |arg|
-          if arg == :default_language
-            {}
-          else
-            Alchemy::Config.show[arg.to_s]
-          end
-        end
-      end
-
-      it "falls back to default database value." do
-        alchemy_get :new
-        expect(assigns(:language).page_layout).to eq("intro")
-      end
-    end
-  end
-
-  describe "#index" do
-    context "editor users" do
-      before do
-        authorize_user(:as_editor)
-      end
-
-      it "should be able to index language" do
-        alchemy_get :index
-        expect(response).to render_template(:index)
-      end
-    end
-  end
-end

data/spec/controllers/alchemy/admin/layoutpages_controller_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe Admin::LayoutpagesController do
-    before(:each) do
-      authorize_user(:as_admin)
-    end
-
-    describe "#index" do
-      it "should assign @layout_root" do
-        alchemy_get :index
-        expect(assigns(:layout_root)).to be_a(Page)
-      end
-
-      it "should assign @languages" do
-        alchemy_get :index
-        expect(assigns(:languages).first).to be_a(Language)
-      end
-    end
-  end
-end

data/spec/controllers/alchemy/admin/pages_controller_spec.rb

@@ -1,639 +0,0 @@
-require 'ostruct'
-require 'spec_helper'
-
-module Alchemy
-  describe Admin::PagesController do
-    context 'a guest' do
-      it 'can not access page tree' do
-        alchemy_get :index
-        expect(request).to redirect_to(Alchemy.login_path)
-      end
-    end
-
-    context 'a member' do
-      before { authorize_user(build(:alchemy_dummy_user)) }
-
-      it 'can not access page tree' do
-        alchemy_get :index
-        expect(request).to redirect_to(root_path)
-      end
-    end
-
-    context 'with logged in editor user' do
-      let(:user) { build(:alchemy_dummy_user, :as_editor) }
-
-      before { authorize_user(user) }
-
-      describe '#index' do
-        let(:language)      { build_stubbed(:alchemy_language) }
-        let(:language_root) { build_stubbed(:alchemy_page, :language_root) }
-
-        context 'with existing language root page' do
-          before do
-            expect(Language).to receive(:current_root_page).and_return(language_root)
-          end
-
-          it "assigns @page_root variable" do
-            alchemy_get :index
-            expect(assigns(:page_root)).to be(language_root)
-          end
-        end
-
-        context 'without language root page' do
-          before do
-            expect(Language).to receive(:current_root_page).and_return(nil)
-            expect(Language).to receive(:find_by).and_return(language)
-            expect(Language).to receive(:all).and_return([language])
-            expect(Language).to receive(:with_root_page).and_return([language])
-          end
-
-          it "it assigns current language" do
-            alchemy_get :index
-            expect(assigns(:language)).to be(language)
-          end
-        end
-      end
-
-      describe '#tree' do
-        let(:page_1) { create(:alchemy_page, visible: true, name: 'one') }
-        let(:page_2) { create(:alchemy_page, visible: true, name: 'two', parent_id: page_1.id) }
-        let(:page_3) { create(:alchemy_page, visible: true, name: 'three', parent_id: page_2.id) }
-        let(:pages)  { [page_1, page_2, page_3] }
-
-        before do
-          pages
-        end
-
-        it 'returns a tree as JSON' do
-          alchemy_get :tree, id: page_1.id, full: 'true'
-
-          expect(response.status).to eq(200)
-          expect(response.content_type).to eq('application/json')
-
-          result = JSON.parse(response.body)
-
-          expect(result).to have_key('pages')
-          expect(result['pages'].count).to eq(1)
-
-          page = result['pages'].first
-
-          expect(page).to have_key('id')
-          expect(page['id']).to eq(page_1.id)
-          expect(page).to have_key('name')
-          expect(page['name']).to eq(page_1.name)
-          expect(page).to have_key('children')
-          expect(page['children'].count).to eq(1)
-
-          page = page['children'].first
-
-          expect(page).to have_key('id')
-          expect(page['id']).to eq(page_2.id)
-          expect(page).to have_key('name')
-          expect(page['name']).to eq(page_2.name)
-          expect(page).to have_key('children')
-          expect(page['children'].count).to eq(1)
-
-          page = page['children'].first
-
-          expect(page).to have_key('id')
-          expect(page['id']).to eq(page_3.id)
-          expect(page).to have_key('name')
-          expect(page['name']).to eq(page_3.name)
-          expect(page).to have_key('children')
-          expect(page['children'].count).to eq(0)
-        end
-
-        it 'does not return a branch that is folded' do
-          alchemy_xhr :post, :fold, id: page_2.id
-          alchemy_get :tree, id: page_1.id, full: 'false'
-
-          expect(response.status).to eq(200)
-          expect(response.content_type).to eq('application/json')
-
-          result = JSON.parse(response.body)
-          page = result['pages'].first['children'].first
-
-          expect(page['children'].count).to eq(0)
-        end
-      end
-
-      describe "#flush" do
-        let(:content_page_1) { create(:alchemy_page, :public, name: "content page 1", published_at: Time.current - 5.days) }
-        let(:content_page_2) { create(:alchemy_page, :public, name: "content page 2", published_at: Time.current - 8.days) }
-        let(:layout_page_1)  { create(:alchemy_page, layoutpage: true, name: "layout_page 1", published_at: Time.current - 5.days) }
-        let(:layout_page_2)  { create(:alchemy_page, layoutpage: true, name: "layout_page 2", published_at: Time.current - 8.days) }
-        let(:content_pages)  { [content_page_1, content_page_2] }
-        let(:layout_pages)   { [layout_page_1, layout_page_2] }
-
-        before do
-          content_pages
-          layout_pages
-        end
-
-        it "should update the published_at field of content pages" do
-          travel_to(Time.current) do
-            alchemy_xhr :post, :flush
-            content_pages.map(&:reload) # Reloading because published_at was directly updated in the database.
-            content_pages.each do |page|
-              expect(page.published_at).to eq(Time.current)
-            end
-          end
-        end
-
-        it "should update the published_at field of layout pages" do
-          travel_to(Time.current) do
-            alchemy_xhr :post, :flush
-            layout_pages.map(&:reload) # Reloading because published_at was directly updated in the database.
-            layout_pages.each do |page|
-              expect(page.published_at).to eq(Time.current)
-            end
-          end
-        end
-      end
-
-      describe '#new' do
-        context "pages in clipboard" do
-          let(:clipboard) { session[:alchemy_clipboard] = {} }
-          let(:page) { mock_model(Alchemy::Page, name: 'Foobar') }
-
-          before { clipboard['pages'] = [{'id' => page.id.to_s, 'action' => 'copy'}] }
-
-          it "should load all pages from clipboard" do
-            alchemy_xhr :get, :new, {page_id: page.id}
-            expect(assigns(:clipboard_items)).to be_kind_of(Array)
-          end
-        end
-      end
-
-      describe '#show' do
-        let(:language) { build_stubbed(:alchemy_language, locale: 'nl') }
-        let(:page) { build_stubbed(:alchemy_page, language: language) }
-
-        before do
-          expect(Page).to receive(:find).with(page.id.to_s).and_return(page)
-          allow(Page).to receive(:language_root_for).and_return(mock_model(Alchemy::Page))
-        end
-
-        it "should assign @preview_mode with true" do
-          alchemy_get :show, id: page.id
-          expect(assigns(:preview_mode)).to eq(true)
-        end
-
-        it "should store page as current preview" do
-          Page.current_preview = nil
-          alchemy_get :show, id: page.id
-          expect(Page.current_preview).to eq(page)
-        end
-
-        it "should set the I18n locale to the pages language code" do
-          alchemy_get :show, id: page.id
-          expect(::I18n.locale).to eq(:nl)
-        end
-
-        it "renders the application layout" do
-          alchemy_get :show, id: page.id
-          expect(response).to render_template(layout: 'application')
-        end
-      end
-
-      describe '#order' do
-        let(:page_1)       { create(:alchemy_page, visible: true) }
-        let(:page_2)       { create(:alchemy_page, visible: true) }
-        let(:page_3)       { create(:alchemy_page, visible: true) }
-        let(:page_item_1)  { {id: page_1.id, slug: page_1.slug, restricted: false, external: page_1.redirects_to_external?, visible: page_1.visible?, children: [page_item_2]} }
-        let(:page_item_2)  { {id: page_2.id, slug: page_2.slug, restricted: false, external: page_2.redirects_to_external?, visible: page_2.visible?, children: [page_item_3]} }
-        let(:page_item_3)  { {id: page_3.id, slug: page_3.slug, restricted: false, external: page_3.redirects_to_external?, visible: page_3.visible? } }
-        let(:set_of_pages) { [page_item_1] }
-
-        it "stores the new order" do
-          alchemy_xhr :post, :order, set: set_of_pages.to_json
-          page_1.reload
-          expect(page_1.descendants).to eq([page_2, page_3])
-        end
-
-        context 'with url nesting enabled' do
-          before do
-            expect(Alchemy::Config).to receive(:get).with(:url_nesting).at_least(:once).and_return(true)
-          end
-
-          it "updates the pages urlnames" do
-            alchemy_xhr :post, :order, set: set_of_pages.to_json
-            [page_1, page_2, page_3].map(&:reload)
-            expect(page_1.urlname).to eq(page_1.slug.to_s)
-            expect(page_2.urlname).to eq("#{page_1.slug}/#{page_2.slug}")
-            expect(page_3.urlname).to eq("#{page_1.slug}/#{page_2.slug}/#{page_3.slug}")
-          end
-
-          context 'with invisible page in tree' do
-            let(:page_item_2) do
-              {
-                id: page_2.id,
-                slug: page_2.slug,
-                children: [page_item_3],
-                visible: false
-              }
-            end
-
-            it "does not use this pages slug in urlnames of descendants" do
-              alchemy_xhr :post, :order, set: set_of_pages.to_json
-              [page_1, page_2, page_3].map(&:reload)
-              expect(page_1.urlname).to eq(page_1.slug.to_s)
-              expect(page_2.urlname).to eq("#{page_1.slug}/#{page_2.slug}")
-              expect(page_3.urlname).to eq("#{page_1.slug}/#{page_3.slug}")
-            end
-          end
-
-          context 'with external page in tree' do
-            let(:page_item_2) do
-              {
-                id: page_2.id,
-                slug: page_2.slug,
-                children: [page_item_3],
-                external: true
-              }
-            end
-
-            it "does not use this pages slug in urlnames of descendants" do
-              alchemy_xhr :post, :order, set: set_of_pages.to_json
-              [page_1, page_2, page_3].map(&:reload)
-              expect(page_3.urlname).to eq("#{page_1.slug}/#{page_3.slug}")
-            end
-          end
-
-          context 'with restricted page in tree' do
-            let(:page_2) { create(:alchemy_page, restricted: true) }
-            let(:page_item_2) do
-              {
-                id: page_2.id,
-                slug: page_2.slug,
-                children: [page_item_3],
-                restricted: true
-              }
-            end
-
-            it "updates restricted status of descendants" do
-              alchemy_xhr :post, :order, set: set_of_pages.to_json
-              page_3.reload
-              expect(page_3.restricted).to be_truthy
-            end
-          end
-
-          context 'with page having number as slug' do
-            let(:page_item_2) do
-              {
-                id: page_2.id,
-                slug: 42,
-                children: [page_item_3]
-              }
-            end
-
-            it "does not raise error" do
-              expect {
-                alchemy_xhr :post, :order, set: set_of_pages.to_json
-              }.not_to raise_error
-            end
-
-            it "still generates the correct urlname on page_3" do
-              alchemy_xhr :post, :order, set: set_of_pages.to_json
-              [page_1, page_2, page_3].map(&:reload)
-              expect(page_3.urlname).to eq("#{page_1.slug}/#{page_2.slug}/#{page_3.slug}")
-            end
-          end
-
-          it "creates legacy urls" do
-            alchemy_xhr :post, :order, set: set_of_pages.to_json
-            [page_2, page_3].map(&:reload)
-            expect(page_2.legacy_urls.size).to eq(1)
-            expect(page_3.legacy_urls.size).to eq(1)
-          end
-        end
-      end
-
-      describe "#configure" do
-        render_views
-
-        context "with page having nested urlname" do
-          let(:page) { create(:alchemy_page, name: 'Foobar', urlname: 'foobar') }
-
-          it "should always show the slug" do
-            alchemy_xhr :get, :configure, {id: page.id}
-            expect(response.body).to match /value="foobar"/
-          end
-        end
-      end
-
-      describe '#create' do
-        let(:language)    { mock_model('Language', code: 'kl') }
-        let(:parent)      { mock_model('Page', language: language) }
-        let(:page_params) { {parent_id: parent.id, name: 'new Page'} }
-
-        context "a new page" do
-          before do
-            allow_any_instance_of(Page).to receive(:set_language_from_parent_or_default)
-            allow_any_instance_of(Page).to receive(:save).and_return(true)
-          end
-
-          it "is nested under given parent" do
-            allow(controller).to receive(:edit_admin_page_path).and_return('bla')
-            alchemy_xhr :post, :create, {page: page_params}
-            expect(assigns(:page).parent_id).to eq(parent.id)
-          end
-
-          it "redirects to edit page template" do
-            expect(controller).to receive(:edit_admin_page_path).and_return('bla')
-            alchemy_post :create, page: page_params
-            expect(response).to redirect_to('bla')
-          end
-
-          context "if new page can not be saved" do
-            it "renders the create form" do
-              allow_any_instance_of(Page).to receive(:save).and_return(false)
-              alchemy_post :create, page: {name: 'page'}
-              expect(response).to render_template('new')
-            end
-          end
-
-          context "with redirect_to in params" do
-            let(:page_params) do
-              {name: "Foobar", page_layout: 'standard', parent_id: parent.id}
-            end
-
-            it "should redirect to given url" do
-              alchemy_post :create, page: page_params, redirect_to: admin_pictures_path
-              expect(response).to redirect_to(admin_pictures_path)
-            end
-
-            context "but new page can not be saved" do
-              render_views
-
-              it "should render the `new` template" do
-                allow_any_instance_of(Page).to receive(:save).and_return(false)
-                alchemy_xhr :post, :create, page: {name: 'page'}, redirect_to: admin_pictures_path
-                expect(response.body).to match /form.+action=\"\/admin\/pages\"/
-              end
-            end
-          end
-
-          context 'with page redirecting to external' do
-            it "redirects to sitemap" do
-              expect_any_instance_of(Page).to receive(:redirects_to_external?).and_return(true)
-              alchemy_post :create, page: page_params
-              expect(response).to redirect_to(admin_pages_path)
-            end
-          end
-        end
-
-        context "with paste_from_clipboard in parameters" do
-          let(:page_in_clipboard) { mock_model(Alchemy::Page) }
-
-          before do
-            allow(Page).to receive(:find_by).with(id: parent.id.to_s).and_return(parent)
-            allow(Page).to receive(:find).with(page_in_clipboard.id.to_s).and_return(page_in_clipboard)
-          end
-
-          it "should call Page#copy_and_paste" do
-            expect(Page).to receive(:copy_and_paste).with(
-              page_in_clipboard,
-              parent,
-              'pasted Page'
-            ).and_return(
-              mock_model('Page', save: true, name: 'pasted Page', redirects_to_external?: false)
-            )
-            alchemy_xhr :post, :create, {paste_from_clipboard: page_in_clipboard.id, page: {parent_id: parent.id, name: 'pasted Page'}}
-          end
-        end
-      end
-
-      describe '#copy_language_tree' do
-        let(:params)                     { {languages: {new_lang_id: '2', old_lang_id: '1'}} }
-        let(:language_root_to_copy_from) { build_stubbed(:alchemy_page, :language_root) }
-        let(:copy_of_language_root)      { build_stubbed(:alchemy_page, :language_root) }
-        let(:root_page)                  { mock_model('Page') }
-
-        before do
-          allow(Page).to receive(:copy).and_return(copy_of_language_root)
-          allow(Page).to receive(:root).and_return(root_page)
-          allow(Page).to receive(:language_root_for).and_return(language_root_to_copy_from)
-          allow_any_instance_of(Page).to receive(:move_to_child_of)
-          allow_any_instance_of(Page).to receive(:copy_children_to)
-          allow(controller).to receive(:store_current_language)
-          allow(Language).to receive(:current).and_return(mock_model('Language', locale: 'de', code: 'de'))
-        end
-
-        it "should copy the language root page over to the other language" do
-          expect(Page).to receive(:copy).with(language_root_to_copy_from, {language_id: '2', language_code: 'de'})
-          alchemy_post :copy_language_tree, params
-        end
-
-        it "should move the newly created language-root-page below the absolute root page" do
-          expect(copy_of_language_root).to receive(:move_to_child_of).with(root_page)
-          alchemy_post :copy_language_tree, params
-        end
-
-        it "should copy all childs of the original page over to the new created one" do
-          expect(controller).to receive(:language_root_to_copy_from).and_return(language_root_to_copy_from)
-          expect(controller).to receive(:copy_of_language_root).and_return(copy_of_language_root)
-          expect(language_root_to_copy_from).to receive(:copy_children_to).with(copy_of_language_root)
-          alchemy_post :copy_language_tree, params
-        end
-
-        it "should redirect to admin_pages_path" do
-          allow(controller).to receive(:copy_of_language_root)
-          allow(controller).to receive(:language_root_to_copy_from).and_return(double(copy_children_to: nil))
-          alchemy_post :copy_language_tree, params
-          expect(response).to redirect_to(admin_pages_path)
-        end
-      end
-
-      describe '#edit' do
-        let!(:page)       { create(:alchemy_page) }
-        let!(:other_user) { create(:alchemy_dummy_user, :as_author) }
-
-        context 'if page is locked by another user' do
-          before { page.lock_to!(other_user) }
-
-          context 'that is signed in' do
-            before do
-              expect_any_instance_of(DummyUser).to receive(:logged_in?).and_return(true)
-            end
-
-            it 'redirects to sitemap' do
-              alchemy_get :edit, id: page.id
-              expect(response).to redirect_to(admin_pages_path)
-            end
-          end
-
-          context 'that is not signed in' do
-            before do
-              expect_any_instance_of(DummyUser).to receive(:logged_in?).and_return(false)
-            end
-
-            it 'renders the edit view' do
-              alchemy_get :edit, id: page.id
-              expect(response).to render_template(:edit)
-            end
-          end
-        end
-
-        context 'if page is locked by myself' do
-          before do
-            expect_any_instance_of(Page).to receive(:locker).and_return(user)
-            expect(user).to receive(:logged_in?).and_return(true)
-          end
-
-          it 'renders the edit view' do
-            alchemy_get :edit, id: page.id
-            expect(response).to render_template(:edit)
-          end
-        end
-
-        context 'if page is not locked' do
-          before do
-            expect_any_instance_of(Page).to receive(:locker).and_return(nil)
-          end
-
-          it 'renders the edit view' do
-            alchemy_get :edit, id: page.id
-            expect(response).to render_template(:edit)
-          end
-
-          it "lockes the page to myself" do
-            expect_any_instance_of(Page).to receive(:lock_to!)
-            alchemy_get :edit, id: page.id
-          end
-        end
-      end
-
-      describe '#destroy' do
-        let(:clipboard) { session[:alchemy_clipboard] = {} }
-        let(:page) { create(:alchemy_page, :public) }
-
-        before { clipboard['pages'] = [{'id' => page.id.to_s}] }
-
-        it "should also remove the page from clipboard" do
-          alchemy_xhr :post, :destroy, {id: page.id, _method: :delete}
-          expect(clipboard['pages']).to be_empty
-        end
-      end
-
-      describe '#publish' do
-        let(:page) { stub_model(Page, published_at: nil, public: false, name: "page", parent_id: 1, urlname: "page", language: stub_model(Language), page_layout: "bla") }
-
-        before do
-          allow(@controller).to receive(:load_page).and_return(page)
-          @controller.instance_variable_set("@page", page)
-        end
-
-        it "should publish the page" do
-          expect(page).to receive(:publish!)
-          alchemy_post :publish, { id: page.id }
-        end
-      end
-
-      describe '#visit' do
-        let(:page) { mock_model(Alchemy::Page, urlname: 'home') }
-
-        before do
-          allow(Page).to receive(:find).with(page.id.to_s).and_return(page)
-          allow(page).to receive(:unlock!).and_return(true)
-          allow(@controller).to receive(:multi_language?).and_return(false)
-        end
-
-        it "should redirect to the page path" do
-          expect(alchemy_post(:visit, id: page.id)).to redirect_to(show_page_path(urlname: 'home'))
-        end
-      end
-
-      describe '#fold' do
-        let(:page) { mock_model(Alchemy::Page) }
-        before { allow(Page).to receive(:find).and_return(page) }
-
-        context "if page is currently not folded" do
-          before { allow(page).to receive(:folded?).and_return(false) }
-
-          it "should fold the page" do
-            expect(page).to receive(:fold!).with(user.id, true).and_return(true)
-            alchemy_xhr :post, :fold, id: page.id
-          end
-        end
-
-        context "if page is already folded" do
-          before { allow(page).to receive(:folded?).and_return(true) }
-
-          it "should unfold the page" do
-            expect(page).to receive(:fold!).with(user.id, false).and_return(true)
-            alchemy_xhr :post, :fold, id: page.id
-          end
-        end
-      end
-
-      describe '#sort' do
-        before { allow(Page).to receive(:language_root_for).and_return(mock_model(Alchemy::Page)) }
-
-        it "should assign @sorting with true" do
-          alchemy_xhr :get, :sort
-          expect(assigns(:sorting)).to eq(true)
-        end
-      end
-
-      describe '#unlock' do
-        let(:page) { mock_model(Alchemy::Page, name: 'Best practices') }
-
-        before do
-          allow(Page).to receive(:find).with(page.id.to_s).and_return(page)
-          allow(Page).to receive(:from_current_site).and_return(double(locked_by: nil))
-          expect(page).to receive(:unlock!).and_return(true)
-        end
-
-        it "should unlock the page" do
-          alchemy_xhr :post, :unlock, id: page.id.to_s
-        end
-
-        context 'requesting for html format' do
-          it "should redirect to admin_pages_path" do
-            expect(alchemy_post(:unlock, id: page.id)).to redirect_to(admin_pages_path)
-          end
-
-          context 'if passing :redirect_to through params' do
-            it "should redirect to the given path" do
-              expect(
-                alchemy_post(:unlock, id: page.id, redirect_to: 'this/path')
-              ).to redirect_to('this/path')
-            end
-          end
-        end
-      end
-
-      describe "#switch_language" do
-        let(:language) { build_stubbed(:alchemy_language, :klingon) }
-
-        before do
-          allow(Language).to receive(:find_by).and_return(language)
-        end
-
-        it "should store the current language in session" do
-          alchemy_get :switch_language, {language_id: language.id}
-          expect(session[:alchemy_language_id]).to eq(language.id)
-        end
-
-        it "should redirect to sitemap" do
-          expect(
-            alchemy_get(:switch_language, language_id: language.id)
-          ).to redirect_to(admin_pages_path)
-        end
-
-        context "coming from layoutpages" do
-          before {
-            allow(request).to receive(:referer).and_return('admin/layoutpages')
-          }
-
-          it "should redirect to layoutpages" do
-            expect(
-              alchemy_get(:switch_language, language_id: language.id)
-            ).to redirect_to(admin_layoutpages_path)
-          end
-        end
-      end
-    end
-  end
-end