qbrick 2.5.0.pre

data/spec/models/brick_type_filter_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Kuhsaft::BrickTypeFilter do
+  let :brick_list do
+    Kuhsaft::Page.new
+  end
+
+  let :brick_type_filter do
+    Kuhsaft::BrickTypeFilter.new(brick_list)
+  end
+
+  describe '#empty?' do
+    context 'when the user cant add childs' do
+      before do
+        brick_list.stub(:user_can_add_childs?).and_return(false)
+      end
+
+      it 'returns true' do
+        brick_type_filter.empty?.should be_true
+      end
+    end
+
+    context 'when there are no bricks to be added' do
+      before do
+        brick_type_filter.stub(:allowed).and_return([])
+      end
+
+      it 'returns true' do
+        brick_type_filter.empty?.should be_true
+      end
+    end
+  end
+
+  describe '#allowed' do
+    context 'when no brick types are registered' do
+      it 'returns an empty array' do
+        Kuhsaft::BrickType.stub_chain(:count, :zero?).and_return(true)
+        brick_type_filter.allowed.should be_empty
+      end
+    end
+
+    context 'when brick types are registered' do
+      before do
+        Kuhsaft::BrickType.stub_chain(:enabled, :count, :zero?).and_return(false)
+      end
+
+      context 'when there are no constraints' do
+        it 'returns all enabled brick types' do
+          brick_list.stub(:allowed_brick_types).and_return([])
+          Kuhsaft::BrickType.should_receive(:enabled)
+          brick_type_filter.allowed
+        end
+      end
+
+      context 'when there are constraints' do
+        it 'constrains the enabled types' do
+          brick_list.stub(:allowed_brick_types).and_return(['Kuhsaft::TextBrick'])
+          Kuhsaft::BrickType.enabled.should_receive(:constrained).with(['Kuhsaft::TextBrick'])
+          brick_type_filter.allowed
+        end
+      end
+    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,49 @@
+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.stub(:image_present?).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
+
+  describe '#user_can_add_childs?' do
+    it 'returns false' do
+      image_brick.user_can_add_childs?.should be_false
+    end
+  end
+
+  describe '#uploader?' do
+    it 'returns true' do
+      image_brick.uploader?.should be_true
+    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,51 @@
+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
+
+  describe '#user_can_add_childs?' do
+    it 'returns false' do
+      link_brick.user_can_add_childs?.should be_false
+    end
+  end
+end

data/spec/models/page_spec.rb

@@ -0,0 +1,472 @@
+require 'spec_helper'
+
+describe Kuhsaft::Page do
+  # subject { described_class }
+
+  describe '.search' do
+    before do
+      3.times { 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
+
+    it 'should find by using the old api' do
+      Kuhsaft::Page.search('English').should == Kuhsaft::Page.search('English')
+    end
+  end
+
+  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
+
+  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 '#initialize' do
+    context 'without values' do
+      let :page do
+        Kuhsaft::Page.new
+      end
+
+      before do
+        page.valid?
+      end
+
+      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 '#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
+  end
+
+  describe '#content_page' do
+    it 'returns only content pages' do
+      p1, p2, p3 = 3.times.map { create(:page) }
+      p2.update_attribute :page_type, Kuhsaft::PageType::REDIRECT
+      Kuhsaft::Page.content_page.should == [p1, p3]
+    end
+  end
+
+  describe '#state_class' do
+
+    let(:page) { Kuhsaft::Page.new }
+
+    it 'returns publsihed as string when page is published' do
+      page.published = Kuhsaft::PublishState::PUBLISHED
+      expect(page.state_class).to eq 'published'
+    end
+
+    it 'returns unpublsihed as string when page is unpublished' do
+      page.published = Kuhsaft::PublishState::UNPUBLISHED
+      expect(page.state_class).to eq 'unpublished'
+    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
+  end
+
+  describe '#nesting_name' do
+    let :page do
+      create(:page)
+    end
+
+    let :child_page do
+      create(:page, parent: page)
+    end
+
+    let :child_child_page do
+      create(:page, parent: child_page)
+    end
+
+    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
+
+    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
+    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 '#parent_pages' do
+    let :page do
+      create(:page)
+    end
+
+    let :child_page do
+      create(:page, parent: page)
+    end
+
+    it 'has a list of parent pages' do
+      child_page.parent_pages.should == [page]
+    end
+
+    it 'is ordered from top to bottom' do
+      child_page.parent_pages.last.should == page
+    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
+  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
+  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
+  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 '#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
+  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
+
+    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
+
+    context 'when it is empty' do
+      it 'generates the slug' do
+        page.should_receive(:create_slug)
+        page.save
+      end
+    end
+
+    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
+    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')
+        child = create(:page, slug: 'child-slug', parent: page)
+        child.url.should == 'en/parent-slug/child-slug'
+      end
+    end
+
+    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', parent: page)
+        child.url.should == 'en/child-slug'
+      end
+    end
+
+    context 'when it is a redirect? page' do
+      it 'returns the absolute url' do
+        page = create(:page, page_type: Kuhsaft::PageType::REDIRECT, redirect_url: 'en/references', slug: 'news')
+        page.link.should eq('/en/news')
+      end
+    end
+
+    context 'when url part is empty' do
+      it 'strips the trailing slash' do
+        page = create(:page, page_type: Kuhsaft::PageType::NAVIGATION)
+        page.link.should eq('/en')
+      end
+    end
+  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
+
+    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
+  end
+
+  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
+  end
+
+  describe 'page types' do
+    it 'returns content by default' do
+      expect(Kuhsaft::Page.new.page_type).to eq('content')
+    end
+
+    it 'returns navigation if set' do
+      expect(Kuhsaft::Page.new(page_type: Kuhsaft::PageType::NAVIGATION).page_type).to eq('navigation')
+    end
+
+    it 'returns redirect if set' do
+      expect(Kuhsaft::Page.new(page_type: Kuhsaft::PageType::REDIRECT).page_type).to eq('redirect')
+    end
+  end
+
+  describe '#translated?' do
+    it 'returns true when page is translated' do
+      @page = create(:page, title: 'Page 1', slug: 'page1')
+      expect(@page.translated?).to be_true
+    end
+
+    it 'returns false when page has no translation' do
+      @page = create(:page, title: 'Page 1', slug: 'page1')
+      I18n.with_locale :de do
+        expect(@page.translated?).to be_false
+      end
+    end
+  end
+
+  describe '#fulltext' do
+    let :page do
+      create(:page, keywords: 'key words', description: 'descrip tion', title: 'my title').tap do |p|
+        p.bricks << Kuhsaft::TextBrick.new(locale: I18n.locale, text: 'oh la la')
+        p.save
+      end
+    end
+
+    context 'when saved' do
+      it 'it collects and assigns the fulltext' do
+        page.should_receive(:collect_fulltext)
+        page.save
+      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
+
+  describe '#before_validation' do
+    it 'generates url automatically' do
+      page = Kuhsaft::Page.new slug: 'slug'
+      page.url.should be_nil
+      page.valid?
+      page.url.should be_present
+    end
+  end
+
+  describe '#after_save' do
+    context 'when updating a parents page type' do
+      it 'updates the child pages url if parent is changed to navigation' do
+        @parent_page = FactoryGirl.create(:page, slug: 'le_parent')
+        @child_page = FactoryGirl.create(:page, slug: 'le_child', parent: @parent_page)
+
+        @parent_page.update_attributes(page_type: Kuhsaft::PageType::NAVIGATION)
+        @child_page.reload.url.should eq("#{I18n.locale}/le_child")
+      end
+
+      it 'updates the child pages url if parent is changed to content' do
+        @parent_page = FactoryGirl.create(:page, slug: 'le_parent', page_type: Kuhsaft::PageType::NAVIGATION)
+        @child_page = FactoryGirl.create(:page, slug: 'le_child', parent: @parent_page)
+
+        @parent_page.update_attributes(page_type: Kuhsaft::PageType::CONTENT)
+        @child_page.reload.url.should eq("#{I18n.locale}/le_parent/le_child")
+      end
+    end
+  end
+
+  describe '#url_without_locale' do
+    let :page do
+      create(:page, slug: 'page')
+    end
+
+    context 'without parent' do
+      it 'returns url without leading /' do
+        page.url_without_locale.should_not start_with '/'
+      end
+
+      it 'returns a single slug' do
+        page.url_without_locale.should == 'page'
+      end
+    end
+
+    context 'when parent is navigation' do
+      let :parent do
+        create(:page, page_type: Kuhsaft::PageType::NAVIGATION)
+      end
+
+      let :child do
+        create(:page, slug: 'child', parent: parent)
+      end
+
+      it 'returns url without leading /' do
+        child.url_without_locale.should_not start_with '/'
+      end
+
+      it 'does not concatenate the parent slug' do
+        child.url_without_locale.should == 'child'
+      end
+    end
+
+    context 'when parent is normal page' do
+      let :parent do
+        create(:page, slug: 'parent')
+      end
+
+      let :child do
+        create(:page, slug: 'child', parent: parent)
+      end
+
+      it 'returns url without leading /' do
+        child.url_without_locale.should_not start_with '/'
+      end
+
+      it 'does not concatenate the parent slug' do
+        child.url_without_locale.should == 'parent/child'
+      end
+    end
+  end
+
+  describe '#translated' do
+    before :each do
+      @page_1 = create(:page, title: 'Page 1', slug: 'page1')
+      @page_2 = create(:page, title: 'Page 2', slug: 'page1')
+      @page_3 = create(:page, title: 'Page 3', slug: 'page1')
+    end
+
+    it 'returns all pages that have a translation' do
+      expect(Kuhsaft::Page.translated).to eq [@page_1, @page_2, @page_3]
+    end
+
+    it 'does not return untranslated pages' do
+      I18n.with_locale :de do
+        @page_1.update(title: 'Page 1 fr', slug: 'page_1_fr')
+        expect(Kuhsaft::Page.translated).to eq [@page_1]
+      end
+    end
+  end
+
+  describe '#identifier' do
+    let(:cat_page) { create :page, identifier: 'cat_content' }
+
+    it 'should check for uniqueness' do
+      expect(build(:page, identifier: cat_page.identifier)).to be_invalid
+    end
+
+    it 'should be findable via scope' do
+      expect(Kuhsaft::Page.by_identifier(cat_page.identifier)).to eq(cat_page)
+    end
+  end
+end