alchemy_cms 3.0.4 → 3.1.0.beta1

data/spec/models/content_spec.rb

@@ -2,24 +2,24 @@ require 'spec_helper'
 
 module Alchemy
   describe Content do
-    let(:element) { FactoryGirl.create(:element, name: 'headline', :create_contents_after_create => true) }
+    let(:element) { create(:element, name: 'headline', :create_contents_after_create => true) }
     let(:content) { element.contents.find_by_essence_type('Alchemy::EssenceText') }
 
     it "should return the ingredient from its essence" do
       content.essence.update_attributes(:body => "Hello")
-      content.ingredient.should == "Hello"
+      expect(content.ingredient).to eq("Hello")
     end
 
     describe '.normalize_essence_type' do
       context "passing namespaced essence type" do
         it "should not add alchemy namespace" do
-          Content.normalize_essence_type('Alchemy::EssenceText').should == "Alchemy::EssenceText"
+          expect(Content.normalize_essence_type('Alchemy::EssenceText')).to eq("Alchemy::EssenceText")
         end
       end
 
       context "passing not namespaced essence type" do
         it "should add alchemy namespace" do
-          Content.normalize_essence_type('EssenceText').should == "Alchemy::EssenceText"
+          expect(Content.normalize_essence_type('EssenceText')).to eq("Alchemy::EssenceText")
         end
       end
     end
@@ -27,13 +27,13 @@ module Alchemy
     describe '#normalized_essence_type' do
       context "without namespace in essence_type column" do
         it "should return the namespaced essence type" do
-          Content.new(:essence_type => 'EssenceText').normalized_essence_type.should == 'Alchemy::EssenceText'
+          expect(Content.new(:essence_type => 'EssenceText').normalized_essence_type).to eq('Alchemy::EssenceText')
         end
       end
 
       context "with namespace in essence_type column" do
         it "should return the namespaced essence type" do
-          Content.new(:essence_type => 'Alchemy::EssenceText').normalized_essence_type.should == 'Alchemy::EssenceText'
+          expect(Content.new(:essence_type => 'Alchemy::EssenceText').normalized_essence_type).to eq('Alchemy::EssenceText')
         end
       end
     end
@@ -49,15 +49,17 @@ module Alchemy
         let(:params)  { {body: 'Mikes Petshop'} }
         let(:essence) { content.essence }
 
-        before { essence.stub(content: content) }
+        before do
+          expect(essence).to receive(:content).at_least(:once).and_return content
+        end
 
         it "updates the attributes of related essence and return true" do
-          should be_true
-          content.ingredient.should == "Mikes Petshop"
+          is_expected.to be_truthy
+          expect(content.ingredient).to eq("Mikes Petshop")
         end
 
         it "updates timestamp after updating related essence" do
-          content.should_receive(:touch)
+          expect(content).to receive(:touch)
           subject
         end
       end
@@ -66,14 +68,14 @@ module Alchemy
         let(:element) { create(:element, name: 'contactform', create_contents_after_create: true) }
 
         it "should add error messages if save fails and return false" do
-          should be_false
-          content.errors[:essence].should have(1).item
+          is_expected.to be_falsey
+          expect(content.errors[:essence].size).to eq(1)
         end
       end
 
       context 'if essence is missing' do
         before do
-          content.stub(essence: nil)
+          expect(content).to receive(:essence).and_return nil
         end
 
         it "should raise error" do
@@ -90,12 +92,12 @@ module Alchemy
 
       it "should create a new record with all attributes of source except given differences" do
         copy = Content.copy(@content, {:name => 'foobar', :element_id => @element.id + 1})
-        copy.name.should == 'foobar'
+        expect(copy.name).to eq('foobar')
       end
 
       it "should make a new record for essence of source" do
         copy = Content.copy(@content, {:element_id => @element.id + 1})
-        copy.essence_id.should_not == @content.essence_id
+        expect(copy.essence_id).not_to eq(@content.essence_id)
       end
 
       it "should copy source essence attributes" do
@@ -108,7 +110,7 @@ module Alchemy
       let(:element) { FactoryGirl.build_stubbed(:element) }
 
       it "builds a new instance from elements.yml description" do
-        Content.build(element, {name: 'headline'}).should be_instance_of(Content)
+        expect(Content.build(element, {name: 'headline'})).to be_instance_of(Content)
       end
     end
 
@@ -117,14 +119,14 @@ module Alchemy
 
       context "with blank name key" do
         it "returns a essence hash build from essence type" do
-          Content.should_receive(:content_description_from_essence_type).with(element, 'EssenceText')
+          expect(Content).to receive(:content_description_from_essence_type).with(element, 'EssenceText')
           Content.content_description(element, essence_type: 'EssenceText')
         end
       end
 
       context "with name key present" do
         it "returns a essence hash from element" do
-          Content.should_receive(:content_description_from_element).with(element, 'headline')
+          expect(Content).to receive(:content_description_from_element).with(element, 'headline')
           Content.content_description(element, name: 'headline')
         end
       end
@@ -135,18 +137,18 @@ module Alchemy
       let(:essence) { {name: 'headline', type: 'EssenceText'} }
 
       it "returns the description hash from element" do
-        element.should_receive(:content_description_for).and_return(essence)
-        Content.content_description(element, name: 'headline').should == essence
+        expect(element).to receive(:content_description_for).and_return(essence)
+        expect(Content.content_description(element, name: 'headline')).to eq(essence)
       end
 
       context "with content description not found" do
         before {
-          element.should_receive(:content_description_for).and_return(nil)
-          element.should_receive(:available_content_description_for).and_return(essence)
+          expect(element).to receive(:content_description_for).and_return(nil)
+          expect(element).to receive(:available_content_description_for).and_return(essence)
         }
 
         it "returns the description hash from available contents" do
-          Content.content_description(element, name: 'headline').should == essence
+          expect(Content.content_description(element, name: 'headline')).to eq(essence)
         end
       end
     end
@@ -155,11 +157,11 @@ module Alchemy
       let(:element) { FactoryGirl.build_stubbed(:element) }
 
       it "returns the description hash from element" do
-        Content.should_receive(:content_name_from_element_and_essence_type).with(element, 'EssenceText').and_return('Foo')
-        Content.content_description_from_essence_type(element, 'EssenceText').should == {
+        expect(Content).to receive(:content_name_from_element_and_essence_type).with(element, 'EssenceText').and_return('Foo')
+        expect(Content.content_description_from_essence_type(element, 'EssenceText')).to eq({
           'type' => 'EssenceText',
           'name' => 'Foo'
-        }
+        })
       end
     end
 
@@ -167,7 +169,7 @@ module Alchemy
       let(:element) { FactoryGirl.build_stubbed(:element) }
 
       it "returns a name from essence type and count of essences in element" do
-        Content.content_name_from_element_and_essence_type(element, 'EssenceText').should == "essence_text_1"
+        expect(Content.content_name_from_element_and_essence_type(element, 'EssenceText')).to eq("essence_text_1")
       end
     end
 
@@ -188,24 +190,24 @@ module Alchemy
 
       context "with default value present" do
         it "should have the ingredient column filled with default value." do
-          Content.stub(:content_description_from_element).and_return({'name' => 'headline', 'type' => 'EssenceText', 'default' => 'Welcome'})
+          allow(Content).to receive(:content_description_from_element).and_return({'name' => 'headline', 'type' => 'EssenceText', 'default' => 'Welcome'})
           content = Content.create_from_scratch(element, name: 'headline')
-          content.ingredient.should == "Welcome"
+          expect(content.ingredient).to eq("Welcome")
         end
       end
     end
 
     describe '#ingredient=' do
-      let (:element) { FactoryGirl.create(:element, name: 'headline') }
+      let(:element) { FactoryGirl.create(:element, name: 'headline') }
 
       it "should set the given value to the ingredient column of essence" do
         c = Content.create_from_scratch(element, name: 'headline')
         c.ingredient = "Welcome"
-        c.ingredient.should == "Welcome"
+        expect(c.ingredient).to eq("Welcome")
       end
 
       context "no essence associated" do
-        let (:element) { FactoryGirl.create(:element, name: 'headline') }
+        let(:element) { FactoryGirl.create(:element, name: 'headline') }
 
         it "should raise error" do
           c = Content.create(:element_id => element.id, name: 'headline')
@@ -216,10 +218,10 @@ module Alchemy
 
     describe "#descriptions" do
       context "without any descriptions in elements.yml file" do
-        before { Element.stub(:descriptions).and_return([]) }
+        before { allow(Element).to receive(:descriptions).and_return([]) }
 
         it "should return an empty array" do
-          Content.descriptions.should == []
+          expect(Content.descriptions).to eq([])
         end
       end
     end
@@ -228,14 +230,14 @@ module Alchemy
       let(:content) { build_stubbed(:content) }
 
       it "returns a dom id string" do
-        content.dom_id.should eq("essence_text_#{content.id}")
+        expect(content.dom_id).to eq("essence_text_#{content.id}")
       end
 
       context "without an essence" do
-        before { content.stub(essence: nil) }
+        before { expect(content).to receive(:essence).and_return nil }
 
         it "returns empty string" do
-          content.dom_id.should eq('')
+          expect(content.dom_id).to eq('')
         end
       end
     end
@@ -244,15 +246,56 @@ module Alchemy
       let(:content) { build_stubbed(:content) }
 
       it "returns the essence#partial_name" do
-        content.essence.should_receive(:partial_name)
+        expect(content.essence).to receive(:partial_name)
         content.essence_partial_name
       end
 
       context "without an essence" do
-        before { content.stub(essence: nil) }
+        before { expect(content).to receive(:essence).and_return nil }
 
         it "returns empty string" do
-          content.essence_partial_name.should eq('')
+          expect(content.essence_partial_name).to eq('')
+        end
+      end
+    end
+
+    describe '#preview_content?' do
+      let(:content) { build_stubbed(:content) }
+
+      context 'not defined as preview content' do
+        it "returns false" do
+          expect(content.preview_content?).to be false
+        end
+      end
+
+      context 'defined as preview content via take_me_for_preview' do
+        before do
+          expect(content).to receive(:description).at_least(:once).and_return({
+            'take_me_for_preview' => true
+          })
+        end
+
+        it "returns true" do
+          ActiveSupport::Deprecation.silence do
+            expect(content.preview_content?).to be true
+          end
+        end
+
+        it "display deprecation warning" do
+          expect(ActiveSupport::Deprecation).to receive(:warn)
+          content.preview_content?
+        end
+      end
+
+      context 'defined as preview content via as_element_title' do
+        before do
+          expect(content).to receive(:description).at_least(:once).and_return({
+            'as_element_title' => true
+          })
+        end
+
+        it "returns true" do
+          expect(content.preview_content?).to be true
         end
       end
     end
@@ -262,7 +305,7 @@ module Alchemy
       let(:content) { c = Content.new; c.essence = essence; c }
 
       it "should return the essences preview_text" do
-        essence.should_receive(:preview_text).with(30)
+        expect(essence).to receive(:preview_text).with(30)
         content.preview_text
       end
     end
@@ -275,7 +318,7 @@ module Alchemy
       it { eq('default_tinymce') }
 
       context 'having custom tinymce config' do
-        before { content.stub(:has_custom_tinymce_config?).and_return(true) }
+        before { allow(content).to receive(:has_custom_tinymce_config?).and_return(true) }
         it('returns name including element name') { eq('custom_tinymce article_text') }
       end
     end
@@ -284,12 +327,12 @@ module Alchemy
       let(:content) { Content.new(id: 1) }
 
       it "returns a name value for form fields with ingredient as default" do
-        content.form_field_name.should == 'contents[1][ingredient]'
+        expect(content.form_field_name).to eq('contents[1][ingredient]')
       end
 
       context 'with a essence column given' do
         it "returns a name value for form fields for that column" do
-          content.form_field_name(:link_title).should == 'contents[1][link_title]'
+          expect(content.form_field_name(:link_title)).to eq('contents[1][link_title]')
         end
       end
     end
@@ -298,12 +341,12 @@ module Alchemy
       let(:content) { Content.new(id: 1) }
 
       it "returns a id value for form fields with ingredient as default" do
-        content.form_field_id.should == 'contents_1_ingredient'
+        expect(content.form_field_id).to eq('contents_1_ingredient')
       end
 
       context 'with a essence column given' do
         it "returns a id value for form fields for that column" do
-          content.form_field_id(:link_title).should == 'contents_1_link_title'
+          expect(content.form_field_id(:link_title)).to eq('contents_1_link_title')
         end
       end
     end
@@ -312,5 +355,22 @@ module Alchemy
       let(:subject) { Content.new }
     end
 
+    describe '#settings' do
+      let(:element) { build_stubbed(:element, name: 'article') }
+      let(:content) { build_stubbed(:content, name: 'headline', element: element) }
+
+      it "returns the settings hash from description" do
+        expect(content.settings).to eq({deletable: true})
+      end
+
+      context 'if settings are not defined' do
+        let(:content) { build_stubbed(:content, name: 'intro', element: element) }
+
+        it "returns empty hash" do
+          expect(content.settings).to eq({})
+        end
+      end
+    end
+
   end
 end

data/spec/models/element_spec.rb

@@ -13,28 +13,28 @@ module Alchemy
 
       it "should not create contents from scratch" do
         copy = Element.copy(element)
-        copy.contents.count.should == element.contents.count
+        expect(copy.contents.count).to eq(element.contents.count)
       end
 
       it "should create a new record with all attributes of source except given differences" do
         copy = Element.copy(element, {:name => 'foobar'})
-        copy.name.should == 'foobar'
+        expect(copy.name).to eq('foobar')
       end
 
       it "should make copies of all contents of source" do
         copy = Element.copy(element)
-        copy.contents.pluck(:id).should_not == element.contents.pluck(:id)
+        expect(copy.contents.pluck(:id)).not_to eq(element.contents.pluck(:id))
       end
 
       it "the copy should include source element tags" do
         copy = Element.copy(element)
-        copy.tag_list.should == element.tag_list
+        expect(copy.tag_list).to eq(element.tag_list)
       end
     end
 
     describe '.definitions' do
       context "without existing yml files" do
-        before { File.stub(:exists?).and_return(false) }
+        before { allow(File).to receive(:exists?).and_return(false) }
 
         it "should raise an error" do
           expect { Element.definitions }.to raise_error(LoadError)
@@ -42,17 +42,17 @@ module Alchemy
       end
 
       context "without any definitions in elements.yml" do
-        before { YAML.stub(:load_file).and_return(false) } # Yes, YAML.load_file returns false if an empty file exists.
+        before { allow(YAML).to receive(:load_file).and_return(false) } # Yes, YAML.load_file returns false if an empty file exists.
 
         it "should return an empty array" do
-          Element.definitions.should == []
+          expect(Element.definitions).to eq([])
         end
       end
     end
 
     describe '.display_name_for' do
       it "should return the translation for the given name" do
-        I18n.should_receive(:t).with('subheadline', scope: "element_names", default: 'Subheadline').and_return('Überschrift')
+        expect(I18n).to receive(:t).with('subheadline', scope: "element_names", default: 'Subheadline').and_return('Überschrift')
         expect(Element.display_name_for('subheadline')).to eq('Überschrift')
       end
 
@@ -66,7 +66,7 @@ module Alchemy
         FactoryGirl.create(:element, :name => 'article')
         FactoryGirl.create(:element, :name => 'article')
         excluded = FactoryGirl.create(:element, :name => 'claim')
-        Element.excluded(['claim']).should_not include(excluded)
+        expect(Element.excluded(['claim'])).not_to include(excluded)
       end
     end
 
@@ -75,8 +75,8 @@ module Alchemy
         element_1 = FactoryGirl.create(:element, :name => 'article')
         element_2 = FactoryGirl.create(:element, :name => 'article')
         elements = Element.named(['article'])
-        elements.should include(element_1)
-        elements.should include(element_2)
+        expect(elements).to include(element_1)
+        expect(elements).to include(element_2)
       end
     end
 
@@ -85,7 +85,7 @@ module Alchemy
         Element.delete_all
         FactoryGirl.create(:element, :cell_id => 6)
         FactoryGirl.create(:element, :cell_id => nil)
-        Element.not_in_cell.should have(1).element
+        expect(Element.not_in_cell.size).to eq(1)
       end
     end
 
@@ -94,8 +94,8 @@ module Alchemy
         element_1 = FactoryGirl.create(:element, :public => true)
         element_2 = FactoryGirl.create(:element, :public => true)
         elements = Element.published
-        elements.should include(element_1)
-        elements.should include(element_2)
+        expect(elements).to include(element_1)
+        expect(elements).to include(element_2)
       end
     end
 
@@ -126,24 +126,24 @@ module Alchemy
       let(:clipboard) { [{'id' => element_1.id.to_s}, {'id' => element_2.id.to_s}] }
 
       before do
-        Element.stub(:all_from_clipboard).and_return([element_1, element_2])
+        allow(Element).to receive(:all_from_clipboard).and_return([element_1, element_2])
       end
 
       it "return all elements from clipboard that could be placed on page" do
         elements = Element.all_from_clipboard_for_page(clipboard, page)
-        elements.should == [element_1]
-        elements.should_not == [element_2]
+        expect(elements).to eq([element_1])
+        expect(elements).not_to eq([element_2])
       end
 
       context "page nil" do
         it "returns empty array" do
-          Element.all_from_clipboard_for_page(clipboard, nil).should == []
+          expect(Element.all_from_clipboard_for_page(clipboard, nil)).to eq([])
         end
       end
 
       context "clipboard nil" do
         it "returns empty array" do
-          Element.all_from_clipboard_for_page(nil, page).should == []
+          expect(Element.all_from_clipboard_for_page(nil, page)).to eq([])
         end
       end
     end
@@ -156,14 +156,14 @@ module Alchemy
 
       context "with namespaced essence type" do
         subject { element.all_contents_by_type('Alchemy::EssenceText') }
-        it { should_not be_empty }
-        it('should return the correct list of essences') { should == expected_contents }
+        it { is_expected.not_to be_empty }
+        it('should return the correct list of essences') { is_expected.to eq(expected_contents) }
       end
 
       context "without namespaced essence type" do
         subject { element.all_contents_by_type('EssenceText') }
-        it { should_not be_empty }
-        it('should return the correct list of essences') { should == expected_contents }
+        it { is_expected.not_to be_empty }
+        it('should return the correct list of essences') { is_expected.to eq(expected_contents) }
       end
     end
 
@@ -173,7 +173,7 @@ module Alchemy
 
       context "with page having cells defining the correct elements" do
         before do
-          Cell.stub(:definitions).and_return([
+          allow(Cell).to receive(:definitions).and_return([
             {'name' => 'header', 'elements' => ['article', 'headline']},
             {'name' => 'footer', 'elements' => ['article', 'text']},
             {'name' => 'sidebar', 'elements' => ['teaser']}
@@ -184,13 +184,13 @@ module Alchemy
           FactoryGirl.create(:cell, name: 'header', page: page)
           FactoryGirl.create(:cell, name: 'footer', page: page)
           FactoryGirl.create(:cell, name: 'sidebar', page: page)
-          element.available_page_cell_names(page).should include('header')
-          element.available_page_cell_names(page).should include('footer')
+          expect(element.available_page_cell_names(page)).to include('header')
+          expect(element.available_page_cell_names(page)).to include('footer')
         end
 
         context "but without any cells" do
           it "should return the 'nil cell'" do
-            element.available_page_cell_names(page).should == ['for_other_elements']
+            expect(element.available_page_cell_names(page)).to eq(['for_other_elements'])
           end
         end
 
@@ -198,7 +198,7 @@ module Alchemy
 
       context "with page having cells defining the wrong elements" do
         before do
-          Cell.stub(:definitions).and_return([
+          allow(Cell).to receive(:definitions).and_return([
             {'name' => 'header', 'elements' => ['download', 'headline']},
             {'name' => 'footer', 'elements' => ['contactform', 'text']},
             {'name' => 'sidebar', 'elements' => ['teaser']}
@@ -209,7 +209,7 @@ module Alchemy
           FactoryGirl.create(:cell, name: 'header', page: page)
           FactoryGirl.create(:cell, name: 'footer', page: page)
           FactoryGirl.create(:cell, name: 'sidebar', page: page)
-          element.available_page_cell_names(page).should == ['for_other_elements']
+          expect(element.available_page_cell_names(page)).to eq(['for_other_elements'])
         end
       end
     end
@@ -222,13 +222,13 @@ module Alchemy
 
       context "with namespaced essence type" do
         it "should return content by passing a essence type" do
-          @element.content_by_type('Alchemy::EssenceText').should == @content
+          expect(@element.content_by_type('Alchemy::EssenceText')).to eq(@content)
         end
       end
 
       context "without namespaced essence type" do
         it "should return content by passing a essence type" do
-          @element.content_by_type('EssenceText').should == @content
+          expect(@element.content_by_type('EssenceText')).to eq(@content)
         end
       end
     end
@@ -237,28 +237,17 @@ module Alchemy
       let(:element) { Element.new(name: 'article') }
 
       it "should call .display_name_for" do
-        Element.should_receive(:display_name_for).with(element.name)
+        expect(Element).to receive(:display_name_for).with(element.name)
         element.display_name
       end
     end
 
-    describe '#essence_error_messages' do
-      let(:element) { Element.new(name: 'article') }
-      it "should return the translation with the translated content label" do
-        I18n.should_receive(:t).with('content_names.content', default: 'Content').and_return('Content')
-        I18n.should_receive(:t).with('content', scope: "content_names.article", default: 'Content').and_return('Contenido')
-        I18n.should_receive(:t).with('article.content.invalid', {:scope=>"content_validations", :default=>[:"fields.content.invalid", :"errors.invalid"], :field=>"Contenido"})
-        element.should_receive(:essence_errors).and_return({'content' => [:invalid]})
-        element.essence_error_messages
-      end
-    end
-
     describe '#display_name_with_preview_text' do
       let(:element) { FactoryGirl.build_stubbed(:element, name: 'Foo') }
 
       it "returns a string with display name and preview text" do
-        element.stub(:preview_text).and_return('Fula')
-        element.display_name_with_preview_text.should == "Foo: Fula"
+        allow(element).to receive(:preview_text).and_return('Fula')
+        expect(element.display_name_with_preview_text).to eq("Foo: Fula")
       end
     end
 
@@ -266,14 +255,14 @@ module Alchemy
       let(:element) { FactoryGirl.build_stubbed(:element) }
 
       it "returns an string from element name and id" do
-        element.dom_id.should == "#{element.name}_#{element.id}"
+        expect(element.dom_id).to eq("#{element.name}_#{element.id}")
       end
     end
 
     describe '#new_from_scratch' do
       it "should initialize an element by name from scratch" do
         el = Element.new_from_scratch({:name => 'article'})
-        el.should be_valid
+        expect(el).to be_valid
       end
 
       it "should raise an error if the given name is not defined in the elements.yml" do
@@ -282,17 +271,17 @@ module Alchemy
 
       it "should take the first part of an given name containing a hash (#)" do
         el = Element.new_from_scratch({:name => 'article#header'})
-        el.name.should == "article"
+        expect(el.name).to eq("article")
       end
 
       it "should merge given attributes into defined ones" do
         el = Element.new_from_scratch({:name => 'article', :page_id => 1})
-        el.page_id.should == 1
+        expect(el.page_id).to eq(1)
       end
 
       it "should not have forbidden attributes from definition" do
         el = Element.new_from_scratch({:name => 'article'})
-        el.contents.should == []
+        expect(el.contents).to eq([])
       end
     end
 
@@ -304,29 +293,29 @@ module Alchemy
 
       context "without a content marked as preview" do
         let(:contents) { [content, content_2] }
-        before { element.stub(:contents).and_return(contents) }
+        before { allow(element).to receive(:contents).and_return(contents) }
 
         it "returns the preview text of first content found" do
-          content.should_receive(:preview_text).with(30)
+          expect(content).to receive(:preview_text).with(30)
           element.preview_text
         end
       end
 
       context "with a content marked as preview" do
         let(:contents) { [content, preview_content] }
-        before { element.stub(:contents).and_return(contents) }
+        before { allow(element).to receive(:contents).and_return(contents) }
 
         it "should return the preview_text of this content" do
-          preview_content.should_receive(:preview_text).with(30)
+          expect(preview_content).to receive(:preview_text).with(30)
           element.preview_text
         end
       end
 
       context "without any contents present" do
-        before { element.stub(:contents).and_return([]) }
+        before { allow(element).to receive(:contents).and_return([]) }
 
         it "should return nil" do
-          element.preview_text.should be_nil
+          expect(element.preview_text).to be_nil
         end
       end
     end
@@ -342,24 +331,24 @@ module Alchemy
 
       describe '#prev' do
         it "should return previous element on same page" do
-          @element3.prev.should == @element2
+          expect(@element3.prev).to eq(@element2)
         end
 
         context "with name as parameter" do
           it "should return previous of this kind" do
-            @element3.prev('headline').should == @element1
+            expect(@element3.prev('headline')).to eq(@element1)
           end
         end
       end
 
       describe '#next' do
         it "should return next element on same page" do
-          @element2.next.should == @element3
+          expect(@element2.next).to eq(@element3)
         end
 
         context "with name as parameter" do
           it "should return next of this kind" do
-            @element1.next('text').should == @element3
+            expect(@element1.next('text')).to eq(@element3)
           end
         end
       end
@@ -369,30 +358,30 @@ module Alchemy
       let(:element) { FactoryGirl.create(:element, :name => 'news', :create_contents_after_create => true) }
 
       it "should return an ingredient by name" do
-        element.ingredient('news_headline').should == EssenceText.first.ingredient
+        expect(element.ingredient('news_headline')).to eq(EssenceText.first.ingredient)
       end
 
       it "should return the content for rss title" do
-        element.content_for_rss_title.should == element.contents.find_by_name('news_headline')
+        expect(element.content_for_rss_title).to eq(element.contents.find_by_name('news_headline'))
       end
 
       it "should return the content for rss descdefinitionription" do
-        element.content_for_rss_description.should == element.contents.find_by_name('body')
+        expect(element.content_for_rss_description).to eq(element.contents.find_by_name('body'))
       end
 
       context 'if no content is defined as rss title' do
-        before { element.stub(content_descriptions: []) }
+        before { expect(element).to receive(:content_descriptions).and_return([]) }
 
         it "should return nil" do
-          element.content_for_rss_title.should be_nil
+          expect(element.content_for_rss_title).to be_nil
         end
       end
 
       context 'if no content is defined as rss description' do
-        before { element.stub(content_descriptions: []) }
+        before { expect(element).to receive(:content_descriptions).and_return([]) }
 
         it "should return nil" do
-          element.content_for_rss_description.should be_nil
+          expect(element.content_for_rss_description).to be_nil
         end
       end
     end
@@ -404,11 +393,11 @@ module Alchemy
       let(:element) { build_stubbed(:element, page: page) }
       let(:content) { double(:content, id: 1) }
 
-      before { element.stub(:contents).and_return([content]) }
+      before { allow(element).to receive(:contents).and_return([content]) }
 
       context "with attributes hash is nil" do
         let(:params) { nil }
-        it { should be_true }
+        it { is_expected.to be_truthy }
       end
 
       context "with valid attributes hash" do
@@ -416,17 +405,17 @@ module Alchemy
 
         context 'with passing validations' do
           before do
-            content.should_receive(:update_essence).with({body: 'Title'}).and_return(true)
+            expect(content).to receive(:update_essence).with({body: 'Title'}).and_return(true)
           end
 
-          it { should be_true }
+          it { is_expected.to be_truthy }
         end
 
         context 'with failing validations' do
           it "adds error and returns false" do
-            content.should_receive(:update_essence).with({body: 'Title'}).and_return(false)
-            should be_false
-            element.errors.should_not be_empty
+            expect(content).to receive(:update_essence).with({body: 'Title'}).and_return(false)
+            is_expected.to be_falsey
+            expect(element.errors).not_to be_empty
           end
         end
       end
@@ -438,7 +427,7 @@ module Alchemy
       let(:now)     { Time.now }
 
       before do
-        Time.stub(now: now)
+        allow(Time).to receive(:now).and_return(now)
       end
 
       context 'with touchable pages' do
@@ -446,19 +435,19 @@ module Alchemy
         let(:pages)   { [page] }
 
         before do
-          Alchemy.user_class.stub(:stamper).and_return(locker.id)
+          expect(Alchemy.user_class).to receive(:stamper).at_least(:once).and_return(locker.id)
         end
 
         it "updates page timestamps" do
-          element.should_receive(:touchable_pages).and_return(pages)
-          pages.should_receive(:update_all).with({updated_at: now, updater_id: locker.id})
+          expect(element).to receive(:touchable_pages).and_return(pages)
+          expect(pages).to receive(:update_all).with({updated_at: now, updater_id: locker.id})
           element.save
         end
 
         it "updates page userstamps" do
           element.save
           page.reload
-          page.updater_id.should eq(locker.id)
+          expect(page.updater_id).to eq(locker.id)
         end
       end
 
@@ -466,11 +455,11 @@ module Alchemy
         let(:cell) { mock_model('Cell') }
 
         before do
-          element.stub(cell: cell)
+          expect(element).to receive(:cell).at_least(:once).and_return(cell)
         end
 
         it "updates timestamp of cell" do
-          element.cell.should_receive(:touch)
+          expect(element.cell).to receive(:touch)
           element.save
         end
       end
@@ -487,22 +476,30 @@ module Alchemy
 
       context "definition has 'taggable' key with true value" do
         it "should return true" do
-          element.stub(:definition).and_return({'name' => 'article', 'taggable' => true})
-          element.taggable?.should be_true
+          expect(element).to receive(:definition).and_return({
+            'name' => 'article',
+            'taggable' => true
+          })
+          expect(element.taggable?).to be_truthy
         end
       end
 
       context "definition has 'taggable' key with foo value" do
         it "should return false" do
-          element.stub(:definition).and_return({'name' => 'article', 'taggable' => 'foo'})
-          element.taggable?.should be_false
+          expect(element).to receive(:definition).and_return({
+            'name' => 'article',
+            'taggable' => 'foo'
+          })
+          expect(element.taggable?).to be_falsey
         end
       end
 
       context "definition has no 'taggable' key" do
         it "should return false" do
-          element.stub(:definition).and_return({'name' => 'article'})
-          element.taggable?.should be_false
+          expect(element).to receive(:definition).and_return({
+            'name' => 'article'
+          })
+          expect(element.taggable?).to be_falsey
         end
       end
     end
@@ -512,18 +509,23 @@ module Alchemy
       let(:trashed_element) { element.trash! ; element }
       subject               { trashed_element }
 
-      it             { should_not be_public }
-      it             { should be_folded }
-      its(:position) { should be_nil }
+      it             { is_expected.not_to be_public }
+      it             { is_expected.to be_folded }
+
+      describe '#position' do
+        subject { super().position }
+        it { is_expected.to be_nil }
+      end
       specify        { expect { element.trash! }.to_not change(element, :page_id) }
       specify        { expect { element.trash! }.to_not change(element, :cell_id) }
 
       context "with already one trashed element on the same page" do
         let(:element_2) { FactoryGirl.create(:element, page_id: 1) }
-        before {
+
+        before do
           trashed_element
           element_2
-        }
+        end
 
         it "it should be possible to trash another" do
           element_2.trash!
@@ -538,29 +540,6 @@ module Alchemy
       end
     end
 
-    describe '#cache_key' do
-      let(:page) { stub_model(Page, published_at: Time.now - 1.week) }
-      let(:element) { stub_model(Element, page: page, updated_at: Time.now) }
-
-      subject { element.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/elements/#{element.id}-#{element.updated_at}") }
-      end
-
-      context "when current page not in preview mode" do
-        let(:preview) { nil }
-
-        it { is_expected.to eq("alchemy/elements/#{element.id}-#{page.published_at}") }
-      end
-    end
-
     it_behaves_like "having a hint" do
       let(:subject) { Element.new }
     end