qbrick 2.5.0.pre → 2.5.0

data/spec/models/brick_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
-describe Kuhsaft::Brick do
+describe Qbrick::Brick, type: :model do
   let :brick do
-    Kuhsaft::Brick.new
+    Qbrick::Brick.new
   end
 
   describe '#valid?' do
     it 'sets a default position' do
-      brick.should_receive(:set_position)
+      expect(brick).to receive(:set_position)
       brick.valid?
     end
   end
@@ -16,7 +16,7 @@ describe Kuhsaft::Brick do
     context 'witout a position' do
       it 'sets a default' do
         brick.set_position
-        brick.position.should be(1)
+        expect(brick.position).to be(1)
       end
     end
 
@@ -29,90 +29,90 @@ describe Kuhsaft::Brick do
   end
 
   describe '#brick_list_type' do
-    it 'returns Kuhsaft::Brick' do
-      brick.brick_list_type.should == 'Kuhsaft::Brick'
+    it 'returns Qbrick::Brick' do
+      expect(brick.brick_list_type).to eq('Qbrick::Brick')
     end
   end
 
   describe '#parents' do
     it 'returns the chain of parents' do
-      item1, item2, item3 = double, double, Kuhsaft::Brick.new
-      item2.stub(:brick_list).and_return(item1)
-      item3.stub(:brick_list).and_return(item2)
-      item3.parents.should == [item1, item2]
+      item1, item2, item3 = double, double, Qbrick::Brick.new
+      allow(item2).to receive(:brick_list).and_return(item1)
+      allow(item3).to receive(:brick_list).and_return(item2)
+      expect(item3.parents).to eq([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'
+      expect(Qbrick::TextBrick.new.to_edit_partial_path).to eq('qbrick/text_bricks/text_brick/edit')
     end
   end
 
   describe '#has_siblings?' do
     it 'returns false if the brick has no siblings' do
-      brick = Kuhsaft::Brick.new
-      brick.has_siblings?.should be_false
+      brick = Qbrick::Brick.new
+      expect(brick.has_siblings?).to be_falsey
     end
 
     it 'returns true if the brick has siblings' do
-      item1, item2, item3 = double, double, Kuhsaft::Brick.new
-      item1.stub(:bricks).and_return([item2, item3])
-      item2.stub(:brick_list).and_return(item1)
-      item3.stub(:brick_list).and_return(item1)
-      item3.has_siblings?.should be_true
+      item1, item2, item3 = double, double, Qbrick::Brick.new
+      allow(item1).to receive(:bricks).and_return([item2, item3])
+      allow(item2).to receive(:brick_list).and_return(item1)
+      allow(item3).to receive(:brick_list).and_return(item1)
+      expect(item3.has_siblings?).to be_truthy
     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'
+      expect(Qbrick::TextBrick.new.to_edit_childs_partial_path).to eq('qbrick/text_bricks/text_brick/childs')
     end
   end
 
   describe '#bricks' do
     it 'can not have childs by default' do
-      brick.should_not respond_to(:bricks)
+      expect(brick).not_to 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'
+      expect(Qbrick::TextBrick.new.to_style_class).to eq('qbrick-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'
+      brick = Qbrick::TextBrick.new
+      allow(brick).to receive(:id).and_return(104)
+      expect(brick.to_style_id).to eq('qbrick-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'
+      brick =  Qbrick::TextBrick.new
+      expect(brick.backend_label).to eq('Text')
     end
 
-    context 'with the parenthesis option given' do
-      brick = Kuhsaft::TextBrick.new
-      brick.backend_label(parenthesis: true).should == '(Text)'
+    it 'with the parenthesis option given' do
+      brick = Qbrick::TextBrick.new
+      expect(brick.backend_label(parenthesis: true)).to eq '(Text)'
     end
   end
 
   describe '#uploader?' do
     it 'returns false' do
-      brick.uploader?.should be_false
+      expect(brick.uploader?).to be_falsey
     end
   end
 
   describe '#after_save' do
     describe 'update_fulltext' do
       let! :brick do
-        Kuhsaft::Brick.new.tap do |b|
-          b.type = Kuhsaft::BrickType.new
+        Qbrick::Brick.new.tap do |b|
+          b.type = 'Qbrick::TextBrick'
         end
       end
 
@@ -124,8 +124,8 @@ describe Kuhsaft::Brick do
       end
 
       it 'updates fulltext on bricklist after saving a single brick' do
-        brick.brick_list.should_receive(:update_fulltext)
-        brick.brick_list.should_receive(:save!)
+        expect(brick.brick_list).to receive(:update_fulltext)
+        expect(brick.brick_list).to receive(:save!)
         brick.text = 'foobar'
         brick.save
       end

data/spec/models/brick_type_filter_spec.rb

@@ -1,32 +1,32 @@
 require 'spec_helper'
 
-describe Kuhsaft::BrickTypeFilter do
+describe Qbrick::BrickTypeFilter, type: :model do
   let :brick_list do
-    Kuhsaft::Page.new
+    Qbrick::Page.new
   end
 
   let :brick_type_filter do
-    Kuhsaft::BrickTypeFilter.new(brick_list)
+    Qbrick::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)
+        allow(brick_list).to receive(:user_can_add_childs?).and_return(false)
       end
 
       it 'returns true' do
-        brick_type_filter.empty?.should be_true
+        expect(brick_type_filter.empty?).to be_truthy
       end
     end
 
     context 'when there are no bricks to be added' do
       before do
-        brick_type_filter.stub(:allowed).and_return([])
+        allow(brick_type_filter).to receive(:allowed).and_return([])
       end
 
       it 'returns true' do
-        brick_type_filter.empty?.should be_true
+        expect(brick_type_filter.empty?).to be_truthy
       end
     end
   end
@@ -34,28 +34,28 @@ describe Kuhsaft::BrickTypeFilter do
   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
+        allow(Qbrick::BrickType).to receive_message_chain(:count, :zero?).and_return(true)
+        expect(brick_type_filter.allowed).to be_empty
       end
     end
 
     context 'when brick types are registered' do
       before do
-        Kuhsaft::BrickType.stub_chain(:enabled, :count, :zero?).and_return(false)
+        allow(Qbrick::BrickType).to receive_message_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)
+          allow(brick_list).to receive(:allowed_brick_types).and_return([])
+          expect(Qbrick::BrickType).to 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'])
+          allow(brick_list).to receive(:allowed_brick_types).and_return(['Qbrick::TextBrick'])
+          expect(Qbrick::BrickType.enabled).to receive(:constrained).with(['Qbrick::TextBrick'])
           brick_type_filter.allowed
         end
       end

data/spec/models/column_brick_spec.rb

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

data/spec/models/image_brick_spec.rb

@@ -1,9 +1,8 @@
 require 'spec_helper'
 
-describe Kuhsaft::ImageBrick do
-
+describe Qbrick::ImageBrick, type: :model do
   let :image_brick do
-    Kuhsaft::ImageBrick.new
+    Qbrick::ImageBrick.new
   end
 
   describe '#valid' do
@@ -13,7 +12,7 @@ describe Kuhsaft::ImageBrick do
 
     context 'without an #image' do
       it 'has en error' do
-        image_brick.should have(1).error_on(:image)
+        expect(image_brick.errors[:image].size).to eq(1)
       end
     end
   end
@@ -21,9 +20,9 @@ describe Kuhsaft::ImageBrick do
   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!)
+        allow(image_brick).to receive(:image_size_changed?).and_return(true)
+        allow(image_brick).to receive(:image_present?).and_return(true)
+        expect(image_brick.image).to receive(:recreate_versions!)
         image_brick.resize_image_if_size_changed
       end
     end
@@ -31,19 +30,19 @@ describe Kuhsaft::ImageBrick do
 
   describe '#bricks' do
     it 'can not have childs' do
-      image_brick.should_not respond_to(:bricks)
+      expect(image_brick).not_to respond_to(:bricks)
     end
   end
 
   describe '#user_can_add_childs?' do
     it 'returns false' do
-      image_brick.user_can_add_childs?.should be_false
+      expect(image_brick.user_can_add_childs?).to be_falsey
     end
   end
 
   describe '#uploader?' do
     it 'returns true' do
-      image_brick.uploader?.should be_true
+      expect(image_brick.uploader?).to be_truthy
     end
   end
 end

data/spec/models/image_size_spec.rb

@@ -1,36 +1,36 @@
 require 'spec_helper'
 
-describe Kuhsaft::ImageSize do
+describe Qbrick::ImageSize, type: :model do
   before do
-    Kuhsaft::ImageSize.build_defaults!
+    Qbrick::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]
+      expect(Qbrick::ImageSize.all).to eq([Qbrick::ImageSize.gallery_size,
+                                           Qbrick::ImageSize.teaser_size])
     end
   end
 
   describe '.clear!' do
     before do
-      Kuhsaft::ImageSize.clear!
+      Qbrick::ImageSize.clear!
     end
 
     it 'empties the list' do
-      Kuhsaft::ImageSize.all.should be_empty
+      expect(Qbrick::ImageSize.all).to 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)
+      expect { Qbrick::ImageSize.add(:stuff, 200, 100) }.to change(Qbrick::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
+      expect(Qbrick::ImageSize.find_by_name('gallery')).to eq(Qbrick::ImageSize.gallery_size)
     end
   end
 end

data/spec/models/link_brick_spec.rb

@@ -1,9 +1,8 @@
 require 'spec_helper'
 
-describe Kuhsaft::LinkBrick do
-
+describe Qbrick::LinkBrick, type: :model do
   let :link_brick do
-    Kuhsaft::LinkBrick.new
+    Qbrick::LinkBrick.new
   end
 
   describe '#valid' do
@@ -13,39 +12,39 @@ describe Kuhsaft::LinkBrick do
 
     context 'without a #href' do
       it 'has en error' do
-        link_brick.should have(1).error_on(:href)
+        expect(link_brick.errors[:href].count).to eq(1)
       end
     end
 
     context 'without a #caption' do
       it 'has an error' do
-        link_brick.should have(1).error_on(:caption)
+        expect(link_brick.errors[:caption].count).to eq(1)
       end
     end
   end
 
   describe '#bricks' do
     it 'can not have childs' do
-      link_brick.should_not respond_to(:bricks)
+      expect(link_brick).not_to 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)
+      expect(Qbrick::LinkBrick.styles).to eq(%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'
+      allow(link_brick).to receive(:link_style).and_return('pdf')
+      expect(link_brick.to_style_class).to eq('qbrick-link-brick pdf')
     end
   end
 
   describe '#user_can_add_childs?' do
     it 'returns false' do
-      link_brick.user_can_add_childs?.should be_false
+      expect(link_brick.user_can_add_childs?).to be_falsey
     end
   end
 end

data/spec/models/page_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Kuhsaft::Page do
+describe Qbrick::Page, type: :model do
   # subject { described_class }
 
   describe '.search' do
@@ -9,47 +9,47 @@ describe Kuhsaft::Page do
     end
 
     it 'should find any containing the search term' do
-      Kuhsaft::Page.search('lorem').should have_at_least(0).items
+      expect(Qbrick::Page.search('lorem').size).to be >= 0
     end
 
     it 'should find with "English Title"' do
-      Kuhsaft::Page.search('English Title').should have_at_least(1).item
+      expect(Qbrick::Page.search('English Title').size).to be >= 1
     end
 
     it 'should only find published results' do
-      Kuhsaft::Page.search('English Title').should be_all { |p| p.published? == true }
+      expect(Qbrick::Page.search('English Title')).to 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')
+      expect(Qbrick::Page.search('English')).to eq(Qbrick::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
+      expect(Qbrick::Page.position_of(page.id)).to eq(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)
+      expect(Qbrick::Page.find_by_url(page.url)).to 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)
+      expect(Qbrick::Page.flat_tree).to eq(tree)
     end
   end
 
   describe '#initialize' do
     context 'without values' do
       let :page do
-        Kuhsaft::Page.new
+        Qbrick::Page.new
       end
 
       before do
@@ -57,11 +57,11 @@ describe Kuhsaft::Page do
       end
 
       it 'has a mandatory title' do
-        page.should have(1).error_on(:title)
+        expect(page.errors[:title].count).to eq(1)
       end
 
       it 'has a mandatory slug' do
-        page.should have(1).error_on(:slug)
+        expect(page.errors[:slug].count).to eq(1)
       end
     end
   end
@@ -69,30 +69,29 @@ describe Kuhsaft::Page do
   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 }
+      p2.update_attribute :published, Qbrick::PublishState::UNPUBLISHED
+      expect(Qbrick::Page.published).to be_all { |p| expect(p.published?).to be_truthy }
     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]
+      p2.update_attribute :page_type, Qbrick::PageType::REDIRECT
+      expect(Qbrick::Page.content_page).to eq([p1, p3])
     end
   end
 
   describe '#state_class' do
-
-    let(:page) { Kuhsaft::Page.new }
+    let(:page) { Qbrick::Page.new }
 
     it 'returns publsihed as string when page is published' do
-      page.published = Kuhsaft::PublishState::PUBLISHED
+      page.published = Qbrick::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
+      page.published = Qbrick::PublishState::UNPUBLISHED
       expect(page.state_class).to eq 'unpublished'
     end
   end
@@ -100,8 +99,8 @@ describe Kuhsaft::Page do
   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)
+      page = Qbrick::Page.first
+      expect(page.without_self).not_to include(page)
     end
   end
 
@@ -120,19 +119,19 @@ describe Kuhsaft::Page do
 
     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)
+        expect(page.nesting_name).to 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}")
+        expect(child_page.nesting_name).to 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}")
+        expect(child_child_page.nesting_name).to eq("-- #{child_child_page.title}")
       end
     end
   end
@@ -147,11 +146,11 @@ describe Kuhsaft::Page do
     end
 
     it 'has a list of parent pages' do
-      child_page.parent_pages.should == [page]
+      expect(child_page.parent_pages).to eq([page])
     end
 
     it 'is ordered from top to bottom' do
-      child_page.parent_pages.last.should == page
+      expect(child_page.parent_pages.last).to eq(page)
     end
   end
 
@@ -162,7 +161,7 @@ describe Kuhsaft::Page do
         child = create(:page, parent: page)
         page.body = nil
         page.save
-        page.link.should == child.link
+        expect(page.link).to eq(child.link)
       end
     end
   end
@@ -172,7 +171,7 @@ describe Kuhsaft::Page do
       page = create :page
       position = page.position
       page.increment_position
-      page.position.should == (position + 1)
+      expect(page.position).to eq(position + 1)
     end
   end
 
@@ -181,7 +180,7 @@ describe Kuhsaft::Page do
       page = create :page
       position = page.position
       page.decrement_position
-      page.position.should == (position - 1)
+      expect(page.position).to eq(position - 1)
     end
   end
 
@@ -190,7 +189,7 @@ describe Kuhsaft::Page do
       _page1 = create :page
       page2 = create :page
       page3 = create :page
-      page3.preceding_sibling.id.should == page2.id
+      expect(page3.preceding_sibling.id).to eq(page2.id)
     end
   end
 
@@ -199,7 +198,7 @@ describe Kuhsaft::Page do
       _page1 = create :page
       page2 = create :page
       page3 = create :page
-      page2.succeeding_sibling.id.should == page3.id
+      expect(page2.succeeding_sibling.id).to eq(page3.id)
     end
   end
 
@@ -209,14 +208,14 @@ describe Kuhsaft::Page do
       _page2 = create :page
       page3 = create :page
       page3.reposition page1.id
-      page3.preceding_sibling.id.should == page1.id
+      expect(page3.preceding_sibling.id).to eq(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
+      expect(page2.position).to eq(1)
     end
   end
 
@@ -227,12 +226,12 @@ describe Kuhsaft::Page do
 
     it 'has a slug by default' do
       page.save
-      page.slug.should eq(page.title.parameterize)
+      expect(page.slug).to eq(page.title.parameterize)
     end
 
     context 'when it is empty' do
       it 'generates the slug' do
-        page.should_receive(:create_slug)
+        expect(page).to receive(:create_slug)
         page.save
       end
     end
@@ -241,7 +240,7 @@ describe Kuhsaft::Page do
       it 'takes the slug provided by the user' do
         page.slug = 'my-slug'
         page.save
-        page.slug.should == 'my-slug'
+        expect(page.slug).to eq('my-slug')
       end
     end
   end
@@ -251,29 +250,29 @@ describe Kuhsaft::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'
+        expect(child.url).to eq('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)
+        page = create(:page, slug: 'parent-slug', page_type: Qbrick::PageType::NAVIGATION)
         child = create(:page, slug: 'child-slug', parent: page)
-        child.url.should == 'en/child-slug'
+        expect(child.url).to eq('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')
+        page = create(:page, page_type: Qbrick::PageType::REDIRECT, redirect_url: 'en/references', slug: 'news')
+        expect(page.link).to 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')
+        page = create(:page, page_type: Qbrick::PageType::NAVIGATION)
+        expect(page.link).to eq('/en')
       end
     end
   end
@@ -281,13 +280,13 @@ describe Kuhsaft::Page do
   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
+        expect(Qbrick::Page.new(page_type: Qbrick::PageType::NAVIGATION).navigation?).to be_truthy
       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
+        expect(Qbrick::Page.new(page_type: Qbrick::PageType::REDIRECT).navigation?).to be_falsey
       end
     end
   end
@@ -295,41 +294,41 @@ describe Kuhsaft::Page do
   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
+        expect(Qbrick::Page.new(page_type: Qbrick::PageType::REDIRECT).redirect?).to be_truthy
       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
+        expect(Qbrick::Page.new(page_type: Qbrick::PageType::NAVIGATION).redirect?).to be_falsey
       end
     end
   end
 
   describe 'page types' do
     it 'returns content by default' do
-      expect(Kuhsaft::Page.new.page_type).to eq('content')
+      expect(Qbrick::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')
+      expect(Qbrick::Page.new(page_type: Qbrick::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')
+      expect(Qbrick::Page.new(page_type: Qbrick::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
+      expect(@page.translated?).to be_truthy
     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
+        expect(@page.translated?).to be_falsey
       end
     end
   end
@@ -337,19 +336,19 @@ describe Kuhsaft::Page do
   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.bricks << Qbrick::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)
+        expect(page).to receive(:collect_fulltext)
         page.save
       end
 
       it 'contains the page part content' do
-        page.fulltext.should include('oh la la')
+        expect(page.fulltext).to include('oh la la')
       end
 
       it 'converts all data to strings' do
@@ -360,10 +359,10 @@ describe Kuhsaft::Page do
 
   describe '#before_validation' do
     it 'generates url automatically' do
-      page = Kuhsaft::Page.new slug: 'slug'
-      page.url.should be_nil
+      page = Qbrick::Page.new slug: 'slug'
+      expect(page.url).to be_nil
       page.valid?
-      page.url.should be_present
+      expect(page.url).to be_present
     end
   end
 
@@ -373,16 +372,16 @@ describe Kuhsaft::Page 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")
+        @parent_page.update_attributes(page_type: Qbrick::PageType::NAVIGATION)
+        expect(@child_page.reload.url).to 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)
+        @parent_page = FactoryGirl.create(:page, slug: 'le_parent', page_type: Qbrick::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")
+        @parent_page.update_attributes(page_type: Qbrick::PageType::CONTENT)
+        expect(@child_page.reload.url).to eq("#{I18n.locale}/le_parent/le_child")
       end
     end
   end
@@ -394,17 +393,17 @@ describe Kuhsaft::Page do
 
     context 'without parent' do
       it 'returns url without leading /' do
-        page.url_without_locale.should_not start_with '/'
+        expect(page.url_without_locale).not_to start_with '/'
       end
 
       it 'returns a single slug' do
-        page.url_without_locale.should == 'page'
+        expect(page.url_without_locale).to eq('page')
       end
     end
 
     context 'when parent is navigation' do
       let :parent do
-        create(:page, page_type: Kuhsaft::PageType::NAVIGATION)
+        create(:page, page_type: Qbrick::PageType::NAVIGATION)
       end
 
       let :child do
@@ -412,11 +411,11 @@ describe Kuhsaft::Page do
       end
 
       it 'returns url without leading /' do
-        child.url_without_locale.should_not start_with '/'
+        expect(child.url_without_locale).not_to start_with '/'
       end
 
       it 'does not concatenate the parent slug' do
-        child.url_without_locale.should == 'child'
+        expect(child.url_without_locale).to eq('child')
       end
     end
 
@@ -430,11 +429,11 @@ describe Kuhsaft::Page do
       end
 
       it 'returns url without leading /' do
-        child.url_without_locale.should_not start_with '/'
+        expect(child.url_without_locale).not_to start_with '/'
       end
 
       it 'does not concatenate the parent slug' do
-        child.url_without_locale.should == 'parent/child'
+        expect(child.url_without_locale).to eq('parent/child')
       end
     end
   end
@@ -447,13 +446,13 @@ describe Kuhsaft::Page do
     end
 
     it 'returns all pages that have a translation' do
-      expect(Kuhsaft::Page.translated).to eq [@page_1, @page_2, @page_3]
+      expect(Qbrick::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]
+        expect(Qbrick::Page.translated).to eq [@page_1]
       end
     end
   end
@@ -466,7 +465,48 @@ describe Kuhsaft::Page do
     end
 
     it 'should be findable via scope' do
-      expect(Kuhsaft::Page.by_identifier(cat_page.identifier)).to eq(cat_page)
+      expect(Qbrick::Page.by_identifier(cat_page.identifier)).to eq(cat_page)
+    end
+  end
+
+  describe '#cloning' do
+    around(:each) do |example|
+      I18n.with_locale :de do
+        example.run
+      end
+    end
+
+    before do
+      @page = create(:page)
+    end
+
+    context 'clearing bricks in target locale' do
+      it 'does not affect pages other than the target page' do
+        another_page = create(:page)
+        FactoryGirl.create(:image_brick, brick_list_type: 'Qbrick::Page', brick_list_id: another_page.id)
+        expect { @page.clear_bricks_for_locale(:de) }.to_not change { another_page.bricks.count }
+      end
+    end
+
+    it 'should copy the asset to the cloned brick' do
+      FactoryGirl.create(:image_brick, brick_list_type: 'Qbrick::Page', brick_list_id: @page.id)
+
+      @page.clone_bricks_to(:en)
+      expect(@page.bricks.unscoped.where(locale: :en).first).to be_valid
+    end
+
+    it 'should copy all child bricks' do
+      accordion = Qbrick::Brick.create(type: 'Qbrick::AccordionBrick',
+                                       brick_list_type: 'Qbrick::Page',
+                                       brick_list_id: @page.id)
+      section   = Qbrick::Brick.create(type: 'Qbrick::AccordionItemBrick',
+                                       caption: 'section',
+                                       brick_list_type: 'Qbrick::Brick',
+                                       brick_list_id: accordion.id)
+      FactoryGirl.create(:text_brick, brick_list_type: 'Qbrick::Brick', brick_list_id: section.id)
+
+      @page.clone_bricks_to(:en)
+      expect(@page.bricks.unscoped.where(locale: :en).count).to eq(3)
     end
   end
 end