alchemy_cms 3.0.4 → 3.1.0.beta1

data/spec/controllers/admin/essence_files_controller_spec.rb

@@ -2,7 +2,6 @@ require "spec_helper"
 
 module Alchemy
   describe Admin::EssenceFilesController do
-
     before do
       sign_in(admin_user)
     end
@@ -13,7 +12,7 @@ module Alchemy
 
     describe '#edit' do
       before do
-        Content.stub(find: content)
+        expect(Content).to receive(:find).and_return(content)
       end
 
       it "should assign @content with the Content found by id" do
@@ -29,19 +28,19 @@ module Alchemy
 
     describe '#update' do
       before do
-        EssenceFile.stub(find: essence_file)
+        expect(EssenceFile).to receive(:find).and_return(essence_file)
       end
 
       it "should update the attributes of essence_file" do
-        essence_file.should_receive(:update_attributes).and_return(true)
+        expect(essence_file).to receive(:update_attributes).and_return(true)
         xhr :put, :update, id: essence_file.id
       end
     end
 
     describe '#assign' do
       before do
-        Content.stub(find_by: content)
-        Attachment.stub(find_by: attachment)
+        expect(Content).to receive(:find_by).and_return(content)
+        expect(Attachment).to receive(:find_by).and_return(attachment)
       end
 
       it "should assign @attachment with the Attachment found by attachment_id" do
@@ -50,7 +49,7 @@ module Alchemy
       end
 
       it "should assign @content.essence.attachment with the attachment found by id" do
-        content.essence.should_receive(:attachment=).with(attachment)
+        expect(content.essence).to receive(:attachment=).with(attachment)
         xhr :put, :assign, content_id: content.id, attachment_id: attachment.id
       end
 

data/spec/controllers/admin/essence_pictures_controller_spec.rb

@@ -10,8 +10,8 @@ module Alchemy
 
     describe '#edit' do
       before do
-        EssencePicture.should_receive(:find).and_return(essence)
-        Content.should_receive(:find).and_return(content)
+        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
@@ -23,11 +23,13 @@ module Alchemy
 
     describe '#crop' do
       before do
-        EssencePicture.should_receive(:find).and_return(essence)
+        expect(EssencePicture).to receive(:find).and_return(essence)
       end
 
       context 'with no picture assigned' do
-        before { essence.should_receive(:picture).and_return(nil) }
+        before do
+          expect(essence).to receive(:picture).at_least(:once).and_return(nil)
+        end
 
         it "renders error message" do
           get :crop, id: 1
@@ -36,69 +38,86 @@ module Alchemy
       end
 
       context 'with picture assigned' do
-        let(:default_mask) { {'x1' => '0', 'y1' => '0', 'x2' => '100', 'y2' => '100'} }
+        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
-          essence.should_receive(:picture).any_number_of_times.and_return(picture)
+          expect(essence).to receive(:picture).at_least(:once).and_return(picture)
         end
 
         context 'with no render_size present in essence' do
           before do
-            essence.should_receive(:render_size).and_return(nil)
+            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
               get :crop, id: 1, options: {image_size: '300x250'}
-              expect(assigns(:size_x)).to eq('300')
-              expect(assigns(:size_y)).to eq('250')
+              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
               get :crop, id: 1
-              expect(assigns(:size_x)).to eq(0)
-              expect(assigns(:size_y)).to eq(0)
+              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
-            essence.stub(:render_size).and_return('30x25')
+            expect(essence).to receive(:render_size).at_least(:once).and_return('30x25')
 
             get :crop, id: 1
-            expect(assigns(:size_x)).to eq(30)
-            expect(assigns(:size_y)).to eq(25)
+            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
-              essence.stub(:render_size).and_return('30')
+              expect(essence).to receive(:render_size).at_least(:once).and_return('30x')
 
               get :crop, id: 1
-              expect(assigns(:size_x)).to eq(30)
-              expect(assigns(:size_y)).to eq(25)
+              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')
+
+              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')
+
+              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
-              essence.stub(:render_size).and_return('x25')
+              expect(essence).to receive(:render_size).at_least(:once).and_return('x25')
 
               get :crop, id: 1
-              expect(assigns(:size_x)).to eq(30)
-              expect(assigns(:size_y)).to eq(25)
+              expect(assigns(:min_size)).to eq({ width: 0, height: 25})
             end
           end
         end
 
         context 'no crop sizes present in essence' do
           before do
-            essence.stub(:crop_from).and_return(nil)
-            essence.stub(:crop_size).and_return(nil)
-            picture.should_receive(:default_mask).and_return(default_mask)
+            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
@@ -112,13 +131,12 @@ module Alchemy
           let(:mask) { {'x1' => '0', 'y1' => '0', 'x2' => '120', 'y2' => '160'} }
 
           before do
-            essence.stub(:crop_from).and_return('0x0')
-            essence.stub(:crop_size).and_return('120x160')
-            picture.should_receive(:default_mask).and_return(default_mask)
+            allow(essence).to receive(:crop_from).and_return('0x0')
+            allow(essence).to receive(:crop_size).and_return('120x160')
           end
 
           it "assigns cropping boxes" do
-            essence.should_receive(:cropping_mask).and_return(mask)
+            expect(essence).to receive(:cropping_mask).and_return(mask)
             get :crop, id: 1
             expect(assigns(:initial_box)).to eq(mask)
             expect(assigns(:default_box)).to eq(default_mask)
@@ -138,40 +156,33 @@ module Alchemy
             expect(assigns(:ratio)).to eq(80.0/60.0)
           end
         end
-
-        context 'with size_y set to zero' do
-          it "sets ratio to 1" do
-            get :crop, id: 1
-            expect(assigns(:ratio)).to eq(1)
-          end
-        end
       end
     end
 
     describe '#update' do
       before do
-        EssencePicture.should_receive(:find).and_return(essence)
-        Content.should_receive(:find).and_return(content)
+        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
-        essence.should_receive(:update).and_return(true)
+        expect(essence).to receive(:update).and_return(true)
         xhr :put, :update, id: 1, essence_picture: attributes
       end
 
       it "saves the cropping mask" do
-        essence.should_receive(:update).and_return(true)
+        expect(essence).to receive(:update).and_return(true)
         xhr :put, :update, id: 1, essence_picture: {render_size: '1x1', crop_from: '0x0', crop_size: '100x100'}
       end
     end
 
     describe '#assign' do
       before do
-        Content.should_receive(:find).and_return(content)
-        Content.any_instance.stub(:essence).and_return(essence)
-        Picture.should_receive(:find_by_id).and_return(picture)
+        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
@@ -179,6 +190,5 @@ module Alchemy
         expect(assigns(:content).essence.picture).to eq(picture)
       end
     end
-
   end
 end

data/spec/controllers/admin/languages_controller_spec.rb

@@ -14,7 +14,7 @@ describe Alchemy::Admin::LanguagesController do
     context "when default_language.page_layout is set" do
       it "should use it as page_layout-default for the new language" do
         # FML :/
-        Alchemy::Config.stub(:get) do |arg|
+        allow(Alchemy::Config).to receive(:get) do |arg|
           if arg == :default_language
             {'page_layout' => "new_standard"}
           else
@@ -22,14 +22,14 @@ describe Alchemy::Admin::LanguagesController do
           end
         end
         get :new
-        assigns(:language).page_layout.should eql("new_standard")
+        expect(assigns(:language).page_layout).to eql("new_standard")
       end
     end
 
     context "when default_language or page_layout aren't configured" do
       it "should fallback to one configured in config.yml" do
         get :new
-        assigns(:language).page_layout.should eql("index")
+        expect(assigns(:language).page_layout).to eql("index")
       end
     end
 

data/spec/controllers/admin/pages_controller_spec.rb

@@ -12,26 +12,26 @@ module Alchemy
 
       context 'with existing language root page' do
         before do
-          Language.should_receive(:current_root_page).and_return(language_root)
+          expect(Language).to receive(:current_root_page).and_return(language_root)
         end
 
         it "assigns @page_root variable" do
           get :index
-          assigns(:page_root).should be(language_root)
+          expect(assigns(:page_root)).to be(language_root)
         end
       end
 
       context 'without language root page' do
         before do
-          Language.should_receive(:current_root_page).and_return(nil)
-          Language.stub(find_by: language)
-          Language.stub(all: [language])
-          Language.stub(with_root_page: [language])
+          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
           get :index
-          assigns(:language).should be(language)
+          expect(assigns(:language)).to be(language)
         end
       end
     end
@@ -42,12 +42,12 @@ module Alchemy
       let(:page_2)   { build_stubbed(:page) }
 
       before do
-        Language.stub(current: language)
+        expect(Language).to receive(:current).at_least(:once).and_return(language)
       end
 
       it "should remove the cache of all pages" do
-        page_1.should_receive(:publish!)
-        page_2.should_receive(:publish!)
+        expect(page_1).to receive(:publish!)
+        expect(page_2).to receive(:publish!)
         xhr :post, :flush
       end
     end
@@ -61,17 +61,17 @@ module Alchemy
 
         it "should load all pages from clipboard" do
           xhr :get, :new, {page_id: page.id}
-          assigns(:clipboard_items).should be_kind_of(Array)
+          expect(assigns(:clipboard_items)).to be_kind_of(Array)
         end
       end
     end
 
     describe '#show' do
-      let(:page) { mock_model(Alchemy::Page, language_code: 'nl') }
+      let(:page) { build_stubbed(:page, language_code: 'nl') }
 
       before do
-        Page.should_receive(:find).with("#{page.id}").and_return(page)
-        Page.stub(:language_root_for).and_return(mock_model(Alchemy::Page))
+        expect(Page).to receive(:find).with("#{page.id}").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
@@ -82,7 +82,7 @@ module Alchemy
       it "should store page as current preview" do
         Page.current_preview = nil
         get :show, id: page.id
-        Page.current_preview.should == page
+        expect(Page.current_preview).to eq(page)
       end
 
       it "should set the I18n locale to the pages language code" do
@@ -112,7 +112,9 @@ module Alchemy
       end
 
       context 'with url nesting enabled' do
-        before { Alchemy::Config.stub(get: true) }
+        before do
+          expect(Alchemy::Config).to receive(:get).with(:url_nesting).at_least(:once).and_return(true)
+        end
 
         it "updates the pages urlnames" do
           xhr :post, :order, set: set_of_pages.to_json
@@ -172,7 +174,7 @@ module Alchemy
           it "updates restricted status of descendants" do
             xhr :post, :order, set: set_of_pages.to_json
             page_3.reload
-            expect(page_3.restricted).to be_true
+            expect(page_3.restricted).to be_truthy
           end
         end
 
@@ -188,7 +190,11 @@ module Alchemy
           it "does not raise error" do
             expect {
               xhr :post, :order, set: set_of_pages.to_json
-            }.to_not raise_error(TypeError)
+            }.not_to raise_error
+          end
+
+          it "still generates the correct urlname on page_3" do
+            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
@@ -211,7 +217,7 @@ module Alchemy
 
         it "should always show the slug" do
           xhr :get, :configure, {id: page.id}
-          response.body.should match /value="foobar"/
+          expect(response.body).to match /value="foobar"/
         end
       end
     end
@@ -223,28 +229,28 @@ module Alchemy
 
       context "a new page" do
         before do
-          Page.any_instance.stub(:set_language_from_parent_or_default)
-          Page.any_instance.stub(save: true)
+          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
-          controller.stub(:edit_admin_page_path).and_return('bla')
+          allow(controller).to receive(:edit_admin_page_path).and_return('bla')
           xhr :post, :create, {page: page_params}
           expect(assigns(:page).parent_id).to eq(parent.id)
         end
 
         it "redirects to edit page template" do
           page = mock_model('Page')
-          controller.should_receive(:edit_admin_page_path).and_return('bla')
+          expect(controller).to receive(:edit_admin_page_path).and_return('bla')
           post :create, page: page_params
-          response.should redirect_to('bla')
+          expect(response).to redirect_to('bla')
         end
 
         context "if new page can not be saved" do
           it "renders the create form" do
-            Page.any_instance.stub(:save).and_return(false)
+            allow_any_instance_of(Page).to receive(:save).and_return(false)
             post :create, page: {name: 'page'}
-            response.should render_template('new')
+            expect(response).to render_template('new')
           end
         end
 
@@ -255,25 +261,25 @@ module Alchemy
 
           it "should redirect to given url" do
             post :create, page: page_params, redirect_to: admin_pictures_path
-            response.should 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
-              Page.any_instance.stub(:save).and_return(false)
+              allow_any_instance_of(Page).to receive(:save).and_return(false)
               xhr :post, :create, page: {name: 'page'}, redirect_to: admin_pictures_path
-              response.body.should match /form.+action=\"\/admin\/pages\"/
+              expect(response.body).to match /form.+action=\"\/admin\/pages\"/
             end
           end
         end
 
         context 'with page redirecting to external' do
           it "redirects to sitemap" do
-            Page.any_instance.should_receive(:redirects_to_external?).and_return(true)
+            expect_any_instance_of(Page).to receive(:redirects_to_external?).and_return(true)
             post :create, page: page_params
-            response.should redirect_to(admin_pages_path)
+            expect(response).to redirect_to(admin_pages_path)
           end
         end
       end
@@ -282,12 +288,12 @@ module Alchemy
         let(:page_in_clipboard) { mock_model(Alchemy::Page) }
 
         before do
-          Page.stub(:find_by).with(id: "#{parent.id}").and_return(parent)
-          Page.stub(:find).with("#{page_in_clipboard.id}").and_return(page_in_clipboard)
+          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)
         end
 
         it "should call Page#copy_and_paste" do
-          Page.should_receive(:copy_and_paste).with(
+          expect(Page).to receive(:copy_and_paste).with(
             page_in_clipboard,
             parent,
             'pasted Page'
@@ -306,35 +312,35 @@ module Alchemy
       let(:root_page)                  { mock_model('Page') }
 
       before do
-        Page.stub(copy: copy_of_language_root)
-        Page.stub(root: root_page)
-        Page.stub(language_root_for: language_root_to_copy_from)
-        Page.any_instance.stub(:move_to_child_of)
-        Page.any_instance.stub(:copy_children_to)
-        controller.stub(:store_current_language)
-        Language.stub(:current).and_return(mock_model('Language', language_code: 'it', code: 'it'))
+        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', language_code: 'it', code: 'it'))
       end
 
       it "should copy the language root page over to the other language" do
-        Page.should_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: 'it'})
         post :copy_language_tree, params
       end
 
       it "should move the newly created language-root-page below the absolute root page" do
-        copy_of_language_root.should_receive(:move_to_child_of).with(root_page)
+        expect(copy_of_language_root).to receive(:move_to_child_of).with(root_page)
         post :copy_language_tree, params
       end
 
       it "should copy all childs of the original page over to the new created one" do
-        controller.stub(language_root_to_copy_from: language_root_to_copy_from)
-        controller.stub(copy_of_language_root: copy_of_language_root)
-        language_root_to_copy_from.should_receive(:copy_children_to).with(copy_of_language_root)
+        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)
         post :copy_language_tree, params
       end
 
       it "should redirect to admin_pages_path" do
-        controller.stub(:copy_of_language_root)
-        controller.stub_chain(:language_root_to_copy_from, :copy_children_to)
+        allow(controller).to receive(:copy_of_language_root)
+        allow(controller).to receive(:language_root_to_copy_from).and_return(double(copy_children_to: nil))
         post :copy_language_tree, params
         expect(response).to redirect_to(admin_pages_path)
       end
@@ -348,7 +354,9 @@ module Alchemy
         before { page.lock_to!(other_user) }
 
         context 'that is signed in' do
-          before { DummyUser.any_instance.stub(logged_in?: true) }
+          before do
+            expect_any_instance_of(DummyUser).to receive(:logged_in?).and_return(true)
+          end
 
           it 'redirects to sitemap' do
             get :edit, id: page.id
@@ -357,7 +365,9 @@ module Alchemy
         end
 
         context 'that is not signed in' do
-          before { DummyUser.any_instance.stub(logged_in?: false) }
+          before do
+            expect_any_instance_of(DummyUser).to receive(:logged_in?).and_return(false)
+          end
 
           it 'renders the edit view' do
             get :edit, id: page.id
@@ -368,8 +378,8 @@ module Alchemy
 
       context 'if page is locked by myself' do
         before do
-          Page.any_instance.stub(locker: user)
-          user.stub(logged_in?: true)
+          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
@@ -380,7 +390,7 @@ module Alchemy
 
       context 'if page is not locked' do
         before do
-          Page.any_instance.stub(locker: nil)
+          expect_any_instance_of(Page).to receive(:locker).and_return(nil)
         end
 
         it 'renders the edit view' do
@@ -389,7 +399,7 @@ module Alchemy
         end
 
         it "lockes the page to myself" do
-          Page.any_instance.should_receive(:lock_to!)
+          expect_any_instance_of(Page).to receive(:lock_to!)
           get :edit, id: page.id
         end
       end
@@ -403,7 +413,7 @@ module Alchemy
 
       it "should also remove the page from clipboard" do
         xhr :post, :destroy, {id: page.id, _method: :delete}
-        clipboard['pages'].should be_empty
+        expect(clipboard['pages']).to be_empty
       end
     end
 
@@ -411,12 +421,12 @@ module Alchemy
       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
-        @controller.stub(:load_page).and_return(page)
+        allow(@controller).to receive(:load_page).and_return(page)
         @controller.instance_variable_set("@page", page)
       end
 
       it "should publish the page" do
-        page.should_receive(:publish!)
+        expect(page).to receive(:publish!)
         post :publish, { id: page.id }
       end
     end
@@ -425,9 +435,9 @@ module Alchemy
       let(:page) { mock_model(Alchemy::Page, urlname: 'home') }
 
       before do
-        Page.stub(:find).with("#{page.id}").and_return(page)
-        page.stub(:unlock!).and_return(true)
-        @controller.stub(:multi_language?).and_return(false)
+        allow(Page).to receive(:find).with("#{page.id}").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
@@ -437,29 +447,29 @@ module Alchemy
 
     describe '#fold' do
       let(:page) { mock_model(Alchemy::Page) }
-      before { Page.stub(:find).and_return(page) }
+      before { allow(Page).to receive(:find).and_return(page) }
 
       context "if page is currently not folded" do
-        before { page.stub(:folded?).and_return(false) }
+        before { allow(page).to receive(:folded?).and_return(false) }
 
         it "should fold the page" do
-          page.should_receive(:fold!).with(user.id, true).and_return(true)
+          expect(page).to receive(:fold!).with(user.id, true).and_return(true)
           xhr :post, :fold, id: page.id
         end
       end
 
       context "if page is already folded" do
-        before { page.stub(:folded?).and_return(true) }
+        before { allow(page).to receive(:folded?).and_return(true) }
 
         it "should unfold the page" do
-          page.should_receive(:fold!).with(user.id, false).and_return(true)
+          expect(page).to receive(:fold!).with(user.id, false).and_return(true)
           xhr :post, :fold, id: page.id
         end
       end
     end
 
     describe '#sort' do
-      before { Page.stub(:language_root_for).and_return(mock_model(Alchemy::Page)) }
+      before { allow(Page).to receive(:language_root_for).and_return(mock_model(Alchemy::Page)) }
 
       it "should assign @sorting with true" do
         xhr :get, :sort
@@ -471,9 +481,9 @@ module Alchemy
       let(:page) { mock_model(Alchemy::Page, name: 'Best practices') }
 
       before do
-        Page.stub(:find).with("#{page.id}").and_return(page)
-        Page.stub_chain(:from_current_site, :all_locked_by).and_return(nil)
-        page.should_receive(:unlock!).and_return(true)
+        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))
+        expect(page).to receive(:unlock!).and_return(true)
       end
 
       it "should unlock the page" do
@@ -497,7 +507,7 @@ module Alchemy
       let(:language) { build_stubbed(:klingonian)}
 
       before do
-        Language.stub(:find_by).and_return(language)
+        allow(Language).to receive(:find_by).and_return(language)
       end
 
       it "should store the current language in session" do
@@ -511,7 +521,7 @@ module Alchemy
 
       context "coming from layoutpages" do
         before {
-          request.stub(:referer).and_return('admin/layoutpages')
+          allow(request).to receive(:referer).and_return('admin/layoutpages')
         }
 
         it "should redirect to layoutpages" do