alchemy_cms 3.2.1 → 3.3.0.rc1

data/spec/models/{legacy_page_url_spec.rb → alchemy/legacy_page_url_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Alchemy::LegacyPageUrl do
-  let(:page) { build_stubbed(:page) }
+  let(:page) { build_stubbed(:alchemy_page) }
 
   let(:page_url_with_parameters) do
     Alchemy::LegacyPageUrl.new(urlname: 'index.php?id=2', page: page)

data/spec/models/{page_spec.rb → alchemy/page_spec.rb}

@@ -4,23 +4,21 @@ require 'spec_helper'
 
 module Alchemy
   describe Page do
-
     let(:rootpage)      { Page.root }
     let(:language)      { Language.default }
-    let(:klingonian)    { FactoryGirl.create(:klingonian) }
-    let(:language_root) { FactoryGirl.create(:language_root_page) }
+    let(:klingon)       { create(:alchemy_language, :klingon) }
+    let(:language_root) { create(:alchemy_page, :language_root) }
     let(:page)          { mock_model(Page, page_layout: 'foo') }
-    let(:public_page)   { FactoryGirl.create(:public_page) }
-    let(:news_page)     { FactoryGirl.create(:public_page, page_layout: 'news', do_not_autogenerate: false) }
-
+    let(:public_page)   { create(:alchemy_page, :public) }
+    let(:news_page)     { create(:alchemy_page, :public, page_layout: 'news', do_not_autogenerate: false) }
 
     # Validations
 
     context 'validations' do
       context "Creating a normal content page" do
-        let(:contentpage)              { FactoryGirl.build(:page) }
-        let(:with_same_urlname)        { FactoryGirl.create(:page, urlname: "existing_twice") }
-        let(:global_with_same_urlname) { FactoryGirl.create(:page, urlname: "existing_twice", layoutpage: true) }
+        let(:contentpage)              { build(:alchemy_page) }
+        let(:with_same_urlname)        { create(:alchemy_page, urlname: "existing_twice") }
+        let(:global_with_same_urlname) { create(:alchemy_page, urlname: "existing_twice", layoutpage: true) }
 
         context "when its urlname exists as global page" do
           before { global_with_same_urlname }
@@ -55,7 +53,7 @@ module Alchemy
         end
 
         context "with url_nesting set to true" do
-          let(:other_parent) { create(:page, parent_id: Page.root.id, visible: true) }
+          let(:other_parent) { create(:alchemy_page, parent_id: Page.root.id, visible: true) }
 
           before do
             allow(Config).to receive(:get).and_return(true)
@@ -76,7 +74,7 @@ module Alchemy
       end
 
       context "creating the rootpage without parent_id and page_layout" do
-        let(:rootpage) { build(:page, parent_id: nil, page_layout: nil, name: 'Rootpage') }
+        let(:rootpage) { build(:alchemy_page, parent_id: nil, page_layout: nil, name: 'Rootpage') }
 
         before do
           Page.delete_all
@@ -88,7 +86,7 @@ module Alchemy
       end
 
       context "saving a systempage" do
-        let(:systempage) { build(:systempage) }
+        let(:systempage) { build(:alchemy_page, :system) }
 
         it "should not validate the page_layout" do
           expect(systempage).to be_valid
@@ -96,7 +94,7 @@ module Alchemy
       end
 
       context 'saving an external page' do
-        let(:external_page) { build(:page, page_layout: 'external') }
+        let(:external_page) { build(:alchemy_page, page_layout: 'external') }
 
         it "does not pass with invalid url given" do
           external_page.urlname = 'not, a valid page url'
@@ -126,12 +124,11 @@ module Alchemy
       end
     end
 
-
     # Callbacks
 
     context 'callbacks' do
       let(:page) do
-        FactoryGirl.create(:page, name: 'My Testpage', language: language, parent_id: language_root.id)
+        create(:alchemy_page, name: 'My Testpage', language: language, parent_id: language_root.id)
       end
 
       context 'before_save' do
@@ -187,7 +184,7 @@ module Alchemy
           it "should update published_at" do
             expect {
               page.update_attributes!(public: true)
-            }.to change {page.read_attribute(:published_at) }
+            }.to change { page.read_attribute(:published_at) }
           end
 
           it "should not update already set published_at" do
@@ -207,9 +204,9 @@ module Alchemy
       end
 
       context 'after_move' do
-        let(:parent_1) { FactoryGirl.create(:page, name: 'Parent 1', visible: true) }
-        let(:parent_2) { FactoryGirl.create(:page, name: 'Parent 2', visible: true) }
-        let(:page)     { FactoryGirl.create(:page, parent_id: parent_1.id, name: 'Page', visible: true) }
+        let(:parent_1) { create(:alchemy_page, name: 'Parent 1', visible: true) }
+        let(:parent_2) { create(:alchemy_page, name: 'Parent 2', visible: true) }
+        let(:page)     { create(:alchemy_page, parent_id: parent_1.id, name: 'Page', visible: true) }
 
         it "updates the urlname" do
           expect(page.urlname).to eq('parent-1/page')
@@ -218,7 +215,7 @@ module Alchemy
         end
 
         context 'of an external page' do
-          let(:external) { FactoryGirl.create(:page, parent_id: parent_1.id, name: 'external', page_layout: 'external', urlname: 'http://google.com') }
+          let(:external) { create(:alchemy_page, parent_id: parent_1.id, name: 'external', page_layout: 'external', urlname: 'http://google.com') }
 
           it "the urlname does not get updated" do
             external.move_to_child_of parent_2
@@ -227,57 +224,79 @@ module Alchemy
         end
       end
 
-      context "a normal page" do
-        before do
-          @page = FactoryGirl.build(:page, language_code: nil, language: klingonian, do_not_autogenerate: false)
+      context "Saving a normal page" do
+        let(:page) do
+          build(:alchemy_page, language_code: nil, language: klingon, do_not_autogenerate: false)
         end
 
-        it "should set the language code" do
-          @page.save
-          expect(@page.language_code).to eq("kl")
+        it "sets the language code" do
+          page.save!
+          expect(page.language_code).to eq("kl")
         end
 
-        it "should autogenerate the elements" do
-          @page.save
-          expect(@page.elements).not_to be_empty
+        it "autogenerates the elements" do
+          page.save!
+          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
-          expect(@page.elements.select { |e| e.name == 'header' }.length).to eq(1)
+        context 'with elements already on the page' do
+          before do
+            page.elements << create(:alchemy_element, name: 'header')
+          end
+
+          it "does not autogenerate" do
+            page.save!
+            expect(page.elements.select { |e| e.name == 'header' }.length).to eq(1)
+          end
         end
 
         context "with cells" do
           before do
-            allow(@page).to receive(:definition).and_return({'name' => 'with_cells', 'cells' => ['header', 'main']})
+            allow(page).to receive(:definition) do
+              {
+                'cells' => %w(header main),
+                'autogenerate' => %w(article)
+              }
+            end
           end
 
-          it "should have the generated elements in their cells" do
-            allow(@page).to receive(:cell_definitions).and_return([{'name' => 'header', 'elements' => ['article']}])
-            @page.save
-            expect(@page.cells.where(name: 'header').first.elements).not_to be_empty
+          context 'with elements defined in cells' do
+            before do
+              allow(page).to receive(:cell_definitions) do
+                [{'name' => 'header', 'elements' => %w(article)}]
+              end
+            end
+
+            it "has the generated elements in their cells" do
+              page.save!
+              expect(page.cells.where(name: 'header').first.elements).not_to be_empty
+            end
           end
 
           context "and no elements in cell definitions" do
+            before do
+              allow(page).to receive(:cell_definitions) do
+                [{'name' => 'header', 'elements' => []}]
+              end
+            end
+
             it "should have the elements in the nil cell" do
-              allow(@page).to receive(:cell_definitions).and_return([{'name' => 'header', 'elements' => []}])
-              @page.save
-              expect(@page.cells.collect(&:elements).flatten).to be_empty
+              page.save!
+              expect(page.cells.collect(&:elements).flatten).to be_empty
             end
           end
         end
 
         context "with children getting restricted set to true" do
           before do
-            @page.save
-            @child1 = FactoryGirl.create(:page, name: 'Child 1', parent_id: @page.id)
-            @page.reload
-            @page.restricted = true
-            @page.save
+            page.save
+            @child1 = create(:alchemy_page, name: 'Child 1', parent_id: page.id)
+            page.reload
+            page.restricted = true
+            page.save
           end
 
-          it "should restrict all its children" do
+          it "restricts all its children" do
             @child1.reload
             expect(@child1.restricted?).to be_truthy
           end
@@ -285,39 +304,37 @@ module Alchemy
 
         context "with restricted parent gets created" do
           before do
-            @page.save
-            @page.parent.update_attributes(restricted: true)
-            @new_page = FactoryGirl.create(:page, name: 'New Page', parent_id: @page.id)
+            page.save
+            page.parent.update!(restricted: true)
+            @new_page = create(:alchemy_page, name: 'New Page', parent_id: page.id)
           end
 
-          it "should also be restricted" do
+          it "is also be restricted" do
             expect(@new_page.restricted?).to be_truthy
           end
         end
 
         context "with do_not_autogenerate set to true" do
           before do
-            @page.do_not_autogenerate = true
+            page.do_not_autogenerate = true
           end
 
           it "should not autogenerate the elements" do
-            @page.save
-            expect(@page.elements).to be_empty
+            page.save
+            expect(page.elements).to be_empty
           end
         end
       end
 
-      context "a systempage" do
-        before do
-          @page = FactoryGirl.create(:systempage)
-        end
+      context "Creating a systempage" do
+        let!(:page) { create(:alchemy_page, :system) }
 
-        it "should not get the language code for language" do
-          expect(@page.language_code).to be_nil
+        it "does not get the language code from language" do
+          expect(page.language_code).to be_nil
         end
 
-        it "should not autogenerate the elements" do
-          expect(@page.elements).to be_empty
+        it "does not autogenerate the elements" do
+          expect(page.elements).to be_empty
         end
       end
 
@@ -325,9 +342,9 @@ module Alchemy
         let(:news_element) { news_page.elements.find_by(name: 'news') }
 
         it "all elements not allowed on this page should be trashed" do
-          expect(news_page.elements.trashed).to be_empty
+          expect(news_page.trashed_elements).to be_empty
           news_page.update_attributes(page_layout: 'standard')
-          trashed = news_page.elements.trashed.pluck(:name)
+          trashed = news_page.trashed_elements.pluck(:name)
           expect(trashed).to eq(['news'])
           expect(trashed).to_not include('article', 'header')
         end
@@ -339,14 +356,13 @@ module Alchemy
       end
     end
 
-
     # ClassMethods (a-z)
 
     describe '.all_from_clipboard_for_select' do
       context "with clipboard holding pages having non unique page layout" do
         it "should return the pages" do
-          page_1 = FactoryGirl.create(:page, language: language)
-          page_2 = FactoryGirl.create(:page, language: language, name: 'Another page')
+          page_1 = create(:alchemy_page, language: language)
+          page_2 = create(:alchemy_page, language: language, name: 'Another page')
           clipboard = [
             {'id' => page_1.id.to_s, 'action' => 'copy'},
             {'id' => page_2.id.to_s, 'action' => 'copy'}
@@ -357,7 +373,7 @@ module Alchemy
 
       context "with clipboard holding a page having unique page layout" do
         it "should not return any pages" do
-          page_1 = FactoryGirl.create(:page, language: language, page_layout: 'contact')
+          page_1 = create(:alchemy_page, language: language, page_layout: 'contact')
           clipboard = [
             {'id' => page_1.id.to_s, 'action' => 'copy'}
           ]
@@ -367,8 +383,8 @@ module Alchemy
 
       context "with clipboard holding two pages. One having a unique page layout." do
         it "should return one page" do
-          page_1 = FactoryGirl.create(:page, language: language, page_layout: 'standard')
-          page_2 = FactoryGirl.create(:page, name: 'Another page', language: language, page_layout: 'contact')
+          page_1 = create(:alchemy_page, language: language, page_layout: 'standard')
+          page_2 = create(:alchemy_page, name: 'Another page', language: language, page_layout: 'contact')
           clipboard = [
             {'id' => page_1.id.to_s, 'action' => 'copy'},
             {'id' => page_2.id.to_s, 'action' => 'copy'}
@@ -378,26 +394,26 @@ module Alchemy
       end
     end
 
-    describe '.all_locked' do
+    describe '.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)
-        expect(Page.all_locked.size).to eq(1)
+        create(:alchemy_page, :public, locked: true, name: 'First Public Child', parent_id: language_root.id, language: language)
+        expect(Page.locked.size).to eq(1)
       end
     end
 
-    describe '.all_locked_by' do
+    describe '.locked_by' do
       let(:user) { double(:user, id: 1, class: DummyUser) }
 
       before do
-        FactoryGirl.create(:public_page, locked: true, locked_by: 53) # This page must not be part of the collection
+        create(:alchemy_page, :public, locked: true, locked_by: 53) # This page must not be part of the collection
         allow(user.class)
           .to receive(:primary_key)
           .and_return('id')
       end
 
       it "should return the correct page collection blocked by a certain user" do
-        page = FactoryGirl.create(:public_page, locked: true, locked_by: 1)
-        expect(Page.all_locked_by(user).pluck(:id)).to eq([page.id])
+        page = create(:alchemy_page, :public, locked: true, locked_by: 1)
+        expect(Page.locked_by(user).pluck(:id)).to eq([page.id])
       end
 
       context 'with user class having a different primary key' do
@@ -410,16 +426,16 @@ module Alchemy
         end
 
         it "should return the correct page collection blocked by a certain user" do
-          page = FactoryGirl.create(:public_page, locked: true, locked_by: 123)
-          expect(Page.all_locked_by(user).pluck(:id)).to eq([page.id])
+          page = create(:alchemy_page, :public, locked: true, locked_by: 123)
+          expect(Page.locked_by(user).pluck(:id)).to eq([page.id])
         end
       end
     end
 
     describe '.ancestors_for' do
       let(:lang_root) { Page.language_root_for(Language.default.id) }
-      let(:parent)    { create(:public_page) }
-      let(:page)      { create(:public_page, parent_id: parent.id) }
+      let(:parent)    { create(:alchemy_page, :public) }
+      let(:page)      { create(:alchemy_page, :public, parent_id: parent.id) }
 
       it "returns an array of all parents including self" do
         expect(Page.ancestors_for(page)).to eq([lang_root, parent, page])
@@ -437,28 +453,56 @@ module Alchemy
     end
 
     describe '.contentpages' do
-      before do
-        layoutroot = Page.find_or_create_layout_root_for(klingonian.id)
-        @layoutpage = FactoryGirl.create(:public_page, name: 'layoutpage', layoutpage: true, parent_id: layoutroot.id, language: klingonian)
-        @klingonian_lang_root = FactoryGirl.create(:language_root_page, name: 'klingonian_lang_root', layoutpage: nil, language: klingonian)
-        @contentpage = FactoryGirl.create(:public_page, name: 'contentpage', parent_id: language_root.id, language: language)
+      let!(:layoutroot) do
+        Page.find_or_create_layout_root_for(klingon.id)
+      end
+
+      let!(:layoutpage) do
+        create :alchemy_page, :public, {
+          name: 'layoutpage',
+          layoutpage: true,
+          parent_id: layoutroot.id,
+          language: klingon
+        }
       end
 
-      it "should return a collection of contentpages" do
-        expect(Page.contentpages.to_a).to include(language_root, @klingonian_lang_root, @contentpage)
+      let!(:klingon_lang_root) do
+        create :alchemy_page, :language_root, {
+          name: 'klingon_lang_root',
+          layoutpage: nil,
+          language: klingon
+        }
+      end
+
+      let!(:contentpage) do
+        create :alchemy_page, :public, {
+          name: 'contentpage',
+          parent_id: language_root.id,
+          language: language
+        }
       end
 
-      it "should not contain pages with attribute :layoutpage set to true" do
+      it "returns a collection of contentpages" do
+        expect(Page.contentpages.to_a).to include(
+          language_root,
+          klingon_lang_root,
+          contentpage
+        )
+      end
+
+      it "does not contain pages with attribute :layoutpage set to true" do
         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
-        expect(Page.contentpages.to_a.select { |p| p.layoutpage == nil }).to include(@klingonian_lang_root)
+      it "contains pages with attribute :layoutpage set to nil" do
+        expect(Page.contentpages.to_a.select do |page|
+          page.layoutpage.nil?
+        end).to include(klingon_lang_root)
       end
     end
 
     describe '.copy' do
-      let(:page) { FactoryGirl.create(:page, name: 'Source') }
+      let(:page) { create(:alchemy_page, name: 'Source') }
       subject { Page.copy(page) }
 
       it "the copy should have added (copy) to name" do
@@ -478,7 +522,7 @@ module Alchemy
       end
 
       context "page with elements" do
-        before { page.elements << FactoryGirl.create(:element) }
+        before { page.elements << create(:alchemy_element) }
 
         it "the copy should have source elements" do
           expect(subject.elements).not_to be_empty
@@ -488,7 +532,7 @@ module Alchemy
 
       context "page with trashed elements" do
         before do
-          page.elements << FactoryGirl.create(:element)
+          page.elements << create(:alchemy_element)
           page.elements.first.trash!
         end
 
@@ -498,7 +542,7 @@ module Alchemy
       end
 
       context "page with cells" do
-        before { page.cells << FactoryGirl.create(:cell) }
+        before { page.cells << create(:alchemy_cell) }
 
         it "the copy should have source cells" do
           expect(subject.cells).not_to be_empty
@@ -508,7 +552,7 @@ module Alchemy
 
       context "page with autogenerate elements" do
         before do
-          page = FactoryGirl.create(:page)
+          page = create(:alchemy_page)
           allow(page).to receive(:definition).and_return({'name' => 'standard', 'elements' => ['headline'], 'autogenerate' => ['headline']})
         end
 
@@ -519,6 +563,7 @@ module Alchemy
 
       context "with different page name given" do
         subject { Page.copy(page, {name: 'Different name'}) }
+
         it "should take this name" do
           expect(subject.name).to eq('Different name')
         end
@@ -528,12 +573,12 @@ module Alchemy
     describe '.create' do
       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 = create(:alchemy_page, name: 'My Testpage', language: language, parent_id: language_root.id)
           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 = create(:alchemy_page, name: 'klingon$&stößel ', language: language, parent_id: language_root.id)
           expect(page.urlname).to eq('klingon-stoessel')
         end
 
@@ -545,22 +590,22 @@ module Alchemy
         end
 
         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 = create(:alchemy_page, name: 'Au', language: language, parent_id: language_root.id)
           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 = create(:alchemy_page, name: 'Aü', language: language, parent_id: language_root.id)
           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 = create(:alchemy_page, name: 'A', language: language, parent_id: language_root.id)
           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 = create(:alchemy_page, name: 'A', language: language, parent_id: language_root.id)
           expect(page.class.stamper_class.to_s).to eq('DummyUser')
         end
 
@@ -613,44 +658,51 @@ 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)
+        create(:alchemy_page, :public, name: 'First Public Child', parent_id: language_root.id, language: language)
         expect(Page.language_roots.size).to eq(1)
       end
     end
 
     describe '.layoutpages' do
       it "should return 1 layoutpage" do
-        FactoryGirl.create(:public_page, layoutpage: true, name: 'Layoutpage', parent_id: rootpage.id, language: language)
+        create(:alchemy_page, :public, layoutpage: true, name: 'Layoutpage', parent_id: rootpage.id, language: language)
         expect(Page.layoutpages.size).to eq(1)
       end
     end
 
     describe '.not_locked' do
       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)
+        create(:alchemy_page, :public, locked: true, name: 'First Public Child', parent_id: language_root.id, language: language)
+        create(:alchemy_page, :public, name: 'Second Public Child', parent_id: language_root.id, language: language)
         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)
+        create(:alchemy_page, :public, name: 'First Public Child', restricted: true, parent_id: language_root.id, language: language)
         expect(Page.not_restricted.size).to eq(2)
       end
     end
 
     describe '.public' do
       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)
+        create(:alchemy_page, :public, name: 'First Public Child', parent_id: language_root.id, language: language)
+        create(:alchemy_page, :public, name: 'Second Public Child', parent_id: language_root.id, language: language)
         expect(Page.published.size).to eq(3)
       end
     end
 
+    describe '.public_language_roots' do
+      it "should return pages that public language roots" do
+        create(:alchemy_page, :public, name: 'First Public Child', parent_id: language_root.id, language: language)
+        expect(Page.public_language_roots.size).to eq(1)
+      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)
+        create(:alchemy_page, :public, name: 'First Public Child', restricted: true, parent_id: language_root.id, language: language)
         expect(Page.restricted.size).to eq(1)
       end
     end
@@ -663,16 +715,15 @@ module Alchemy
 
     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)
+        create(:alchemy_page, :public, name: 'First Public Child', visible: true, parent_id: language_root.id, language: language)
         expect(Page.visible.size).to eq(1)
       end
     end
 
-
     # InstanceMethods (a-z)
 
     describe '#available_element_definitions' do
-      let(:page) { FactoryGirl.build_stubbed(:public_page) }
+      let(:page) { build_stubbed(:alchemy_page, :public) }
 
       it "returns all element definitions of available elements" do
         expect(page.available_element_definitions).to be_an(Array)
@@ -680,7 +731,7 @@ module Alchemy
       end
 
       context "with unique elements already on page" do
-        let(:element) { FactoryGirl.build_stubbed(:unique_element) }
+        let(:element) { build_stubbed(:alchemy_element, :unique) }
 
         before do
           allow(page)
@@ -695,11 +746,13 @@ module Alchemy
       end
 
       context 'limited amount' do
-        let(:page) { FactoryGirl.build_stubbed(:page, page_layout: 'columns') }
-        let(:unique_element) { FactoryGirl.build_stubbed(:unique_element, name: 'unique_headline') }
-        let(:element_1) { FactoryGirl.build_stubbed(:element, name: 'column_headline') }
-        let(:element_2) { FactoryGirl.build_stubbed(:element, name: 'column_headline') }
-        let(:element_3) { FactoryGirl.build_stubbed(:element, name: 'column_headline') }
+        let(:page) { build_stubbed(:alchemy_page, page_layout: 'columns') }
+        let(:unique_element) do
+          build_stubbed(:alchemy_element, :unique, name: 'unique_headline')
+        end
+        let(:element_1) { build_stubbed(:alchemy_element, name: 'column_headline') }
+        let(:element_2) { build_stubbed(:alchemy_element, name: 'column_headline') }
+        let(:element_3) { build_stubbed(:alchemy_element, name: 'column_headline') }
 
         before {
           allow(Element).to receive(:definitions).and_return([
@@ -746,7 +799,7 @@ module Alchemy
     end
 
     describe '#available_element_names' do
-      let(:page) { FactoryGirl.build_stubbed(:page) }
+      let(:page) { build_stubbed(:alchemy_page) }
 
       it "returns all names of elements that could be placed on current page" do
         page.available_element_names == %w(header article)
@@ -755,7 +808,7 @@ module Alchemy
 
     describe '#cache_key' do
       let(:page) do
-        stub_model(Page, updated_at: Time.now, published_at: Time.now - 1.week)
+        stub_model(Page, updated_at: Time.current, published_at: Time.current - 1.week)
       end
 
       subject { page.cache_key }
@@ -779,14 +832,14 @@ module Alchemy
 
     describe '#cell_definitions' do
       before do
-        @page = FactoryGirl.build(:page, page_layout: 'foo')
+        @page = build(:alchemy_page, page_layout: 'foo')
         allow(@page).to receive(:definition).and_return({'name' => "foo", 'cells' => ["foo_cell"]})
-        @cell_descriptions = [{'name' => "foo_cell", 'elements' => ["1", "2"]}]
-        allow(Cell).to receive(:definitions).and_return(@cell_descriptions)
+        @cell_definitions = [{'name' => "foo_cell", 'elements' => ["1", "2"]}]
+        allow(Cell).to receive(:definitions).and_return(@cell_definitions)
       end
 
       it "should return all cell definitions for its page_layout" do
-        expect(@page.cell_definitions).to eq(@cell_descriptions)
+        expect(@page.cell_definitions).to eq(@cell_definitions)
       end
 
       it "should return empty array if no cells defined in page layout" do
@@ -806,8 +859,86 @@ module Alchemy
       end
     end
 
+    describe "#elements" do
+      let(:page) { create(:alchemy_page) }
+      let!(:element_1) { create(:alchemy_element, page: page) }
+      let!(:element_2) { create(:alchemy_element, page: page) }
+      let!(:element_3) { create(:alchemy_element, page: page) }
+
+      before do
+        element_3.move_to_top
+      end
+
+      it 'returns a ordered active record collection of elements on that page' do
+        expect(page.elements).to eq([element_3, element_1, element_2])
+      end
+
+      context 'with nestable elements' do
+        let(:nestable_element) { create(:alchemy_element, :with_nestable_elements) }
+
+        before do
+          nestable_element.nested_elements << create(:alchemy_element, name: 'slide')
+          page.elements << nestable_element
+        end
+
+        it 'does not contain nested elements of an element' do
+          expect(nestable_element.nested_elements).to_not be_empty
+          expect(page.elements).to_not include(nestable_element.nested_elements.first)
+        end
+      end
+    end
+
+    describe "#descendent_elements" do
+      let!(:page) do
+        create(:alchemy_page)
+      end
+
+      let!(:element_1) do
+        create(:alchemy_element, page_id: page.id)
+      end
+
+      let!(:element_2) do
+        create(:alchemy_element, :with_nestable_elements, page_id: page.id, parent_element_id: element_1.id)
+      end
+
+      let!(:element_3) do
+        create(:alchemy_element, page_id: page.id)
+      end
+
+      it 'returns an active record collection of all elements including nested elements on that page' do
+        expect(page.descendent_elements.count).to eq(3)
+      end
+    end
+
+    describe "#descendent_contents" do
+      let!(:page) do
+        create(:alchemy_page)
+      end
+
+      let!(:element_1) do
+        create(:alchemy_element, :with_nestable_elements, :with_contents, name: 'slider', page_id: page.id)
+      end
+
+      let!(:element_2) do
+        create :alchemy_element,
+          :with_contents, {
+            name: 'slide',
+            page_id: page.id,
+            parent_element_id: element_1.id
+          }
+      end
+
+      let!(:element_3) do
+        create(:alchemy_element, :with_contents, name: 'slide', page_id: page.id)
+      end
+
+      it 'returns an active record collection of all content including nested elements on that page' do
+        expect(page.descendent_contents.count).to eq(2)
+      end
+    end
+
     describe '#element_definitions' do
-      let(:page) { FactoryGirl.build_stubbed(:page) }
+      let(:page) { build_stubbed(:alchemy_page) }
       subject { page.element_definitions }
       before { expect(Element).to receive(:definitions).and_return([{'name' => 'article'}, {'name' => 'header'}]) }
 
@@ -818,7 +949,7 @@ module Alchemy
     end
 
     describe '#element_definitions_by_name' do
-      let(:page) { FactoryGirl.build_stubbed(:public_page) }
+      let(:page) { build_stubbed(:alchemy_page, :public) }
 
       context "with no name given" do
         it "returns empty array" do
@@ -842,103 +973,78 @@ module Alchemy
     end
 
     describe '#element_definition_names' do
-      let(:page) { FactoryGirl.build_stubbed(:public_page) }
+      let(:page) { build_stubbed(:alchemy_page, :public) }
 
-      context "with assigned elements from page and cell definition" do
-        before do
-          allow(page).to receive(:element_names_from_page_definition).and_return(['header', 'article'])
-          allow(page).to receive(:element_names_from_cell_definition).and_return(['search'])
-        end
+      subject { page.element_definition_names }
 
-        it "returns the combined element names" do
-          expect(page.element_definition_names).to eq(%w(header article search))
-        end
-
-        context "when cell definition contains same element name as page definition" do
-          before do
-            allow(page).to receive(:element_names_from_page_definition).and_return(['header', 'article'])
-            allow(page).to receive(:element_names_from_cell_definition).and_return(['header', 'search'])
-          end
-
-          it "returns no duplicates" do
-            expect(page.element_definition_names).to eq(%w(header article search))
-          end
-        end
+      before do
+        allow(page).to receive(:definition) { page_definition }
+        allow(page).to receive(:cell_definitions) { cell_definitions }
       end
 
-      context "without assigned elements from page definition" do
-        before do
-          allow(page).to receive(:element_names_from_page_definition).and_return([])
-          allow(page).to receive(:element_names_from_cell_definition).and_return(['article'])
+      context "with elements only assigned in page definition" do
+        let(:page_definition) do
+          {'elements' => %w(article)}
         end
 
-        it "returns an array" do
-          expect(page.element_definition_names).to be_an(Array)
+        let(:cell_definitions) { [] }
+
+        it "returns an array of the page's element names" do
+          is_expected.to eq %w(article)
         end
       end
 
-      context "without assigned elements from cell definition" do
+      context "with elements assigned only in cell definition" do
         before do
-          allow(page).to receive(:element_names_from_page_definition).and_return(['article'])
-          allow(page).to receive(:element_names_from_cell_definition).and_return([])
+          allow(page).to receive(:definition).and_return({})
+          allow(page).to receive(:cell_definitions) do
+            [{'elements' => ['search']}]
+          end
         end
 
-        it "returns an array" do
-          expect(page.element_definition_names).to be_an(Array)
+        it "returns an array of the cell's element names" do
+          is_expected.to eq(['search'])
         end
       end
-    end
-
-    describe "#element_names_from_page_definition" do
-      let(:page) { FactoryGirl.build_stubbed(:public_page) }
 
-      context "with assigned elements from page definition" do
-        before do
-          allow(page).to receive(:definition).and_return(
-            {'name' => 'test_page', 'elements' => ['article']}
-          )
+      context "with elements assigned in page and cell definition" do
+        let(:page_definition) do
+          {'elements' => %w(header article)}
         end
 
-        it "returns an array of the page's element names" do
-          expect(page.element_names_from_page_definition).to eq(['article'])
+        let(:cell_definitions) do
+          [{'elements' => %w(search)}]
         end
-      end
 
-      context "without assigned elements from page definition" do
-        before do
-          allow(page).to receive(:definition).and_return({})
-        end
-
-        it "returns an array" do
-          expect(page.element_names_from_page_definition).to be_an(Array)
+        it "returns the combined element names" do
+          is_expected.to eq %w(header article search)
         end
-      end
-    end
 
-    describe "#element_names_from_cell_definition" do
-      let(:page) { FactoryGirl.build_stubbed(:public_page) }
+        context "and cell definition contains same element name as page definition" do
+          let(:page_definition) do
+            {'elements' => %w(header article)}
+          end
 
-      context "with assigned elements from cell definition" do
-        before do
-          allow(page).to receive(:cell_definitions).and_return([
-            {'name' => 'header', 'elements' => ['article']}
-          ])
-        end
+          let(:cell_definitions) do
+            [{'elements' => %w(header search)}]
+          end
 
-        it "returns an array of the cell's element names" do
-          expect(page.element_names_from_cell_definition).to eq(['article'])
+          it "includes no duplicates" do
+            is_expected.to eq %w(header article search)
+          end
         end
       end
 
-      context "without assigned elements from cell definition" do
-        it "returns an array" do
-          expect(page.element_names_from_cell_definition).to be_an(Array)
-        end
+      context "without elements assigned in page definition or cell definition" do
+        let(:page_definition) { {} }
+        let(:cell_definitions) { [] }
+
+        it { is_expected.to eq([]) }
       end
     end
 
     describe '#elements_grouped_by_cells' do
-      let(:page) { FactoryGirl.create(:public_page, do_not_autogenerate: false) }
+      let(:page) { create(:alchemy_page, :public, do_not_autogenerate: false) }
 
       before do
         allow(PageLayout).to receive(:get).and_return({
@@ -965,16 +1071,28 @@ module Alchemy
     end
 
     describe '#feed_elements' do
-      it "should return all rss feed elements" do
+      let(:news_element) { create(:alchemy_element, name: 'news', public: false, page: news_page) }
+
+      it "should return all published rss feed elements" do
         expect(news_page.feed_elements).not_to be_empty
-        expect(news_page.feed_elements).to eq(Element.where(name: 'news').to_a)
+        expect(news_page.feed_elements).to eq(Element.where(name: 'news').available.to_a)
+      end
+
+      it "should not return unpublished rss feed elements" do
+        expect(news_page.feed_elements).not_to include(news_element)
+      end
+
+      it "should not return trashed rss feed elements" do
+        news_element.update(public: true)
+        news_element.trash!
+        expect(news_page.feed_elements).not_to include(news_element)
       end
     end
 
     describe '#find_elements' do
       before do
-        FactoryGirl.create(:element, public: false, page: public_page)
-        FactoryGirl.create(:element, public: false, page: public_page)
+        create(:alchemy_element, public: false, page: public_page)
+        create(:alchemy_element, public: false, page: public_page)
       end
 
       context "with show_non_public argument TRUE" do
@@ -1000,7 +1118,7 @@ module Alchemy
       end
 
       context "with options[:from_cell]" do
-        let(:element) { FactoryGirl.build_stubbed(:element) }
+        let(:element) { build_stubbed(:alchemy_element) }
 
         context "given as String" do
           context 'with elements present' do
@@ -1016,7 +1134,7 @@ module Alchemy
           end
 
           context "that can not be found" do
-            let(:elements) {[]}
+            let(:elements) { [] }
 
             before do
               allow(elements)
@@ -1037,7 +1155,7 @@ module Alchemy
         end
 
         context "given as cell object" do
-          let(:cell) { FactoryGirl.build_stubbed(:cell, page: public_page) }
+          let(:cell) { build_stubbed(:alchemy_cell, page: public_page) }
 
           it "returns only the elements from given cell" do
             expect(cell)
@@ -1051,7 +1169,7 @@ module Alchemy
 
       context "with show_non_public argument FALSE" do
         it "should return all elements from empty arguments" do
-          expect(public_page.find_elements().to_a).to eq(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
@@ -1074,11 +1192,11 @@ module Alchemy
 
     describe '#first_public_child' do
       before do
-        FactoryGirl.create(:page, name: "First child", language: language, public: false, parent_id: language_root.id)
+        create(:alchemy_page, name: "First child", language: language, public: false, parent_id: language_root.id)
       end
 
       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)
+        first_public_child = create(:alchemy_page, :public, name: "First public child", language: language, parent_id: language_root.id)
         expect(language_root.first_public_child).to eq(first_public_child)
       end
 
@@ -1121,7 +1239,7 @@ module Alchemy
 
           context 'if page is not folded' do
             it "should return false" do
-              expect(page.folded?(101093)).to eq(false)
+              expect(page.folded?(101_093)).to eq(false)
             end
           end
         end
@@ -1137,33 +1255,33 @@ module Alchemy
       end
     end
 
-    describe '#layout_description' do
+    describe '#definition' do
       context 'if the page layout could not be found in the definition file' do
-        let(:page) { build_stubbed(:page, page_layout: 'notexisting') }
+        let(:page) { build_stubbed(:alchemy_page, page_layout: 'notexisting') }
 
         it "it loggs a warning." do
           expect(Alchemy::Logger).to receive(:warn)
-          page.layout_description
+          page.definition
         end
 
         it "it returns empty hash." do
-          expect(page.layout_description).to eq({})
+          expect(page.definition).to eq({})
         end
       end
 
       context "for a language root page" do
-        it "it returns the page layout description as hash." do
-          expect(language_root.layout_description['name']).to eq('index')
+        it "it returns the page layout definition as hash." do
+          expect(language_root.definition['name']).to eq('index')
         end
 
         it "it returns an empty hash for root page." do
-          expect(rootpage.layout_description).to eq({})
+          expect(rootpage.definition).to eq({})
         end
       end
     end
 
     describe '#lock_to!' do
-      let(:page) { create(:page) }
+      let(:page) { create(:alchemy_page) }
       let(:user) { mock_model('DummyUser') }
 
       it "should set locked to true" do
@@ -1184,8 +1302,8 @@ module Alchemy
     end
 
     describe '#copy_and_paste' do
-      let(:source) { FactoryGirl.build_stubbed(:page) }
-      let(:new_parent) { FactoryGirl.build_stubbed(:page) }
+      let(:source) { build_stubbed(:alchemy_page) }
+      let(:new_parent) { build_stubbed(:alchemy_page) }
       let(:page_name) { "Pagename (pasted)" }
       let(:copied_page) { mock_model('Page') }
 
@@ -1217,10 +1335,10 @@ module Alchemy
     end
 
     context 'previous and next.' do
-      let(:center_page)     { FactoryGirl.create(:public_page, name: 'Center Page') }
-      let(:next_page)       { FactoryGirl.create(:public_page, name: 'Next Page') }
-      let(:non_public_page) { FactoryGirl.create(:page, name: 'Not public Page') }
-      let(:restricted_page) { FactoryGirl.create(:restricted_page, public: true) }
+      let(:center_page)     { create(:alchemy_page, :public, name: 'Center Page') }
+      let(:next_page)       { create(:alchemy_page, :public, name: 'Next Page') }
+      let(:non_public_page) { create(:alchemy_page, name: 'Not public Page') }
+      let(:restricted_page) { create(:alchemy_page, :restricted, public: true) }
 
       before do
         public_page
@@ -1285,8 +1403,8 @@ module Alchemy
     end
 
     describe '#publish!' do
-      let(:page) { FactoryGirl.build_stubbed(:page, public: false) }
-      let(:current_time) { Time.now }
+      let(:page) { build_stubbed(:alchemy_page, public: false) }
+      let(:current_time) { Time.current }
 
       before do
         current_time
@@ -1342,7 +1460,7 @@ module Alchemy
     describe '#taggable?' do
       context "definition has 'taggable' key with true value" do
         it "should return true" do
-          page = FactoryGirl.build(:page)
+          page = build(:alchemy_page)
           allow(page).to receive(:definition).and_return({'name' => 'standard', 'taggable' => true})
           expect(page.taggable?).to be_truthy
         end
@@ -1350,7 +1468,7 @@ module Alchemy
 
       context "definition has 'taggable' key with foo value" do
         it "should return false" do
-          page = FactoryGirl.build(:page)
+          page = build(:alchemy_page)
           allow(page).to receive(:definition).and_return({'name' => 'standard', 'taggable' => 'foo'})
           expect(page.taggable?).to be_falsey
         end
@@ -1358,7 +1476,7 @@ module Alchemy
 
       context "definition has no 'taggable' key" do
         it "should return false" do
-          page = FactoryGirl.build(:page)
+          page = build(:alchemy_page)
           allow(page).to receive(:definition).and_return({'name' => 'standard'})
           expect(page.taggable?).to be_falsey
         end
@@ -1366,7 +1484,7 @@ module Alchemy
     end
 
     describe '#unlock!' do
-      let(:page) { FactoryGirl.create(:page, locked: true, locked_by: 1) }
+      let(:page) { create(:alchemy_page, locked: true, locked_by: 1) }
 
       before do
         allow(page).to receive(:save).and_return(true)
@@ -1396,12 +1514,12 @@ module Alchemy
     end
 
     context 'urlname updating' do
-      let(:parentparent)  { FactoryGirl.create(:page, name: 'parentparent', visible: true) }
-      let(:parent)        { FactoryGirl.create(:page, parent_id: parentparent.id, name: 'parent', visible: true) }
-      let(:page)          { FactoryGirl.create(:page, parent_id: parent.id, name: 'page', visible: true) }
-      let(:invisible)     { FactoryGirl.create(:page, parent_id: page.id, name: 'invisible', visible: false) }
-      let(:contact)       { FactoryGirl.create(:page, parent_id: invisible.id, name: 'contact', visible: true) }
-      let(:external)      { FactoryGirl.create(:page, parent_id: parent.id, name: 'external', page_layout: 'external', urlname: 'http://google.com') }
+      let(:parentparent)  { create(:alchemy_page, name: 'parentparent', visible: true) }
+      let(:parent)        { create(:alchemy_page, parent_id: parentparent.id, name: 'parent', visible: true) }
+      let(:page)          { create(:alchemy_page, parent_id: parent.id, name: 'page', visible: true) }
+      let(:invisible)     { create(:alchemy_page, parent_id: page.id, name: 'invisible', visible: false) }
+      let(:contact)       { create(:alchemy_page, parent_id: invisible.id, name: 'contact', visible: true) }
+      let(:external)      { create(:alchemy_page, parent_id: parent.id, name: 'external', page_layout: 'external', urlname: 'http://google.com') }
       let(:language_root) { parentparent.parent }
 
       context "with activated url_nesting" do
@@ -1485,16 +1603,14 @@ module Alchemy
     end
 
     describe "#update_node!" do
-
       let(:original_url) { "sample-url" }
-      let(:page) { FactoryGirl.create(:page, language: language, parent_id: language_root.id, urlname: original_url, restricted: false) }
+      let(:page) { create(:alchemy_page, language: language, parent_id: language_root.id, urlname: original_url, restricted: false) }
       let(:node) { TreeNode.new(10, 11, 12, 13, "another-url", true) }
 
       context "when nesting is enabled" do
         before { allow(Alchemy::Config).to receive(:get).with(:url_nesting) { true } }
 
         context "when page is not external" do
-
           before do
             expect(page).to receive(:redirects_to_external?).and_return(false)
           end
@@ -1609,9 +1725,45 @@ module Alchemy
       end
     end
 
+    describe '#cache_page?' do
+      let(:page) { Page.new(page_layout: "news") }
+      subject { page.cache_page? }
+
+      before { Rails.application.config.action_controller.perform_caching = true }
+      after { Rails.application.config.action_controller.perform_caching = false }
+
+      it 'returns true when everthing is alright' do
+        expect(subject).to be true
+      end
+
+      it 'returns false when the Rails app does not perform caching' do
+        Rails.application.config.action_controller.perform_caching = false
+        expect(subject).to be false
+      end
+
+      it 'returns false when caching is deactivated in the Alchemy config' do
+        allow(Alchemy::Config).to receive(:get).with(:cache_pages).and_return(false)
+        expect(subject).to be false
+      end
+
+      it 'returns false when the page layout is set to cache = false' do
+        page_layout = PageLayout.get('news')
+        page_layout['cache'] = false
+        allow(PageLayout).to receive(:get).with('news').and_return(page_layout)
+        expect(subject).to be false
+      end
+
+      it 'returns false when the page layout is set to searchresults = true' do
+        page_layout = PageLayout.get('news')
+        page_layout['searchresults'] = true
+        allow(PageLayout).to receive(:get).with('news').and_return(page_layout)
+        expect(subject).to be false
+      end
+    end
+
     describe '#slug' do
       context "with parents path saved in urlname" do
-        let(:page) { FactoryGirl.build(:page, urlname: 'root/parent/my-name')}
+        let(:page) { build(:alchemy_page, urlname: 'root/parent/my-name') }
 
         it "should return the last part of the urlname" do
           expect(page.slug).to eq('my-name')
@@ -1619,7 +1771,7 @@ module Alchemy
       end
 
       context "with single urlname" do
-        let(:page) { FactoryGirl.build(:page, urlname: 'my-name')}
+        let(:page) { build(:alchemy_page, urlname: 'my-name') }
 
         it "should return the last part of the urlname" do
           expect(page.slug).to eq('my-name')
@@ -1627,7 +1779,7 @@ module Alchemy
       end
 
       context "with nil as urlname" do
-        let(:page) { FactoryGirl.build(:page, urlname: nil)}
+        let(:page) { build(:alchemy_page, urlname: nil) }
 
         it "should return nil" do
           expect(page.slug).to be_nil
@@ -1636,10 +1788,10 @@ module Alchemy
     end
 
     describe '#external_urlname' do
-      let(:external_page) { build(:page, page_layout: 'external') }
+      let(:external_page) { build(:alchemy_page, page_layout: 'external') }
 
       context 'with missing protocol' do
-        before { external_page.urlname = 'google.com'}
+        before { external_page.urlname = 'google.com' }
 
         it "returns an urlname prefixed with http://" do
           expect(external_page.external_urlname).to eq 'http://google.com'
@@ -1647,7 +1799,7 @@ module Alchemy
       end
 
       context 'with protocol present' do
-        before { external_page.urlname = 'ftp://google.com'}
+        before { external_page.urlname = 'ftp://google.com' }
 
         it "returns the urlname" do
           expect(external_page.external_urlname).to eq 'ftp://google.com'
@@ -1655,7 +1807,7 @@ module Alchemy
       end
 
       context 'beginngin with a slash' do
-        before { external_page.urlname = '/internal-url'}
+        before { external_page.urlname = '/internal-url' }
 
         it "returns the urlname" do
           expect(external_page.external_urlname).to eq '/internal-url'
@@ -1664,7 +1816,7 @@ module Alchemy
     end
 
     context 'page status methods' do
-      let(:page) { FactoryGirl.build(:page, public: true, visible: true, restricted: false, locked: false)}
+      let(:page) { build(:alchemy_page, public: true, visible: true, restricted: false, locked: false) }
 
       describe '#status' do
         it "returns a combined status hash" do
@@ -1849,10 +2001,10 @@ module Alchemy
     describe '#controller_and_action' do
       let(:page) { Page.new }
 
-      context 'if the page has a custom controller defined in its description' do
+      context 'if the page has a custom controller defined in its definition' do
         before do
           allow(page).to receive(:has_controller?).and_return(true)
-          allow(page).to receive(:layout_description).and_return({'controller' => 'comments', 'action' => 'index'})
+          allow(page).to receive(:definition).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'})
@@ -1874,8 +2026,8 @@ module Alchemy
 
     describe '#published_at' do
       context 'with published_at date set' do
-        let(:published_at) { Time.now }
-        let(:page)         { build_stubbed(:page, published_at: published_at) }
+        let(:published_at) { Time.current }
+        let(:page)         { build_stubbed(:alchemy_page, published_at: published_at) }
 
         it "returns the published_at value from database" do
           expect(page.published_at).to eq(published_at)
@@ -1883,8 +2035,8 @@ module Alchemy
       end
 
       context 'with published_at is nil' do
-        let(:updated_at) { Time.now }
-        let(:page)       { build_stubbed(:page, published_at: nil, updated_at: updated_at) }
+        let(:updated_at) { Time.current }
+        let(:page)       { build_stubbed(:alchemy_page, published_at: nil, updated_at: updated_at) }
 
         it "returns the updated_at value" do
           expect(page.published_at).to eq(updated_at)
@@ -1892,5 +2044,65 @@ module Alchemy
       end
     end
 
+    describe "#richtext_contents_ids" do
+      let!(:page) { create(:alchemy_page) }
+
+      let!(:expanded_element) do
+        create :alchemy_element,
+          name: 'article',
+          page: page,
+          folded: false,
+          create_contents_after_create: true
+      end
+
+      let!(:folded_element) do
+        create :alchemy_element,
+          name: 'article',
+          page: page,
+          folded: true,
+          create_contents_after_create: true
+      end
+
+      subject(:richtext_contents_ids) { page.richtext_contents_ids }
+
+      it 'returns content ids for all expanded elements that have tinymce enabled' do
+        expanded_rtf_contents = expanded_element.contents.essence_richtexts
+        expect(richtext_contents_ids).to eq(expanded_rtf_contents.pluck(:id))
+        folded_rtf_content = folded_element.contents.essence_richtexts.first
+        expect(richtext_contents_ids).to_not include(folded_rtf_content.id)
+      end
+
+      context 'with nested elements' do
+        let!(:nested_expanded_element) do
+          create :alchemy_element,
+            name: 'article',
+            page: page,
+            parent_element: expanded_element,
+            folded: false,
+            create_contents_after_create: true
+        end
+
+        let!(:nested_folded_element) do
+          create :alchemy_element,
+            name: 'article',
+            page: page,
+            parent_element: folded_element,
+            folded: true,
+            create_contents_after_create: true
+        end
+
+        it 'returns content ids for all expanded nested elements that have tinymce enabled' do
+          expanded_rtf_contents = expanded_element.contents.essence_richtexts
+          nested_expanded_rtf_contents = nested_expanded_element.contents.essence_richtexts
+          rtf_content_ids = expanded_rtf_contents.pluck(:id) +
+                            nested_expanded_rtf_contents.pluck(:id)
+          expect(richtext_contents_ids.sort).to eq(rtf_content_ids)
+
+          nested_folded_rtf_content = nested_folded_element.contents.essence_richtexts.first
+
+          expect(richtext_contents_ids).to_not include(nested_folded_rtf_content.id)
+        end
+      end
+    end
   end
 end