alchemy_cms 2.2.rc8 → 2.2.rc11

data/spec/integration/pages_controller_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 
 describe Alchemy::PagesController do
 
-  before(:each) do
+  before(:all) do
     @default_language = Alchemy::Language.get_default
     @default_language_root = FactoryGirl.create(:language_root_page, :language => @default_language, :name => 'Home')
   end
@@ -31,7 +31,7 @@ describe Alchemy::PagesController do
 
   describe "fulltext search" do
 
-    before(:each) do
+    before(:all) do
       @page = FactoryGirl.create(:public_page, :language => @default_language, :visible => true, :name => 'Page 1', :parent_id => @default_language_root.id)
       @element = FactoryGirl.create(:element, :name => 'article', :page => @page)
       FactoryGirl.create(:public_page, :language => @default_language, :name => 'Suche', :page_layout => 'search', :parent_id => @default_language_root.id)
@@ -145,7 +145,7 @@ describe Alchemy::PagesController do
 
       context "with url nesting" do
 
-        before(:each) do
+        before(:all) do
           @level1 = FactoryGirl.create(:public_page, :parent_id => @default_language_root.id, :name => 'catalog', :language => @default_language)
           @level2 = FactoryGirl.create(:public_page, :parent_id => @level1.id, :name => 'products', :language => @default_language)
           @level3 = FactoryGirl.create(:public_page, :parent_id => @level2.id, :name => 'screwdriver', :language => @default_language)
@@ -256,6 +256,27 @@ describe Alchemy::PagesController do
 
   describe "Handling of non-existing pages" do
 
+    context "when a language root page exists" do
+
+      before(:all) do
+        # We need an admin user, because otherwise we will be redirected to UserSessions controller to create a new user
+        FactoryGirl.create(:admin_user, :login => 'foo-boo', :email => 'foo@boo.org')
+      end
+
+      before(:each) do
+        visit "/alchemy/non-existing-page"
+      end
+
+      it "should render the status code in the title tag" do
+        within("title") { page.should have_content("404") }
+      end
+
+      it "should render the layout" do
+        page.should have_selector("#language_select")
+      end
+
+    end
+
     context "404-Errors are handled by Rails now, so no need to test anymore.
              However, it still serves as documentation how they can be handled, so we leave it here" do
 

data/spec/integration/security_spec.rb

@@ -2,13 +2,14 @@ require 'spec_helper'
 
 describe "Security: " do
 
-  context "If no user is present" do
+  before(:all) do
+    Alchemy::Page.root.children.destroy_all
+    Alchemy::User.delete_all
+    # ensuring that we have the correct locale here
+    ::I18n.locale = :en
+  end
 
-    before(:all) do
-      Alchemy::User.delete_all
-      # ensuring that we have the correct locale here
-      ::I18n.locale = :en
-    end
+  context "If no user is present" do
 
     it "render the signup view" do
       visit '/alchemy/'
@@ -19,7 +20,7 @@ describe "Security: " do
   context "If user is present" do
 
     before(:all) do
-      FactoryGirl.build(:admin_user).save_without_session_maintenance
+      create_admin_user
     end
 
     it "a visitor should not be able to signup" do
@@ -35,17 +36,16 @@ describe "Security: " do
     end
 
     context "that is already logged in" do
-      before(:all) do
-        visit '/alchemy/admin/login'
-        fill_in('alchemy_user_session_login', :with => 'jdoe')
-        fill_in('alchemy_user_session_password', :with => 's3cr3t')
-        click_on('Login')
+
+      before(:each) do
+        login_into_alchemy
       end
 
       it "should be redirected to dashboard" do
         visit '/alchemy/admin/login'
         current_path.should == '/alchemy/admin/dashboard'
       end
+
     end
 
   end

data/spec/libraries/resource_spec.rb

@@ -29,36 +29,34 @@ describe Alchemy::Resource do
   end
 
   describe "instance methods" do
-    before :each do
-      @resource = Alchemy::Resource.new("admin/events")
-    end
+      let(:resource) { Alchemy::Resource.new("admin/events") }
 
     describe "model" do
       it "returns resource's model-class" do
-        @resource.model.should be(Event)
+        resource.model.should be(Event)
       end
 
       describe "resources_name" do
         it "returns plural name (like events for model Event)" do
-          @resource.resources_name.should == 'events'
+          resource.resources_name.should == 'events'
         end
       end
 
       describe "model_name" do
         it "returns model_name (like event for model Event" do
-          @resource.model_name.should == 'event'
+          resource.model_name.should == 'event'
         end
       end
 
       describe "permission_scope" do
         it "should return the permissions_scope usable in declarative authorization" do
-          @resource.permission_scope.should == :admin_events
+          resource.permission_scope.should == :admin_events
         end
       end
 
       describe "namespace_for_scope" do
         it "returns a scope for use in url_for-based path-helpers" do
-          @resource.namespace_for_scope.should == ['admin']
+          resource.namespace_for_scope.should == ['admin']
         end
       end
 
@@ -76,24 +74,24 @@ describe Alchemy::Resource do
         end
 
         it "parses and returns the resource-model's attributes from ActiveRecord::ModelSchema" do
-          @resource.attributes.should == [{:name => "name", :type => :string}, {:name => "hidden_value", :type => :string}, {:name => "description", :type => :string}, {:name => "starts_at", :type => :datetime}]
+          resource.attributes.should == [{:name => "name", :type => :string}, {:name => "hidden_value", :type => :string}, {:name => "description", :type => :string}, {:name => "starts_at", :type => :datetime}]
         end
 
-        it "skips attributes mentioned in SKIP_ATTRIBUTES" do
-          @resource.attributes.should_not include({:name => "id", :type => :integer})
-          @resource.attributes.should include({:name => "hidden_value", :type => :string})
+        it "skips a set of default attributes (DEFAULT_SKIPPED_ATTRIBUTES)" do
+          resource.attributes.should_not include({:name => "id", :type => :integer})
+          resource.attributes.should include({:name => "hidden_value", :type => :string})
         end
 
-        it "should prefer SKIP_ATTRIBUTES in model if defined" do
-          Event.const_set :SKIP_ATTRIBUTES, %W[hidden_value]
-          @resource.attributes.should include({:name => "id", :type => :integer})
-          @resource.attributes.should_not include({:name => "hidden_value", :type => :string})
+        it "should skip attributes set via skip_attributes" do
+          resource.skip_attributes = %W[hidden_value]
+          resource.attributes.should include({:name => "id", :type => :integer})
+          resource.attributes.should_not include({:name => "hidden_value", :type => :string})
         end
 
         describe "searchable_attributes" do
           it "should return all attributes of type string" do
-            Event.const_set :SKIP_ATTRIBUTES, []
-            @resource.searchable_attributes.should == [{:name => "name", :type => :string}, {:name => "hidden_value", :type => :string}, {:name => "description", :type => :string}]
+            resource.skip_attributes = []
+            resource.searchable_attributes.should == [{:name => "name", :type => :string}, {:name => "hidden_value", :type => :string}, {:name => "description", :type => :string}]
           end
         end
       end

data/spec/models/page_spec.rb

@@ -2,481 +2,506 @@
 
 require 'spec_helper'
 
-describe Alchemy::Page do
+module Alchemy
+  describe Page do
 
-  before(:each) do
-    @rootpage = Alchemy::Page.root
-    @language = Alchemy::Language.get_default
-    @language_root = FactoryGirl.create(:language_root_page, :name => 'Default Language Root', :language => @language)
-  end
+    before(:all) 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
+
+    describe ".layout_description" do
 
-  describe ".layout_description" do
+      context "for a language root page" 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
 
-      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 == {}
+      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
       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
+    it "should contain one rootpage" do
+      Page.rootpage.should be_instance_of(Page)
     end
 
-  end
-
-  it "should contain one rootpage" do
-    Alchemy::Page.rootpage.should be_instance_of(Alchemy::Page)
-  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')
+    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 == Alchemy::Element.find_all_by_name('news')
-  end
+    context "finding elements" do
 
-  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)
+        ]
+      end
 
-    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)
-      ]
-    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
+      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
-    end
+      context "with show_non_public argument TRUE" do
 
-    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
+        end
 
-      it "should return all elements from empty options" do
-        @page.find_elements({}, true).all.should == @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
+        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
-      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
+        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
-      end
+        it "should return elements offsetted" do
+          @page.find_elements({:offset => 2}, true).all.should == @page.elements.offset(2)
+        end
 
-      it "should return elements offsetted" do
-        @page.find_elements({:offset => 2}, true).all.should == @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)
+        end
 
-      it "should return elements limitted in count" do
-        @page.find_elements({:count => 1}, true).all.should == @page.elements.limit(1)
       end
 
-    end
+      context "with show_non_public argument FALSE" do
 
-    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
+        end
 
-      it "should return all elements from empty arguments" do
-        @page.find_elements().all.should == @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
+        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
-      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
+        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
-      end
+        it "should return elements offsetted" do
+          @page.find_elements({:offset => 2}).all.should == @page.elements.published.offset(2)
+        end
 
-      it "should return elements offsetted" do
-        @page.find_elements({:offset => 2}).all.should == @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)
+        end
 
-      it "should return elements limitted in count" do
-        @page.find_elements({:count => 1}).all.should == @page.elements.published.limit(1)
       end
 
     end
 
-  end
+    describe '#create' do
 
-  describe '#create' do
+      context "before/after filter" 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 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 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" 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 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
 
-      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
 
     end
 
-  end
+    describe '#update' do
 
-  describe '#update' do
+      context "before/after filter" do
 
-    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.name = "My Renaming Test"
+          page.save; page.reload
+          page.title.should == "My Testpage"
+        end
 
-      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.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.title = "I like SEO"
+          page.save; page.reload
+          page.title.should == "I like SEO"
+        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.title = "I like SEO"
-        page.save; page.reload
-        page.title.should == "I like SEO"
       end
 
     end
 
-  end
-
-  context "with children" do
+    context "with children" 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)
-
-      @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)
-    end
+      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)
 
-    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
+        @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)
       end
-    end
-
-  end
 
-  context ".contentpages" do
+      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
+      end
 
-    before(:each) do
-      @klingonian = FactoryGirl.create(:language)
-      @layoutroot = Alchemy::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
-      Alchemy::Page.contentpages.to_a.should include(@language_root, @klingonian_lang_root, @contentpage)
-    end
+    context ".contentpages" do
 
-    it "should not contain pages with attribute :layoutpage set to true" do
-      Alchemy::Page.contentpages.to_a.select { |p| p.layoutpage == true }.should be_empty
-    end
+      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)
+      end
 
-    it "should contain pages with attribute :layoutpage set to nil" do
-      Alchemy::Page.contentpages.to_a.select { |p| p.layoutpage == nil }.should include(@klingonian_lang_root)
-    end
+      it "should return a collection of contentpages" do
+        Page.contentpages.to_a.should include(@language_root, @klingonian_lang_root, @contentpage)
+      end
 
-  end
+      it "should not contain pages with attribute :layoutpage set to true" do
+        Page.contentpages.to_a.select { |p| p.layoutpage == true }.should be_empty
+      end
 
-  context ".public" do
+      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
 
-    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)
-      Alchemy::Page.published.should have(3).pages
     end
 
-  end
+    context ".public" do
 
-  context ".not_locked" 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
 
-    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)
-      Alchemy::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)
-      Alchemy::Page.all_locked.should have(1).pages
-    end
-  end
+    context ".not_locked" do
 
-  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)
-      Alchemy::Page.language_roots.should have(1).pages
+      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
-  end
 
-
-  context ".layoutpages" do
-    it "should return 1 layoutpage" do
-      FactoryGirl.create(:public_page, :layoutpage => true, :name => 'Layoutpage', :parent_id => @rootpage.id, :language => @language)
-      Alchemy::Page.layoutpages.should have(1).pages
+    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
+      end
     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)
-      Alchemy::Page.visible.should have(1).pages
+    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)
+        Page.language_roots.should have(1).pages
+      end
     end
-  end
 
-  context ".accessable" do
-    it "should return 2 accessable pages" do
-      FactoryGirl.create(:public_page, :name => 'First Public Child', :restricted => true, :parent_id => @language_root.id, :language => @language)
-      Alchemy::Page.accessable.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)
-      Alchemy::Page.restricted.should have(1).pages
+    context ".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
-  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
+    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
+      end
     end
-  end
-
-  describe "#cell_definitions" do
 
-    before(:each) 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"]}]
-      Alchemy::Cell.stub!(:definitions).and_return(@cell_descriptions)
+    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)
+        Page.accessible.should have(2).pages
+      end
     end
 
-    it "should return all cell definitions for its page_layout" do
-      @page.cell_definitions.should == @cell_descriptions
+    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)
+        Page.restricted.should have(1).pages
+      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 == []
+    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
+      end
     end
 
-  end
+    describe "#cell_definitions" do
 
-  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
+      before(:each) do
         @page = FactoryGirl.build(:page, :page_layout => 'foo')
-        @page.stub!(:layout_description).and_return({'name' => "foo", 'cells' => ["foo_cell"], 'elements' => ["1", "2"]})
+        @page.stub!(:layout_description).and_return({'name' => "foo", 'cells' => ["foo_cell"]})
         @cell_descriptions = [{'name' => "foo_cell", 'elements' => ["1", "2"]}]
-        Alchemy::Cell.stub!(:definitions).and_return(@cell_descriptions)
-        @page.elements_grouped_by_cells.keys.collect(&:name).should_not include('for_other_elements')
+        Cell.stub!(:definitions).and_return(@cell_descriptions)
       end
-    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"]}]
-        Alchemy::Cell.stub!(:definitions).and_return(@cell_descriptions)
-        @page.elements_grouped_by_cells.keys.collect(&:name).should include('for_other_elements')
+      it "should return all cell definitions for its page_layout" do
+        @page.cell_definitions.should == @cell_descriptions
       end
-    end
-
-  end
-
-  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"}
-        ]
-        Alchemy::Page.all_from_clipboard_for_select(clipboard, @language.id).should == [page_1, page_2]
+      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
 
-    context "with clipboard holding a page having unique page layout" do
+    describe "#elements_grouped_by_cells" 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"}
-        ]
-        Alchemy::Page.all_from_clipboard_for_select(clipboard, @language.id).should == []
+      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
       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"}
-        ]
-        Alchemy::Page.all_from_clipboard_for_select(clipboard, @language.id).should == [page_1]
+      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
       end
 
     end
 
-  end
+    describe '.all_from_clipboard_for_select' do
+
+      context "with clipboard holding pages having non unique page layout" do
 
-  describe "validations" 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
 
-    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
       end
-    end
 
-    context "creating a normal content page" do
+      context "with clipboard holding a page having unique page layout" do
 
-      before(:each) do
-        @contentpage = FactoryGirl.build(:page, :parent_id => nil, :page_layout => nil)
-      end
+        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
 
-      it "should validate the page_layout" do
-        @contentpage.save
-        @contentpage.should have(1).error_on(:page_layout)
       end
 
-      it "should validate the parent_id" do
-        @contentpage.save
-        @contentpage.should have(1).error_on(:parent_id)
+      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
 
-    context "creating the rootpage without parent_id and page_layout" do
+    describe "validations" do
 
-      before(:each) do
-        Alchemy::Page.delete_all
-        @rootpage = FactoryGirl.build(:page, :parent_id => nil, :page_layout => nil, :name => 'Rootpage')
+      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
+        end
       end
 
-      it "should be valid" do
-        @rootpage.save
-        @rootpage.should be_valid
-      end
+      context "creating a normal content page" do
 
-    end
+        before(:each) do
+          @contentpage = FactoryGirl.build(:page, :parent_id => nil, :page_layout => nil)
+        end
 
-    context "saving a systempage" do
+        it "should validate the page_layout" do
+          @contentpage.save
+          @contentpage.should have(1).error_on(:page_layout)
+        end
 
-      before(:each) do
-        @systempage = FactoryGirl.build(:systempage)
-      end
+        it "should validate the parent_id" do
+          @contentpage.save
+          @contentpage.should have(1).error_on(:parent_id)
+        end
 
-      it "should not validate the page_layout" do
-        @systempage.save
-        @systempage.should be_valid
       end
 
-    end
+      context "creating the rootpage without parent_id and page_layout" do
 
-  end
-
-  describe 'before and after filters' do
+        before(:each) do
+          Page.delete_all
+          @rootpage = FactoryGirl.build(:page, :parent_id => nil, :page_layout => nil, :name => 'Rootpage')
+        end
 
-    context "a normal page" do
+        it "should be valid" do
+          @rootpage.save
+          @rootpage.should be_valid
+        end
 
-      before(:each) do
-        @page = FactoryGirl.build(:page, :language_code => nil, :language => FactoryGirl.create(:language))
       end
 
-      it "should get the language code for language" do
-        @page.save
-        @page.language_code.should == "kl"
-      end
+      context "saving a systempage" do
+
+        before(:each) do
+          @systempage = FactoryGirl.build(:systempage)
+        end
+
+        it "should not validate the page_layout" do
+          @systempage.save
+          @systempage.should be_valid
+        end
 
-      it "should autogenerate the elements" do
-        @page.save
-        @page.elements.should_not be_empty
       end
 
-      context "with children getting restricted set to true" do
+    end
+
+    describe 'before and after filters' do
+
+      context "a normal page" do
 
         before(:each) do
+          @page = FactoryGirl.build(:page, :language_code => nil, :language => FactoryGirl.create(:language))
+        end
+
+        it "should get the language code for language" do
           @page.save
-          @child1 = FactoryGirl.create(:page, :name => 'Child 1', :parent_id => @page.id)
-          @page.reload
-          @page.restricted = true
+          @page.language_code.should == "kl"
+        end
+
+        it "should autogenerate the elements" do
           @page.save
+          @page.elements.should_not be_empty
         end
 
-        it "should restrict all its children" do
-          @child1.reload
-          @child1.restricted?.should be_true
+        context "with children getting restricted set to true" do
+
+          before(:each) do
+            @page.save
+            @child1 = FactoryGirl.create(:page, :name => 'Child 1', :parent_id => @page.id)
+            @page.reload
+            @page.restricted = true
+            @page.save
+          end
+
+          it "should restrict all its children" do
+            @child1.reload
+            @child1.restricted?.should be_true
+          end
+
         end
 
-      end
+        context "with restricted parent gets created" do
 
-      context "with restricted parent gets created" do
+          before(:each) do
+            @page.save
+            @page.parent.update_attributes(:restricted => true)
+            @new_page = FactoryGirl.create(:page, :name => 'New Page', :parent_id => @page.id)
+          end
+
+          it "should also be restricted" do
+            @new_page.restricted?.should be_true
+          end
 
-        before(:each) do
-          @page.save
-          @page.parent.update_attributes(:restricted => true)
-          @new_page = FactoryGirl.create(:page, :name => 'New Page', :parent_id => @page.id)
         end
 
-        it "should also be restricted" do
-          @new_page.restricted?.should be_true
+        context "with do_not_autogenerate set to true" do
+
+          before(:each) do
+            @page.do_not_autogenerate = true
+          end
+
+          it "should not autogenerate the elements" do
+            @page.save
+            @page.elements.should be_empty
+          end
+
         end
 
       end
 
-      context "with do_not_autogenerate set to true" do
+      context "a systempage" do
 
         before(:each) do
-          @page.do_not_autogenerate = true
+          @page = FactoryGirl.create(:systempage)
+        end
+
+        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.save
           @page.elements.should be_empty
         end
 
@@ -484,22 +509,23 @@ describe Alchemy::Page do
 
     end
 
-    context "a systempage" do
+    describe '#fold' do
 
       before(:each) do
-        @page = FactoryGirl.create(:systempage)
+        @page = FactoryGirl.create(:public_page)
+        @user = FactoryGirl.create(:admin_user, :email => 'faz@baz.com', :login => 'foo_baz')
       end
 
-      it "should not get the language code for language" do
-        @page.language_code.should be_nil
-      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
+        end
 
-      it "should not autogenerate the elements" do
-        @page.elements.should be_empty
       end
 
     end
 
   end
-
 end