kuhsaft 0.3.6 → 1.0.0

data/spec/models/asset_spec.rb

@@ -1,39 +1,41 @@
 require 'spec_helper'
 
 describe Kuhsaft::Asset do
+
+  let :asset do
+    create(:asset)
+  end
+
+  let :uploader do
+    u = Kuhsaft::AssetUploader.new(asset, :file)
+    u.store!(File.open(File.join(Kuhsaft::Engine.root, 'spec', 'dummy', 'app', 'assets', 'images', 'spec-image.png')))
+    u
+  end
+
   before do
     Kuhsaft::AssetUploader.enable_processing = true
-    @asset = Factory(:asset)
-    @uploader = Kuhsaft::AssetUploader.new(@asset, :file)
-    @uploader.store!(File.open(File.join(Kuhsaft::Engine.root, 'spec', 'dummy', 'app', 'assets', 'images', 'spec-image.png')))
   end
-  
+
   after do
     Kuhsaft::AssetUploader.enable_processing = false
   end
-  
-  it 'should have a thumbnail' do
-    @uploader.should respond_to(:thumb)
+
+  it 'has a thumbnail' do
+    uploader.should respond_to(:thumb)
   end
-  
-  it "should make the image readable only to the owner and not executable" do
+
+  it "makes the image readable only to the owner and not executable" do
     pending 'how and where do we ensure permissions?'
-    @uploader.should have_permissions(0600)
+    uploader.should have_permissions(0600)
   end
-  
+
   describe '#file_type' do
-    it 'should have a file_type' do
-      @asset.should respond_to(:file_type)
+    it 'has a file_type' do
+      asset.should respond_to(:file_type)
     end
-    
-    it 'should be symbolized' do
-      @asset.file_type.should be_a(Symbol)
-    end
-  end
-  
-  describe '#name' do
-    it 'should have a name' do
-      @asset.should respond_to(:name)
+
+    it 'is symbolized' do
+      asset.file_type.should be_a(Symbol)
     end
   end
-end
+end

data/spec/models/brick_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe Kuhsaft::Brick do
+  let :brick do
+    Kuhsaft::Brick.new
+  end
+
+  describe '#valid?' do
+    it 'sets a default locale' do
+      brick.should_receive(:set_locale)
+      brick.valid?
+    end
+
+    it 'sets a default position' do
+      brick.should_receive(:set_position)
+      brick.valid?
+    end
+  end
+
+  describe '#set_position' do
+    context 'witout a position' do
+      it 'sets a default' do
+        brick.set_position
+        brick.position.should be(1)
+      end
+    end
+
+    context 'with a position' do
+      it 'does not change' do
+        brick.position = 3
+        expect { brick.set_position }.to_not change(brick, :position)
+      end
+    end
+  end
+
+  describe '#set_locale' do
+    context 'witout a locale' do
+      it 'sets a default' do
+        brick.set_locale
+        brick.locale.should == I18n.locale
+      end
+    end
+
+    context 'with a locale' do
+      it 'does not change' do
+        brick.locale = 'de'
+        expect { brick.set_locale }.to_not change(brick, :locale)
+      end
+    end
+  end
+
+  describe '#brick_list_type' do
+    it 'returns Kuhsaft::Brick' do
+      brick.brick_list_type.should == 'Kuhsaft::Brick'
+    end
+  end
+
+  describe '#parents' do
+    it 'returns the chain of parents' do
+      item1, item2, item3 = mock, mock, Kuhsaft::Brick.new
+      item2.stub(:brick_list).and_return(item1)
+      item3.stub(:brick_list).and_return(item2)
+      item3.parents.should == [item1, item2]
+    end
+  end
+
+  describe '#to_edit_partial_path' do
+    it 'returns the path to the form partial' do
+      Kuhsaft::TextBrick.new.to_edit_partial_path.should == 'kuhsaft/text_bricks/text_brick/edit'
+    end
+  end
+
+  describe '#to_edit_childs_partial_path' do
+    it 'returns the path to the form partial' do
+      Kuhsaft::TextBrick.new.to_edit_childs_partial_path.should == 'kuhsaft/text_bricks/text_brick/childs'
+    end
+  end
+
+  describe '#bricks' do
+    it 'can not have childs by default' do
+      brick.should_not respond_to(:bricks)
+    end
+  end
+
+  describe '#to_style_class' do
+    it 'returns a css classname' do
+      Kuhsaft::TextBrick.new.to_style_class.should == 'kuhsaft-text-brick'
+    end
+  end
+
+  describe '#to_style_id' do
+    it 'returns a unique DOM id' do
+      brick = Kuhsaft::TextBrick.new
+      brick.stub(:id).and_return(104)
+      brick.to_style_id.should == 'kuhsaft-text-brick-104'
+    end
+  end
+
+  describe '#backend_label' do
+    it 'returns the name of the brick' do
+      brick =  Kuhsaft::TextBrick.new
+      brick.backend_label.should == 'Text'
+    end
+
+    context 'with the parenthesis option given' do
+      brick = Kuhsaft::TextBrick.new
+      brick.backend_label(:parenthesis => true).should == '(Text)'
+    end
+  end
+end

data/spec/models/cms/admin_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Kuhsaft::Cms::Admin do
+
+  let :admin do
+    Kuhsaft::Cms::Admin.new
+  end
+
+  describe '#admin?' do
+    it 'is true and the default' do
+      admin.admin?.should be_true
+    end
+  end
+
+  describe '#editor?' do
+    it 'is false' do
+      admin.editor?.should be_false
+    end
+  end
+
+  describe '#author?' do
+    it 'is false' do
+      admin.author?.should be_false
+    end
+  end
+end

data/spec/models/column_brick_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Kuhsaft::ColumnBrick do
+
+  let :column_brick do
+    Kuhsaft::ColumnBrick.new
+  end
+
+  describe '#user_can_delete?' do
+    it 'returns false' do
+      column_brick.user_can_delete?.should be_false
+    end
+  end
+
+  describe '#user_can_save' do
+    it 'returns false' do
+      column_brick.user_can_save?.should be_false
+    end
+  end
+
+  describe '#renders_own_childs?' do
+    it 'returns false' do
+      column_brick.renders_own_childs?.should be_false
+    end
+  end
+
+  describe '#bricks' do
+    it 'can have childs' do
+      column_brick.should respond_to(:bricks)
+    end
+  end
+end

data/spec/models/image_brick_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Kuhsaft::ImageBrick do
+
+  let :image_brick do
+    Kuhsaft::ImageBrick.new
+  end
+
+  describe '#valid' do
+    before do
+      image_brick.valid?
+    end
+
+    context 'without an #image' do
+      it 'has en error' do
+        image_brick.should have(1).error_on(:image)
+      end
+    end
+  end
+
+  describe '#save' do
+    context 'when changing the image size' do
+      it 'regenerates the image version' do
+        image_brick.stub(:image_size_changed?).and_return(true)
+        image_brick.image.should_receive(:recreate_versions!)
+        image_brick.resize_image_if_size_changed
+      end
+    end
+  end
+
+  describe '#bricks' do
+    it 'can not have childs' do
+      image_brick.should_not respond_to(:bricks)
+    end
+  end
+end

data/spec/models/image_size_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Kuhsaft::ImageSize do
+  before do
+    Kuhsaft::ImageSize.build_defaults!
+  end
+
+  describe '.build_defaults!' do
+    it 'sets the default sizes' do
+      Kuhsaft::ImageSize.all.should == [Kuhsaft::ImageSize.gallery_size,
+                                        Kuhsaft::ImageSize.teaser_size]
+    end
+  end
+
+  describe '.clear!' do
+    before do
+      Kuhsaft::ImageSize.clear!
+    end
+
+    it 'empties the list' do
+      Kuhsaft::ImageSize.all.should be_empty
+    end
+  end
+
+  describe '.add' do
+    it 'adds a new image size' do
+      expect { Kuhsaft::ImageSize.add(:stuff, 200, 100) }.to change(Kuhsaft::ImageSize.all, :count).by(1)
+    end
+  end
+
+  describe '.find_by_name' do
+    it 'returns the size' do
+      Kuhsaft::ImageSize.find_by_name('gallery').should == Kuhsaft::ImageSize.gallery_size
+    end
+  end
+end

data/spec/models/link_brick_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Kuhsaft::LinkBrick do
+
+  let :link_brick do
+    Kuhsaft::LinkBrick.new
+  end
+
+  describe '#valid' do
+    before do
+      link_brick.valid?
+    end
+
+    context 'without a #href' do
+      it 'has en error' do
+        link_brick.should have(1).error_on(:href)
+      end
+    end
+
+    context 'without a #caption' do
+      it 'has an error' do
+        link_brick.should have(1).error_on(:caption)
+      end
+    end
+  end
+
+  describe '#bricks' do
+    it 'can not have childs' do
+      link_brick.should_not respond_to(:bricks)
+    end
+  end
+
+  describe '.styles' do
+    it 'returns the available link styles' do
+      Kuhsaft::LinkBrick.styles.should == %w(pdf word excel button external)
+    end
+  end
+
+  describe '#to_style_class' do
+    it 'includes the link style' do
+      link_brick.stub(:link_style).and_return('pdf')
+      link_brick.to_style_class.should == 'kuhsaft-link-brick pdf'
+    end
+  end
+end

data/spec/models/page_spec.rb

@@ -1,331 +1,312 @@
 require 'spec_helper'
 
 describe Kuhsaft::Page do
-  
-  before do
-    set_lang :en
+  subject { described_class }
+
+  describe '.search' do
+    before do
+      create :page
+      create :page
+      create :page
+    end
+
+    it 'should find any containing the search term' do
+      Kuhsaft::Page.search('lorem').should have_at_least(0).items
+    end
+
+    it 'should find with "English Title"' do
+      Kuhsaft::Page.search('English Title').should have_at_least(1).item
+    end
+
+    it 'should only find published results' do
+      Kuhsaft::Page.search('English Title').should be_all { |p| p.published? == true }
+    end
   end
-  
-  after do
-    reset_lang
+
+  describe '.position_of' do
+    it 'should find the position of a page' do
+      page = create(:page)
+      Kuhsaft::Page.position_of(page.id).should == page.position
+    end
   end
-  
-  before :each do 
-    destroy_all_pages
-    @page = Factory.create :page
+
+  describe '.find_by_url' do
+    it 'should find its translated content by url' do
+      page = create(:page)
+      Kuhsaft::Page.find_by_url(page.url).should eq(page)
+    end
+  end
+
+  describe '.flat_tree' do
+    it 'should create an ordered, flat list of the page tree' do
+      tree = create_page_tree
+      Kuhsaft::Page.flat_tree.should eq(tree)
+    end
   end
-  
-  describe 'associations' do
-    describe '#localized_pages' do
-      it 'should have localized_pages' do
-        @page.should respond_to(:localized_pages)
+
+  describe '#initialize' do
+    context 'without values' do
+      let :page do
+        Kuhsaft::Page.new
       end
-      
-      it 'should have at least 1 localized page' do
-        @page.localized_pages.should have_at_least(1).item
+
+      before do
+        page.valid?
       end
-    end
-    
-    describe '#childs' do
-      it 'should have child pages' do
-        @page.childs << Factory.create(:page)
-        @page.childs.should have_at_least(1).page
+
+      it 'has a mandatory title' do
+        page.should have(1).error_on(:title)
+      end
+
+      it 'has a mandatory slug' do
+        page.should have(1).error_on(:slug)
       end
     end
   end
-  
-  describe 'class methods' do
-    describe '#root_pages' do
-      before { destroy_all_pages }            
-      it 'should have a list of the toplevel pages' do
-        root_page = Factory.create :page
-        Kuhsaft::Page.root_pages.should have_at_least(1).page
-      end
+
+  describe '#published' do
+    it 'returns only published pages' do
+      p1, p2, p3 = 3.times.map { create(:page) }
+      p2.update_attribute :published, Kuhsaft::PublishState::UNPUBLISHED
+      Kuhsaft::Page.published.should be_all { |p| p.published?.should be_true }
     end
-    
-    describe '#position_of' do
-      it 'should find the position of a page' do
-        page = Factory.create :page
-        position = page.position
-        Kuhsaft::Page.position_of(page.id).should == position
-      end
+  end
+
+  describe '#without_self' do
+    it 'returns pages but not itself' do
+      2.times { create(:page) }
+      page = Kuhsaft::Page.first
+      page.without_self.should_not include(page)
     end
-    
-    describe '#find_by_url' do
-      before { destroy_all_pages }
-      it 'should find its translated content by url' do
-        page = Factory.create(:page)
-        Kuhsaft::Page.find_by_url(page.url).should eq(page)
-      end
+  end
+
+  describe '#nesting_name' do
+    let :page do
+      create(:page)
     end
-    
-    describe '#flat_tree' do
-      before { destroy_all_pages }
-      it 'should create an ordered, flat list of the page tree' do
-        tree = create_page_tree
-        Kuhsaft::Page.flat_tree.should eq(tree)
-      end
+
+    let :child_page do
+      create(:page, :parent => page)
     end
-    
-    describe '#published' do
-      before { destroy_all_pages }
-      it 'should get only published pages' do
-        p1, p2, p3 = 3.times.map { Factory.create :page }
-        p2.translation.update_attribute :published, Kuhsaft::PublishState::UNPUBLISHED
-        Kuhsaft::Page.published.should be_all { |p| p.published?.should be_true }
-        Kuhsaft::Page.published.length.should be(2)
-      end
+
+    let :child_child_page do
+      create(:page, :parent => child_page)
     end
-    
-    describe '#current_locale' do
-      before { destroy_all_pages }
-      it 'should only return pages with translations in the current locale' do
-        p1 = Factory.create :page
-        p1.translation.update_attribute :locale, :fr
-        p2 = Factory.create :page
-        p2.translation.update_attribute :locale, :fr
-        p3 = Factory.create :page
-        Kuhsaft::Page.current_translation_locale = :fr
-        Kuhsaft::Page.current_locale.should have(2).items
-        Kuhsaft::Page.current_translation_locale = :en
+
+    context 'on the topmost level' do
+      it 'has a label representing it\'s nesting depth without a leading dash' do
+        page.nesting_name.should eq(page.title)
       end
     end
-    
-    describe 'languages and locales' do
-      describe '#translation_locales' do
-        it 'should provide an array of translation locales' do
-          Kuhsaft::Page.translation_locales.should be_an_instance_of(Array)
-        end
-        
-        it 'should contain :en as minimal translation locale' do
-          Kuhsaft::Page.translation_locales.include?(:en).should be_true
-        end
-        
-        it 'should contain only locale symbols' do
-          Kuhsaft::Page.translation_locales = ['de']
-          Kuhsaft::Page.translation_locales.should be_all { |l| l.should be_an_instance_of(Symbol)}
-        end
+
+    context 'on the first level' do
+      it 'should have a label with one dash' do
+        child_page.nesting_name.should eq("- #{child_page.title}")
       end
-      
-      describe '#current_translation_locale' do
-        it 'should have the current translation locale' do
-          Kuhsaft::Page.current_translation_locale = 'de'
-          Kuhsaft::Page.current_translation_locale.should be(:de)
-        end
+    end
+
+    context 'on the second level' do
+      it 'should have a label with two dashes' do
+        child_child_page.nesting_name.should eq("-- #{child_child_page.title}")
       end
     end
   end
-  
-  describe 'instance methods' do
-    describe '#root?' do
-      it 'should return true for a page without a parent' do
-        Factory::create(:page).root?.should be_true
-      end
+
+  describe '#parent_pages' do
+    let :page do
+      create(:page)
     end
-    
-    describe '#without_self' do
-      it 'should return pages but not itself' do
-        10.times { Factory.create :page }
-        page = Kuhsaft::Page.first
-        page.without_self.should_not include(page)
-      end
-      after { destroy_all_pages }
+
+    let :child_page do
+      create(:page, :parent => page)
     end
-    
-    describe '#nesting_name' do
-      before do
-        @p1, @p2, @p3 = create_page_tree
-      end
-      
-      context 'on the topmost level' do
-        it 'should have a label representing it\'s nesting depth without a leading dash' do
-          @p1.nesting_name.should eq('English Title 1')
-        end
-      end
-      
-      context 'on the first level' do
-        it 'should have a label with one dash' do
-          @p2.nesting_name.should eq('- English Title 2')
-        end
-      end
-      
-      context 'on the second level' do 
-        it 'should have a label with two dashes' do
-          @p3.nesting_name.should eq('-- English Title 3')
-        end
-      end      
-    end
-    
-    describe '#siblings' do
-      it 'should know it\'s siblings' do
-        Factory.create(:page).should respond_to(:siblings)
-      end
-      
-      it 'should be a list of pages' do
-        Factory.create(:page).siblings.should be_all { |p| p.should be_an_instance_of(Kuhsaft::Page) }
-      end
+
+    it 'has a list of parent pages' do
+      child_page.parent_pages.should == [page]
     end
-    
-    describe '#parent' do
-      before do
-        @page = Factory::create :page
-        @child = Factory::create :page
-        @page.childs << @child
-      end
-      
-      it 'should know it\'s parent page' do
-        @child.should respond_to(:parent)
-      end
-      
-      it 'should be a Kuhsaft::Page' do
-        @child.parent.should be_an_instance_of(Kuhsaft::Page)
-      end
+
+    it 'is ordered from top to bottom' do
+      child_page.parent_pages.last.should == page
     end
-    
-    describe '#translation' do
-      it 'should have a translation' do
-        @page.should respond_to(:translation)
-      end
-      
-      it 'should return a Kuhsaft::LocalizedPage' do
-        @page.translation.should be_an_instance_of(Kuhsaft::LocalizedPage)
-      end
-      
-      context 'when saving the page' do
-        it 'should save the translation' do
-          @page.translation.title = 'some localized title'
-          @page.should_receive(:save_translation)
-          @page.save
-        end
+  end
+
+  describe '#link' do
+    context 'when it has no content' do
+      it 'should return the link of it\'s first child' do
+        page = create(:page)
+        child = create(:page, :parent => page)
+        page.body = nil
+        page.save
+        page.link.should == child.link
       end
     end
-    
-    describe '#page_part_type' do
-      it 'accepts a page_part_type to determine which page_part needs to be added' do
-        @page.should respond_to(:page_part_type)
-      end
+  end
+
+  describe '#increment_position' do
+    it 'increments the position by 1' do
+      page = create :page
+      position = page.position
+      page.increment_position
+      page.position.should == (position + 1)
     end
-    
-    describe '#parent_pages' do
-      it 'should have parent_pages' do
-        @page.should respond_to(:parent_pages)
-      end
-    
-      it 'should have a list of parent pages' do
-        @page.parent_pages.should be_instance_of(Array)
-      end
-    
-      it 'should be ordered from top to bottom' do
-        @page.parent_pages.last.should be(@page)
-      end
+  end
+
+  describe '#decrement_position' do
+    it 'decrements the position by 1' do
+      page = create :page
+      position = page.position
+      page.decrement_position
+      page.position.should == (position - 1)
     end
-    
-    describe '#link' do
-      it 'should have a link' do
-        @page.should respond_to(:link)
-      end
-      
-      context 'when it has no content' do
-        it 'should return the link of it\'s first child' do
-          page = Factory.create :page
-          child = Factory.create :page
-          page.childs << child
-          page.translation.body = nil
-          page.save
-          page.link.should == child.link
-        end
-      end
+  end
+
+  describe '#preceding_sibling' do
+    it 'finds the predecing sibling' do
+      page1 = create :page
+      page2 = create :page
+      page3 = create :page
+      page3.preceding_sibling.id.should == page2.id
     end
   end
-  
-  describe 'custom ordering' do
-    describe '#increment_position' do
-      it 'should increment it\'s position by 1' do
-        page = Factory.create :page
-        position = page.position
-        page.increment_position
-        page.position.should == (position + 1)
-      end
+
+  describe '#succeeding_sibling' do
+    it 'finds the succeeding sibling' do
+      page1 = create :page
+      page2 = create :page
+      page3 = create :page
+      page2.succeeding_sibling.id.should == page3.id
     end
-    
-    describe '#decrement_position' do
-      it 'should decrement it\'s position by 1' do
-        page = Factory.create :page
-        position = page.position
-        page.decrement_position
-        page.position.should == (position - 1)
-      end
+  end
+
+  describe '#reposition' do
+    it 'repositions before a page, specified by id' do
+      page1 = create :page
+      page2 = create :page
+      page3 = create :page
+      page3.reposition page1.id
+      page3.preceding_sibling.id.should == page1.id
     end
-    
-    describe '#preceding_sibling' do
-      it 'should find the predecing sibling' do
-        page1 = Factory.create :page
-        page2 = Factory.create :page
-        page3 = Factory.create :page
-        page3.preceding_sibling.id.should == page2.id
-      end
+
+    it 'repositions before all siblings, specified by nil' do
+      page1 = create :page
+      page2 = create :page
+      page2.reposition nil
+      page2.position.should == 1
+    end
+  end
+
+  describe '#slug' do
+    let :page do
+      build(:page)
+    end
+
+    it 'has a slug by default' do
+      page.save
+      page.slug.should eq(page.title.parameterize)
     end
-    
-    describe '#succeeding_sibling' do
-      it 'should find the succeeding sibling' do
-        page1 = Factory.create :page
-        page2 = Factory.create :page
-        page3 = Factory.create :page
-        page2.succeeding_sibling.id.should == page3.id
+
+    context 'when it is empty' do
+      it 'generates the slug' do
+        page.should_receive(:create_slug)
+        page.save
       end
     end
-    
-    describe '#reposition' do
-      it 'should reposition before a page, specified by id' do
-        page1 = Factory.create :page
-        page2 = Factory.create :page
-        page3 = Factory.create :page
-        page3.reposition page1.id
-        page3.preceding_sibling.id.should == page1.id
+
+    context 'when it is not empty' do
+      it 'takes the slug provided by the user' do
+        page.slug = 'my-slug'
+        page.save
+        page.slug.should == 'my-slug'
       end
-    
-      it 'should reposition before all siblings, specified by nil' do
-        page1 = Factory.create :page
-        page2 = Factory.create :page
-        page2.reposition nil
-        page2.position.should == 1
+    end
+  end
+
+  describe '#url' do
+    context 'when it is a normal page' do
+      it 'returns the concatenated slug of the whole child/parent tree' do
+        page = create(:page, :slug => 'parent-slug', :page_type => '')
+        child = create(:page, :slug => 'child-slug', :page_type => '', :parent => page)
+        child.url.should == 'en/parent-slug/child-slug'
       end
     end
-    
-    describe '#siblings' do
-      pending 'describe'
+
+    context 'when it is a navigation? page' do
+      it 'returns without the parent page slug' do
+        page = create(:page, :slug => 'parent-slug', :page_type => Kuhsaft::PageType::NAVIGATION)
+        child = create(:page, :slug => 'child-slug', :page_type => '', :parent => page)
+        child.url.should == 'en/child-slug'
+      end
     end
-    
-    describe '#position_to_top' do
-      pending 'describe'
+
+    context 'when it is a redirect? page' do
+      it 'returns the plain url' do
+        page = create(:page, :page_type => Kuhsaft::PageType::REDIRECT, :url => '/en/news')
+        page.link.should eq('/en/news')
+      end
     end
-    
-    describe '#recount_siblings_position_from' do
-      pending 'describe'
+  end
+
+  describe '#navigation?' do
+    context 'when the page_type is navigation' do
+      it 'returns true if the page_type is PageType::NAVIGATION' do
+        Kuhsaft::Page.new(:page_type => Kuhsaft::PageType::NAVIGATION).navigation?.should be_true
+      end
     end
-    
-    describe '#reposition' do
-      pending 'describe'
+
+    context 'when the page_type is anything else' do
+      it 'returns false' do
+        Kuhsaft::Page.new(:page_type => Kuhsaft::PageType::REDIRECT).navigation?.should be_false
+      end
     end
-    
-    describe '#set_position' do
-      pending
-    end    
   end
-  
-  describe 'should delegate' do
-    it 'slug, title, published, published?, page_type, fulltext, keywords, page_parts and description to the translation' do
-      [:slug, :title, :published, :published?, :page_type, :fulltext, :keywords, :page_parts, :description].each do |attr|
-        @page.send(attr).should eq(@page.translation.send(attr))
+
+  describe '#redirect?' do
+    context 'when the page_type is a redirect' do
+      it 'returns true' do
+        Kuhsaft::Page.new(:page_type => Kuhsaft::PageType::REDIRECT).redirect?.should be_true
+      end
+    end
+
+    context 'when the page type is anything else' do
+      it 'returns false' do
+        Kuhsaft::Page.new(:page_type => Kuhsaft::PageType::NAVIGATION).redirect?.should be_false
       end
     end
-    
-    it 'url to the translation' do
-      @page.url.should eq(@page.translation.url)
+  end
+
+  describe '#fulltext' do
+    let :page do
+      p = create(:page, :keywords => 'key words', :description => 'descrip tion', :title => 'my title')
+      p.bricks << Kuhsaft::TextBrick.new(:locale => I18n.locale, :text => 'oh la la')
+      p.save
+      p
     end
-    
-    it 'locale to the translation' do
-      @page.locale.should be(@page.translation.locale)
+
+    context 'when saved' do
+      it 'it collects and assigns the fulltext' do
+        page.should_receive(:collect_fulltext)
+        page.save
+      end
+
+      it 'contains the title' do
+        page.fulltext.should include('my title')
+      end
+
+      it 'contains the keywords' do
+        page.fulltext.should include('key words')
+      end
+
+      it 'contains the description' do
+        page.fulltext.should include('descrip tion')
+      end
+
+      it 'contains the page part content' do
+        page.fulltext.should include('oh la la')
+      end
+
+      it 'converts all data to strings' do
+        expect { page.collect_fulltext }.to_not raise_error
+      end
     end
   end
-end
+end