alchemy_cms 3.0.4 → 3.1.0.beta1

data/spec/helpers/base_helper_spec.rb

@@ -6,36 +6,36 @@ module Alchemy
     describe "#render_message" do
       context "if no argument is passed" do
         it "should render a div with an info icon and the given content" do
-          helper.render_message{ content_tag(:p, "my notice") }.should match(/<div class="info message"><span class="icon info"><\/span><p>my notice/)
+          expect(helper.render_message{ content_tag(:p, "my notice") }).to match(/<div class="info message"><span class="icon info"><\/span><p>my notice/)
         end
       end
 
       context "if an argument is passed" do
         it "should render the passed argument as the css classname for the icon container" do
-          helper.render_message(:error){ content_tag(:p, "my notice") }.should match(/<div class="error message"><span class="icon error">/)
+          expect(helper.render_message(:error){ content_tag(:p, "my notice") }).to match(/<div class="error message"><span class="icon error">/)
         end
       end
     end
 
     describe "#configuration" do
       it "should return certain configuration options" do
-        Config.stub(:show).and_return({"some_option" => true})
-        helper.configuration(:some_option).should == true
+        allow(Config).to receive(:show).and_return({"some_option" => true})
+        expect(helper.configuration(:some_option)).to eq(true)
       end
     end
 
     describe "#multi_language?" do
       context "if more than one published language exists" do
         it "should return true" do
-          Alchemy::Language.stub_chain(:published, :count).and_return(2)
-          helper.multi_language?.should == true
+          allow(Alchemy::Language).to receive(:published).and_return double(count: 2)
+          expect(helper.multi_language?).to eq(true)
         end
       end
 
       context "if less than two published languages exists" do
         it "should return false" do
-          Alchemy::Language.stub_chain(:published, :count).and_return(1)
-          helper.multi_language?.should == false
+          allow(Alchemy::Language).to receive(:published).and_return double(count: 1)
+          expect(helper.multi_language?).to eq(false)
         end
       end
     end
@@ -46,16 +46,16 @@ module Alchemy
       let(:page)      { FactoryGirl.create(:public_page, parent_id: parent.id) }
 
       it "returns an array of all parents including self" do
-        helper.breadcrumb(page).should == [lang_root, parent, page]
+        expect(helper.breadcrumb(page)).to eq([lang_root, parent, page])
       end
 
       it "does not include the root page" do
-        helper.breadcrumb(page).should_not include(Page.root)
+        expect(helper.breadcrumb(page)).not_to include(Page.root)
       end
 
       context "with current page nil" do
         it "should return an empty array" do
-          helper.breadcrumb(nil).should == []
+          expect(helper.breadcrumb(nil)).to eq([])
         end
       end
     end

data/spec/helpers/elements_block_helper_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 include Alchemy::ElementsHelper
 
 module Alchemy
-  describe ElementsBlockHelper do
+  describe 'ElementsBlockHelper' do
     let(:page)    { FactoryGirl.create(:public_page) }
     let(:element) { FactoryGirl.create(:element, page: page, tag_list: 'foo, bar') }
     let(:expected_wrapper_tag) { "div.#{element.name}##{element_dom_id(element)}" }
@@ -15,35 +15,35 @@ module Alchemy
       end
 
       it "should wrap its output in a DOM element" do
-        element_view_for(element).
-          should have_css expected_wrapper_tag
+        expect(element_view_for(element)).
+          to have_css expected_wrapper_tag
       end
 
       it "should change the wrapping DOM element according to parameters" do
-        element_view_for(element, tag: 'span', class: 'some_class', id: 'some_id').
-          should have_css 'span.some_class#some_id'
+        expect(element_view_for(element, tag: 'span', class: 'some_class', id: 'some_id')).
+          to have_css 'span.some_class#some_id'
       end
 
       it "should include the element's tags in the wrapper DOM element" do
-        element_view_for(element).
-          should have_css "#{expected_wrapper_tag}[data-element-tags='foo bar']"
+        expect(element_view_for(element)).
+          to have_css "#{expected_wrapper_tag}[data-element-tags='foo bar']"
       end
 
       it "should use the provided tags formatter to format tags" do
-        element_view_for(element, tags_formatter: lambda { |tags| tags.join ", " }).
-          should have_css "#{expected_wrapper_tag}[data-element-tags='foo, bar']"
+        expect(element_view_for(element, tags_formatter: lambda { |tags| tags.join ", " })).
+          to have_css "#{expected_wrapper_tag}[data-element-tags='foo, bar']"
       end
 
       it "should include the contents rendered by the block passed to it" do
-        element_view_for(element) do
+        expect(element_view_for(element) do
           'view'
-        end.should have_content 'view'
+        end).to have_content 'view'
       end
 
       context "when/if preview mode is not active" do
         subject { element_view_for(element) }
-        it { should have_css expected_wrapper_tag }
-        it { should_not have_css "#{expected_wrapper_tag}[data-alchemy-element]" }
+        it { is_expected.to have_css expected_wrapper_tag }
+        it { is_expected.not_to have_css "#{expected_wrapper_tag}[data-alchemy-element]" }
       end
 
       context "when/if preview mode is active" do
@@ -53,7 +53,7 @@ module Alchemy
         end
 
         subject { helper.element_view_for(element) }
-        it { should have_css "#{expected_wrapper_tag}[data-alchemy-element='#{element.id}']" }
+        it { is_expected.to have_css "#{expected_wrapper_tag}[data-alchemy-element='#{element.id}']" }
       end
     end
 
@@ -64,13 +64,13 @@ module Alchemy
       end
 
       it "should not add any extra elements" do
-        element_editor_for(element) do
+        expect(element_editor_for(element) do
           'view'
-        end.should == 'view'
+        end).to eq('view')
       end
     end
 
-    describe ElementsBlockHelper::ElementViewHelper do
+    describe 'ElementsBlockHelper::ElementViewHelper' do
       let(:scope) { double }
       subject { ElementsBlockHelper::ElementViewHelper.new(scope, element: element) }
 
@@ -80,35 +80,35 @@ module Alchemy
 
       describe '#render' do
         it 'should delegate to the render_essence_view_by_name helper' do
-          scope.should_receive(:render_essence_view_by_name).with(element, "title", foo: 'bar')
+          expect(scope).to receive(:render_essence_view_by_name).with(element, "title", foo: 'bar')
           subject.render :title, foo: 'bar'
         end
       end
 
       describe '#content' do
         it "should delegate to the element's #content_by_name method" do
-          element.should_receive(:content_by_name).with(:title)
+          expect(element).to receive(:content_by_name).with(:title)
           subject.content :title
         end
       end
 
       describe '#ingredient' do
         it "should delegate to the element's #ingredient method" do
-          element.should_receive(:ingredient).with(:title)
+          expect(element).to receive(:ingredient).with(:title)
           subject.ingredient :title
         end
       end
 
       describe '#has?' do
         it "should delegate to the element's #has_ingredient? method" do
-          element.should_receive(:has_ingredient?).with(:title)
+          expect(element).to receive(:has_ingredient?).with(:title)
           subject.has? :title
         end
       end
 
       describe '#essence' do
         it "should provide the specified content essence" do
-          subject.should_receive(:content).with(:title).
+          expect(subject).to receive(:content).with(:title).
             and_return(mock_model('Content', :essence => mock_model('EssenceText')))
 
           subject.essence :title
@@ -116,7 +116,7 @@ module Alchemy
       end
     end
 
-    describe ElementsBlockHelper::ElementEditorHelper do
+    describe 'ElementsBlockHelper::ElementEditorHelper' do
       let(:scope) { double }
       subject { ElementsBlockHelper::ElementEditorHelper.new(scope, element: element) }
 
@@ -126,7 +126,7 @@ module Alchemy
 
       describe '#edit' do
         it "should delegate to the render_essence_editor_by_name helper" do
-          scope.should_receive(:render_essence_editor_by_name).with(element, "title", foo: 'bar')
+          expect(scope).to receive(:render_essence_editor_by_name).with(element, "title", foo: 'bar')
           subject.edit :title, foo: 'bar'
         end
       end

data/spec/helpers/elements_helper_spec.rb

@@ -8,7 +8,7 @@ module Alchemy
 
     before do
       assign(:page, page)
-      Element.any_instance.stub(store_page: true)
+      allow_any_instance_of(Element).to receive(:store_page).and_return(true)
     end
 
     describe '#render_element' do
@@ -17,21 +17,21 @@ module Alchemy
       context 'with nil element' do
         let(:element) { nil }
         let(:part)    { :view }
-        it { should be_nil }
+        it { is_expected.to be_nil }
       end
 
       context 'with view as part given' do
         let(:part) {:view}
 
         it "renders the element's view partial" do
-          should have_selector("##{element.name}_#{element.id}")
+          is_expected.to have_selector("##{element.name}_#{element.id}")
         end
 
         context 'with element view partial not found' do
           let(:element) { build_stubbed(:element, name: 'not_present')}
 
           it "renders the view not found partial" do
-            should match(/Missing view for not_present element/)
+            is_expected.to match(/Missing view for not_present element/)
           end
         end
       end
@@ -40,7 +40,7 @@ module Alchemy
         let(:part) {:editor}
 
         it "renders the element's editor partial" do
-          helper.should_receive(:render_essence_editor_by_name)
+          expect(helper).to receive(:render_essence_editor_by_name)
           subject
         end
 
@@ -48,8 +48,8 @@ module Alchemy
           let(:element) { build_stubbed(:element, name: 'not_present')}
 
           it "renders the editor not found partial" do
-            should have_selector('div.error')
-            should have_content('Element editor partial not found')
+            is_expected.to have_selector('div.error')
+            is_expected.to have_content('Element editor partial not found')
           end
         end
       end
@@ -59,7 +59,7 @@ module Alchemy
       subject { helper.element_dom_id(element) }
 
       it "should render a unique dom id for element" do
-        should == "#{element.name}_#{element.id}"
+        is_expected.to eq("#{element.name}_#{element.id}")
       end
     end
 
@@ -73,12 +73,12 @@ module Alchemy
         let(:options) { {} }
 
         before do
-          page.should_receive(:find_elements).and_return(elements)
+          expect(page).to receive(:find_elements).and_return(elements)
         end
 
         it "should render all elements from page." do
-          should have_selector("##{element.name}_#{element.id}")
-          should have_selector("##{another_element.name}_#{another_element.id}")
+          is_expected.to have_selector("##{element.name}_#{element.id}")
+          is_expected.to have_selector("##{another_element.name}_#{another_element.id}")
         end
       end
 
@@ -88,12 +88,12 @@ module Alchemy
           let(:options)      { {from_page: another_page} }
 
           before do
-            another_page.should_receive(:find_elements).and_return(elements)
+            expect(another_page).to receive(:find_elements).and_return(elements)
           end
 
           it "should render all elements from that page." do
-            should have_selector("##{element.name}_#{element.id}")
-            should have_selector("##{another_element.name}_#{another_element.id}")
+            is_expected.to have_selector("##{element.name}_#{element.id}")
+            is_expected.to have_selector("##{another_element.name}_#{another_element.id}")
           end
         end
 
@@ -104,15 +104,15 @@ module Alchemy
           let(:options)         { {from_page: 'news'} }
 
           before do
-            Language.stub_chain(:current, :pages, :where).and_return(pages)
-            another_page.should_receive(:find_elements).and_return(other_elements)
+            allow(Language).to receive(:current).and_return double(pages: double(where: pages))
+            expect(another_page).to receive(:find_elements).and_return(other_elements)
           end
 
           context 'and one page can be found by page layout' do
             let(:pages) { [another_page] }
 
             it "it renders all elements from that page." do
-              should have_selector("##{another_element.name}_#{another_element.id}")
+              is_expected.to have_selector("##{another_element.name}_#{another_element.id}")
             end
           end
 
@@ -120,12 +120,12 @@ module Alchemy
             let(:pages) { [page, another_page] }
 
             before do
-              page.should_receive(:find_elements).and_return(elements)
+              expect(page).to receive(:find_elements).and_return(elements)
             end
 
             it 'renders elements from these pages' do
-              should have_selector("##{element.name}_#{element.id}")
-              should have_selector("##{another_element.name}_#{another_element.id}")
+              is_expected.to have_selector("##{element.name}_#{element.id}")
+              is_expected.to have_selector("##{another_element.name}_#{another_element.id}")
             end
           end
         end
@@ -133,7 +133,7 @@ module Alchemy
 
       context 'if page is nil' do
         let(:options) { {from_page: nil} }
-        it { should be_blank }
+        it { is_expected.to be_blank }
       end
 
       context 'with sort_by option given' do
@@ -141,12 +141,12 @@ module Alchemy
         let(:sorted_elements) { [another_element, element] }
 
         before do
-          elements.should_receive(:sort_by).and_return(sorted_elements)
-          page.should_receive(:find_elements).and_return(elements)
+          expect(elements).to receive(:sort_by).and_return(sorted_elements)
+          expect(page).to receive(:find_elements).and_return(elements)
         end
 
         it "renders the elements in the order of given content name" do
-          should_not be_blank
+          is_expected.not_to be_blank
         end
       end
 
@@ -159,12 +159,12 @@ module Alchemy
           let(:options) { {fallback: {for: 'higgs', with: 'news', from: 'news'}} }
 
           before do
-            Language.stub_chain(:current, :pages, :find_by).and_return(another_page)
-            another_page.stub_chain(:elements, :named).and_return(elements)
+            allow(Language).to receive(:current).and_return double(pages: double(find_by: another_page))
+            allow(another_page).to receive(:elements).and_return double(named: elements)
           end
 
           it "renders the fallback element" do
-            should have_selector("#news_#{another_element.id}")
+            is_expected.to have_selector("#news_#{another_element.id}")
           end
         end
 
@@ -172,11 +172,11 @@ module Alchemy
           let(:options) { {fallback: {for: 'higgs', with: 'news', from: another_page}} }
 
           before do
-            another_page.stub_chain(:elements, :named).and_return(elements)
+            allow(another_page).to receive(:elements).and_return double(named: elements)
           end
 
           it "renders the fallback element" do
-            should have_selector("#news_#{another_element.id}")
+            is_expected.to have_selector("#news_#{another_element.id}")
           end
         end
       end
@@ -185,11 +185,11 @@ module Alchemy
         let(:options) { {separator: '<hr>'} }
 
         before do
-          page.should_receive(:find_elements).and_return(elements)
+          expect(page).to receive(:find_elements).and_return(elements)
         end
 
         it "joins element partials with given string" do
-          should have_selector('hr')
+          is_expected.to have_selector('hr')
         end
       end
     end
@@ -201,13 +201,13 @@ module Alchemy
         before { assign(:preview_mode, true) }
 
         it "should return the data-alchemy-element HTML attribute for element" do
-          should == {:'data-alchemy-element' => element.id}
+          is_expected.to eq({:'data-alchemy-element' => element.id})
         end
       end
 
       context 'not in preview_mode' do
         it "should return an empty hash" do
-          should == {}
+          is_expected.to eq({})
         end
       end
     end
@@ -219,13 +219,13 @@ module Alchemy
         before { assign(:preview_mode, true) }
 
         it "should return the data-alchemy-element HTML attribute for element" do
-          should == " data-alchemy-element=\"#{element.id}\""
+          is_expected.to eq(" data-alchemy-element=\"#{element.id}\"")
         end
       end
 
       context 'not in preview_mode' do
         it "should not return the data-alchemy-element HTML attribute" do
-          should_not == " data-alchemy-element=\"#{element.id}\""
+          is_expected.not_to eq(" data-alchemy-element=\"#{element.id}\"")
         end
       end
     end
@@ -241,7 +241,7 @@ module Alchemy
 
         context "with no formatter lambda given" do
           it "should return tag list as HTML data attribute" do
-            should == " data-element-tags=\"peter lustig\""
+            is_expected.to eq(" data-element-tags=\"peter lustig\"")
           end
         end
 
@@ -249,13 +249,13 @@ module Alchemy
           let(:options) { {formatter: ->(tags) { tags.join ", " }} }
 
           it "should return a properly formatted HTML data attribute" do
-            should == " data-element-tags=\"peter, lustig\""
+            is_expected.to eq(" data-element-tags=\"peter, lustig\"")
           end
         end
       end
 
       context "element not having tags" do
-        it { should be_blank }
+        it { is_expected.to be_blank }
       end
     end
 
@@ -271,13 +271,13 @@ module Alchemy
       let(:elements)     { [element_1, element_2, element_3] }
 
       before do
-        element_1.should_receive(:content_by_name).and_return(ingredient_b)
-        element_2.should_receive(:content_by_name).and_return(ingredient_c)
-        element_3.should_receive(:content_by_name).and_return(ingredient_a)
+        expect(element_1).to receive(:content_by_name).and_return(ingredient_b)
+        expect(element_2).to receive(:content_by_name).and_return(ingredient_c)
+        expect(element_3).to receive(:content_by_name).and_return(ingredient_a)
       end
 
       it "sorts the elements by content" do
-        should eq [element_3, element_1, element_2]
+        is_expected.to eq [element_3, element_1, element_2]
       end
 
       context 'with element not having this content' do
@@ -285,11 +285,11 @@ module Alchemy
         let(:elements)  { [element_1, element_2, element_3, element_4] }
 
         before do
-          element_4.should_receive(:content_by_name).and_return(nil)
+          expect(element_4).to receive(:content_by_name).and_return(nil)
         end
 
         it "puts it at first place" do
-          should eq [element_4, element_3, element_1, element_2]
+          is_expected.to eq [element_4, element_3, element_1, element_2]
         end
       end
 
@@ -298,11 +298,11 @@ module Alchemy
         let(:elements)  { [element_1, element_2, element_3, element_4] }
 
         before do
-          element_4.should_receive(:content_by_name).and_return(double(ingredient: nil))
+          expect(element_4).to receive(:content_by_name).and_return(double(ingredient: nil))
         end
 
         it "puts it at first place" do
-          should eq [element_4, element_3, element_1, element_2]
+          is_expected.to eq [element_4, element_3, element_1, element_2]
         end
       end
     end