alchemy_cms 2.2.4 → 2.3.rc5

data/spec/models/language_spec.rb

@@ -1,96 +1,121 @@
 # encoding: UTF-8
 require 'spec_helper'
 
-describe Alchemy::Language do
+module Alchemy
+  describe Language do
 
-  before(:each) do
-    @language = FactoryGirl.create(:language)
-  end
+    let(:language) { FactoryGirl.create(:klingonian) }
+    let(:page) { FactoryGirl.create(:page, :language => language) }
 
-  it "should return a label for code" do
-    @language.label(:code).should == 'kl'
-  end
+    it "should return a label for code" do
+      language.label(:code).should == 'kl'
+    end
 
-  it "should return a label for name" do
-    @language.label(:name).should == 'Klingonian'
-  end
+    it "should return a label for name" do
+      language.label(:name).should == 'Klingonian'
+    end
+
+    context "with language_code and empty country_code" do
+
+      it "#code should return language locale only" do
+        language.country_code = ''
+        language.code.should == 'kl'
+      end
+
+      context "adding a value for country code" do
 
-  context "with language_code and empty country_code" do
+        it "#code should return a joined locale" do
+          language.country_code = 'cr'
+          language.code.should == 'kl-cr'
+        end
+
+        it "should update all associated Pages with self.code as value for Page#language_code" do
+          page = FactoryGirl.create(:page, :language => language)
+          language.country_code = 'cr'
+          language.save
+          page.reload; page.language_code.should == 'kl-cr'
+        end
+      end
 
-    it "#code should return language locale only" do
-      @language.country_code = ''
-      @language.code.should == 'kl'
     end
 
-    context "adding a value for country code" do
+    context "with country_code and_language_code" do
+
+      context "removing the country_code" do
+
+        it "should update all associated Pages´s language_code with Language#code" do
+          language = FactoryGirl.create(:language, :country_code => 'kl')
+
+          language.country_code = ''
+          language.save
+          page.reload; page.language_code.should == "kl"
+        end
 
-      it "#code should return a joined locale" do
-        @language.country_code = 'cr'
-        @language.code.should == 'kl-cr'
       end
 
-      it "should update all associated Pages with self.code as value for Page#language_code" do
-        @page = FactoryGirl.create(:page, :language => @language)
-        @language.country_code = 'cr'
-        @language.save
-        @page.reload; @page.language_code.should == 'kl-cr'
+    end
+
+    it "should not be deletable if it is the default language" do
+      @default_language = Alchemy::Language.find_by_default(true)
+      if !@default_language
+        @default_language = FactoryGirl.create(:language, :name => "default", :code => "aa", :frontpage_name => "intro", :default => true)
       end
+      expect { @default_language.destroy }.to raise_error
     end
 
-  end
+    describe "before save" do
 
-  context "with country_code and_language_code" do
+      describe "#remove_old_default if default attribute has changed to true" do
+
+        it "should unset the default status of the old default-language" do
+          @default_language = Alchemy::Language.get_default
+          language.update_attributes(:default => true)
+          @default_language.reload
+          @default_language.default.should be(false)
+        end
 
-    context "removing the country_code" do
-      it "should update all associated Pages´s language_code with Language#code" do
-        language = FactoryGirl.create(:language_with_country_code)
-        @page = FactoryGirl.create(:page, :language => language)
-        language.country_code = ''
-        language.save
-        @page.reload; @page.language_code.should == "kl"
       end
+
     end
 
-  end
+    context "after_update" do
 
-  it "should not be deletable if it is the default language" do
-    @default_language = Alchemy::Language.find_by_default(true)
-    if !@default_language
-      @default_language = FactoryGirl.create(:language, :name => "default", :code => "aa", :frontpage_name => "intro", :default => true)
-    end
-    expect { @default_language.destroy }.to raise_error
-  end
+      describe "#set_pages_language if language´s code has changed" do
+
+        it "should update all its pages with the new code" do
+          @other_page = FactoryGirl.create(:page, :language => language)
+          language.update_attributes(:code => "fo")
+          language.reload; page.reload; @other_page.reload
+          [page.language_code, @other_page.language_code].should == [language.code, language.code]
+        end
 
-  describe "before save" do
-    describe "#remove_old_default if default attribute has changed to true" do
-      it "should unset the default status of the old default-language" do
-        @default_language = Alchemy::Language.get_default
-        @language.update_attributes(:default => true)
-        @default_language.reload
-        @default_language.default.should be(false)
       end
-    end
-  end
 
-  context "after_update" do
-    describe "#set_pages_language if language´s code has changed" do
-      it "should update all its pages with the new code" do
-        @page = FactoryGirl.create(:page, :language => @language)
-        @other_page = FactoryGirl.create(:page, :language => @language)
-        @language.update_attributes(:code => "fo")
-        @language.reload; @page.reload; @other_page.reload
-        [@page.language_code, @other_page.language_code].should == [@language.code, @language.code]
+      describe "#unpublish_pages" do
+
+        it "should set all pages to unpublic if it gets set to unpublic" do
+          page = FactoryGirl.create(:page, :language => language)
+          @other_page = FactoryGirl.create(:page, :language => language)
+          language.update_attributes(:public => false)
+          language.reload; page.reload; @other_page.reload
+          [page.public?, @other_page.public?].should == [false, false]
+        end
+
       end
+
     end
-    describe "#unpublish_pages" do
-      it "should set all pages to unpublic if it gets set to unpublic" do
-        @page = FactoryGirl.create(:page, :language => @language)
-        @other_page = FactoryGirl.create(:page, :language => @language)
-        @language.update_attributes(:public => false)
-        @language.reload; @page.reload; @other_page.reload
-        [@page.public?, @other_page.public?].should == [false, false]
+
+    describe '.find_by_code' do
+
+      context "with only the language code given" do
+
+        it "should find the language" do
+          Language.find_by_code(language.code).should == language
+        end
+
       end
+
     end
-  end
 
+  end
 end

data/spec/models/page_layout_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+module Alchemy
+  describe PageLayout do
+
+    context "method get_layouts" do
+
+      it "should generally return page_layouts, nothing else!" do
+        PageLayout.read_layouts_file.should be_instance_of(Array)
+      end
+
+    end
+
+    context "with custom page layouts" do
+
+      it "should return the users page_layouts if exists in the application" do
+        @config_path = Rails.root.join("config/alchemy")
+        FileUtils.mv(File.join(@config_path, 'page_layouts.yml'), File.join(@config_path, 'page_layouts.bak'))
+        layouts_file = File.join(@config_path, 'page_layouts.yml')
+        File.open(layouts_file, 'w') do |page_layouts|
+          page_layouts.puts "- name: testlayout\n  elements:"
+        end
+        PageLayout.read_layouts_file.first.values.should include("testlayout")
+      end
+
+      after(:each) do
+        FileUtils.mv(File.join(@config_path, 'page_layouts.bak'), File.join(@config_path, 'page_layouts.yml'))
+      end
+
+    end
+
+    it "should not display hidden page layouts" do
+      PageLayout.selectable_layouts(Language.get_default).each { |e| e["hide"].should_not == true }
+    end
+
+  end
+end

data/spec/models/page_spec.rb

@@ -5,30 +5,30 @@ require 'spec_helper'
 module Alchemy
   describe Page do
 
-    before(:each) do
-      @rootpage = Page.root
-      @rootpage.children.destroy_all
-      @language = Language.get_default
-      @language_root = FactoryGirl.create(:language_root_page, :name => 'Default Language Root', :language => @language)
-    end
+    let(:rootpage)      { Page.root }
+    let(:language)      { Language.get_default }
+    let(:klingonian)    { FactoryGirl.create(:klingonian) }
+    let(:language_root) { FactoryGirl.create(:language_root_page) }
+    let(:page)          { mock(: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) }
 
     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'
+          language_root.layout_description['name'].should == 'intro'
         end
 
         it "should return an empty hash for root page" do
-          @rootpage.layout_description.should == {}
+          rootpage.layout_description.should == {}
         end
 
       end
 
       it "should raise Exception if the page_layout could not be found in the definition file" do
-        @page = mock(:page, :page_layout => 'foo')
-        expect { @page.layout_description }.to raise_error
+        expect { page.layout_description }.to raise_error
       end
 
     end
@@ -38,45 +38,42 @@ module Alchemy
     end
 
     it "should return all rss feed elements" do
-      @page = FactoryGirl.create(:public_page, :page_layout => 'news', :parent_id => @language_root.id, :language => @language)
-      @page.feed_elements.should == Element.find_all_by_name('news')
+      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(:each) do
-        @page = FactoryGirl.create(:public_page)
-        @non_public_elements = [
-          FactoryGirl.create(:element, :public => false, :page => @page),
-          FactoryGirl.create(:element, :public => false, :page => @page)
-        ]
+      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 => @page.elements}
-        @page.find_elements(options).all.should == @page.elements.all
+        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
-          @page.find_elements({}, true).all.should == @page.elements.all
+          public_page.find_elements({}, true).all.should == public_page.elements.all
         end
 
         it "should only return the elements passed as options[:only]" do
-          @page.find_elements({:only => ['article']}, true).all.should == @page.elements.named('article').all
+          public_page.find_elements({:only => ['article']}, true).all.should == public_page.elements.named('article').all
         end
 
         it "should not return the elements passed as options[:except]" do
-          @page.find_elements({:except => ['article']}, true).all.should == @page.elements - @page.elements.named('article').all
+          public_page.find_elements({:except => ['article']}, true).all.should == public_page.elements - public_page.elements.named('article').all
         end
 
         it "should return elements offsetted" do
-          @page.find_elements({:offset => 2}, true).all.should == @page.elements.offset(2)
+          public_page.find_elements({:offset => 2}, true).all.should == public_page.elements.offset(2)
         end
 
         it "should return elements limitted in count" do
-          @page.find_elements({:count => 1}, true).all.should == @page.elements.limit(1)
+          public_page.find_elements({:count => 1}, true).all.should == public_page.elements.limit(1)
         end
 
       end
@@ -84,23 +81,23 @@ module Alchemy
       context "with show_non_public argument FALSE" do
 
         it "should return all elements from empty arguments" do
-          @page.find_elements().all.should == @page.elements.published.all
+          public_page.find_elements().all.should == public_page.elements.published.all
         end
 
         it "should only return the public elements passed as options[:only]" do
-          @page.find_elements(:only => ['article']).all.should == @page.elements.published.named('article').all
+          public_page.find_elements(:only => ['article']).all.should == public_page.elements.published.named('article').all
         end
 
         it "should return all public elements except the ones passed as options[:except]" do
-          @page.find_elements(:except => ['article']).all.should == @page.elements.published.all - @page.elements.published.named('article').all
+          public_page.find_elements(:except => ['article']).all.should == public_page.elements.published.all - public_page.elements.published.named('article').all
         end
 
         it "should return elements offsetted" do
-          @page.find_elements({:offset => 2}).all.should == @page.elements.published.offset(2)
+          public_page.find_elements({:offset => 2}).all.should == public_page.elements.published.offset(2)
         end
 
         it "should return elements limitted in count" do
-          @page.find_elements({:count => 1}).all.should == @page.elements.published.limit(1)
+          public_page.find_elements({:count => 1}).all.should == public_page.elements.published.limit(1)
         end
 
       end
@@ -112,32 +109,32 @@ module Alchemy
       context "before/after filter" do
 
         it "should automatically set the title from its name" do
-          page = FactoryGirl.create(:page, :name => 'My Testpage', :language => @language, :parent_id => @language_root.id)
+          page = 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 = 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 = 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 = 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 = 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 = FactoryGirl.create(:page, :name => 'A', :language => language, :parent_id => language_root.id)
           page.class.stamper_class.to_s.should == 'Alchemy::User'
         end
 
@@ -150,14 +147,14 @@ module Alchemy
       context "before/after filter" do
 
         it "should not set the title automatically if the name changed but title is not blank" do
-          page = FactoryGirl.create(:page, :name => 'My Testpage', :language => @language, :parent_id => @language_root.id)
+          page = FactoryGirl.create(:page, :name => 'My Testpage', :language => language, :parent_id => language_root.id)
           page.name = "My Renaming Test"
           page.save; page.reload
           page.title.should == "My Testpage"
         end
 
         it "should not automatically set the title if it changed its value" do
-          page = FactoryGirl.create(:page, :name => 'My Testpage', :language => @language, :parent_id => @language_root.id)
+          page = FactoryGirl.create(:page, :name => 'My Testpage', :language => language, :parent_id => language_root.id)
           page.title = "I like SEO"
           page.save; page.reload
           page.title.should == "I like SEO"
@@ -167,38 +164,34 @@ module Alchemy
 
     end
 
-    context "with children" do
+    describe '#first_public_child' do
 
-      before(:each) do
-        @first_child = FactoryGirl.create(:page, :name => "First child", :language => @language, :public => false, :parent_id => @language_root.id)
-        @first_child.move_to_child_of(@language_root)
+      before do
+        FactoryGirl.create(:page, :name => "First child", :language => language, :public => false, :parent_id => language_root.id)
+      end
 
-        @first_public_child = FactoryGirl.create(:page, :name => "First public child", :language => @language, :parent_id => @language_root.id, :public => true)
-        @first_public_child.move_to_child_of(@language_root)
+      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 "should return a page object (or nil if no public child exists) for first_public_child" do
-        if @language_root.children.any?
-          @language_root.first_public_child.should == @first_public_child
-        else
-          @language_root.first_public_child.should == nil
-        end
+      it "should return nil if no public child exists" do
+        language_root.first_public_child.should == nil
       end
 
     end
 
     context ".contentpages" do
 
-      before(:each) do
-        @klingonian = FactoryGirl.create(:language)
-        @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)
+      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)
       end
 
       it "should return a collection of contentpages" do
-        Page.contentpages.to_a.should include(@language_root, @klingonian_lang_root, @contentpage)
+        Page.contentpages.to_a.should include(language_root, @klingonian_lang_root, @contentpage)
       end
 
       it "should not contain pages with attribute :layoutpage set to true" do
@@ -214,8 +207,8 @@ module Alchemy
     context ".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)
+        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
 
@@ -224,22 +217,22 @@ module Alchemy
     context ".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)
+        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 ".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)
+        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
 
     context ".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)
+        FactoryGirl.create(:public_page, :name => 'First Public Child', :parent_id => language_root.id, :language => language)
         Page.language_roots.should have(1).pages
       end
     end
@@ -247,43 +240,43 @@ module Alchemy
 
     context ".layoutpages" do
       it "should return 1 layoutpage" do
-        FactoryGirl.create(:public_page, :layoutpage => true, :name => 'Layoutpage', :parent_id => @rootpage.id, :language => @language)
+        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)
+        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
 
     context ".accessible" 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)
+        FactoryGirl.create(:public_page, :name => 'First Public Child', :restricted => true, :parent_id => language_root.id, :language => language)
         Page.accessible.should have(2).pages
       end
     end
 
     context ".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)
+        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
+        page = FactoryGirl.create(:public_page, :locked => true)
+        page.unlock
+        page.locked.should == false
       end
     end
 
     describe "#cell_definitions" do
 
-      before(:each) 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"]}]
@@ -303,24 +296,27 @@ module Alchemy
 
     describe "#elements_grouped_by_cells" do
 
-      context "with no elements defined that are not defined in a cell" do
-        it "should not have a cell for 'other elements'" do
-          @page = FactoryGirl.build(:page, :page_layout => 'foo')
-          @page.stub!(:layout_description).and_return({'name' => "foo", 'cells' => ["foo_cell"], 'elements' => ["1", "2"]})
-          @cell_descriptions = [{'name' => "foo_cell", 'elements' => ["1", "2"]}]
-          Cell.stub!(:definitions).and_return(@cell_descriptions)
-          @page.elements_grouped_by_cells.keys.collect(&:name).should_not include('for_other_elements')
-        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"]
+        }])
+        @page = FactoryGirl.create(:public_page, :do_not_autogenerate => false)
       end
 
-      context "with elements defined that are not defined in a cell" do
-        it "should have a cell for 'other elements'" do
-          @page = FactoryGirl.build(:page, :page_layout => 'foo')
-          @page.stub!(:layout_description).and_return({'name' => "foo", 'cells' => ["foo_cell"], 'elements' => ["1", "2", "3"]})
-          @cell_descriptions = [{'name' => "foo_cell", 'elements' => ["1", "2"]}]
-          Cell.stub!(:definitions).and_return(@cell_descriptions)
-          @page.elements_grouped_by_cells.keys.collect(&:name).should include('for_other_elements')
-        end
+      it "should return elements grouped by cell" do
+        @page.elements_grouped_by_cells.keys.first.should be_instance_of(Cell)
+        @page.elements_grouped_by_cells.values.first.first.should be_instance_of(Element)
+      end
+
+      it "should only include elements beeing in a cell " do
+        @page.elements_grouped_by_cells.keys.should_not include(nil)
       end
 
     end
@@ -330,13 +326,13 @@ module Alchemy
       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 = 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)
+          Page.all_from_clipboard_for_select(clipboard, language.id).should include(page_1, page_2)
         end
 
       end
@@ -344,11 +340,11 @@ 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 = 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 == []
+          Page.all_from_clipboard_for_select(clipboard, language.id).should == []
         end
 
       end
@@ -356,13 +352,13 @@ 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 = 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]
+          Page.all_from_clipboard_for_select(clipboard, language.id).should == [page_1]
         end
 
       end
@@ -372,26 +368,30 @@ module Alchemy
     describe "validations" do
 
       context "saving a normal content page" do
+
         it "should be possible to save when its urlname already exists in the scope of global pages" do
-          @contentpage = FactoryGirl.create(:page, :urlname => "existing_twice")
-          @global_with_same_urlname = FactoryGirl.create(:page, :urlname => "existing_twice", :layoutpage => true)
-          @contentpage.title = "new Title"
-          @contentpage.save.should == true
+          contentpage = FactoryGirl.create(:page, :urlname => "existing_twice")
+          global_with_same_urlname = FactoryGirl.create(:page, :urlname => "existing_twice", :layoutpage => true)
+          contentpage.title = "new Title"
+          contentpage.save.should == true
         end
+
       end
 
       context "creating a normal content page" do
 
-        before(:each) do
-          @contentpage = FactoryGirl.build(:page, :parent_id => nil, :page_layout => nil)
+        before do
+          @contentpage = FactoryGirl.build(:page)
         end
 
         it "should validate the page_layout" do
+          @contentpage.page_layout = nil
           @contentpage.save
           @contentpage.should have(1).error_on(:page_layout)
         end
 
         it "should validate the parent_id" do
+          @contentpage.parent_id = nil
           @contentpage.save
           @contentpage.should have(1).error_on(:parent_id)
         end
@@ -400,7 +400,7 @@ module Alchemy
 
       context "creating the rootpage without parent_id and page_layout" do
 
-        before(:each) do
+        before do
           Page.delete_all
           @rootpage = FactoryGirl.build(:page, :parent_id => nil, :page_layout => nil, :name => 'Rootpage')
         end
@@ -414,7 +414,7 @@ module Alchemy
 
       context "saving a systempage" do
 
-        before(:each) do
+        before do
           @systempage = FactoryGirl.build(:systempage)
         end
 
@@ -431,8 +431,8 @@ module Alchemy
 
       context "a normal page" do
 
-        before(:each) do
-          @page = FactoryGirl.build(:page, :language_code => nil, :language => FactoryGirl.create(:language))
+        before do
+          @page = FactoryGirl.build(:page, :language_code => nil, :language => klingonian, :do_not_autogenerate => false)
         end
 
         it "should get the language code for language" do
@@ -445,9 +445,33 @@ module Alchemy
           @page.elements.should_not be_empty
         end
 
+        context "with cells" do
+
+          before do
+            @page.stub!(:definition).and_return({'name' => 'with_cells', 'cells' => ['header', 'main']})
+          end
+
+          it "should have the generated elements in their cells" do
+            @page.stub!(:cell_definitions).and_return([{'name' => 'header', 'elements' => ['article']}])
+            @page.save
+            @page.cells.where(:name => 'header').first.elements.should_not be_empty
+          end
+
+          context "and no elements in cell definitions" do
+
+            it "should have the elements in the nil cell" do
+              @page.stub!(:cell_definitions).and_return([{'name' => 'header', 'elements' => []}])
+              @page.save
+              @page.cells.collect(&:elements).flatten.should be_empty
+            end
+
+          end
+
+        end
+
         context "with children getting restricted set to true" do
 
-          before(:each) do
+          before do
             @page.save
             @child1 = FactoryGirl.create(:page, :name => 'Child 1', :parent_id => @page.id)
             @page.reload
@@ -464,7 +488,7 @@ module Alchemy
 
         context "with restricted parent gets created" do
 
-          before(:each) do
+          before do
             @page.save
             @page.parent.update_attributes(:restricted => true)
             @new_page = FactoryGirl.create(:page, :name => 'New Page', :parent_id => @page.id)
@@ -478,7 +502,7 @@ module Alchemy
 
         context "with do_not_autogenerate set to true" do
 
-          before(:each) do
+          before do
             @page.do_not_autogenerate = true
           end
 
@@ -493,7 +517,7 @@ module Alchemy
 
       context "a systempage" do
 
-        before(:each) do
+        before do
           @page = FactoryGirl.create(:systempage)
         end
 
@@ -511,16 +535,60 @@ module Alchemy
 
     describe '#fold' do
 
-      before(:each) do
-        @page = FactoryGirl.create(:public_page)
+      before do
         @user = FactoryGirl.create(:admin_user, :email => 'faz@baz.com', :login => 'foo_baz')
       end
 
       context "with folded status set to true" do
 
         it "should create a folded page for user" do
-          @page.fold(@user.id, true)
-          FoldedPage.find_or_create_by_user_id_and_page_id(@user.id, @page.id).should_not be_nil
+          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
+        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') }
+
+      before do
+        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
+
+      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