alchemy_cms 2.6.3 → 2.7.0

data/spec/models/essence_date_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+module Alchemy
+  describe EssenceDate do
+    let(:essence_date) { EssenceDate.new }
+
+    describe '#preview_text' do
+
+      context "if no date set" do
+        it "should return an empty string" do
+          expect(essence_date.preview_text).to eq("")
+        end
+      end
+
+      context "if date set" do
+        it "should format the date by i18n" do
+          essence_date.date = Date.today
+          ::I18n.should_receive(:l).with(essence_date.date, format: :date)
+          essence_date.preview_text
+        end
+      end
+
+    end
+  end
+end

data/spec/models/essence_file_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module Alchemy
+  describe EssenceFile do
+
+    describe '#preview_text' do
+      let(:attachment) { mock_model(Attachment, name: 'File') }
+      let(:essence) { EssenceFile.new }
+
+      it "returns the attachment's name as preview text" do
+        essence.stub(:attachment).and_return(attachment)
+        essence.preview_text.should == 'File'
+      end
+
+      context "with no attachment assigned" do
+        it "returns empty string" do
+          essence.preview_text.should == ''
+        end
+      end
+    end
+
+  end
+end

data/spec/models/essence_html_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+module Alchemy
+  describe EssenceHtml do
+    describe '#preview_text' do
+      let (:essence_html) { EssenceHtml.new(source: '<p>hello!</p>') }
+
+      it "should return html escaped source code" do
+        expect(essence_html.preview_text).to eq('&lt;p&gt;hello!&lt;/p&gt;')
+      end
+    end
+  end
+end

data/spec/models/essence_picture_spec.rb

@@ -23,5 +23,21 @@ module Alchemy
       essence.caption.should == "hello<br/>kitty"
     end
 
+    describe '#preview_text' do
+      let(:picture) { mock_model(Picture, name: 'Cute Cat Kittens')}
+      let(:essence) { EssencePicture.new }
+
+      it "should return the pictures name as preview text" do
+        essence.stub(:picture).and_return(picture)
+        essence.preview_text.should == 'Cute Cat Kittens'
+      end
+
+      context "with no picture assigned" do
+        it "returns empty string" do
+          essence.preview_text.should == ''
+        end
+      end
+    end
+
   end
 end

data/spec/models/essence_text_spec.rb

@@ -37,5 +37,34 @@ module Alchemy
       end
     end
 
+    context "acts_as_essence methods" do
+
+      describe '#preview_text' do
+        let(:essence) { EssenceText.new(body: 'Lorem ipsum') }
+
+        it "should return a preview text" do
+          essence.preview_text.should == 'Lorem ipsum'
+        end
+
+        context "with maxlength of 2" do
+          it "should return very short preview text" do
+            essence.preview_text(2).should == 'Lo'
+          end
+        end
+
+        context "with another preview_text_column defined" do
+          before {
+            essence.stub(:title).and_return('Title column')
+            essence.stub(:preview_text_column).and_return(:title)
+          }
+
+          it "should use this column as preview text method" do
+            essence.preview_text.should == 'Title column'
+          end
+        end
+      end
+
+    end
+
   end
 end

data/spec/models/language_spec.rb

@@ -117,5 +117,39 @@ module Alchemy
 
     end
 
+    describe '.all_codes_for_published' do
+      it "should return all codes of published languages" do
+        Language.stub!(:published).and_return([mock_model('Language', code: 'de'), mock_model('Language', code: 'en')])
+        expect(Language.all_codes_for_published).to eq(['de', 'en'])
+      end
+    end
+
+    context 'validations' do
+      let(:language) { Language.new(default: true, public: false) }
+
+      describe 'publicity_of_default_language' do
+        context 'if language is not published' do
+          it "should add an error to the object" do
+            expect(language.valid?).to eq(false)
+            expect(language.errors.messages).to have_key(:base)
+          end
+        end
+      end
+
+      describe 'presence_of_default_language' do
+        context 'if no default language would exist anymore' do
+          before do
+            Language.stub!(:get_default).and_return(language)
+            language.stub!(:default_changed?).and_return(true)
+          end
+
+          it "should add an error to the object" do
+            expect(language.valid?).to eq(false)
+            expect(language.errors.messages).to have_key(:base)
+          end
+        end
+      end
+    end
+
   end
 end

data/spec/models/message_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+module Alchemy
+  describe Message do
+    let(:message) { Message.new }
+
+    describe '.config' do
+      it "should return the mailer config" do
+        Config.should_receive(:get).with(:mailer)
+        Message.config
+      end
+    end
+
+    describe '#persisted?' do
+      it "should return false" do
+        expect(message.persisted?).to eq(false)
+      end
+    end
+
+    describe '#attributes' do
+      it "should call .attributes" do
+        Message.should_receive(:attributes)
+        message.attributes
+      end
+    end
+
+    describe '#email_is_filled' do
+      context 'if email attribute is filled' do
+        it "should return true" do
+          message.stub!(:email).and_return('me@you.com')
+          expect(message.send(:email_is_filled)).to eq(true)
+        end
+      end
+
+      context 'if email attribute is not filled' do
+        it "should return false" do
+          message.stub!(:email).and_return('')
+          expect(message.send(:email_is_filled)).to eq(false)
+        end
+      end
+    end
+  end
+end

data/spec/models/page_spec.rb

@@ -13,141 +13,91 @@ module Alchemy
     let(:public_page)   { FactoryGirl.create(:public_page) }
     let(:news_page)     { FactoryGirl.create(:public_page, :page_layout => 'news', :do_not_autogenerate => false) }
 
-    describe ".layout_description" do
 
-      context "for a language root page" do
-
-        it "should return the page layout description as hash" do
-          language_root.layout_description['name'].should == 'intro'
-        end
-
-        it "should return an empty hash for root page" do
-          rootpage.layout_description.should == {}
-        end
-
-      end
-
-      it "should raise Exception if the page_layout could not be found in the definition file" do
-        expect { page.layout_description }.to raise_error
-      end
-
-    end
-
-    it "should contain one rootpage" do
-      Page.rootpage.should be_instance_of(Page)
-    end
-
-    it "should return all rss feed elements" do
-      news_page.feed_elements.should_not be_empty
-      news_page.feed_elements.should == Element.find_all_by_name('news')
-    end
-
-    context "finding elements" do
-
-      before do
-        FactoryGirl.create(:element, :public => false, :page => public_page)
-        FactoryGirl.create(:element, :public => false, :page => public_page)
-      end
-
-      it "should return the collection of elements if passed an array into options[:collection]" do
-        options = {:collection => public_page.elements}
-        public_page.find_elements(options).all.should == public_page.elements.all
-      end
-
-      context "with show_non_public argument TRUE" do
-
-        it "should return all elements from empty options" do
-          public_page.find_elements({}, true).all.should == public_page.elements.all
-        end
-
-        it "should only return the elements passed as options[:only]" do
-          public_page.find_elements({:only => ['article']}, true).all.should == public_page.elements.named('article').all
-        end
+    # Validations
 
-        it "should not return the elements passed as options[:except]" do
-          public_page.find_elements({:except => ['article']}, true).all.should == public_page.elements - public_page.elements.named('article').all
-        end
+    context 'validations' do
+      context "Creating a normal content page" do
+        let(:contentpage) { FactoryGirl.build(:page) }
 
-        it "should return elements offsetted" do
-          public_page.find_elements({:offset => 2}, true).all.should == public_page.elements.offset(2)
+        context "when its urlname exists as global page" do
+          it "it should be possible to save." do
+            contentpage.urlname = "existing_twice"
+            global_with_same_urlname = FactoryGirl.create(:page, :urlname => "existing_twice", :layoutpage => true)
+            contentpage.should be_valid
+          end
         end
 
-        it "should return elements limitted in count" do
-          public_page.find_elements({:count => 1}, true).all.should == public_page.elements.limit(1)
+        it "should validate the page_layout" do
+          contentpage.page_layout = nil
+          contentpage.save
+          contentpage.should have(1).error_on(:page_layout)
         end
 
-      end
-
-      context "with show_non_public argument FALSE" do
-
-        it "should return all elements from empty arguments" do
-          public_page.find_elements().all.should == public_page.elements.published.all
+        it "should validate the parent_id" do
+          contentpage.parent_id = nil
+          contentpage.save
+          contentpage.should have(1).error_on(:parent_id)
         end
 
-        it "should only return the public elements passed as options[:only]" do
-          public_page.find_elements(:only => ['article']).all.should == public_page.elements.published.named('article').all
+        it "should validate the uniqueness of urlname" do
+          with_same_urlname = FactoryGirl.create(:page, :urlname => "existing_twice")
+          contentpage.urlname = 'existing_twice'
+          contentpage.should_not be_valid
         end
 
-        it "should return all public elements except the ones passed as options[:except]" do
-          public_page.find_elements(:except => ['article']).all.should == public_page.elements.published.all - public_page.elements.published.named('article').all
-        end
+        context "with url_nesting set to true" do
+          before { Config.stub!(:get).and_return(true) }
 
-        it "should return elements offsetted" do
-          public_page.find_elements({:offset => 2}).all.should == public_page.elements.published.offset(2)
-        end
+          it "should only validate urlname dependent of parent" do
+            other_parent = FactoryGirl.create(:page, parent_id: Page.root.id)
+            with_same_urlname = FactoryGirl.create(:page, :urlname => "existing_twice")
+            contentpage.urlname = 'existing_twice'
+            contentpage.parent_id = other_parent.id
+            contentpage.should be_valid
+          end
 
-        it "should return elements limitted in count" do
-          public_page.find_elements({:count => 1}).all.should == public_page.elements.published.limit(1)
+          it "should validate urlname dependent of parent" do
+            with_same_urlname = FactoryGirl.create(:page, :urlname => "existing_twice")
+            contentpage.urlname = 'existing_twice'
+            contentpage.should_not be_valid
+          end
         end
-
       end
 
-    end
-
-    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.title.should == 'My Testpage'
-        end
-
-        it "should get a webfriendly urlname" do
-          page = FactoryGirl.create(:page, :name => 'klingon$&stößel ', :language => language, :parent_id => language_root.id)
-          page.urlname.should == 'klingon-stoessel'
-        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.urlname.should == '-au'
+      context "creating the rootpage without parent_id and page_layout" do
+        before do
+          Page.delete_all
+          @rootpage = FactoryGirl.build(:page, :parent_id => nil, :page_layout => nil, :name => 'Rootpage')
         end
 
-        it "should generate a three letter urlname from two letter name with umlaut" do
-          page = FactoryGirl.create(:page, :name => 'Aü', :language => language, :parent_id => language_root.id)
-          page.urlname.should == 'aue'
+        it "should be valid" do
+          @rootpage.save
+          @rootpage.should be_valid
         end
+      end
 
-        it "should generate a three letter urlname from one letter name" do
-          page = FactoryGirl.create(:page, :name => 'A', :language => language, :parent_id => language_root.id)
-          page.urlname.should == '--a'
+      context "saving a systempage" do
+        before do
+          @systempage = FactoryGirl.build(:systempage)
         end
 
-        it "should add a user stamper" do
-          page = FactoryGirl.create(:page, :name => 'A', :language => language, :parent_id => language_root.id)
-          page.class.stamper_class.to_s.should == 'Alchemy::User'
+        it "should not validate the page_layout" do
+          @systempage.save
+          @systempage.should be_valid
         end
-
       end
-
     end
 
-    describe '#update' do
 
-      let(:page) { FactoryGirl.create(:page, :name => 'My Testpage', :language => language, :parent_id => language_root.id) }
+    # Callbacks
 
-      context "before/after filter" do
+    context 'callbacks' do
+      let(:page) do
+        FactoryGirl.create(:page, :name => 'My Testpage', :language => language, :parent_id => language_root.id)
+      end
 
+      context 'before_save' do
         it "should not set the title automatically if the name changed but title is not blank" do
           page.name = "My Renaming Test"
           page.save; page.reload
@@ -159,9 +109,10 @@ module Alchemy
           page.save; page.reload
           page.title.should == "I like SEO"
         end
+      end
 
+      context 'after_update' do
         context "urlname has changed" do
-
           it "should store legacy url if page is not redirect to external page" do
             page.urlname = 'new-urlname'
             page.save!
@@ -185,178 +136,174 @@ module Alchemy
             page.save!
             page.legacy_urls.select { |u| u.urlname == 'my-testpage' }.size.should == 1
           end
-
         end
 
         context "urlname has not changed" do
-
           it "should not store a legacy url" do
             page.urlname = 'my-testpage'
             page.save!
             page.legacy_urls.should be_empty
           end
-
         end
-
       end
 
-    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(:node) { TreeNode.new(10, 11, 12, 13, "another-url", true) }
+      context "a normal page" do
+        before do
+          @page = FactoryGirl.build(:page, :language_code => nil, :language => klingonian, :do_not_autogenerate => false)
+        end
 
-      context "when nesting is enabled" do
-        before { Alchemy::Config.stub(:get).with(:url_nesting) { true } }
+        it "should set the language code" do
+          @page.save
+          @page.language_code.should == "kl"
+        end
 
-        context "when page is not external" do
+        it "should autogenerate the elements" do
+          @page.save
+          @page.elements.should_not be_empty
+        end
 
-          before { page.stub(redirects_to_external?: false)}
+        it "should not autogenerate elements that are already on the page" do
+          @page.elements << FactoryGirl.create(:element, :name => 'header')
+          @page.save
+          @page.elements.select { |e| e.name == 'header' }.length.should == 1
+        end
 
-          it "should update all attributes" do
-            page.update_node!(node)
-            page.reload
-            expect(page.lft).to eq(node.left)
-            expect(page.rgt).to eq(node.right)
-            expect(page.parent_id).to eq(node.parent)
-            expect(page.depth).to eq(node.depth)
-            expect(page.urlname).to eq(node.url)
-            expect(page.restricted).to eq(node.restricted)
+        context "with cells" do
+          before do
+            @page.stub!(:definition).and_return({'name' => 'with_cells', 'cells' => ['header', 'main']})
           end
 
-          context "when url is the same" do
-            let(:node) { TreeNode.new(10, 11, 12, 13, original_url, true) }
-
-            it "should not create a legacy url" do
-              page.update_node!(node)
-              page.reload
-              expect(page.legacy_urls.size).to eq(0)
-            end
+          it "should have the generated elements in their cells" do
+            @page.stub!(:cell_definitions).and_return([{'name' => 'header', 'elements' => ['article']}])
+            @page.save
+            @page.cells.where(:name => 'header').first.elements.should_not be_empty
           end
 
-          context "when url is not the same" do
-            it "should create a legacy url" do
-              page.update_node!(node)
-              page.reload
-              expect(page.legacy_urls.size).to eq(1)
+          context "and no elements in cell definitions" do
+            it "should have the elements in the nil cell" do
+              @page.stub!(:cell_definitions).and_return([{'name' => 'header', 'elements' => []}])
+              @page.save
+              @page.cells.collect(&:elements).flatten.should be_empty
             end
           end
         end
 
-        context "when page is external" do
-
-          before { page.stub(redirects_to_external?: true) }
-
-          it "should update all attributes except url" do
-            page.update_node!(node)
-            page.reload
-            expect(page.lft).to eq(node.left)
-            expect(page.rgt).to eq(node.right)
-            expect(page.parent_id).to eq(node.parent)
-            expect(page.depth).to eq(node.depth)
-            expect(page.urlname).to eq(original_url)
-            expect(page.restricted).to eq(node.restricted)
+        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
           end
 
-          it "should not create a legacy url" do
-            page.update_node!(node)
-            page.reload
-            expect(page.legacy_urls.size).to eq(0)
+          it "should restrict all its children" do
+            @child1.reload
+            @child1.restricted?.should be_true
           end
         end
-      end
 
-      context "when nesting is disabled" do
-        before { Alchemy::Config.stub(:get).with(:url_nesting) { false } }
-
-        context "when page is not external" do
-
-          before { page.stub(redirects_to_external?: false)}
-
-          it "should update all attributes except url" do
-            page.update_node!(node)
-            page.reload
-            expect(page.lft).to eq(node.left)
-            expect(page.rgt).to eq(node.right)
-            expect(page.parent_id).to eq(node.parent)
-            expect(page.depth).to eq(node.depth)
-            expect(page.urlname).to eq(original_url)
-            expect(page.restricted).to eq(node.restricted)
+        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)
           end
 
-          it "should not create a legacy url" do
-            page.update_node!(node)
-            page.reload
-            expect(page.legacy_urls.size).to eq(0)
+          it "should also be restricted" do
+            @new_page.restricted?.should be_true
           end
-
         end
 
-        context "when page is external" do
-
-          before { page.stub(redirects_to_external?: true) }
-
-          before { Alchemy::Config.stub(get: true) }
-
-          it "should update all attributes except url" do
-            page.update_node!(node)
-            page.reload
-            expect(page.lft).to eq(node.left)
-            expect(page.rgt).to eq(node.right)
-            expect(page.parent_id).to eq(node.parent)
-            expect(page.depth).to eq(node.depth)
-            expect(page.urlname).to eq(original_url)
-            expect(page.restricted).to eq(node.restricted)
+        context "with do_not_autogenerate set to true" do
+          before do
+            @page.do_not_autogenerate = true
           end
 
-          it "should not create a legacy url" do
-            page.update_node!(node)
-            page.reload
-            expect(page.legacy_urls.size).to eq(0)
+          it "should not autogenerate the elements" do
+            @page.save
+            @page.elements.should be_empty
           end
         end
       end
-    end
-
-
-    describe "#destroy" do
-
-      context "with trashed but still assigned elements" do
 
+      context "a systempage" do
         before do
-          news_page.elements.map(&:trash)
+          @page = FactoryGirl.create(:systempage)
         end
 
-        it "should not delete the trashed elements" do
-          news_page.destroy
-          Element.trashed.should_not be_empty
+        it "should not get the language code for language" do
+          @page.language_code.should be_nil
         end
 
+        it "should not autogenerate the elements" do
+          @page.elements.should be_empty
+        end
       end
 
-    end
-
-    describe '#first_public_child' do
-
-      before do
-        FactoryGirl.create(:page, :name => "First child", :language => language, :public => false, :parent_id => language_root.id)
-      end
+      context "after changing the page layout" do
+        let(:news_element) { FactoryGirl.create(:element, :name => 'news') }
 
-      it "should return first_public_child" do
-        first_public_child = FactoryGirl.create(:public_page, :name => "First public child", :language => language, :parent_id => language_root.id)
-        language_root.first_public_child.should == first_public_child
-      end
+        it "all elements not allowed on this page should be trashed" do
+          news_page.elements << news_element
+          news_page.update_attributes :page_layout => 'standard'
+          news_page.elements.trashed.should include(news_element)
+        end
 
-      it "should return nil if no public child exists" do
-        language_root.first_public_child.should == nil
+        it "should autogenerate elements" do
+          news_page.update_attributes :page_layout => 'standard'
+          news_page.elements.available.collect(&:name).should include('header')
+        end
       end
-
     end
 
-    context ".contentpages" do
 
+    # 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')
+          clipboard = [
+            {:id => page_1.id, :action => "copy"},
+            {:id => page_2.id, :action => "copy"}
+          ]
+          Page.all_from_clipboard_for_select(clipboard, language.id).should include(page_1, page_2)
+        end
+      end
+
+      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')
+          clipboard = [
+            {:id => page_1.id, :action => "copy"}
+          ]
+          Page.all_from_clipboard_for_select(clipboard, language.id).should == []
+        end
+      end
+
+      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')
+          clipboard = [
+            {:id => page_1.id, :action => "copy"},
+            {:id => page_2.id, :action => "copy"}
+          ]
+          Page.all_from_clipboard_for_select(clipboard, language.id).should == [page_1]
+        end
+      end
+    end
+
+    describe '.all_locked' do
+      it "should return 1 page that is blocked by a user at the moment" do
+        FactoryGirl.create(:public_page, :locked => true, :name => 'First Public Child', :parent_id => language_root.id, :language => language)
+        Page.all_locked.should have(1).pages
+      end
+    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)
@@ -375,460 +322,693 @@ module Alchemy
       it "should contain pages with attribute :layoutpage set to nil" do
         Page.contentpages.to_a.select { |p| p.layoutpage == nil }.should include(@klingonian_lang_root)
       end
-
     end
 
-    context ".public" do
+    describe '.copy' do
+      let(:page) { FactoryGirl.create(:page, :name => 'Source') }
+      subject { Page.copy(page) }
 
-      it "should return pages that are public" do
-        FactoryGirl.create(:public_page, :name => 'First Public Child', :parent_id => language_root.id, :language => language)
-        FactoryGirl.create(:public_page, :name => 'Second Public Child', :parent_id => language_root.id, :language => language)
-        Page.published.should have(3).pages
+      it "the copy should have added (copy) to name" do
+        subject.name.should == "#{page.name} (Copy)"
       end
 
-    end
+      context "page with tags" do
+        before { page.tag_list = 'red, yellow'; page.save }
+
+        it "the copy should have source tag_list" do
+          # The order of tags varies between postgresql and sqlite/mysql
+          # This is related to acts-as-taggable-on v.2.4.1
+          # To fix the spec we sort the tags until the issue is solved (https://github.com/mbleigh/acts-as-taggable-on/issues/363)
+          subject.tag_list.should_not be_empty
+          subject.tag_list.sort.should == page.tag_list.sort
+        end
+      end
 
-    context ".not_locked" do
+      context "page with elements" do
+        before { page.elements << FactoryGirl.create(:element) }
 
-      it "should return pages that are not blocked by a user at the moment" do
-        FactoryGirl.create(:public_page, :locked => true, :name => 'First Public Child', :parent_id => language_root.id, :language => language)
-        FactoryGirl.create(:public_page, :name => 'Second Public Child', :parent_id => language_root.id, :language => language)
-        Page.not_locked.should have(3).pages
+        it "the copy should have source elements" do
+          subject.elements.should_not be_empty
+          subject.elements.count.should == page.elements.count
+        end
+      end
+
+      context "page with trashed elements" do
+        before do
+          page.elements << FactoryGirl.create(:element)
+          page.elements.first.trash
+        end
+
+        it "the copy should not hold a copy of the trashed elements" do
+          subject.elements.should be_empty
+        end
+      end
+
+      context "page with cells" do
+        before { page.cells << FactoryGirl.create(:cell) }
+
+        it "the copy should have source cells" do
+          subject.cells.should_not be_empty
+          subject.cells.count.should == page.cells.length # It must be length, because!
+        end
+      end
+
+      context "page with autogenerate elements" do
+        before do
+          page = FactoryGirl.create(:page)
+          page.stub!(:definition).and_return({'name' => 'standard', 'elements' => ['headline'], 'autogenerate' => ['headline']})
+        end
+
+        it "the copy should not autogenerate elements" do
+          subject.elements.should be_empty
+        end
+      end
+
+      context "with different page name given" do
+        subject { Page.copy(page, {:name => 'Different name'}) }
+        it "should take this name" do
+          subject.name.should == 'Different name'
+        end
       end
     end
 
-    context ".all_locked" do
-      it "should return 1 page that is blocked by a user at the moment" do
-        FactoryGirl.create(:public_page, :locked => true, :name => 'First Public Child', :parent_id => language_root.id, :language => language)
-        Page.all_locked.should have(1).pages
+    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.title.should == 'My Testpage'
+        end
+
+        it "should get a webfriendly urlname" do
+          page = FactoryGirl.create(:page, :name => 'klingon$&stößel ', :language => language, :parent_id => language_root.id)
+          page.urlname.should == 'klingon-stoessel'
+        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.urlname.should == '-au'
+        end
+
+        it "should generate a three letter urlname from two letter name with umlaut" do
+          page = FactoryGirl.create(:page, :name => 'Aü', :language => language, :parent_id => language_root.id)
+          page.urlname.should == 'aue'
+        end
+
+        it "should generate a three letter urlname from one letter name" do
+          page = FactoryGirl.create(:page, :name => 'A', :language => language, :parent_id => language_root.id)
+          page.urlname.should == '--a'
+        end
+
+        it "should add a user stamper" do
+          page = FactoryGirl.create(:page, :name => 'A', :language => language, :parent_id => language_root.id)
+          page.class.stamper_class.to_s.should == 'Alchemy::User'
+        end
       end
     end
 
-    context ".language_roots" do
+    describe '.language_roots' do
       it "should return 1 language_root" do
         FactoryGirl.create(:public_page, :name => 'First Public Child', :parent_id => language_root.id, :language => language)
         Page.language_roots.should have(1).pages
       end
     end
 
+    describe '.layout_description' do
+      it "should raise Exception if the page_layout could not be found in the definition file" do
+        expect { page.layout_description }.to raise_error
+      end
+
+      context "for a language root page" do
+        it "should return the page layout description as hash" do
+          language_root.layout_description['name'].should == 'intro'
+        end
+
+        it "should return an empty hash for root page" do
+          rootpage.layout_description.should == {}
+        end
+      end
+    end
 
-    context ".layoutpages" do
+    describe '.layoutpages' do
       it "should return 1 layoutpage" do
         FactoryGirl.create(:public_page, :layoutpage => true, :name => 'Layoutpage', :parent_id => rootpage.id, :language => language)
         Page.layoutpages.should have(1).pages
       end
     end
 
-    context ".visible" do
-      it "should return 1 visible page" do
-        FactoryGirl.create(:public_page, :name => 'First Public Child', :visible => true, :parent_id => language_root.id, :language => language)
-        Page.visible.should have(1).pages
+    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)
+        Page.not_locked.should have(3).pages
       end
     end
 
-    context ".not_restricted" do
+    describe '.not_restricted' do
       it "should return 2 accessible pages" do
         FactoryGirl.create(:public_page, :name => 'First Public Child', :restricted => true, :parent_id => language_root.id, :language => language)
         Page.not_restricted.should have(2).pages
       end
     end
 
-    context ".restricted" do
+    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)
+        Page.published.should have(3).pages
+      end
+    end
+
+    describe '.restricted' do
       it "should return 1 restricted page" do
         FactoryGirl.create(:public_page, :name => 'First Public Child', :restricted => true, :parent_id => language_root.id, :language => language)
         Page.restricted.should have(1).pages
       end
     end
 
-    context "#unlock" do
-      it "should set the locked status to false" do
-        page = FactoryGirl.create(:public_page, :locked => true)
-        page.unlock
-        page.locked.should == false
+    describe '.rootpage' do
+      it "should contain one rootpage" do
+        Page.rootpage.should be_instance_of(Page)
       end
     end
 
-    describe "#cell_definitions" do
-
-      before do
-        @page = FactoryGirl.build(:page, :page_layout => 'foo')
-        @page.stub!(:layout_description).and_return({'name' => "foo", 'cells' => ["foo_cell"]})
-        @cell_descriptions = [{'name' => "foo_cell", 'elements' => ["1", "2"]}]
-        Cell.stub!(:definitions).and_return(@cell_descriptions)
-      end
-
-      it "should return all cell definitions for its page_layout" do
-        @page.cell_definitions.should == @cell_descriptions
-      end
-
-      it "should return empty array if no cells defined in page layout" do
-        @page.stub!(:layout_description).and_return({'name' => "foo"})
-        @page.cell_definitions.should == []
+    describe '.visible' do
+      it "should return 1 visible page" do
+        FactoryGirl.create(:public_page, :name => 'First Public Child', :visible => true, :parent_id => language_root.id, :language => language)
+        Page.visible.should have(1).pages
       end
-
     end
 
-    describe "#elements_grouped_by_cells" do
-      let(:page) { FactoryGirl.create(:public_page, :do_not_autogenerate => false) }
 
-      before do
-        PageLayout.stub(:get).and_return({
-          'name' => 'standard',
-          'cells' => ['header'],
-          'elements' => ['header', 'text'],
-          'autogenerate' => ['header', 'text']
-        })
-        Cell.stub!(:definitions).and_return([{
-          'name' => "header",
-          'elements' => ["header"]
-        }])
-      end
+    # InstanceMethods (a-z)
 
-      it "should return elements grouped by cell" do
-        elements = page.elements_grouped_by_cells
-        elements.keys.first.should be_instance_of(Cell)
-        elements.values.first.first.should be_instance_of(Element)
-      end
+    describe '#available_element_definitions' do
+      let(:page) { FactoryGirl.build_stubbed(:public_page) }
 
-      it "should only include elements beeing in a cell " do
-        page.elements_grouped_by_cells.keys.should_not include(nil)
+      it "returns all element definitions of available elements" do
+        page.available_element_definitions.should be_an(Array)
+        page.available_element_definitions.collect { |e| e['name'] }.should include('header')
       end
 
-    end
-
-    describe '.all_from_clipboard_for_select' do
-
-      context "with clipboard holding pages having non unique page layout" do
+      context "with unique elements already on page" do
+        let(:element) { FactoryGirl.build_stubbed(:unique_element) }
+        before { page.stub_chain(:elements, :not_trashed, :pluck).and_return([element.name]) }
 
-        it "should return the pages" do
-          page_1 = FactoryGirl.create(:page, :language => language)
-          page_2 = FactoryGirl.create(:page, :language => language, :name => 'Another page')
-          clipboard = [
-            {:id => page_1.id, :action => "copy"},
-            {:id => page_2.id, :action => "copy"}
-          ]
-          Page.all_from_clipboard_for_select(clipboard, language.id).should include(page_1, page_2)
+        it "does not return unique element definitions" do
+          page.available_element_definitions.collect { |e| e['name'] }.should include('article')
+          page.available_element_definitions.collect { |e| e['name'] }.should_not include('header')
         end
-
       end
 
-      context "with clipboard holding a page having unique page layout" do
+      context "for page_layout not existing" do
+        let(:page) { FactoryGirl.build_stubbed(:page, page_layout: 'not_existing_one') }
 
-        it "should not return any pages" do
-          page_1 = FactoryGirl.create(:page, :language => language, :page_layout => 'contact')
-          clipboard = [
-            {:id => page_1.id, :action => "copy"}
-          ]
-          Page.all_from_clipboard_for_select(clipboard, language.id).should == []
+        it "should raise error" do
+          expect {
+            page.available_element_definitions
+          }.to raise_error(Alchemy::PageLayoutDefinitionError)
         end
-
       end
 
-      context "with clipboard holding two pages. One having a unique page layout." do
+      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') }
 
-        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')
-          clipboard = [
-            {:id => page_1.id, :action => "copy"},
-            {:id => page_2.id, :action => "copy"}
-          ]
-          Page.all_from_clipboard_for_select(clipboard, language.id).should == [page_1]
+        before {
+          Element.stub(:definitions).and_return([
+            {
+              'name' => 'column_headline',
+              'amount' => 3,
+              'contents' => [{'name' => 'headline', 'type' => 'EssenceText'}]
+            },
+            {
+              'name' => 'unique_headline',
+              'unique' => true,
+              'amount' => 3,
+              'contents' => [{'name' => 'headline', 'type' => 'EssenceText'}]
+            }
+          ])
+          PageLayout.stub(:get).and_return({
+            'name' => 'columns',
+            'elements' => ['column_headline', 'unique_headline'],
+            'autogenerate' => ['unique_headline', 'column_headline', 'column_headline', 'column_headline']
+          })
+          page.stub_chain(:elements, :not_trashed, :pluck).and_return([unique_element.name, element_1.name, element_2.name, element_3.name])
+        }
+
+        it "should be readable" do
+          element = page.element_definitions_by_name('column_headline').first
+          element['amount'].should be 3
+        end
+
+        it "should limit elements" do
+          page.available_element_definitions.collect { |e| e['name'] }.should_not include('column_headline')
         end
 
+        it "should be ignored if unique" do
+          page.available_element_definitions.collect { |e| e['name'] }.should_not include('unique_headline')
+        end
       end
+    end
+
+    describe '#available_element_names' do
+      let(:page) { FactoryGirl.build_stubbed(:page) }
 
+      it "returns all names of elements that could be placed on current page" do
+        page.available_element_names == %w(header article)
+      end
     end
 
-    describe "Validations: " do
+    describe '#cache_key' do
+      let(:page) { stub_model(Page) }
+      subject { page }
+      its(:cache_key) { should match(page.id.to_s) }
+    end
 
-      context "Creating a normal content page" do
+    describe '#cell_definitions' do
+      before do
+        @page = FactoryGirl.build(:page, :page_layout => 'foo')
+        @page.stub!(:layout_description).and_return({'name' => "foo", 'cells' => ["foo_cell"]})
+        @cell_descriptions = [{'name' => "foo_cell", 'elements' => ["1", "2"]}]
+        Cell.stub!(:definitions).and_return(@cell_descriptions)
+      end
 
-        let(:contentpage) { FactoryGirl.build(:page) }
+      it "should return all cell definitions for its page_layout" do
+        @page.cell_definitions.should == @cell_descriptions
+      end
 
-        context "when its urlname exists as global page" do
-          it "it should be possible to save." do
-            contentpage.urlname = "existing_twice"
-            global_with_same_urlname = FactoryGirl.create(:page, :urlname => "existing_twice", :layoutpage => true)
-            contentpage.should be_valid
-          end
-        end
+      it "should return empty array if no cells defined in page layout" do
+        @page.stub!(:layout_description).and_return({'name' => "foo"})
+        @page.cell_definitions.should == []
+      end
+    end
 
-        it "should validate the page_layout" do
-          contentpage.page_layout = nil
-          contentpage.save
-          contentpage.should have(1).error_on(:page_layout)
-        end
+    describe '#destroy' do
+      context "with trashed but still assigned elements" do
 
-        it "should validate the parent_id" do
-          contentpage.parent_id = nil
-          contentpage.save
-          contentpage.should have(1).error_on(:parent_id)
-        end
+        before { news_page.elements.map(&:trash) }
 
-        it "should validate the uniqueness of urlname" do
-          with_same_urlname = FactoryGirl.create(:page, :urlname => "existing_twice")
-          contentpage.urlname = 'existing_twice'
-          contentpage.should_not be_valid
+        it "should not delete the trashed elements" do
+          news_page.destroy
+          Element.trashed.should_not be_empty
         end
 
-        context "with url_nesting set to true" do
-          before { Config.stub!(:get).and_return(true) }
-
-          it "should only validate urlname dependent of parent" do
-            other_parent = FactoryGirl.create(:page, parent_id: Page.root.id)
-            with_same_urlname = FactoryGirl.create(:page, :urlname => "existing_twice")
-            contentpage.urlname = 'existing_twice'
-            contentpage.parent_id = other_parent.id
-            contentpage.should be_valid
-          end
+      end
+    end
 
-          it "should validate urlname dependent of parent" do
-            with_same_urlname = FactoryGirl.create(:page, :urlname => "existing_twice")
-            contentpage.urlname = 'existing_twice'
-            contentpage.should_not be_valid
-          end
-        end
+    describe '#element_definitions' do
+      let(:page) { FactoryGirl.build_stubbed(:page) }
+      subject { page.element_definitions }
+      before { Element.should_receive(:definitions).and_return([{'name' => 'article'}, {'name' => 'header'}]) }
 
+      it "returns all element definitions that could be placed on current page" do
+        should include({'name' => 'article'})
+        should include({'name' => 'header'})
       end
+    end
 
-      context "creating the rootpage without parent_id and page_layout" do
+    describe '#element_definitions_by_name' do
+      let(:page) { FactoryGirl.build_stubbed(:public_page) }
 
-        before do
-          Page.delete_all
-          @rootpage = FactoryGirl.build(:page, :parent_id => nil, :page_layout => nil, :name => 'Rootpage')
+      context "with no name given" do
+        it "returns empty array" do
+          page.element_definitions_by_name(nil).should == []
         end
+      end
 
-        it "should be valid" do
-          @rootpage.save
-          @rootpage.should be_valid
+      context "with 'all' passed as name" do
+        it "returns all element definitions" do
+          Element.should_receive(:definitions)
+          page.element_definitions_by_name('all')
         end
-
       end
 
-      context "saving a systempage" do
-
-        before do
-          @systempage = FactoryGirl.build(:systempage)
+      context "with :all passed as name" do
+        it "returns all element definitions" do
+          Element.should_receive(:definitions)
+          page.element_definitions_by_name(:all)
         end
+      end
+    end
 
-        it "should not validate the page_layout" do
-          @systempage.save
-          @systempage.should be_valid
-        end
+    describe '#element_definition_names' do
+      let(:page) { FactoryGirl.build_stubbed(:public_page) }
 
+      it "returns all element names defined in page layout" do
+        page.element_definition_names.should == %w(article header)
       end
 
+      it "returns always an array" do
+        page.stub(:definition).and_return({})
+        page.element_definition_names.should be_an(Array)
+      end
     end
 
-    describe 'before and after filters' do
-
-      context "a normal page" do
-
-        before do
-          @page = FactoryGirl.build(:page, :language_code => nil, :language => klingonian, :do_not_autogenerate => false)
-        end
+    describe '#elements_grouped_by_cells' do
+      let(:page) { FactoryGirl.create(:public_page, :do_not_autogenerate => false) }
 
-        it "should get the language code for language" do
-          @page.save
-          @page.language_code.should == "kl"
-        end
+      before do
+        PageLayout.stub(:get).and_return({
+          'name' => 'standard',
+          'cells' => ['header'],
+          'elements' => ['header', 'text'],
+          'autogenerate' => ['header', 'text']
+        })
+        Cell.stub!(:definitions).and_return([{
+          'name' => "header",
+          'elements' => ["header"]
+        }])
+      end
 
-        it "should autogenerate the elements" do
-          @page.save
-          @page.elements.should_not be_empty
-        end
+      it "should return elements grouped by cell" do
+        elements = page.elements_grouped_by_cells
+        elements.keys.first.should be_instance_of(Cell)
+        elements.values.first.first.should be_instance_of(Element)
+      end
 
-        it "should not autogenerate elements that are already on the page" do
-          @page.elements << FactoryGirl.create(:element, :name => 'header')
-          @page.save
-          @page.elements.select { |e| e.name == 'header' }.length.should == 1
-        end
+      it "should only include elements beeing in a cell " do
+        page.elements_grouped_by_cells.keys.should_not include(nil)
+      end
+    end
 
-        context "with cells" do
+    describe '#feed_elements' do
+      it "should return all rss feed elements" do
+        news_page.feed_elements.should_not be_empty
+        news_page.feed_elements.should == Element.find_all_by_name('news')
+      end
+    end
 
-          before do
-            @page.stub!(:definition).and_return({'name' => 'with_cells', 'cells' => ['header', 'main']})
-          end
+    describe '#find_elements' do
+      before do
+        FactoryGirl.create(:element, :public => false, :page => public_page)
+        FactoryGirl.create(:element, :public => false, :page => public_page)
+      end
 
-          it "should have the generated elements in their cells" do
-            @page.stub!(:cell_definitions).and_return([{'name' => 'header', 'elements' => ['article']}])
-            @page.save
-            @page.cells.where(:name => 'header').first.elements.should_not be_empty
-          end
+      context "with show_non_public argument TRUE" do
+        it "should return all elements from empty options" do
+          public_page.find_elements({}, true).all.should == public_page.elements.all
+        end
 
-          context "and no elements in cell definitions" do
+        it "should only return the elements passed as options[:only]" do
+          public_page.find_elements({:only => ['article']}, true).all.should == public_page.elements.named('article').all
+        end
 
-            it "should have the elements in the nil cell" do
-              @page.stub!(:cell_definitions).and_return([{'name' => 'header', 'elements' => []}])
-              @page.save
-              @page.cells.collect(&:elements).flatten.should be_empty
-            end
+        it "should not return the elements passed as options[:except]" do
+          public_page.find_elements({:except => ['article']}, true).all.should == public_page.elements - public_page.elements.named('article').all
+        end
 
-          end
+        it "should return elements offsetted" do
+          public_page.find_elements({:offset => 2}, true).all.should == public_page.elements.offset(2)
+        end
 
+        it "should return elements limitted in count" do
+          public_page.find_elements({:count => 1}, true).all.should == public_page.elements.limit(1)
         end
+      end
 
-        context "with children" do
-          before {
-            @page.save
-            @child1 = FactoryGirl.create(:page, :name => 'Child 1', :parent_id => @page.id)
-            @page.reload
-          }
+      context "with options[:from_cell]" do
+        let(:element) { FactoryGirl.build_stubbed(:element) }
 
-          context "and restricted been set to true" do
+        context "given as String" do
+          context '' do
             before {
-              @page.restricted = true
-              @page.save
+              public_page.cells.stub_chain(:find_by_name, :elements, :offset, :limit, :published).and_return([element])
             }
 
-            it "should restrict all children" do
-              @child1.reload
-              @child1.restricted?.should be_true
+            it "returns only the elements from given cell" do
+              public_page.find_elements(from_cell: 'A Cell').to_a.should == [element]
             end
           end
 
-          context "and restricted been set to false" do
+          context "that can not be found" do
+            let(:elements) {[]}
             before {
-              @page.restricted = false
-              @page.save
+              elements.stub_chain(:offset, :limit, :published).and_return([])
             }
 
-            it "should unrestrict all children" do
-              @child1.reload
-              @child1.restricted?.should be_false
+            it "returns empty set" do
+              public_page.elements.should_receive(:where).with('1 = 0').and_return(elements)
+              public_page.find_elements(from_cell: 'Lolo').to_a.should == []
+            end
+
+            it "loggs a warning" do
+              Rails.logger.should_receive(:debug)
+              public_page.find_elements(from_cell: 'Lolo')
             end
           end
         end
 
-        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)
-          end
+        context "given as cell object" do
+          let(:cell) { FactoryGirl.build_stubbed(:cell, page: public_page) }
 
-          it "should also be restricted" do
-            @new_page.restricted?.should be_true
+          it "returns only the elements from given cell" do
+            cell.stub_chain(:elements, :offset, :limit, :published).and_return([element])
+            public_page.find_elements(from_cell: cell).to_a.should == [element]
           end
+        end
+      end
 
+      context "with show_non_public argument FALSE" do
+        it "should return all elements from empty arguments" do
+          public_page.find_elements().all.should == public_page.elements.published.all
         end
 
-        context "with do_not_autogenerate set to true" do
+        it "should only return the public elements passed as options[:only]" do
+          public_page.find_elements(:only => ['article']).all.should == public_page.elements.published.named('article').all
+        end
 
-          before do
-            @page.do_not_autogenerate = true
-          end
+        it "should return all public elements except the ones passed as options[:except]" do
+          public_page.find_elements(:except => ['article']).all.should == public_page.elements.published.all - public_page.elements.published.named('article').all
+        end
 
-          it "should not autogenerate the elements" do
-            @page.save
-            @page.elements.should be_empty
-          end
+        it "should return elements offsetted" do
+          public_page.find_elements({:offset => 2}).all.should == public_page.elements.published.offset(2)
+        end
 
+        it "should return elements limitted in count" do
+          public_page.find_elements({:count => 1}).all.should == public_page.elements.published.limit(1)
         end
+      end
+    end
 
+    describe '#first_public_child' do
+      before do
+        FactoryGirl.create(:page, :name => "First child", :language => language, :public => false, :parent_id => language_root.id)
       end
 
-      context "a systempage" do
+      it "should return first_public_child" do
+        first_public_child = FactoryGirl.create(:public_page, :name => "First public child", :language => language, :parent_id => language_root.id)
+        language_root.first_public_child.should == first_public_child
+      end
 
-        before do
-          @page = FactoryGirl.create(:systempage)
-        end
+      it "should return nil if no public child exists" do
+        language_root.first_public_child.should == nil
+      end
+    end
 
-        it "should not get the language code for language" do
-          @page.language_code.should be_nil
-        end
+    context 'folding' do
+      let(:user) { mock_model('User') }
 
-        it "should not autogenerate the elements" do
-          @page.elements.should be_empty
+      describe '#fold!' do
+        context "with folded status set to true" do
+          it "should create a folded page for user" do
+            public_page.fold!(user.id, true)
+            expect(public_page.folded_pages.first.user_id).to eq(user.id)
+          end
         end
-
       end
 
-      context "after changing the page layout" do
+      describe '#folded?' do
+        let(:page) { Page.new }
 
-        let(:news_element) { FactoryGirl.create(:element, :name => 'news') }
+        context 'if page is folded' do
+          before do
+            page.stub_chain(:folded_pages, :find_by_user_id).and_return(mock_model('FoldedPage', folded: true))
+          end
 
-        it "all elements not allowed on this page should be trashed" do
-          news_page.elements << news_element
-          news_page.update_attributes :page_layout => 'standard'
-          news_page.elements.trashed.should include(news_element)
+          it "should return true" do
+            expect(page.folded?(user.id)).to eq(true)
+          end
         end
 
-        it "should autogenerate elements" do
-          news_page.update_attributes :page_layout => 'standard'
-          news_page.elements.available.collect(&:name).should include('header')
+        context 'if page is not folded' do
+          it "should return false" do
+            expect(page.folded?(101093)).to eq(false)
+          end
         end
+      end
+    end
+
+    describe '#lock!' do
+      let(:page) { FactoryGirl.create(:page) }
+      let(:user) { mock_model('User') }
 
+      it "should set locked to true" do
+        page.lock!(user)
+        page.reload
+        page.locked.should == true
       end
 
+      it "should not update the timestamps " do
+        expect { page.lock!(user) }.to_not change(page, :updated_at)
+      end
+
+      it "should set locked_by to the users id" do
+        page.lock!(user)
+        page.reload
+        page.locked_by.should == user.id
+      end
     end
 
-    describe '#fold' do
+    describe '#paste_from_clipboard' do
+      let(:source) { FactoryGirl.build_stubbed(:page) }
+      let(:new_parent) { FactoryGirl.build_stubbed(:page) }
+      let(:page_name) { "Pagename (pasted)" }
+      let(:copied_page) { mock_model('Page') }
 
-      before do
-        @user = FactoryGirl.create(:admin_user, :email => 'faz@baz.com', :login => 'foo_baz')
+      subject { Page.paste_from_clipboard(source, new_parent, page_name) }
+
+      it "should copy the source page with the given name to the new parent" do
+        Page.should_receive(:copy).with(source, {
+          parent_id: new_parent.id,
+          language: new_parent.language,
+          name: page_name,
+          title: page_name
+          })
+        subject
       end
 
-      context "with folded status set to true" do
+      it "should return the copied page" do
+        Page.stub!(:copy).and_return(copied_page)
+        expect(subject).to be_a(copied_page.class)
+      end
 
-        it "should create a folded page for user" do
-          public_page.fold(@user.id, true)
-          FoldedPage.find_or_create_by_user_id_and_page_id(@user.id, public_page.id).should_not be_nil
+      context "if source page has children" do
+        it "should also copy and paste the children" do
+          Page.stub!(:copy).and_return(copied_page)
+          source.stub!(:children).and_return([mock_model('Page')])
+          source.should_receive(:copy_children_to).with(copied_page)
+          subject
         end
-
       end
-
     end
 
-    describe 'previous and next. ' do
-
-      let(:center_page) { FactoryGirl.create(:public_page, :name => 'Center Page') }
-      let(:next_page) { FactoryGirl.create(:public_page, :name => 'Next Page') }
+    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) }
 
       before do
         public_page
+        restricted_page
+        non_public_page
         center_page
         next_page
       end
 
       describe '#previous' do
-
         it "should return the previous page on the same level" do
           center_page.previous.should == public_page
         end
 
         context "no previous page on same level present" do
-
           it "should return nil" do
             public_page.previous.should be_nil
           end
+        end
+
+        context "with options restricted" do
+          context "set to true" do
+            it "returns previous restricted page" do
+              center_page.previous(restricted: true).should == restricted_page
+            end
+          end
 
+          context "set to false" do
+            it "skips restricted page" do
+              center_page.previous(restricted: false).should == public_page
+            end
+          end
         end
 
+        context "with options public" do
+          context "set to true" do
+            it "returns previous public page" do
+              center_page.previous(public: true).should == public_page
+            end
+          end
+
+          context "set to false" do
+            it "skips public page" do
+              center_page.previous(public: false).should == non_public_page
+            end
+          end
+        end
       end
 
       describe '#next' do
-
         it "should return the next page on the same level" do
           center_page.next.should == next_page
         end
 
         context "no next page on same level present" do
-
           it "should return nil" do
             next_page.next.should be_nil
           end
+        end
+      end
+    end
+
+    describe '#publish!' do
+      let(:page) { FactoryGirl.build_stubbed(:page, public: false) }
+
+      before do
+        page.stub!(:save).and_return(true)
+        page.publish!
+      end
 
+      it "sets public attribute to true" do
+        page.public.should == true
+      end
+    end
+
+    describe '#set_language_from_parent_or_default_language' do
+      let(:default_language) { mock_model('Language', code: 'es') }
+      let(:page) { Page.new }
+
+      before { page.stub!(:parent).and_return(parent) }
+
+      subject { page }
+
+      context "parent has a language" do
+        let(:parent) { mock_model('Page', language: default_language, language_id: default_language.id, language_code: default_language.code) }
+
+        before do
+          page.set_language_from_parent_or_default_language
         end
 
+        its(:language_id) { should eq(parent.language_id) }
+        its(:language_code) { should eq(parent.language_code) }
       end
 
+      context "parent has no language" do
+        let(:parent) { mock_model('Page', language: nil, language_id: nil, language_code: nil) }
+
+        before do
+          Language.stub!(:get_default).and_return(default_language)
+          page.set_language_from_parent_or_default_language
+        end
+
+        its(:language_id) { should eq(default_language.id) }
+        its(:language_code) { should eq(default_language.code) }
+      end
     end
 
     describe '#taggable?' do
-
       context "definition has 'taggable' key with true value" do
         it "should return true" do
           page = FactoryGirl.build(:page)
@@ -852,93 +1032,29 @@ module Alchemy
           page.taggable?.should be_false
         end
       end
-
     end
 
-    describe '.copy' do
-      let(:page) { FactoryGirl.create(:page, :name => 'Source') }
-      subject { Page.copy(page) }
-
-      it "the copy should have added (copy) to name" do
-        subject.name.should == "#{page.name} (Copy)"
-      end
-
-      context "page with tags" do
-        before { page.tag_list = 'red, yellow'; page.save }
-
-        it "the copy should have source tag_list" do
-          # The order of tags varies between postgresql and sqlite/mysql
-          # This is related to acts-as-taggable-on v.2.4.1
-          # To fix the spec we sort the tags until the issue is solved (https://github.com/mbleigh/acts-as-taggable-on/issues/363)
-          subject.tag_list.should_not be_empty
-          subject.tag_list.sort.should == page.tag_list.sort
-        end
-      end
-
-      context "page with elements" do
-        before { page.elements << FactoryGirl.create(:element) }
-
-        it "the copy should have source elements" do
-          subject.elements.should_not be_empty
-          subject.elements.count.should == page.elements.count
-        end
-      end
-
-      context "page with trashed elements" do
-        before do
-          page.elements << FactoryGirl.create(:element)
-          page.elements.first.trash
-        end
-
-        it "the copy should not hold a copy of the trashed elements" do
-          subject.elements.should be_empty
-        end
-      end
-
-      context "page with cells" do
-        before { page.cells << FactoryGirl.create(:cell) }
-
-        it "the copy should have source cells" do
-          subject.cells.should_not be_empty
-          subject.cells.count.should == page.cells.length # It must be length, because!
-        end
-      end
-
-      context "page with autogenerate elements" do
-        before do
-          page = FactoryGirl.create(:page)
-          page.stub!(:definition).and_return({'name' => 'standard', 'elements' => ['headline'], 'autogenerate' => ['headline']})
-        end
+    describe '#unlock!' do
+      let(:page) { FactoryGirl.create(:page, locked: true, locked_by: 1) }
 
-        it "the copy should not autogenerate elements" do
-          subject.elements.should be_empty
-        end
+      its "should set the locked status to false" do
+        page.unlock!
+        page.reload
+        page.locked.should == false
       end
 
-      context "with different page name given" do
-        subject { Page.copy(page, {:name => 'Different name'}) }
-        it "should take this name" do
-          subject.name.should == 'Different name'
-        end
+      it "should not update the timestamps " do
+        expect { page.unlock! }.to_not change(page, :updated_at)
       end
-    end
-
-    describe "#cache_key" do
-      let(:page) { stub_model(Page) }
-      subject { page }
-      its(:cache_key) { should match(page.id.to_s) }
-    end
-
-    describe "#publish!" do
-      let(:page) { FactoryGirl.create(:page) }
-      before { page.publish! }
 
-      it "sets public attribute to true" do
-        page.public.should == true
+      it "should set locked_by to nil" do
+        page.unlock!
+        page.reload
+        page.locked_by.should == nil
       end
     end
 
-    describe 'urlname updating' do
+    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) }
@@ -1027,7 +1143,7 @@ module Alchemy
       end
     end
 
-    describe "page status methods" do
+    context 'page status methods' do
       let(:page) { FactoryGirl.build(:page, public: true, visible: true, restricted: false, locked: false)}
 
       describe '#status' do
@@ -1053,7 +1169,50 @@ module Alchemy
           page.status_title(:restricted).should == 'Page is not restricted.'
         end
       end
+    end
+
+    context 'indicate page editors' do
+      let(:page) { Page.new }
+      let(:user) { User.new(firstname: 'Paul', lastname: 'Page') }
+
+      describe '#creator_name' do
+        before { page.stub(:creator).and_return(user) }
+
+        it "should return the name of the creator" do
+          expect(page.creator_name).to eq('Paul Page')
+        end
+      end
+
+      describe '#updater_name' do
+        before { page.stub(:updater).and_return(user) }
+
+        it "should return the name of the updater" do
+          expect(page.updater_name).to eq('Paul Page')
+        end
+      end
+
+      describe '#locker_name' do
+        before { page.stub(:locker).and_return(user) }
+
+        it "should return the name of the current page editor" do
+          expect(page.locker_name).to eq('Paul Page')
+        end
+      end
+
+    end
+
+    describe '#controller_and_action' do
+      let(:page) { Page.new }
 
+      context 'if the page has a custom controller defined in its description' do
+        before do
+          page.stub!(:has_controller?).and_return(true)
+          page.stub!(:layout_description).and_return({'controller' => 'comments', 'action' => 'index'})
+        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'})
+        end
+      end
     end
 
   end