alchemy_cms 3.0.4 → 3.1.0.beta1

data/spec/helpers/admin/base_helper_spec.rb

@@ -9,129 +9,129 @@ module Alchemy
 
       context "with max_images option set to emtpy string" do
         let(:options) { {max_images: ""} }
-        it { should eq(nil) }
+        it { is_expected.to eq(nil) }
       end
 
       context "with max_images option set to '1'" do
         let(:options) { {max_images: "1"} }
-        it { should eq(1) }
+        it { is_expected.to eq(1) }
       end
 
       context "with maximum_amount_of_images option set to emtpy string" do
         let(:options) { {maximum_amount_of_images: ""} }
-        it { should eq(nil) }
+        it { is_expected.to eq(nil) }
       end
 
       context "with maximum_amount_of_images option set to '1'" do
         let(:options) { {maximum_amount_of_images: "1"} }
-        it { should eq(1) }
+        it { is_expected.to eq(1) }
       end
     end
 
     describe "#merge_params" do
       before do
-        controller.stub(:params).and_return({:first => '1', :second => '2'})
+        allow(controller).to receive(:params).and_return({:first => '1', :second => '2'})
       end
 
       it "returns a hash that contains the current params and additional params given as attributes" do
-        helper.merge_params(:third => '3', :fourth => '4').should == {:first => '1', :second => '2', :third => '3', :fourth => '4'}
+        expect(helper.merge_params(:third => '3', :fourth => '4')).to eq({:first => '1', :second => '2', :third => '3', :fourth => '4'})
       end
     end
 
     describe "#merge_params_without" do
       before do
-        controller.stub(:params).and_return({:first => '1', :second => '2'})
+        allow(controller).to receive(:params).and_return({:first => '1', :second => '2'})
       end
 
       it "can delete a single param" do
-        helper.merge_params_without(:second).should == {:first => '1'}
+        expect(helper.merge_params_without(:second)).to eq({:first => '1'})
       end
 
       it "can delete several params" do
-        helper.merge_params_without([:first, :second]).should == {}
+        expect(helper.merge_params_without([:first, :second])).to eq({})
       end
 
       it "can delete a param and add new params at the same time" do
-        helper.merge_params_without([:first], {:third => '3'}).should == {:second => '2', :third => '3'}
+        expect(helper.merge_params_without([:first], {:third => '3'})).to eq({:second => '2', :third => '3'})
       end
 
       it "should not change params" do
         helper.merge_params_without([:first])
-        controller.params.should == {:first => '1', :second => '2'}
+        expect(controller.params).to eq({:first => '1', :second => '2'})
       end
     end
 
     describe "#merge_params_only" do
       before do
-        controller.stub(:params).and_return({:first => '1', :second => '2', :third => '3'})
+        allow(controller).to receive(:params).and_return({:first => '1', :second => '2', :third => '3'})
       end
 
       it "can keep a single param" do
-        helper.merge_params_only(:second).should == {:second => '2'}
+        expect(helper.merge_params_only(:second)).to eq({:second => '2'})
       end
 
       it "can keep several params" do
-        helper.merge_params_only([:first, :second]).should == {:first => '1', :second => '2'}
+        expect(helper.merge_params_only([:first, :second])).to eq({:first => '1', :second => '2'})
       end
 
       it "can keep a param and add new params at the same time" do
-        helper.merge_params_only([:first], {:third => '3'}).should == {:first => '1', :third => '3'}
+        expect(helper.merge_params_only([:first], {:third => '3'})).to eq({:first => '1', :third => '3'})
       end
 
       it "should not change params" do
         helper.merge_params_only([:first])
-        controller.params.should == {:first => '1', :second => '2', :third => '3'}
+        expect(controller.params).to eq({:first => '1', :second => '2', :third => '3'})
       end
     end
 
     describe '#toolbar_button' do
       context "with permission" do
-        before { helper.stub(:can?).and_return(true) }
+        before { allow(helper).to receive(:can?).and_return(true) }
 
         it "renders a toolbar button" do
-          helper.toolbar_button(
+          expect(helper.toolbar_button(
             url: admin_dashboard_path
-          ).should match /<div.+class="button_with_label/
+          )).to match /<div.+class="button_with_label/
         end
       end
 
       context "without permission" do
-        before { helper.stub(:can?).and_return(false) }
+        before { allow(helper).to receive(:can?).and_return(false) }
 
         it "returns empty string" do
-          helper.toolbar_button(
+          expect(helper.toolbar_button(
             url: admin_dashboard_path
-          ).should be_empty
+          )).to be_empty
         end
       end
 
       context "with disabled permission check" do
-        before { helper.stub(:can?).and_return(false) }
+        before { allow(helper).to receive(:can?).and_return(false) }
 
         it "returns the button" do
-          helper.toolbar_button(
+          expect(helper.toolbar_button(
             url: admin_dashboard_path,
             skip_permission_check: true
-          ).should match /<div.+class="button_with_label/
+          )).to match /<div.+class="button_with_label/
         end
       end
 
       context "with empty permission option" do
-        before { helper.stub(:can?).and_return(true) }
+        before { allow(helper).to receive(:can?).and_return(true) }
 
         it "returns reads the permission from url" do
-          helper.should_receive(:permission_array_from_url)
-          helper.toolbar_button(
+          expect(helper).to receive(:permission_array_from_url)
+          expect(helper.toolbar_button(
             url: admin_dashboard_path,
             if_permitted_to: ''
-          ).should_not be_empty
+          )).not_to be_empty
         end
       end
 
       context "with overlay option set to false" do
         before do
-          helper.stub(:can?).and_return(true)
-          helper.should_receive(:permission_array_from_url)
+          allow(helper).to receive(:can?).and_return(true)
+          expect(helper).to receive(:permission_array_from_url)
         end
 
         it "renders a normal link" do
@@ -139,16 +139,16 @@ module Alchemy
             url: admin_dashboard_path,
             overlay: false
           )
-          button.should match /<a.+href="#{admin_dashboard_path}"/
-          button.should_not match /data-alchemy-overlay/
+          expect(button).to match /<a.+href="#{admin_dashboard_path}"/
+          expect(button).not_to match /data-alchemy-overlay/
         end
       end
     end
 
     describe "#translations_for_select" do
       it "should return an Array of Arrays with available locales" do
-        Alchemy::I18n.stub(:available_locales).and_return([:de, :en, :cz, :it])
-        expect(helper.translations_for_select).to have(4).items
+        allow(Alchemy::I18n).to receive(:available_locales).and_return([:de, :en, :cz, :it])
+        expect(helper.translations_for_select.size).to eq(4)
       end
     end
 
@@ -161,14 +161,14 @@ module Alchemy
         let(:clipboard_items) { [element] }
 
         it "should include select options with the display name and preview text" do
-          element.stub(:display_name_with_preview_text).and_return('Name with Preview text')
+          allow(element).to receive(:display_name_with_preview_text).and_return('Name with Preview text')
           expect(helper.clipboard_select_tag_options(clipboard_items)).to have_selector('option', text: 'Name with Preview text')
         end
 
         context "when @page can have cells" do
-          before { page.stub(:can_have_cells?).and_return(true) }
+          before { allow(page).to receive(:can_have_cells?).and_return(true) }
           it "should group the elements in the clipboard by cell" do
-            helper.should_receive(:grouped_elements_for_select).and_return({})
+            expect(helper).to receive(:grouped_elements_for_select).and_return({})
             helper.clipboard_select_tag_options(clipboard_items)
           end
         end
@@ -188,7 +188,7 @@ module Alchemy
       subject { button_with_confirm }
 
       it "renders a button tag with a data attribute for confirm dialog" do
-        should have_selector('button[data-alchemy-confirm]')
+        is_expected.to have_selector('button[data-alchemy-confirm]')
       end
     end
 
@@ -196,11 +196,11 @@ module Alchemy
       subject { delete_button('/admin/pages') }
 
       it "renders a button tag" do
-        should have_selector('button')
+        is_expected.to have_selector('button')
       end
 
       it "returns a form tag with method=delete" do
-        should have_selector('form input[name="_method"][value="delete"]')
+        is_expected.to have_selector('form input[name="_method"][value="delete"]')
       end
     end
 
@@ -211,11 +211,11 @@ module Alchemy
       let(:now)     { Time.now }
 
       it "renders a date field" do
-        should have_selector("input[type='date']")
+        is_expected.to have_selector("input[type='date']")
       end
 
       it "sets default date as value" do
-        should have_selector("input[value='#{::I18n.l(now, format: :datepicker)}']")
+        is_expected.to have_selector("input[value='#{::I18n.l(now, format: :datepicker)}']")
       end
 
       context 'with date stored on object' do
@@ -223,7 +223,7 @@ module Alchemy
         let(:essence) { EssenceDate.new(date: date) }
 
         it "sets this date as value" do
-          should have_selector("input[value='#{::I18n.l(date, format: :datepicker)}']")
+          is_expected.to have_selector("input[value='#{::I18n.l(date, format: :datepicker)}']")
         end
       end
     end
@@ -231,21 +231,21 @@ module Alchemy
     describe '#current_alchemy_user_name' do
       subject { helper.current_alchemy_user_name }
 
-      before { helper.stub(current_alchemy_user: user) }
+      before { expect(helper).to receive(:current_alchemy_user).and_return(user) }
 
       context 'with a user having a `alchemy_display_name` method' do
         let(:user) { double('User', alchemy_display_name: 'Peter Schroeder') }
 
         it "Returns a span showing the name of the currently logged in user." do
-          should have_content("#{Alchemy::I18n.t('Logged in as')} Peter Schroeder")
-          should have_selector("span.current-user-name")
+          is_expected.to have_content("#{Alchemy::I18n.t('Logged in as')} Peter Schroeder")
+          is_expected.to have_selector("span.current-user-name")
         end
       end
 
       context 'with a user not having a `alchemy_display_name` method' do
         let(:user) { double('User', name: 'Peter Schroeder') }
 
-        it { should be_nil }
+        it { is_expected.to be_nil }
       end
     end
 
@@ -257,7 +257,9 @@ module Alchemy
       end
 
       context 'if the expression from config is nil' do
-        before { Alchemy::Config.stub(get: {link_url: nil}) }
+        before do
+          expect(Alchemy::Config).to receive(:get).and_return({link_url: nil})
+        end
 
         it "returns the default expression" do
           expect(subject).to_not be_nil

data/spec/helpers/admin/contents_helper_spec.rb

@@ -15,31 +15,31 @@ describe Alchemy::Admin::ContentsHelper do
     subject { helper.render_content_name(content) }
 
     it "returns the content name" do
-      should == "Intro"
+      is_expected.to eq("Intro")
     end
 
     context 'if content is nil' do
       let(:content) { nil }
 
       it "returns nil" do
-        should be_nil
+        is_expected.to be_nil
       end
     end
 
     context 'with missing description' do
-      before { content.stub(description: {}) }
+      before { expect(content).to receive(:description).and_return({}) }
 
       it "renders a warning" do
-        should have_selector('span.warning')
-        should have_content('Intro')
+        is_expected.to have_selector('span.warning')
+        is_expected.to have_content('Intro')
       end
     end
 
     context 'with validations' do
-      before { content.stub(has_validations?: true) }
+      before { expect(content).to receive(:has_validations?).and_return(true) }
 
       it "show a validation indicator" do
-        should have_selector('.validation_indicator')
+        is_expected.to have_selector('.validation_indicator')
       end
     end
   end
@@ -48,8 +48,8 @@ describe Alchemy::Admin::ContentsHelper do
     subject { helper.render_new_content_link(element) }
 
     it "renders a link to add new content to element" do
-      helper.stub(:render_icon).and_return('')
-      should match(/a.+href.*admin\/elements\/#{element.id}\/contents\/new/m)
+      allow(helper).to receive(:render_icon).and_return('')
+      is_expected.to match(/a.+href.*admin\/elements\/#{element.id}\/contents\/new/m)
     end
   end
 
@@ -57,8 +57,8 @@ describe Alchemy::Admin::ContentsHelper do
     subject { helper.render_create_content_link(element, 'headline') }
 
     it "should render a link to create a content in element" do
-      helper.stub(:render_icon).and_return('')
-      should have_selector('a.new_content_link[data-method="post"]')
+      allow(helper).to receive(:render_icon).and_return('')
+      is_expected.to have_selector('a.new_content_link[data-method="post"]')
     end
   end
 

data/spec/helpers/admin/elements_helper_spec.rb

@@ -8,12 +8,12 @@ module Alchemy
 
     context "partial rendering" do
       it "should render an element editor partial" do
-        should_receive(:render_element).with(element, :editor)
-        render_editor(element)
+        expect(helper).to receive(:render_element).with(element, :editor)
+        helper.render_editor(element)
       end
 
       it "should render a picture gallery editor partial" do
-        render_picture_gallery_editor(element).should match(/class=".+picture_gallery_editor"/)
+        expect(render_picture_gallery_editor(element)).to match(/class=".+picture_gallery_editor"/)
       end
     end
 
@@ -26,29 +26,32 @@ module Alchemy
       }
 
       before do
-        page.stub(layout_description: {'name' => "foo", 'cells' => ["foo_cell", "empty_cell"]})
-        cell_descriptions = [
-          {'name' => "foo_cell", 'elements' => ["1", "2"]},
-          {'name' => 'empty_cell', 'elements' => []}
-        ]
-        Cell.stub(:definitions).and_return(cell_descriptions)
+        allow(page).to receive(:layout_description).and_return({
+          'name' => "foo",
+          'cells' => ["foo_cell"]
+        })
+        cell_descriptions = [{
+          'name' => "foo_cell",
+          'elements' => ["1", "2"]
+        }]
+        allow(Cell).to receive(:definitions).and_return(cell_descriptions)
         helper.instance_variable_set('@page', page)
       end
 
       it "should return array of elements grouped by cell for select_tag helper" do
-        helper.grouped_elements_for_select(elements).should include("Foo cell" => [["1", "1#foo_cell"], ["2", "2#foo_cell"]])
+        expect(helper.grouped_elements_for_select(elements)).to include("Foo cell" => [["1", "1#foo_cell"], ["2", "2#foo_cell"]])
       end
 
       context "with empty elements array" do
         it "should return an empty string" do
-          helper.grouped_elements_for_select([]).should == ""
+          expect(helper.grouped_elements_for_select([])).to eq("")
         end
       end
 
       context "with empty cell definitions" do
         it "should return an empty string" do
-          page.stub(layout_description: {'name' => "foo"})
-          helper.grouped_elements_for_select(elements).should == ""
+          allow(page).to receive(:layout_description).and_return({'name' => "foo"})
+          expect(helper.grouped_elements_for_select(elements)).to eq("")
         end
       end
 
@@ -69,8 +72,8 @@ module Alchemy
         end
 
         it "should return a array for option tags" do
-          helper.elements_for_select(element_objects).should include(['Element 1', 'element_1'])
-          helper.elements_for_select(element_objects).should include(['Element 2', 'element_2'])
+          expect(helper.elements_for_select(element_objects)).to include(['Element 1', 'element_1'])
+          expect(helper.elements_for_select(element_objects)).to include(['Element 2', 'element_2'])
         end
       end
 
@@ -85,11 +88,11 @@ module Alchemy
         subject { helper.elements_for_select(element_descriptions) }
 
         it "should return a array for option tags" do
-          subject.should include(['Headline', 'headline'])
+          expect(subject).to include(['Headline', 'headline'])
         end
 
         it "should render the elements display name" do
-          Element.should_receive(:display_name_for).with('headline')
+          expect(Element).to receive(:display_name_for).with('headline')
           subject
         end
       end

data/spec/helpers/admin/essences_helper_spec.rb

@@ -15,7 +15,7 @@ describe Alchemy::Admin::EssencesHelper do
     describe '#render_essence_editor' do
       it "should render an essence editor" do
         content = element.content_by_name('intro')
-        helper.render_essence_editor(content).should match(/input.+type="text".+value="hello!/)
+        expect(helper.render_essence_editor(content)).to match(/input.+type="text".+value="hello!/)
       end
     end
 
@@ -25,15 +25,15 @@ describe Alchemy::Admin::EssencesHelper do
       let(:content) { 'intro' }
 
       it "renders an essence editor by given name" do
-        should match(/input.+type="text".+value="hello!/)
+        is_expected.to match(/input.+type="text".+value="hello!/)
       end
 
       context 'when element is nil' do
         let(:element) { nil }
 
         it "displays a warning" do
-          should have_selector(".content_editor_error")
-          should have_content("No element given.")
+          is_expected.to have_selector(".content_editor_error")
+          is_expected.to have_content("No element given.")
         end
       end
 
@@ -41,7 +41,7 @@ describe Alchemy::Admin::EssencesHelper do
         let(:content) { 'sputz' }
 
         it "displays a warning" do
-          should have_selector(".content_editor.missing")
+          is_expected.to have_selector(".content_editor.missing")
         end
       end
     end
@@ -62,13 +62,13 @@ describe Alchemy::Admin::EssencesHelper do
 
     context "with no arguments given" do
       it "should return options for select with all pages ordered by lft" do
-        helper.pages_for_select.should match(/option.*Page B.*Page A/m)
+        expect(helper.pages_for_select).to match(/option.*Page B.*Page A/m)
       end
 
       it "should return options for select with nested page names" do
         page_c
         output = helper.pages_for_select
-        output.should match(/option.*Startseite.*>  Page B.*>    Page C.*>  Page A/m)
+        expect(output).to match(/option.*Startseite.*>  Page B.*>    Page C.*>  Page A/m)
       end
     end
 
@@ -80,13 +80,13 @@ describe Alchemy::Admin::EssencesHelper do
 
       it "should return options for select with only these pages" do
         output = helper.pages_for_select(@pages)
-        output.should match(/#{@pages.collect(&:name).join('.*')}/m)
-        output.should_not match(/Page A/m)
+        expect(output).to match(/#{@pages.collect(&:name).join('.*')}/m)
+        expect(output).not_to match(/Page A/m)
       end
 
       it "should not nest the page names" do
         output = helper.pages_for_select(@pages)
-        output.should_not match(/option.* /m)
+        expect(output).not_to match(/option.* /m)
       end
     end
   end
@@ -99,11 +99,42 @@ describe Alchemy::Admin::EssencesHelper do
     end
 
     context 'when given content has no ingredient' do
-      before { content.stub(:ingredient).and_return(nil) }
+      before { allow(content).to receive(:ingredient).and_return(nil) }
+
       it "should return nil" do
         expect(helper.essence_picture_thumbnail(content, {})).to eq(nil)
       end
     end
+
+    context 'when the picture given has a size of 140x169 and it should be cropped to 250x250' do
+      before do
+        allow(content.essence).to receive(:image_file_width).and_return(140)
+        allow(content.essence).to receive(:image_file_height).and_return(169)
+      end
+
+      it 'the thumbnail url should contain 77 and 93 as thumbnail width and height' do
+        expect(helper.essence_picture_thumbnail(content, {image_size: "250x250", crop: true})).to match(/77x93/)
+      end
+
+      it 'the thumbnail url should contain 77 and 93 as thumbnail width and height' do
+        expect(helper.essence_picture_thumbnail(content, {image_size: "250x250"})).to match(/77x93/)
+      end
+    end
+
+    context 'when the picture given has a size of 300x50 and it should be cropped/resized to 225x175' do
+      before do
+        allow(content.essence).to receive(:image_file_width).and_return(300)
+        allow(content.essence).to receive(:image_file_height).and_return(50)
+      end
+
+      it 'the thumbnail url should contain 111x25 as thumbnail width and height' do
+        expect(helper.essence_picture_thumbnail(content, { size: "225x175", crop: true})).to match(/111x25/)
+      end
+
+      it 'the thumbnail url should contain 111x19 as thumbnail width and height' do
+        expect(helper.essence_picture_thumbnail(content, { size: "225x175"})).to match(/111x19/)
+      end
+    end
   end
 
 end