alchemy_cms 3.2.1 → 3.3.0.rc1

data/spec/controllers/{admin → alchemy/admin}/base_controller_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Alchemy::Admin::BaseController do
-
   describe '#options_from_params' do
     subject { controller.send(:options_from_params) }
 
@@ -71,4 +70,18 @@ describe Alchemy::Admin::BaseController do
     end
   end
 
+  context 'when current_alchemy_user is present' do
+    let!(:page) { create(:alchemy_page) }
+    let!(:user) { create(:alchemy_dummy_user, :as_admin) }
+
+    before do
+      allow(controller).to receive(:current_alchemy_user) { user }
+      page.lock_to!(user)
+    end
+
+    it 'loads locked pages' do
+      controller.send(:load_locked_pages)
+      expect(assigns(:locked_pages)).to include(page)
+    end
+  end
 end

data/spec/controllers/{admin → alchemy/admin}/clipboard_controller_spec.rb

@@ -2,9 +2,9 @@ require 'spec_helper'
 
 module Alchemy
   describe Admin::ClipboardController do
-    let(:public_page)     { build_stubbed(:public_page) }
-    let(:element)         { build_stubbed(:element, page: public_page) }
-    let(:another_element) { build_stubbed(:element, page: public_page) }
+    let(:public_page)     { build_stubbed(:alchemy_page, :public) }
+    let(:element)         { build_stubbed(:alchemy_element, page: public_page) }
+    let(:another_element) { build_stubbed(:alchemy_element, page: public_page) }
 
     before do
       authorize_user(:as_admin)

data/spec/controllers/{admin → alchemy/admin}/contents_controller_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 module Alchemy
   describe Admin::ContentsController do
-    let(:element) { build_stubbed(:element) }
-    let(:content) { build_stubbed(:content, element: element) }
+    let(:element) { build_stubbed(:alchemy_element) }
+    let(:content) { build_stubbed(:alchemy_content, element: element) }
 
     before do
       authorize_user(:as_admin)
@@ -15,7 +15,7 @@ module Alchemy
       end
 
       describe '#create' do
-        let(:element) { build_stubbed(:element, name: 'headline') }
+        let(:element) { build_stubbed(:alchemy_element, name: 'headline') }
 
         it "creates a content from name" do
           expect(Content).to receive(:create_from_scratch).and_return(content)
@@ -61,7 +61,7 @@ module Alchemy
     describe "#order" do
       context "with content_ids in params" do
         let(:element) do
-          create(:element, name: 'all_you_can_eat', create_contents_after_create: true)
+          create(:alchemy_element, name: 'all_you_can_eat', create_contents_after_create: true)
         end
 
         let(:content_ids) { element.contents.pluck(:id).shuffle }

data/spec/controllers/{admin → alchemy/admin}/dashboard_controller_spec.rb

@@ -2,14 +2,19 @@ require 'spec_helper'
 
 module Alchemy
   describe Admin::DashboardController do
-    let(:user) { build(:alchemy_dummy_user, :as_admin) }
+    let(:user) { build_stubbed(:alchemy_dummy_user, :as_admin) }
 
     before { authorize_user(user) }
 
     describe '#index' do
       before do
-        expect(Page).to receive(:from_current_site).and_return(double(all_last_edited_from: []))
-        expect(Page).to receive(:from_current_site).and_return(double(all_locked: []))
+        allow(Page).to receive(:from_current_site).and_return(
+          double(
+            all_last_edited_from: [],
+            locked_by: [],
+            locked: []
+          )
+        )
       end
 
       it "assigns @last_edited_pages" do
@@ -17,9 +22,9 @@ module Alchemy
         expect(assigns(:last_edited_pages)).to eq([])
       end
 
-      it "assigns @locked_pages" do
+      it "assigns @all_locked_pages" do
         alchemy_get :index
-        expect(assigns(:locked_pages)).to eq([])
+        expect(assigns(:all_locked_pages)).to eq([])
       end
 
       context 'with user class having logged_in scope' do
@@ -47,7 +52,7 @@ module Alchemy
       context 'user having signed in before' do
         before do
           expect(user).to receive(:sign_in_count).and_return(5)
-          expect(user).to receive(:last_sign_in_at).and_return(Time.now)
+          expect(user).to receive(:last_sign_in_at).and_return(Time.current)
         end
 
         it "assigns @first_time" do

data/spec/controllers/{admin → alchemy/admin}/elements_controller_spec.rb

@@ -2,22 +2,22 @@ require 'spec_helper'
 
 module Alchemy
   describe Admin::ElementsController do
-    let(:alchemy_page)         { create(:page) }
-    let(:element)              { create(:element, :page_id => alchemy_page.id) }
-    let(:element_in_clipboard) { create(:element, :page_id => alchemy_page.id) }
+    let(:alchemy_page)         { create(:alchemy_page) }
+    let(:element)              { create(:alchemy_element, page_id: alchemy_page.id) }
+    let(:element_in_clipboard) { create(:alchemy_element, page_id: alchemy_page.id) }
     let(:clipboard)            { session[:alchemy_clipboard] = {} }
 
     before { authorize_user(:as_author) }
 
     describe '#index' do
-      let(:alchemy_page) { build_stubbed(:page) }
+      let(:alchemy_page) { build_stubbed(:alchemy_page) }
 
       before do
         expect(Page).to receive(:find).and_return alchemy_page
       end
 
       context 'with cells' do
-        let(:cell) { build_stubbed(:cell, page: alchemy_page) }
+        let(:cell) { build_stubbed(:alchemy_cell, page: alchemy_page) }
 
         before do
           expect(alchemy_page).to receive(:cells).and_return [cell]
@@ -69,9 +69,9 @@ module Alchemy
     end
 
     describe '#order' do
-      let(:element_1)   { FactoryGirl.create(:element) }
-      let(:element_2)   { FactoryGirl.create(:element) }
-      let(:element_3)   { FactoryGirl.create(:element) }
+      let(:element_1)   { create(:alchemy_element) }
+      let(:element_2)   { create(:alchemy_element) }
+      let(:element_3)   { create(:alchemy_element) }
       let(:element_ids) { [element_1.id, element_3.id, element_2.id] }
 
       it "sets new position for given element ids" do
@@ -79,8 +79,16 @@ module Alchemy
         expect(Element.all.pluck(:id)).to eq(element_ids)
       end
 
+      context 'with missing [:element_ids] param' do
+        it 'does not raise any error and silently rejects to order' do
+          expect {
+            alchemy_xhr :post, :order
+          }.to_not raise_error
+        end
+      end
+
       context "untrashing" do
-        let(:trashed_element) { FactoryGirl.create(:element, public: false, position: nil, page_id: 58, cell_id: 32) }
+        let(:trashed_element) { create(:alchemy_element, public: false, position: nil, page_id: 58, cell_id: 32) }
 
         before do
           # Because of a before_create filter it can not be created with a nil position and needs to be trashed here
@@ -113,10 +121,10 @@ module Alchemy
     end
 
     describe '#new' do
-      let(:alchemy_page) { build_stubbed(:page) }
+      let(:alchemy_page) { build_stubbed(:alchemy_page) }
 
       before do
-        expect(Page).to receive(:find_by_id).and_return(alchemy_page)
+        expect(Page).to receive(:find).and_return(alchemy_page)
       end
 
       it "assign variable for all available element definitions" do
@@ -165,7 +173,7 @@ module Alchemy
       end
 
       context "if page has cells" do
-        let(:page) { create(:public_page, do_not_autogenerate: false) }
+        let(:page) { create(:alchemy_page, :public, do_not_autogenerate: false) }
         let(:cell) { page.cells.first }
 
         context "not pasting from clipboard" do
@@ -234,17 +242,17 @@ module Alchemy
 
             context "and no cell name in element name" do
               it "should create the element in the nil cell" do
-                alchemy_xhr :post, :create, {element: {page_id: page.id}, paste_from_clipboard: "#{element_in_clipboard.id}"}
+                alchemy_xhr :post, :create, {element: {page_id: page.id}, paste_from_clipboard: element_in_clipboard.id.to_s}
                 expect(page.elements.first.cell).to eq(nil)
               end
             end
           end
 
           context "on a page with a setting for insert_elements_at of top" do
-            let!(:alchemy_page)         { create(:public_page, name: 'News') }
-            let!(:element_in_clipboard) { create(:element, page: alchemy_page, name: 'news') }
-            let!(:cell)                 { create(:cell, name: 'news', page: alchemy_page) }
-            let!(:element)              { create(:element, name: 'news', page: alchemy_page, cell: cell) }
+            let!(:alchemy_page)         { create(:alchemy_page, :public, name: 'News') }
+            let!(:element_in_clipboard) { create(:alchemy_element, page: alchemy_page, name: 'news') }
+            let!(:cell)                 { create(:alchemy_cell, name: 'news', page: alchemy_page) }
+            let!(:element)              { create(:alchemy_element, name: 'news', page: alchemy_page, cell: cell) }
 
             before do
               expect(PageLayout).to receive(:get).at_least(:once).and_return({
@@ -329,7 +337,7 @@ module Alchemy
 
         context "with the cell already present" do
           before do
-            create(:cell, page: alchemy_page, name: 'header')
+            create(:alchemy_cell, page: alchemy_page, name: 'header')
           end
 
           it "should load the cell" do
@@ -363,8 +371,8 @@ module Alchemy
     end
 
     describe '#update' do
-      let(:page)    { build_stubbed(:page) }
-      let(:element) { build_stubbed(:element, page: page) }
+      let(:page)    { build_stubbed(:alchemy_page) }
+      let(:element) { build_stubbed(:alchemy_element, page: page) }
       let(:contents_parameters) { ActionController::Parameters.new(1 => {ingredient: 'Title'}) }
       let(:element_parameters) { ActionController::Parameters.new(tag_list: 'Tag 1', public: false) }
 
@@ -414,16 +422,31 @@ module Alchemy
       context "element params" do
         let(:parameters) { ActionController::Parameters.new(element: {public: true}) }
 
-        specify ":element is required" do
-          expect(controller.params).to receive(:require).with(:element).and_return(parameters)
-          controller.send :element_params
+        before do
+          expect(controller).to receive(:params).and_return(parameters)
+          expect(parameters).to receive(:fetch).with(:element, {}).and_return(parameters)
         end
 
-        specify ":public and :tag_list is permitted" do
-          expect(controller).to receive(:params).and_return(parameters)
-          expect(parameters).to receive(:require).with(:element).and_return(parameters)
-          expect(parameters).to receive(:permit).with(:public, :tag_list)
-          controller.send :element_params
+        context 'with taggable element' do
+          before do
+            controller.instance_variable_set(:'@element', mock_model(Element, taggable?: true))
+          end
+
+          specify ":tag_list is permitted" do
+            expect(parameters).to receive(:permit).with(:tag_list)
+            controller.send :element_params
+          end
+        end
+
+        context 'with not taggable element' do
+          before do
+            controller.instance_variable_set(:'@element', mock_model(Element, taggable?: false))
+          end
+
+          specify ":tag_list is not permitted" do
+            expect(parameters).to_not receive(:permit)
+            controller.send :element_params
+          end
         end
       end
     end
@@ -431,7 +454,7 @@ module Alchemy
     describe '#trash' do
       subject { alchemy_xhr :delete, :trash, {id: element.id} }
 
-      let(:element) { build_stubbed(:element) }
+      let(:element) { build_stubbed(:alchemy_element) }
 
       before { expect(Element).to receive(:find).and_return element }
 
@@ -444,7 +467,7 @@ module Alchemy
     describe '#fold' do
       subject { alchemy_xhr :post, :fold, {id: element.id} }
 
-      let(:element) { build_stubbed(:element) }
+      let(:element) { build_stubbed(:alchemy_element) }
 
       before do
         expect(element).to receive(:save).and_return true
@@ -455,7 +478,7 @@ module Alchemy
         before { expect(element).to receive(:folded).and_return true }
 
         it "sets folded to false." do
-          expect(element).to receive(:folded=).with(false).and_return(true)
+          expect(element).to receive(:folded=).with(false).and_return(false)
           subject
         end
       end

data/spec/controllers/{admin → alchemy/admin}/essence_files_controller_spec.rb

@@ -29,21 +29,26 @@ module Alchemy
     end
 
     describe '#update' do
-      let(:essence_file) { FactoryGirl.create(:essence_file) }
+      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'}
+        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(:content) }
+      let(:content) { create(:alchemy_content) }
 
       before do
         expect(Content).to receive(:find_by).and_return(content)

data/spec/controllers/{admin → alchemy/admin}/essence_pictures_controller_spec.rb

@@ -33,7 +33,7 @@ module Alchemy
 
         it "renders error message" do
           alchemy_get :crop, id: 1
-          expect(assigns(:no_image_notice)).to eq(Alchemy::I18n.t(:no_image_for_cropper_found))
+          expect(assigns(:no_image_notice)).to eq(Alchemy.t(:no_image_for_cropper_found))
         end
       end
 
@@ -153,7 +153,7 @@ module Alchemy
         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)
+            expect(assigns(:ratio)).to eq(80.0 / 60.0)
           end
         end
       end
@@ -179,7 +179,7 @@ module Alchemy
     end
 
     describe '#assign' do
-      let(:content) { create(:content) }
+      let(:content) { create(:alchemy_content) }
 
       before do
         expect(Content).to receive(:find).and_return(content)

data/spec/controllers/{admin → alchemy/admin}/languages_controller_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Alchemy::Admin::LanguagesController do
-
   before do
     authorize_user(:as_admin)
   end
@@ -58,4 +57,17 @@ describe Alchemy::Admin::LanguagesController do
       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/{admin → alchemy/admin}/layoutpages_controller_spec.rb

@@ -2,17 +2,11 @@ require 'spec_helper'
 
 module Alchemy
   describe Admin::LayoutpagesController do
-
     before(:each) do
       authorize_user(:as_admin)
     end
 
     describe "#index" do
-      it "should assign @locked_pages" do
-        alchemy_get :index
-        expect(assigns(:locked_pages)).to eq([])
-      end
-
       it "should assign @layout_root" do
         alchemy_get :index
         expect(assigns(:layout_root)).to be_a(Page)

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

@@ -3,7 +3,6 @@ require 'spec_helper'
 
 module Alchemy
   describe Admin::PagesController do
-
     context 'a guest' do
       it 'can not access page tree' do
         alchemy_get :index
@@ -26,8 +25,8 @@ module Alchemy
       before { authorize_user(user) }
 
       describe '#index' do
-        let(:language)      { build_stubbed(:language) }
-        let(:language_root) { build_stubbed(:language_root_page) }
+        let(:language)      { build_stubbed(:alchemy_language) }
+        let(:language_root) { build_stubbed(:alchemy_page, :language_root) }
 
         context 'with existing language root page' do
           before do
@@ -55,11 +54,74 @@ module Alchemy
         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(:public_page, name: "content page 1", published_at: Time.current - 5.days) }
-        let(:content_page_2) { create(:public_page, name: "content page 2", published_at: Time.current - 8.days) }
-        let(:layout_page_1)  { create(:page, layoutpage: true, name: "layout_page 1", published_at: Time.current - 5.days) }
-        let(:layout_page_2)  { create(:page, layoutpage: true, name: "layout_page 2", published_at: Time.current - 8.days) }
+        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] }
 
@@ -104,10 +166,11 @@ module Alchemy
       end
 
       describe '#show' do
-        let(:page) { build_stubbed(:page, language_code: 'nl') }
+        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}").and_return(page)
+          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
 
@@ -134,9 +197,9 @@ module Alchemy
       end
 
       describe '#order' do
-        let(:page_1)       { FactoryGirl.create(:page, visible: true) }
-        let(:page_2)       { FactoryGirl.create(:page, visible: true) }
-        let(:page_3)       { FactoryGirl.create(:page, visible: true) }
+        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? } }
@@ -156,7 +219,7 @@ module Alchemy
           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}")
+            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
@@ -174,7 +237,7 @@ module Alchemy
             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}")
+              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
@@ -198,7 +261,7 @@ module Alchemy
           end
 
           context 'with restricted page in tree' do
-            let(:page_2) { FactoryGirl.create(:page, restricted: true) }
+            let(:page_2) { create(:alchemy_page, restricted: true) }
             let(:page_item_2) do
               {
                 id: page_2.id,
@@ -250,7 +313,7 @@ module Alchemy
         render_views
 
         context "with page having nested urlname" do
-          let(:page) { create(:page, name: 'Foobar', urlname: 'foobar') }
+          let(:page) { create(:alchemy_page, name: 'Foobar', urlname: 'foobar') }
 
           it "should always show the slug" do
             alchemy_xhr :get, :configure, {id: page.id}
@@ -277,7 +340,6 @@ module Alchemy
           end
 
           it "redirects to edit page template" do
-            page = mock_model('Page')
             expect(controller).to receive(:edit_admin_page_path).and_return('bla')
             alchemy_post :create, page: page_params
             expect(response).to redirect_to('bla')
@@ -325,8 +387,8 @@ module Alchemy
           let(:page_in_clipboard) { mock_model(Alchemy::Page) }
 
           before do
-            allow(Page).to receive(:find_by).with(id: "#{parent.id}").and_return(parent)
-            allow(Page).to receive(:find).with("#{page_in_clipboard.id}").and_return(page_in_clipboard)
+            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
@@ -344,8 +406,8 @@ module Alchemy
 
       describe '#copy_language_tree' do
         let(:params)                     { {languages: {new_lang_id: '2', old_lang_id: '1'}} }
-        let(:language_root_to_copy_from) { build_stubbed(:language_root_page) }
-        let(:copy_of_language_root)      { build_stubbed(:language_root_page) }
+        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
@@ -355,11 +417,11 @@ module Alchemy
           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', language_code: 'it', code: 'it'))
+          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: 'it'})
+          expect(Page).to receive(:copy).with(language_root_to_copy_from, {language_id: '2', language_code: 'de'})
           alchemy_post :copy_language_tree, params
         end
 
@@ -384,7 +446,7 @@ module Alchemy
       end
 
       describe '#edit' do
-        let!(:page)       { create(:page) }
+        let!(:page)       { create(:alchemy_page) }
         let!(:other_user) { create(:alchemy_dummy_user, :as_author) }
 
         context 'if page is locked by another user' do
@@ -444,7 +506,7 @@ module Alchemy
 
       describe '#destroy' do
         let(:clipboard) { session[:alchemy_clipboard] = {} }
-        let(:page) { FactoryGirl.create(:public_page) }
+        let(:page) { create(:alchemy_page, :public) }
 
         before { clipboard['pages'] = [{'id' => page.id.to_s}] }
 
@@ -472,13 +534,13 @@ module Alchemy
         let(:page) { mock_model(Alchemy::Page, urlname: 'home') }
 
         before do
-          allow(Page).to receive(:find).with("#{page.id}").and_return(page)
+          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'))
+          expect(alchemy_post(:visit, id: page.id)).to redirect_to(show_page_path(urlname: 'home'))
         end
       end
 
@@ -518,30 +580,32 @@ module Alchemy
         let(:page) { mock_model(Alchemy::Page, name: 'Best practices') }
 
         before do
-          allow(Page).to receive(:find).with("#{page.id}").and_return(page)
-          allow(Page).to receive(:from_current_site).and_return(double(all_locked_by: nil))
+          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}"
+          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)
+            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')
+              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(:klingonian)}
+        let(:language) { build_stubbed(:alchemy_language, :klingon) }
 
         before do
           allow(Language).to receive(:find_by).and_return(language)
@@ -553,7 +617,9 @@ module Alchemy
         end
 
         it "should redirect to sitemap" do
-          expect(alchemy_get :switch_language, {language_id: language.id}).to redirect_to(admin_pages_path)
+          expect(
+            alchemy_get(:switch_language, language_id: language.id)
+          ).to redirect_to(admin_pages_path)
         end
 
         context "coming from layoutpages" do
@@ -562,7 +628,9 @@ module Alchemy
           }
 
           it "should redirect to layoutpages" do
-            expect(alchemy_get :switch_language, {language_id: language.id}).to redirect_to(admin_layoutpages_path)
+            expect(
+              alchemy_get(:switch_language, language_id: language.id)
+            ).to redirect_to(admin_layoutpages_path)
           end
         end
       end