alchemy_cms 3.0.4 → 3.1.0.beta1

data/spec/models/essence_date_spec.rb

@@ -19,7 +19,7 @@ module Alchemy
       context "if date set" do
         it "should format the date by i18n" do
           essence.date = DateTime.now
-          ::I18n.should_receive(:l).with(essence.date, format: :date)
+          expect(::I18n).to receive(:l).with(essence.date, format: :date)
           essence.preview_text
         end
       end

data/spec/models/essence_file_spec.rb

@@ -15,26 +15,26 @@ module Alchemy
       subject { essence.attachment_url }
 
       it "returns the download attachment url." do
-        should match(/\/attachment\/#{attachment.id}\/download\/#{attachment.file_name}/)
+        is_expected.to match(/\/attachment\/#{attachment.id}\/download\/#{attachment.file_name}/)
       end
 
       context 'without attachment assigned' do
         let(:attachment) { nil }
 
-        it { should be_nil }
+        it { is_expected.to be_nil }
       end
     end
 
     describe '#preview_text' do
 
       it "returns the attachment's name as preview text" do
-        essence.preview_text.should == attachment.name
+        expect(essence.preview_text).to eq(attachment.name)
       end
 
       context "with no attachment assigned" do
         it "returns empty string" do
           essence.attachment = nil
-          essence.preview_text.should == ''
+          expect(essence.preview_text).to eq('')
         end
       end
     end

data/spec/models/essence_picture_spec.rb

@@ -7,24 +7,28 @@ module Alchemy
       let(:ingredient_value) { Picture.new }
     end
 
+    it_behaves_like "has image transformations" do
+      let(:picture) { build_stubbed(:essence_picture) }
+    end
+
     it "should not store negative values for crop values" do
       essence = EssencePicture.new(:crop_from => '-1x100', :crop_size => '-20x30')
       essence.save!
-      essence.crop_from.should == "0x100"
-      essence.crop_size.should == "0x30"
+      expect(essence.crop_from).to eq("0x100")
+      expect(essence.crop_size).to eq("0x30")
     end
 
     it "should not store float values for crop values" do
       essence = EssencePicture.new(:crop_from => '0.05x104.5', :crop_size => '99.5x203.4')
       essence.save!
-      essence.crop_from.should == "0x105"
-      essence.crop_size.should == "100x203"
+      expect(essence.crop_from).to eq("0x105")
+      expect(essence.crop_size).to eq("100x203")
     end
 
     it "should convert newlines in caption into <br/>s" do
       essence = EssencePicture.new(:caption => "hello\nkitty")
       essence.save!
-      essence.caption.should == "hello<br/>kitty"
+      expect(essence.caption).to eq("hello<br/>kitty")
     end
 
     describe '#picture_url' do
@@ -35,24 +39,24 @@ module Alchemy
       let(:essence) { build_stubbed(:essence_picture, picture: picture) }
 
       it "returns the show picture url." do
-        should match(/\/pictures\/#{picture.id}\/show\/#{picture.urlname}\.#{Config.get(:image_output_format)}/)
+        is_expected.to match(/\/pictures\/#{picture.id}\/show\/#{picture.urlname}\.#{Config.get(:image_output_format)}/)
       end
 
       it "includes the secure hash." do
-        should match(/\?sh=\S+\z/)
+        is_expected.to match(/\?sh=\S+\z/)
       end
 
       context 'with size in the options' do
         let(:options) { {size: '200x300'} }
 
         it "includes the size in the url." do
-          should match(/200x300/)
+          is_expected.to match(/200x300/)
         end
       end
 
       context 'with no format in the options' do
         it "includes the default image output format." do
-          should match(/#{Config.get(:image_output_format)}/)
+          is_expected.to match(/#{Config.get(:image_output_format)}/)
         end
       end
 
@@ -60,24 +64,27 @@ module Alchemy
         let(:options) { {format: 'png'} }
 
         it "takes this as format." do
-          should match(/png/)
+          is_expected.to match(/png/)
         end
       end
 
       context 'with crop sizes set' do
-        before { essence.stub(crop_size: '200x200', crop_from: '10x10') }
+        before do
+          expect(essence).to receive(:crop_size).at_least(:once).and_return('200x200')
+          expect(essence).to receive(:crop_from).at_least(:once).and_return('10x10')
+        end
 
         it "includes the crop sizes in the url." do
-          should match(/200x200/)
-          should match(/10x10/)
+          is_expected.to match(/200x200/)
+          is_expected.to match(/10x10/)
         end
 
         context 'but with crop sizes in the options' do
           let(:options) { {crop_from: '30x30', crop_size: '75x75'} }
 
           it "includes these crop sizes instead." do
-            should match(/30x30/)
-            should match(/75x75/)
+            is_expected.to match(/30x30/)
+            is_expected.to match(/75x75/)
           end
         end
       end
@@ -86,8 +93,8 @@ module Alchemy
         let(:options) { {crop: true} }
 
         it 'converts the value into `crop`' do
-          should match /crop/
-          should_not match /true/
+          is_expected.to match /crop/
+          is_expected.not_to match /true/
         end
       end
 
@@ -95,7 +102,7 @@ module Alchemy
         let(:options) { {image_size: '100x100'} }
 
         it 'converts the key into `size`' do
-          should match /100x100/
+          is_expected.to match /100x100/
         end
       end
 
@@ -103,14 +110,14 @@ module Alchemy
         let(:options) { {foo: 'baz'} }
 
         it 'it removes them from params' do
-          should_not match /foo/
+          is_expected.not_to match /foo/
         end
       end
 
       context 'without picture assigned' do
         let(:picture) { nil }
 
-        it { should be_nil }
+        it { is_expected.to be_nil }
       end
     end
 
@@ -121,14 +128,14 @@ module Alchemy
         let(:essence) { build_stubbed(:essence_picture, crop_from: '0x0', crop_size: '100x100') }
 
         it "returns a hash containing cropping coordinates" do
-          should == {x1: 0, y1: 0, x2: 100, y2: 100}
+          is_expected.to eq({x1: 0, y1: 0, x2: 100, y2: 100})
         end
       end
 
       context 'with no crop values given' do
         let(:essence) { build_stubbed(:essence_picture) }
 
-        it { should be_nil }
+        it { is_expected.to be_nil }
       end
     end
 
@@ -137,13 +144,37 @@ module Alchemy
       let(:essence) { EssencePicture.new }
 
       it "should return the pictures name as preview text" do
-        essence.stub(:picture).and_return(picture)
-        essence.preview_text.should == 'Cute Cat Kittens'
+        allow(essence).to receive(:picture).and_return(picture)
+        expect(essence.preview_text).to eq('Cute Cat Kittens')
       end
 
       context "with no picture assigned" do
         it "returns empty string" do
-          essence.preview_text.should == ''
+          expect(essence.preview_text).to eq('')
+        end
+      end
+    end
+
+    describe '#serialized_ingredient' do
+      let(:content) { Content.new }
+      let(:picture) { mock_model(Picture, name: 'Cute Cat Kittens', urlname: 'cute-cat-kittens', security_token: 'kljhgfd')}
+      let(:essence) { EssencePicture.new(content: content, picture: picture) }
+
+      it "returns the url to render the picture" do
+        expect(essence.serialized_ingredient).to eq("/pictures/#{picture.id}/show/#{picture.urlname}.jpg?sh=#{picture.security_token}")
+      end
+
+      context 'with image settings given at content' do
+        before do
+          expect(content).to receive(:settings).and_return({size: '150x150', format: 'png', select_values: [1,2,3]})
+        end
+
+        it "returns the url with cropping and resizing options" do
+          expect(essence.serialized_ingredient).to eq("/pictures/#{picture.id}/show/150x150/#{picture.urlname}.png?sh=#{picture.security_token}")
+        end
+
+        it "rejects options that are not cropping and resizing options" do
+          expect(essence.serialized_ingredient).to_not match("select_values")
         end
       end
     end

data/spec/models/essence_richtext_spec.rb

@@ -11,7 +11,7 @@ module Alchemy
 
     it "should save a HTML tag free version of body column" do
       essence.save
-      essence.stripped_body.should == "Hello!Welcome to Peters Petshop."
+      expect(essence.stripped_body).to eq("Hello!Welcome to Peters Petshop.")
     end
 
   end

data/spec/models/essence_text_spec.rb

@@ -17,23 +17,23 @@ module Alchemy
       end
 
       it "should return a preview text" do
-        essence.preview_text.should == "#{ingredient_value}"
+        expect(essence.preview_text).to eq("#{ingredient_value}")
       end
 
       context "with given maxlength" do
         it "should return as much beginning characters as defined with maxlength" do
-          essence.preview_text(2).should == "#{ingredient_value}"[0..1]
+          expect(essence.preview_text(2)).to eq("#{ingredient_value}"[0..1])
         end
       end
 
       context "with another preview_text_column defined" do
         before do
-          essence.stub(:title).and_return('Title column')
-          essence.stub(:preview_text_column).and_return(:title)
+          allow(essence).to receive(:title).and_return('Title column')
+          allow(essence).to receive(:preview_text_column).and_return(:title)
         end
 
         it "should use this column as preview text method" do
-          essence.preview_text.should == 'Title column'
+          expect(essence.preview_text).to eq('Title column')
         end
       end
     end
@@ -65,7 +65,7 @@ module Alchemy
 
         context 'given a regex string' do
           before do
-            essence.stub(:description).and_return({'validate' => [{'format' => /\Ahttps:\/\/[\S]+/}]})
+            allow(essence).to receive(:description).and_return({'validate' => [{'format' => /\Ahttps:\/\/[\S]+/}]})
           end
 
           context 'when ingredient string does not match the given regex' do
@@ -87,7 +87,7 @@ module Alchemy
 
         context 'given a key from the config`s format_matcher list' do
           before do
-            essence.stub(:description).and_return({'validate' => [{'format' => 'email'}]})
+            allow(essence).to receive(:description).and_return({'validate' => [{'format' => 'email'}]})
           end
 
           context 'when ingredient string does not match the given format matcher' do

data/spec/models/language_spec.rb

@@ -8,30 +8,30 @@ module Alchemy
     let(:page)             { FactoryGirl.create(:page, language: language) }
 
     it "should return a label for code" do
-      language.label(:code).should == 'kl'
+      expect(language.label(:code)).to eq('kl')
     end
 
     it "should return a label for name" do
-      language.label(:name).should == 'Klingonian'
+      expect(language.label(:name)).to eq('Klingonian')
     end
 
     context "with language_code and empty country_code" do
       it "#code should return language locale only" do
         language.country_code = ''
-        language.code.should == 'kl'
+        expect(language.code).to eq('kl')
       end
 
       context "adding a value for country code" do
         it "#code should return a joined locale" do
           language.country_code = 'cr'
-          language.code.should == 'kl-cr'
+          expect(language.code).to eq('kl-cr')
         end
 
         it "should update all associated Pages with self.code as value for Page#language_code" do
           page = FactoryGirl.create(:page, language: language)
           language.country_code = 'cr'
           language.save
-          page.reload; page.language_code.should == 'kl-cr'
+          page.reload; expect(page.language_code).to eq('kl-cr')
         end
       end
     end
@@ -42,7 +42,7 @@ module Alchemy
           language = FactoryGirl.create(:language, country_code: 'kl')
           language.country_code = ''
           language.save
-          page.reload; page.language_code.should == "kl"
+          page.reload; expect(page.language_code).to eq("kl")
         end
       end
     end
@@ -57,7 +57,7 @@ module Alchemy
           default_language
           language.update_attributes(default: true)
           default_language.reload
-          default_language.default.should be_false
+          expect(default_language.default).to be_falsey
         end
       end
     end
@@ -68,7 +68,7 @@ module Alchemy
           @other_page = FactoryGirl.create(:page, language: language)
           language.update_attributes(code: "fo")
           language.reload; page.reload; @other_page.reload
-          [page.language_code, @other_page.language_code].should == [language.code, language.code]
+          expect([page.language_code, @other_page.language_code]).to eq([language.code, language.code])
         end
       end
 
@@ -78,7 +78,7 @@ module Alchemy
           @other_page = FactoryGirl.create(:page, language: language)
           language.update_attributes(public: false)
           language.reload; page.reload; @other_page.reload
-          [page.public?, @other_page.public?].should == [false, false]
+          expect([page.public?, @other_page.public?]).to eq([false, false])
         end
       end
     end
@@ -86,7 +86,7 @@ module Alchemy
     describe '.find_by_code' do
       context "with only the language code given" do
         it "should find the language" do
-          Language.find_by_code(language.code).should == language
+          expect(Language.find_by_code(language.code)).to eq(language)
         end
       end
     end
@@ -106,8 +106,8 @@ module Alchemy
       describe 'presence_of_default_language' do
         context 'if no default language would exist anymore' do
           before do
-            Language.stub(:default).and_return(language)
-            language.stub(:default_changed?).and_return(true)
+            allow(Language).to receive(:default).and_return(language)
+            allow(language).to receive(:default_changed?).and_return(true)
           end
 
           it "should add an error to the object" do

data/spec/models/legacy_page_url_spec.rb

@@ -12,10 +12,10 @@ describe Alchemy::LegacyPageUrl do
   end
 
   it 'is only valid with correct urlname format' do
-    valid_page_url.should be_valid
+    expect(valid_page_url).to be_valid
   end
 
   it 'is also valid with get parameters in urlname' do
-    page_url_with_parameters.should be_valid
+    expect(page_url_with_parameters).to be_valid
   end
 end

data/spec/models/message_spec.rb

@@ -9,7 +9,7 @@ module Alchemy
 
     describe '.config' do
       it "should return the mailer config" do
-        Config.should_receive(:get).with(:mailer)
+        expect(Config).to receive(:get).with(:mailer)
         Message.config
       end
     end
@@ -25,21 +25,28 @@ module Alchemy
       context "all fields defined in mailer config" do
         it "adds errors on that fields" do
           Config.get(:mailer)['validate_fields'].each do |field|
-            expect(message).to have(1).error_on(field)
+            expect(message).to_not be_valid
+            expect(message.errors[field].size).to eq(1)
           end
         end
       end
 
       context 'field containing email in its name' do
         context "when field has a value" do
+          before { message.email_of_my_boss = 'wrong email format' }
+
           it "adds error notice (is invalid) to the field" do
-            message.email_of_my_boss = 'wrong email format'
-            expect(message.errors_on(:email_of_my_boss)).to include("is invalid")
+            expect(message).to_not be_valid
+            expect(message.errors[:email_of_my_boss]).to include("is invalid")
           end
         end
+
         context "when field is blank" do
+          before { message.email_of_my_boss = '' }
+
           it "adds error notice (can't be blank) to the field" do
-            expect(message.errors_on(:email_of_my_boss)).to include("can't be blank")
+            expect(message).to_not be_valid
+            expect(message.errors[:email_of_my_boss]).to include("can't be blank")
           end
         end
       end

data/spec/models/page_spec.rb

@@ -27,20 +27,22 @@ module Alchemy
 
           it "it should be possible to save." do
             contentpage.urlname = "existing_twice"
-            contentpage.should be_valid
+            expect(contentpage).to be_valid
           end
         end
 
         it "should validate the page_layout" do
           contentpage.page_layout = nil
-          contentpage.should_not be_valid
-          contentpage.should have(1).error_on(:page_layout)
+          expect(contentpage).not_to be_valid
+          contentpage.valid?
+          expect(contentpage.errors[:page_layout].size).to eq(1)
         end
 
         it "should validate the parent_id" do
           contentpage.parent_id = nil
-          contentpage.should_not be_valid
-          contentpage.should have(1).error_on(:parent_id)
+          expect(contentpage).not_to be_valid
+          contentpage.valid?
+          expect(contentpage.errors[:parent_id].size).to eq(1)
         end
 
         context 'with page having same urlname' do
@@ -48,7 +50,7 @@ module Alchemy
 
           it "should not be valid" do
             contentpage.urlname = 'existing_twice'
-            contentpage.should_not be_valid
+            expect(contentpage).not_to be_valid
           end
         end
 
@@ -56,19 +58,19 @@ module Alchemy
           let(:other_parent) { FactoryGirl.create(:page, parent_id: Page.root.id) }
 
           before do
-            Config.stub(:get).and_return(true)
+            allow(Config).to receive(:get).and_return(true)
             with_same_urlname
           end
 
           it "should only validate urlname dependent of parent" do
             contentpage.urlname = 'existing_twice'
             contentpage.parent_id = other_parent.id
-            contentpage.should be_valid
+            expect(contentpage).to be_valid
           end
 
           it "should validate urlname dependent of parent" do
             contentpage.urlname = 'existing_twice'
-            contentpage.should_not be_valid
+            expect(contentpage).not_to be_valid
           end
         end
       end
@@ -81,7 +83,7 @@ module Alchemy
         end
 
         it "should be valid" do
-          rootpage.should be_valid
+          expect(rootpage).to be_valid
         end
       end
 
@@ -89,7 +91,7 @@ module Alchemy
         let(:systempage) { build(:systempage) }
 
         it "should not validate the page_layout" do
-          systempage.should be_valid
+          expect(systempage).to be_valid
         end
       end
 
@@ -136,13 +138,13 @@ module Alchemy
         it "should not set the title automatically if the name changed but title is not blank" do
           page.name = "My Renaming Test"
           page.save; page.reload
-          page.title.should == "My Testpage"
+          expect(page.title).to eq("My Testpage")
         end
 
         it "should not automatically set the title if it changed its value" do
           page.title = "I like SEO"
           page.save; page.reload
-          page.title.should == "I like SEO"
+          expect(page.title).to eq("I like SEO")
         end
       end
 
@@ -151,15 +153,15 @@ module Alchemy
           it "should store legacy url if page is not redirect to external page" do
             page.urlname = 'new-urlname'
             page.save!
-            page.legacy_urls.should_not be_empty
-            page.legacy_urls.first.urlname.should == 'my-testpage'
+            expect(page.legacy_urls).not_to be_empty
+            expect(page.legacy_urls.first.urlname).to eq('my-testpage')
           end
 
           it "should not store legacy url if page is redirect to external page" do
             page.urlname = 'new-urlname'
             page.page_layout = "external"
             page.save!
-            page.legacy_urls.should be_empty
+            expect(page.legacy_urls).to be_empty
           end
 
           it "should not store legacy url twice for same urlname" do
@@ -169,7 +171,7 @@ module Alchemy
             page.save!
             page.urlname = 'another-urlname'
             page.save!
-            page.legacy_urls.select { |u| u.urlname == 'my-testpage' }.size.should == 1
+            expect(page.legacy_urls.select { |u| u.urlname == 'my-testpage' }.size).to eq(1)
           end
         end
 
@@ -177,7 +179,7 @@ module Alchemy
           it "should not store a legacy url" do
             page.urlname = 'my-testpage'
             page.save!
-            page.legacy_urls.should be_empty
+            expect(page.legacy_urls).to be_empty
           end
         end
 
@@ -199,7 +201,7 @@ module Alchemy
         context "public has not changed" do
           it "should not update published_at" do
             page.update_attributes!(name: 'New Name')
-            page.read_attribute(:published_at).should be_nil
+            expect(page.read_attribute(:published_at)).to be_nil
           end
         end
       end
@@ -210,9 +212,9 @@ module Alchemy
         let(:page)     { FactoryGirl.create(:page, parent_id: parent_1.id, name: 'Page', visible: true) }
 
         it "updates the urlname" do
-          page.urlname.should == 'parent-1/page'
+          expect(page.urlname).to eq('parent-1/page')
           page.move_to_child_of parent_2
-          page.urlname.should == 'parent-2/page'
+          expect(page.urlname).to eq('parent-2/page')
         end
 
         context 'of an external page' do
@@ -220,7 +222,7 @@ module Alchemy
 
           it "the urlname does not get updated" do
             external.move_to_child_of parent_2
-            external.urlname.should == 'http://google.com'
+            expect(external.urlname).to eq('http://google.com')
           end
         end
       end
@@ -232,36 +234,36 @@ module Alchemy
 
         it "should set the language code" do
           @page.save
-          @page.language_code.should == "kl"
+          expect(@page.language_code).to eq("kl")
         end
 
         it "should autogenerate the elements" do
           @page.save
-          @page.elements.should_not be_empty
+          expect(@page.elements).not_to be_empty
         end
 
         it "should not autogenerate elements that are already on the page" do
           @page.elements << FactoryGirl.create(:element, :name => 'header')
           @page.save
-          @page.elements.select { |e| e.name == 'header' }.length.should == 1
+          expect(@page.elements.select { |e| e.name == 'header' }.length).to eq(1)
         end
 
         context "with cells" do
           before do
-            @page.stub(:definition).and_return({'name' => 'with_cells', 'cells' => ['header', 'main']})
+            allow(@page).to receive(:definition).and_return({'name' => 'with_cells', 'cells' => ['header', 'main']})
           end
 
           it "should have the generated elements in their cells" do
-            @page.stub(:cell_definitions).and_return([{'name' => 'header', 'elements' => ['article']}])
+            allow(@page).to receive(:cell_definitions).and_return([{'name' => 'header', 'elements' => ['article']}])
             @page.save
-            @page.cells.where(:name => 'header').first.elements.should_not be_empty
+            expect(@page.cells.where(:name => 'header').first.elements).not_to be_empty
           end
 
           context "and no elements in cell definitions" do
             it "should have the elements in the nil cell" do
-              @page.stub(:cell_definitions).and_return([{'name' => 'header', 'elements' => []}])
+              allow(@page).to receive(:cell_definitions).and_return([{'name' => 'header', 'elements' => []}])
               @page.save
-              @page.cells.collect(&:elements).flatten.should be_empty
+              expect(@page.cells.collect(&:elements).flatten).to be_empty
             end
           end
         end
@@ -277,7 +279,7 @@ module Alchemy
 
           it "should restrict all its children" do
             @child1.reload
-            @child1.restricted?.should be_true
+            expect(@child1.restricted?).to be_truthy
           end
         end
 
@@ -289,7 +291,7 @@ module Alchemy
           end
 
           it "should also be restricted" do
-            @new_page.restricted?.should be_true
+            expect(@new_page.restricted?).to be_truthy
           end
         end
 
@@ -300,7 +302,7 @@ module Alchemy
 
           it "should not autogenerate the elements" do
             @page.save
-            @page.elements.should be_empty
+            expect(@page.elements).to be_empty
           end
         end
       end
@@ -311,11 +313,11 @@ module Alchemy
         end
 
         it "should not get the language code for language" do
-          @page.language_code.should be_nil
+          expect(@page.language_code).to be_nil
         end
 
         it "should not autogenerate the elements" do
-          @page.elements.should be_empty
+          expect(@page.elements).to be_empty
         end
       end
 
@@ -332,7 +334,7 @@ module Alchemy
 
         it "should autogenerate elements" do
           news_page.update_attributes(page_layout: 'contact')
-          news_page.elements.pluck(:name).should include('contactform')
+          expect(news_page.elements.pluck(:name)).to include('contactform')
         end
       end
     end
@@ -349,7 +351,7 @@ module Alchemy
             {'id' => page_1.id.to_s, 'action' => 'copy'},
             {'id' => page_2.id.to_s, 'action' => 'copy'}
           ]
-          Page.all_from_clipboard_for_select(clipboard, language.id).should include(page_1, page_2)
+          expect(Page.all_from_clipboard_for_select(clipboard, language.id)).to include(page_1, page_2)
         end
       end
 
@@ -359,7 +361,7 @@ module Alchemy
           clipboard = [
             {'id' => page_1.id.to_s, 'action' => 'copy'}
           ]
-          Page.all_from_clipboard_for_select(clipboard, language.id).should == []
+          expect(Page.all_from_clipboard_for_select(clipboard, language.id)).to eq([])
         end
       end
 
@@ -371,7 +373,7 @@ module Alchemy
             {'id' => page_1.id.to_s, 'action' => 'copy'},
             {'id' => page_2.id.to_s, 'action' => 'copy'}
           ]
-          Page.all_from_clipboard_for_select(clipboard, language.id).should == [page_1]
+          expect(Page.all_from_clipboard_for_select(clipboard, language.id)).to eq([page_1])
         end
       end
     end
@@ -379,7 +381,7 @@ module Alchemy
     describe '.all_locked' do
       it "should return 1 page that is blocked by a user at the moment" do
         FactoryGirl.create(:public_page, :locked => true, :name => 'First Public Child', :parent_id => language_root.id, :language => language)
-        Page.all_locked.should have(1).pages
+        expect(Page.all_locked.size).to eq(1)
       end
     end
 
@@ -392,15 +394,15 @@ module Alchemy
       end
 
       it "should return a collection of contentpages" do
-        Page.contentpages.to_a.should include(language_root, @klingonian_lang_root, @contentpage)
+        expect(Page.contentpages.to_a).to include(language_root, @klingonian_lang_root, @contentpage)
       end
 
       it "should not contain pages with attribute :layoutpage set to true" do
-        Page.contentpages.to_a.select { |p| p.layoutpage == true }.should be_empty
+        expect(Page.contentpages.to_a.select { |p| p.layoutpage == true }).to be_empty
       end
 
       it "should contain pages with attribute :layoutpage set to nil" do
-        Page.contentpages.to_a.select { |p| p.layoutpage == nil }.should include(@klingonian_lang_root)
+        expect(Page.contentpages.to_a.select { |p| p.layoutpage == nil }).to include(@klingonian_lang_root)
       end
     end
 
@@ -409,7 +411,7 @@ module Alchemy
       subject { Page.copy(page) }
 
       it "the copy should have added (copy) to name" do
-        subject.name.should == "#{page.name} (Copy)"
+        expect(subject.name).to eq("#{page.name} (Copy)")
       end
 
       context "page with tags" do
@@ -419,8 +421,8 @@ module Alchemy
           # The order of tags varies between postgresql and sqlite/mysql
           # This is related to acts-as-taggable-on v.2.4.1
           # To fix the spec we sort the tags until the issue is solved (https://github.com/mbleigh/acts-as-taggable-on/issues/363)
-          subject.tag_list.should_not be_empty
-          subject.tag_list.sort.should == page.tag_list.sort
+          expect(subject.tag_list).not_to be_empty
+          expect(subject.tag_list.sort).to eq(page.tag_list.sort)
         end
       end
 
@@ -428,8 +430,8 @@ module Alchemy
         before { page.elements << FactoryGirl.create(:element) }
 
         it "the copy should have source elements" do
-          subject.elements.should_not be_empty
-          subject.elements.count.should == page.elements.count
+          expect(subject.elements).not_to be_empty
+          expect(subject.elements.count).to eq(page.elements.count)
         end
       end
 
@@ -440,7 +442,7 @@ module Alchemy
         end
 
         it "the copy should not hold a copy of the trashed elements" do
-          subject.elements.should be_empty
+          expect(subject.elements).to be_empty
         end
       end
 
@@ -448,26 +450,26 @@ module Alchemy
         before { page.cells << FactoryGirl.create(:cell) }
 
         it "the copy should have source cells" do
-          subject.cells.should_not be_empty
-          subject.cells.count.should == page.cells.length # It must be length, because!
+          expect(subject.cells).not_to be_empty
+          expect(subject.cells.count).to eq(page.cells.length) # It must be length, because!
         end
       end
 
       context "page with autogenerate elements" do
         before do
           page = FactoryGirl.create(:page)
-          page.stub(:definition).and_return({'name' => 'standard', 'elements' => ['headline'], 'autogenerate' => ['headline']})
+          allow(page).to receive(:definition).and_return({'name' => 'standard', 'elements' => ['headline'], 'autogenerate' => ['headline']})
         end
 
         it "the copy should not autogenerate elements" do
-          subject.elements.should be_empty
+          expect(subject.elements).to be_empty
         end
       end
 
       context "with different page name given" do
         subject { Page.copy(page, {:name => 'Different name'}) }
         it "should take this name" do
-          subject.name.should == 'Different name'
+          expect(subject.name).to eq('Different name')
         end
       end
     end
@@ -476,12 +478,12 @@ module Alchemy
       context "before/after filter" do
         it "should automatically set the title from its name" do
           page = FactoryGirl.create(:page, :name => 'My Testpage', :language => language, :parent_id => language_root.id)
-          page.title.should == 'My Testpage'
+          expect(page.title).to eq('My Testpage')
         end
 
         it "should get a webfriendly urlname" do
           page = FactoryGirl.create(:page, :name => 'klingon$&stößel ', :language => language, :parent_id => language_root.id)
-          page.urlname.should == 'klingon-stoessel'
+          expect(page.urlname).to eq('klingon-stoessel')
         end
 
         context "with no name set" do
@@ -493,34 +495,34 @@ module Alchemy
 
         it "should generate a three letter urlname from two letter name" do
           page = FactoryGirl.create(:page, :name => 'Au', :language => language, :parent_id => language_root.id)
-          page.urlname.should == '-au'
+          expect(page.urlname).to eq('-au')
         end
 
         it "should generate a three letter urlname from two letter name with umlaut" do
           page = FactoryGirl.create(:page, :name => 'Aü', :language => language, :parent_id => language_root.id)
-          page.urlname.should == 'aue'
+          expect(page.urlname).to eq('aue')
         end
 
         it "should generate a three letter urlname from one letter name" do
           page = FactoryGirl.create(:page, :name => 'A', :language => language, :parent_id => language_root.id)
-          page.urlname.should == '--a'
+          expect(page.urlname).to eq('--a')
         end
 
         it "should add a user stamper" do
           page = FactoryGirl.create(:page, :name => 'A', :language => language, :parent_id => language_root.id)
-          page.class.stamper_class.to_s.should == 'DummyUser'
+          expect(page.class.stamper_class.to_s).to eq('DummyUser')
         end
 
         context "with language given" do
           it "does not set the language from parent" do
-            Page.any_instance.should_not_receive(:set_language_from_parent_or_default)
+            expect_any_instance_of(Page).not_to receive(:set_language_from_parent_or_default)
             Page.create!(name: 'A', parent_id: language_root.id, page_layout: 'standard', language: language)
           end
         end
 
         context "with no language given" do
           it "sets the language from parent" do
-            Page.any_instance.should_receive(:set_language_from_parent_or_default)
+            expect_any_instance_of(Page).to receive(:set_language_from_parent_or_default)
             Page.create!(name: 'A', parent_id: language_root.id, page_layout: 'standard')
           end
         end
@@ -533,15 +535,15 @@ module Alchemy
       let(:language)    { mock_model('Language', name: 'English') }
       let(:language_id) { language.id }
 
-      before { Language.stub(:find).and_return(language) }
+      before { allow(Language).to receive(:find).and_return(language) }
 
       context 'if no layout root page for given language id could be found' do
         before do
-          Page.should_receive(:create!).and_return(page)
+          expect(Page).to receive(:create!).and_return(page)
         end
 
         it "creates one" do
-          should eq(page)
+          is_expected.to eq(page)
         end
       end
 
@@ -549,11 +551,11 @@ module Alchemy
         let(:page) { mock_model('Page') }
 
         before do
-          Page.should_receive(:layout_root_for).and_return(page)
+          expect(Page).to receive(:layout_root_for).and_return(page)
         end
 
         it "returns layout root page" do
-          should eq(page)
+          is_expected.to eq(page)
         end
       end
     end
@@ -561,7 +563,7 @@ module Alchemy
     describe '.language_roots' do
       it "should return 1 language_root" do
         FactoryGirl.create(:public_page, :name => 'First Public Child', :parent_id => language_root.id, :language => language)
-        Page.language_roots.should have(1).pages
+        expect(Page.language_roots.size).to eq(1)
       end
     end
 
@@ -572,11 +574,11 @@ module Alchemy
 
       context "for a language root page" do
         it "should return the page layout description as hash" do
-          language_root.layout_description['name'].should == 'intro'
+          expect(language_root.layout_description['name']).to eq('intro')
         end
 
         it "should return an empty hash for root page" do
-          rootpage.layout_description.should == {}
+          expect(rootpage.layout_description).to eq({})
         end
       end
     end
@@ -584,7 +586,7 @@ module Alchemy
     describe '.layoutpages' do
       it "should return 1 layoutpage" do
         FactoryGirl.create(:public_page, :layoutpage => true, :name => 'Layoutpage', :parent_id => rootpage.id, :language => language)
-        Page.layoutpages.should have(1).pages
+        expect(Page.layoutpages.size).to eq(1)
       end
     end
 
@@ -592,14 +594,14 @@ module Alchemy
       it "should return pages that are not blocked by a user at the moment" do
         FactoryGirl.create(:public_page, :locked => true, :name => 'First Public Child', :parent_id => language_root.id, :language => language)
         FactoryGirl.create(:public_page, :name => 'Second Public Child', :parent_id => language_root.id, :language => language)
-        Page.not_locked.should have(3).pages
+        expect(Page.not_locked.size).to eq(3)
       end
     end
 
     describe '.not_restricted' do
       it "should return 2 accessible pages" do
         FactoryGirl.create(:public_page, :name => 'First Public Child', :restricted => true, :parent_id => language_root.id, :language => language)
-        Page.not_restricted.should have(2).pages
+        expect(Page.not_restricted.size).to eq(2)
       end
     end
 
@@ -607,27 +609,27 @@ module Alchemy
       it "should return pages that are public" do
         FactoryGirl.create(:public_page, :name => 'First Public Child', :parent_id => language_root.id, :language => language)
         FactoryGirl.create(:public_page, :name => 'Second Public Child', :parent_id => language_root.id, :language => language)
-        Page.published.should have(3).pages
+        expect(Page.published.size).to eq(3)
       end
     end
 
     describe '.restricted' do
       it "should return 1 restricted page" do
         FactoryGirl.create(:public_page, :name => 'First Public Child', :restricted => true, :parent_id => language_root.id, :language => language)
-        Page.restricted.should have(1).pages
+        expect(Page.restricted.size).to eq(1)
       end
     end
 
     describe '.rootpage' do
       it "should contain one rootpage" do
-        Page.rootpage.should be_instance_of(Page)
+        expect(Page.rootpage).to be_instance_of(Page)
       end
     end
 
     describe '.visible' do
       it "should return 1 visible page" do
         FactoryGirl.create(:public_page, :name => 'First Public Child', :visible => true, :parent_id => language_root.id, :language => language)
-        Page.visible.should have(1).pages
+        expect(Page.visible.size).to eq(1)
       end
     end
 
@@ -638,17 +640,22 @@ module Alchemy
       let(:page) { FactoryGirl.build_stubbed(:public_page) }
 
       it "returns all element definitions of available elements" do
-        page.available_element_definitions.should be_an(Array)
-        page.available_element_definitions.collect { |e| e['name'] }.should include('header')
+        expect(page.available_element_definitions).to be_an(Array)
+        expect(page.available_element_definitions.collect { |e| e['name'] }).to include('header')
       end
 
       context "with unique elements already on page" do
         let(:element) { FactoryGirl.build_stubbed(:unique_element) }
-        before { page.stub_chain(:elements, :not_trashed, :pluck).and_return([element.name]) }
+
+        before do
+          allow(page)
+            .to receive(:elements)
+            .and_return double(not_trashed: double(pluck: [element.name]))
+        end
 
         it "does not return unique element definitions" do
-          page.available_element_definitions.collect { |e| e['name'] }.should include('article')
-          page.available_element_definitions.collect { |e| e['name'] }.should_not include('header')
+          expect(page.available_element_definitions.collect { |e| e['name'] }).to include('article')
+          expect(page.available_element_definitions.collect { |e| e['name'] }).not_to include('header')
         end
       end
 
@@ -670,7 +677,7 @@ module Alchemy
         let(:element_3) { FactoryGirl.build_stubbed(:element, name: 'column_headline') }
 
         before {
-          Element.stub(:definitions).and_return([
+          allow(Element).to receive(:definitions).and_return([
             {
               'name' => 'column_headline',
               'amount' => 3,
@@ -683,25 +690,32 @@ module Alchemy
               'contents' => [{'name' => 'headline', 'type' => 'EssenceText'}]
             }
           ])
-          PageLayout.stub(:get).and_return({
+          allow(PageLayout).to receive(:get).and_return({
             'name' => 'columns',
             'elements' => ['column_headline', 'unique_headline'],
             'autogenerate' => ['unique_headline', 'column_headline', 'column_headline', 'column_headline']
           })
-          page.stub_chain(:elements, :not_trashed, :pluck).and_return([unique_element.name, element_1.name, element_2.name, element_3.name])
+          allow(page).to receive(:elements).and_return double(
+            not_trashed: double(pluck: [
+              unique_element.name,
+              element_1.name,
+              element_2.name,
+              element_3.name
+            ])
+          )
         }
 
         it "should be readable" do
           element = page.element_definitions_by_name('column_headline').first
-          element['amount'].should be 3
+          expect(element['amount']).to be 3
         end
 
         it "should limit elements" do
-          page.available_element_definitions.collect { |e| e['name'] }.should_not include('column_headline')
+          expect(page.available_element_definitions.collect { |e| e['name'] }).not_to include('column_headline')
         end
 
         it "should be ignored if unique" do
-          page.available_element_definitions.collect { |e| e['name'] }.should_not include('unique_headline')
+          expect(page.available_element_definitions.collect { |e| e['name'] }).not_to include('unique_headline')
         end
       end
     end
@@ -715,44 +729,30 @@ module Alchemy
     end
 
     describe '#cache_key' do
-      let(:page) do
-        stub_model(Page, updated_at: Time.now, published_at: Time.now - 1.week)
-      end
-
-      subject { page.cache_key }
-
-      before do
-        expect(Page).to receive(:current_preview).and_return(preview)
-      end
-
-      context "when current page rendered in preview mode" do
-        let(:preview) { page }
-
-        it { is_expected.to eq("alchemy/pages/#{page.id}-#{page.updated_at}") }
-      end
-
-      context "when current page not in preview mode" do
-        let(:preview) { nil }
+      let(:page) { stub_model(Page) }
+      subject { page }
 
-        it { is_expected.to eq("alchemy/pages/#{page.id}-#{page.published_at}") }
+      describe '#cache_key' do
+        subject { super().cache_key }
+        it { is_expected.to match(page.id.to_s) }
       end
     end
 
     describe '#cell_definitions' do
       before do
         @page = FactoryGirl.build(:page, :page_layout => 'foo')
-        @page.stub(:layout_description).and_return({'name' => "foo", 'cells' => ["foo_cell"]})
+        allow(@page).to receive(:layout_description).and_return({'name' => "foo", 'cells' => ["foo_cell"]})
         @cell_descriptions = [{'name' => "foo_cell", 'elements' => ["1", "2"]}]
-        Cell.stub(:definitions).and_return(@cell_descriptions)
+        allow(Cell).to receive(:definitions).and_return(@cell_descriptions)
       end
 
       it "should return all cell definitions for its page_layout" do
-        @page.cell_definitions.should == @cell_descriptions
+        expect(@page.cell_definitions).to eq(@cell_descriptions)
       end
 
       it "should return empty array if no cells defined in page layout" do
-        @page.stub(:layout_description).and_return({'name' => "foo"})
-        @page.cell_definitions.should == []
+        allow(@page).to receive(:layout_description).and_return({'name' => "foo"})
+        expect(@page.cell_definitions).to eq([])
       end
     end
 
@@ -762,7 +762,7 @@ module Alchemy
 
         it "should not delete the trashed elements" do
           news_page.destroy
-          Element.trashed.should_not be_empty
+          expect(Element.trashed).not_to be_empty
         end
       end
     end
@@ -770,22 +770,22 @@ module Alchemy
     describe '#element_definitions' do
       let(:page) { FactoryGirl.build_stubbed(:page) }
       subject { page.element_definitions }
-      before { Element.should_receive(:definitions).and_return([{'name' => 'article'}, {'name' => 'header'}]) }
+      before { expect(Element).to receive(:definitions).and_return([{'name' => 'article'}, {'name' => 'header'}]) }
 
       it "returns all element definitions that could be placed on current page" do
-        should include({'name' => 'article'})
-        should include({'name' => 'header'})
+        is_expected.to include({'name' => 'article'})
+        is_expected.to include({'name' => 'header'})
       end
     end
 
     describe '#element_definitions' do
       let(:page) { FactoryGirl.build_stubbed(:page) }
       subject { page.element_definitions }
-      before { Element.should_receive(:definitions).and_return([{'name' => 'article'}, {'name' => 'header'}]) }
+      before { expect(Element).to receive(:definitions).and_return([{'name' => 'article'}, {'name' => 'header'}]) }
 
       it "returns all element definitions that could be placed on current page" do
-        should include({'name' => 'article'})
-        should include({'name' => 'header'})
+        is_expected.to include({'name' => 'article'})
+        is_expected.to include({'name' => 'header'})
       end
     end
 
@@ -794,20 +794,20 @@ module Alchemy
 
       context "with no name given" do
         it "returns empty array" do
-          page.element_definitions_by_name(nil).should == []
+          expect(page.element_definitions_by_name(nil)).to eq([])
         end
       end
 
       context "with 'all' passed as name" do
         it "returns all element definitions" do
-          Element.should_receive(:definitions)
+          expect(Element).to receive(:definitions)
           page.element_definitions_by_name('all')
         end
       end
 
       context "with :all passed as name" do
         it "returns all element definitions" do
-          Element.should_receive(:definitions)
+          expect(Element).to receive(:definitions)
           page.element_definitions_by_name(:all)
         end
       end
@@ -817,12 +817,12 @@ module Alchemy
       let(:page) { FactoryGirl.build_stubbed(:public_page) }
 
       it "returns all element names defined in page layout" do
-        page.element_definition_names.should == %w(article header)
+        expect(page.element_definition_names).to eq(%w(article header))
       end
 
       it "returns always an array" do
-        page.stub(:definition).and_return({})
-        page.element_definition_names.should be_an(Array)
+        allow(page).to receive(:definition).and_return({})
+        expect(page.element_definition_names).to be_an(Array)
       end
     end
 
@@ -830,13 +830,13 @@ module Alchemy
       let(:page) { FactoryGirl.create(:public_page, :do_not_autogenerate => false) }
 
       before do
-        PageLayout.stub(:get).and_return({
+        allow(PageLayout).to receive(:get).and_return({
           'name' => 'standard',
           'cells' => ['header'],
           'elements' => ['header', 'text'],
           'autogenerate' => ['header', 'text']
         })
-        Cell.stub(:definitions).and_return([{
+        allow(Cell).to receive(:definitions).and_return([{
           'name' => "header",
           'elements' => ["header"]
         }])
@@ -844,19 +844,19 @@ module Alchemy
 
       it "should return elements grouped by cell" do
         elements = page.elements_grouped_by_cells
-        elements.keys.first.should be_instance_of(Cell)
-        elements.values.first.first.should be_instance_of(Element)
+        expect(elements.keys.first).to be_instance_of(Cell)
+        expect(elements.values.first.first).to be_instance_of(Element)
       end
 
       it "should only include elements beeing in a cell " do
-        page.elements_grouped_by_cells.keys.should_not include(nil)
+        expect(page.elements_grouped_by_cells.keys).not_to include(nil)
       end
     end
 
     describe '#feed_elements' do
       it "should return all rss feed elements" do
-        news_page.feed_elements.should_not be_empty
-        news_page.feed_elements.should == Element.where(name: 'news').to_a
+        expect(news_page.feed_elements).not_to be_empty
+        expect(news_page.feed_elements).to eq(Element.where(name: 'news').to_a)
       end
     end
 
@@ -868,23 +868,23 @@ module Alchemy
 
       context "with show_non_public argument TRUE" do
         it "should return all elements from empty options" do
-          public_page.find_elements({}, true).to_a.should == public_page.elements.to_a
+          expect(public_page.find_elements({}, true).to_a).to eq(public_page.elements.to_a)
         end
 
         it "should only return the elements passed as options[:only]" do
-          public_page.find_elements({:only => ['article']}, true).to_a.should == public_page.elements.named('article').to_a
+          expect(public_page.find_elements({:only => ['article']}, true).to_a).to eq(public_page.elements.named('article').to_a)
         end
 
         it "should not return the elements passed as options[:except]" do
-          public_page.find_elements({:except => ['article']}, true).to_a.should == public_page.elements - public_page.elements.named('article').to_a
+          expect(public_page.find_elements({:except => ['article']}, true).to_a).to eq(public_page.elements - public_page.elements.named('article').to_a)
         end
 
         it "should return elements offsetted" do
-          public_page.find_elements({:offset => 2}, true).to_a.should == public_page.elements.offset(2)
+          expect(public_page.find_elements({:offset => 2}, true).to_a).to eq(public_page.elements.offset(2))
         end
 
         it "should return elements limitted in count" do
-          public_page.find_elements({:count => 1}, true).to_a.should == public_page.elements.limit(1)
+          expect(public_page.find_elements({:count => 1}, true).to_a).to eq(public_page.elements.limit(1))
         end
       end
 
@@ -892,29 +892,34 @@ module Alchemy
         let(:element) { FactoryGirl.build_stubbed(:element) }
 
         context "given as String" do
-          context '' do
-            before {
-              public_page.cells.stub_chain(:find_by_name, :elements, :offset, :limit, :published).and_return([element])
-            }
+          context 'with elements present' do
+            before do
+              expect(public_page.cells)
+                .to receive(:find_by_name)
+                .and_return double(elements: double(offset: double(limit: double(published: [element]))))
+            end
 
             it "returns only the elements from given cell" do
-              public_page.find_elements(from_cell: 'A Cell').to_a.should == [element]
+              expect(public_page.find_elements(from_cell: 'A Cell').to_a).to eq([element])
             end
           end
 
           context "that can not be found" do
             let(:elements) {[]}
-            before {
-              elements.stub_chain(:offset, :limit, :published).and_return([])
-            }
+
+            before do
+              allow(elements)
+                .to receive(:offset)
+                .and_return double(limit: double(published: elements))
+            end
 
             it "returns empty set" do
-              Element.should_receive(:none).and_return(elements)
-              public_page.find_elements(from_cell: 'Lolo').to_a.should == []
+              expect(Element).to receive(:none).and_return(elements)
+              expect(public_page.find_elements(from_cell: 'Lolo').to_a).to eq([])
             end
 
             it "loggs a warning" do
-              Rails.logger.should_receive(:debug)
+              expect(Rails.logger).to receive(:debug)
               public_page.find_elements(from_cell: 'Lolo')
             end
           end
@@ -924,31 +929,34 @@ module Alchemy
           let(:cell) { FactoryGirl.build_stubbed(:cell, page: public_page) }
 
           it "returns only the elements from given cell" do
-            cell.stub_chain(:elements, :offset, :limit, :published).and_return([element])
-            public_page.find_elements(from_cell: cell).to_a.should == [element]
+            expect(cell)
+              .to receive(:elements)
+              .and_return double(offset: double(limit: double(published: [element])))
+
+            expect(public_page.find_elements(from_cell: cell).to_a).to eq([element])
           end
         end
       end
 
       context "with show_non_public argument FALSE" do
         it "should return all elements from empty arguments" do
-          public_page.find_elements().to_a.should == public_page.elements.published.to_a
+          expect(public_page.find_elements().to_a).to eq(public_page.elements.published.to_a)
         end
 
         it "should only return the public elements passed as options[:only]" do
-          public_page.find_elements(:only => ['article']).to_a.should == public_page.elements.published.named('article').to_a
+          expect(public_page.find_elements(:only => ['article']).to_a).to eq(public_page.elements.published.named('article').to_a)
         end
 
         it "should return all public elements except the ones passed as options[:except]" do
-          public_page.find_elements(:except => ['article']).to_a.should == public_page.elements.published.to_a - public_page.elements.published.named('article').to_a
+          expect(public_page.find_elements(:except => ['article']).to_a).to eq(public_page.elements.published.to_a - public_page.elements.published.named('article').to_a)
         end
 
         it "should return elements offsetted" do
-          public_page.find_elements({:offset => 2}).to_a.should == public_page.elements.published.offset(2)
+          expect(public_page.find_elements({:offset => 2}).to_a).to eq(public_page.elements.published.offset(2))
         end
 
         it "should return elements limitted in count" do
-          public_page.find_elements({:count => 1}).to_a.should == public_page.elements.published.limit(1)
+          expect(public_page.find_elements({:count => 1}).to_a).to eq(public_page.elements.published.limit(1))
         end
       end
     end
@@ -960,11 +968,11 @@ module Alchemy
 
       it "should return first_public_child" do
         first_public_child = FactoryGirl.create(:public_page, :name => "First public child", :language => language, :parent_id => language_root.id)
-        language_root.first_public_child.should == first_public_child
+        expect(language_root.first_public_child).to eq(first_public_child)
       end
 
       it "should return nil if no public child exists" do
-        language_root.first_public_child.should == nil
+        expect(language_root.first_public_child).to eq(nil)
       end
     end
 
@@ -985,12 +993,14 @@ module Alchemy
 
         context 'with user is a active record model' do
           before do
-            Alchemy.user_class.should_receive(:'<').and_return(true)
+            expect(Alchemy.user_class).to receive(:'<').and_return(true)
           end
 
           context 'if page is folded' do
             before do
-              page.stub_chain(:folded_pages, :where, :any?).and_return(true)
+              expect(page)
+                .to receive(:folded_pages)
+                .and_return double(where: double(any?: true))
             end
 
             it "should return true" do
@@ -1008,10 +1018,11 @@ module Alchemy
     end
 
     describe '#get_language_root' do
+      before { language_root }
       subject { public_page.get_language_root }
 
       it "returns the language root page" do
-        should eq language_root
+        is_expected.to eq language_root
       end
     end
 
@@ -1022,7 +1033,7 @@ module Alchemy
       it "should set locked to true" do
         page.lock_to!(user)
         page.reload
-        page.locked.should == true
+        expect(page.locked).to eq(true)
       end
 
       it "should not update the timestamps " do
@@ -1032,7 +1043,7 @@ module Alchemy
       it "should set locked_by to the users id" do
         page.lock_to!(user)
         page.reload
-        page.locked_by.should == user.id
+        expect(page.locked_by).to eq(user.id)
       end
     end
 
@@ -1045,7 +1056,7 @@ module Alchemy
       subject { Page.copy_and_paste(source, new_parent, page_name) }
 
       it "should copy the source page with the given name to the new parent" do
-        Page.should_receive(:copy).with(source, {
+        expect(Page).to receive(:copy).with(source, {
           parent_id: new_parent.id,
           language: new_parent.language,
           name: page_name,
@@ -1055,15 +1066,15 @@ module Alchemy
       end
 
       it "should return the copied page" do
-        Page.stub(:copy).and_return(copied_page)
+        allow(Page).to receive(:copy).and_return(copied_page)
         expect(subject).to be_a(copied_page.class)
       end
 
       context "if source page has children" do
         it "should also copy and paste the children" do
-          Page.stub(:copy).and_return(copied_page)
-          source.stub(:children).and_return([mock_model('Page')])
-          source.should_receive(:copy_children_to).with(copied_page)
+          allow(Page).to receive(:copy).and_return(copied_page)
+          allow(source).to receive(:children).and_return([mock_model('Page')])
+          expect(source).to receive(:copy_children_to).with(copied_page)
           subject
         end
       end
@@ -1085,26 +1096,26 @@ module Alchemy
 
       describe '#previous' do
         it "should return the previous page on the same level" do
-          center_page.previous.should == public_page
-          next_page.previous.should == center_page
+          expect(center_page.previous).to eq(public_page)
+          expect(next_page.previous).to eq(center_page)
         end
 
         context "no previous page on same level present" do
           it "should return nil" do
-            public_page.previous.should be_nil
+            expect(public_page.previous).to be_nil
           end
         end
 
         context "with options restricted" do
           context "set to true" do
             it "returns previous restricted page" do
-              center_page.previous(restricted: true).should == restricted_page
+              expect(center_page.previous(restricted: true)).to eq(restricted_page)
             end
           end
 
           context "set to false" do
             it "skips restricted page" do
-              center_page.previous(restricted: false).should == public_page
+              expect(center_page.previous(restricted: false)).to eq(public_page)
             end
           end
         end
@@ -1112,13 +1123,13 @@ module Alchemy
         context "with options public" do
           context "set to true" do
             it "returns previous public page" do
-              center_page.previous(public: true).should == public_page
+              expect(center_page.previous(public: true)).to eq(public_page)
             end
           end
 
           context "set to false" do
             it "skips public page" do
-              center_page.previous(public: false).should == non_public_page
+              expect(center_page.previous(public: false)).to eq(non_public_page)
             end
           end
         end
@@ -1126,12 +1137,12 @@ module Alchemy
 
       describe '#next' do
         it "should return the next page on the same level" do
-          center_page.next.should == next_page
+          expect(center_page.next).to eq(next_page)
         end
 
         context "no next page on same level present" do
           it "should return nil" do
-            next_page.next.should be_nil
+            expect(next_page.next).to be_nil
           end
         end
       end
@@ -1143,16 +1154,16 @@ module Alchemy
 
       before do
         current_time
-        Time.stub(:now).and_return(current_time)
+        allow(Time).to receive(:now).and_return(current_time)
         page.publish!
       end
 
       it "sets public attribute to true" do
-        page.public.should == true
+        expect(page.public).to eq(true)
       end
 
       it "sets published_at attribute to current time" do
-        page.published_at.should == current_time
+        expect(page.published_at).to eq(current_time)
       end
     end
 
@@ -1160,7 +1171,7 @@ module Alchemy
       let(:default_language) { mock_model('Language', code: 'es') }
       let(:page) { Page.new }
 
-      before { page.stub(:parent).and_return(parent) }
+      before { allow(page).to receive(:parent).and_return(parent) }
 
       subject { page }
 
@@ -1171,18 +1182,24 @@ module Alchemy
           page.send(:set_language_from_parent_or_default)
         end
 
-        its(:language_id) { should eq(parent.language_id) }
+        describe '#language_id' do
+          subject { super().language_id }
+          it { is_expected.to eq(parent.language_id) }
+        end
       end
 
       context "parent has no language" do
         let(:parent) { mock_model('Page', language: nil, language_id: nil, language_code: nil) }
 
         before do
-          Language.stub(:default).and_return(default_language)
+          allow(Language).to receive(:default).and_return(default_language)
           page.send(:set_language_from_parent_or_default)
         end
 
-        its(:language_id) { should eq(default_language.id) }
+        describe '#language_id' do
+          subject { super().language_id }
+          it { is_expected.to eq(default_language.id) }
+        end
       end
     end
 
@@ -1190,24 +1207,24 @@ module Alchemy
       context "definition has 'taggable' key with true value" do
         it "should return true" do
           page = FactoryGirl.build(:page)
-          page.stub(:definition).and_return({'name' => 'standard', 'taggable' => true})
-          page.taggable?.should be_true
+          allow(page).to receive(:definition).and_return({'name' => 'standard', 'taggable' => true})
+          expect(page.taggable?).to be_truthy
         end
       end
 
       context "definition has 'taggable' key with foo value" do
         it "should return false" do
           page = FactoryGirl.build(:page)
-          page.stub(:definition).and_return({'name' => 'standard', 'taggable' => 'foo'})
-          page.taggable?.should be_false
+          allow(page).to receive(:definition).and_return({'name' => 'standard', 'taggable' => 'foo'})
+          expect(page.taggable?).to be_falsey
         end
       end
 
       context "definition has no 'taggable' key" do
         it "should return false" do
           page = FactoryGirl.build(:page)
-          page.stub(:definition).and_return({'name' => 'standard'})
-          page.taggable?.should be_false
+          allow(page).to receive(:definition).and_return({'name' => 'standard'})
+          expect(page.taggable?).to be_falsey
         end
       end
     end
@@ -1216,13 +1233,13 @@ module Alchemy
       let(:page) { FactoryGirl.create(:page, locked: true, locked_by: 1) }
 
       before do
-        page.stub(:save).and_return(true)
+        allow(page).to receive(:save).and_return(true)
       end
 
       it "should set the locked status to false" do
         page.unlock!
         page.reload
-        page.locked.should == false
+        expect(page.locked).to eq(false)
       end
 
       it "should not update the timestamps " do
@@ -1232,13 +1249,13 @@ module Alchemy
       it "should set locked_by to nil" do
         page.unlock!
         page.reload
-        page.locked_by.should == nil
+        expect(page.locked_by).to eq(nil)
       end
 
       it "sets current preview to nil" do
         Page.current_preview = page
         page.unlock!
-        Page.current_preview.should be_nil
+        expect(Page.current_preview).to be_nil
       end
     end
 
@@ -1252,24 +1269,24 @@ module Alchemy
       let(:language_root) { parentparent.parent }
 
       context "with activated url_nesting" do
-        before { Config.stub(:get).and_return(true) }
+        before { allow(Config).to receive(:get).and_return(true) }
 
         it "should store all parents urlnames delimited by slash" do
-          page.urlname.should == 'parentparent/parent/page'
+          expect(page.urlname).to eq('parentparent/parent/page')
         end
 
         it "should not include the root page" do
           Page.root.update_column(:urlname, 'root')
           language_root.update(urlname: 'new-urlname')
-          language_root.urlname.should_not =~ /root/
+          expect(language_root.urlname).not_to match(/root/)
         end
 
         it "should not include the language root page" do
-          page.urlname.should_not =~ /startseite/
+          expect(page.urlname).not_to match(/startseite/)
         end
 
         it "should not include invisible pages" do
-          contact.urlname.should_not =~ /invisible/
+          expect(contact.urlname).not_to match(/invisible/)
         end
 
         context "after changing page's urlname" do
@@ -1278,7 +1295,7 @@ module Alchemy
             parentparent.urlname = 'new-urlname'
             parentparent.save!
             page.reload
-            page.urlname.should == 'new-urlname/parent/page'
+            expect(page.urlname).to eq('new-urlname/parent/page')
           end
 
           context 'with descendants that are redirecting to external' do
@@ -1287,15 +1304,15 @@ module Alchemy
               parent.urlname = 'new-urlname'
               parent.save!
               external.reload
-              external.urlname.should == 'http://google.com'
+              expect(external.urlname).to eq('http://google.com')
             end
           end
 
           it "should create a legacy url" do
-            page.stub(:slug).and_return('foo')
+            allow(page).to receive(:slug).and_return('foo')
             page.update_urlname!
-            page.legacy_urls.should_not be_empty
-            page.legacy_urls.pluck(:urlname).should include('parentparent/parent/page')
+            expect(page.legacy_urls).not_to be_empty
+            expect(page.legacy_urls.pluck(:urlname)).to include('parentparent/parent/page')
           end
         end
 
@@ -1305,16 +1322,16 @@ module Alchemy
             parentparent.visible = false
             parentparent.save!
             page.reload
-            page.urlname.should == 'parent/page'
+            expect(page.urlname).to eq('parent/page')
           end
         end
       end
 
       context "with disabled url_nesting" do
-        before { Config.stub(:get).and_return(false) }
+        before { allow(Config).to receive(:get).and_return(false) }
 
         it "should only store my urlname" do
-          page.urlname.should == 'page'
+          expect(page.urlname).to eq('page')
         end
       end
     end
@@ -1326,11 +1343,13 @@ module Alchemy
       let(:node) { TreeNode.new(10, 11, 12, 13, "another-url", true) }
 
       context "when nesting is enabled" do
-        before { Alchemy::Config.stub(:get).with(:url_nesting) { true } }
+        before { allow(Alchemy::Config).to receive(:get).with(:url_nesting) { true } }
 
         context "when page is not external" do
 
-          before { page.stub(redirects_to_external?: false)}
+          before do
+            expect(page).to receive(:redirects_to_external?).and_return(false)
+          end
 
           it "should update all attributes" do
             page.update_node!(node)
@@ -1363,8 +1382,11 @@ module Alchemy
         end
 
         context "when page is external" do
-
-          before { page.stub(redirects_to_external?: true) }
+          before do
+            expect(page)
+              .to receive(:redirects_to_external?)
+              .and_return(true)
+          end
 
           it "should update all attributes except url" do
             page.update_node!(node)
@@ -1386,11 +1408,14 @@ module Alchemy
       end
 
       context "when nesting is disabled" do
-        before { Alchemy::Config.stub(:get).with(:url_nesting) { false } }
+        before do
+          allow(Alchemy::Config).to receive(:get).with(:url_nesting) { false }
+        end
 
         context "when page is not external" do
-
-          before { page.stub(redirects_to_external?: false)}
+          before do
+            allow(page).to receive(:redirects_to_external?).and_return(false)
+          end
 
           it "should update all attributes except url" do
             page.update_node!(node)
@@ -1408,14 +1433,13 @@ module Alchemy
             page.reload
             expect(page.legacy_urls.size).to eq(0)
           end
-
         end
 
         context "when page is external" do
-
-          before { page.stub(redirects_to_external?: true) }
-
-          before { Alchemy::Config.stub(get: true) }
+          before do
+            expect(Alchemy::Config).to receive(:get).and_return(true)
+            allow(page).to receive(:redirects_to_external?).and_return(true)
+          end
 
           it "should update all attributes except url" do
             page.update_node!(node)
@@ -1442,7 +1466,7 @@ module Alchemy
         let(:page) { FactoryGirl.build(:page, urlname: 'root/parent/my-name')}
 
         it "should return the last part of the urlname" do
-          page.slug.should == 'my-name'
+          expect(page.slug).to eq('my-name')
         end
       end
 
@@ -1450,7 +1474,7 @@ module Alchemy
         let(:page) { FactoryGirl.build(:page, urlname: 'my-name')}
 
         it "should return the last part of the urlname" do
-          page.slug.should == 'my-name'
+          expect(page.slug).to eq('my-name')
         end
       end
 
@@ -1458,7 +1482,7 @@ module Alchemy
         let(:page) { FactoryGirl.build(:page, urlname: nil)}
 
         it "should return nil" do
-          page.slug.should be_nil
+          expect(page.slug).to be_nil
         end
       end
     end
@@ -1496,25 +1520,25 @@ module Alchemy
 
       describe '#status' do
         it "returns a combined status hash" do
-          page.status.should == {public: true, visible: true, restricted: false, locked: false}
+          expect(page.status).to eq({public: true, visible: true, restricted: false, locked: false})
         end
       end
 
       describe '#status_title' do
         it "returns a translated status string for public status" do
-          page.status_title(:public).should == 'Page is published.'
+          expect(page.status_title(:public)).to eq('Page is published.')
         end
 
         it "returns a translated status string for visible status" do
-          page.status_title(:visible).should == 'Page is visible in navigation.'
+          expect(page.status_title(:visible)).to eq('Page is visible in navigation.')
         end
 
         it "returns a translated status string for locked status" do
-          page.status_title(:locked).should == ''
+          expect(page.status_title(:locked)).to eq('')
         end
 
         it "returns a translated status string for restricted status" do
-          page.status_title(:restricted).should == 'Page is not restricted.'
+          expect(page.status_title(:restricted)).to eq('Page is not restricted.')
         end
       end
     end
@@ -1552,7 +1576,7 @@ module Alchemy
           %w(creator updater locker).each do |user_type|
             expect {
               page.send(user_type)
-            }.to_not raise_error(ActiveRecord::RecordNotFound)
+            }.to_not raise_error
           end
         end
       end
@@ -1561,7 +1585,7 @@ module Alchemy
         let(:user) { double(name: 'Paul Page') }
 
         describe '#creator_name' do
-          before { page.stub(:creator).and_return(user) }
+          before { allow(page).to receive(:creator).and_return(user) }
 
           it "returns the name of the creator" do
             expect(page.creator_name).to eq('Paul Page')
@@ -1569,7 +1593,7 @@ module Alchemy
         end
 
         describe '#updater_name' do
-          before { page.stub(:updater).and_return(user) }
+          before { allow(page).to receive(:updater).and_return(user) }
 
           it "returns the name of the updater" do
             expect(page.updater_name).to eq('Paul Page')
@@ -1577,7 +1601,7 @@ module Alchemy
         end
 
         describe '#locker_name' do
-          before { page.stub(:locker).and_return(user) }
+          before { allow(page).to receive(:locker).and_return(user) }
 
           it "returns the name of the current page editor" do
             expect(page.locker_name).to eq('Paul Page')
@@ -1589,7 +1613,7 @@ module Alchemy
         let(:user) { Alchemy.user_class.new }
 
         describe '#creator_name' do
-          before { page.stub(:creator).and_return(user) }
+          before { allow(page).to receive(:creator).and_return(user) }
 
           it "returns unknown" do
             expect(page.creator_name).to eq('unknown')
@@ -1597,7 +1621,7 @@ module Alchemy
         end
 
         describe '#updater_name' do
-          before { page.stub(:updater).and_return(user) }
+          before { allow(page).to receive(:updater).and_return(user) }
 
           it "returns unknown" do
             expect(page.updater_name).to eq('unknown')
@@ -1605,7 +1629,7 @@ module Alchemy
         end
 
         describe '#locker_name' do
-          before { page.stub(:locker).and_return(user) }
+          before { allow(page).to receive(:locker).and_return(user) }
 
           it "returns unknown" do
             expect(page.locker_name).to eq('unknown')
@@ -1619,8 +1643,8 @@ module Alchemy
 
       context 'if the page has a custom controller defined in its description' do
         before do
-          page.stub(:has_controller?).and_return(true)
-          page.stub(:layout_description).and_return({'controller' => 'comments', 'action' => 'index'})
+          allow(page).to receive(:has_controller?).and_return(true)
+          allow(page).to receive(:layout_description).and_return({'controller' => 'comments', 'action' => 'index'})
         end
         it "should return a Hash with controller and action key-value pairs" do
           expect(page.controller_and_action).to eq({controller: '/comments', action: 'index'})