lc_alchemy_cms 3.2.0

data/spec/helpers/admin/attachments_helper_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Alchemy::Admin::AttachmentsHelper do
+  describe '#mime_to_human' do
+    context 'when given mime type has no translation' do
+      it "should return the default" do
+        expect(helper.mime_to_human('something')).to eq('File')
+      end
+    end
+
+    it "should return the translation for the given mime type" do
+      expect(helper.mime_to_human('text/plain')).to eq('Text-Document')
+    end
+  end
+end

data/spec/helpers/admin/base_helper_spec.rb

@@ -0,0 +1,270 @@
+require 'spec_helper'
+
+module Alchemy
+  describe Admin::BaseHelper do
+    context "maximum amount of images option" do
+      subject { helper.max_image_count }
+
+      before { helper.instance_variable_set('@options', options) }
+
+      context "with max_images option set to emtpy string" do
+        let(:options) { {max_images: ""} }
+        it { is_expected.to eq(nil) }
+      end
+
+      context "with max_images option set to '1'" do
+        let(:options) { {max_images: "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 { 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 { is_expected.to eq(1) }
+      end
+    end
+
+    describe "#merge_params" do
+      before do
+        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
+        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
+        allow(controller).to receive(:params).and_return({:first => '1', :second => '2'})
+      end
+
+      it "can delete a single param" do
+        expect(helper.merge_params_without(:second)).to eq({:first => '1'})
+      end
+
+      it "can delete several params" do
+        expect(helper.merge_params_without([:first, :second])).to eq({})
+      end
+
+      it "can delete a param and add new params at the same time" do
+        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])
+        expect(controller.params).to eq({:first => '1', :second => '2'})
+      end
+    end
+
+    describe "#merge_params_only" do
+      before do
+        allow(controller).to receive(:params).and_return({:first => '1', :second => '2', :third => '3'})
+      end
+
+      it "can keep a single param" do
+        expect(helper.merge_params_only(:second)).to eq({:second => '2'})
+      end
+
+      it "can keep several params" do
+        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
+        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])
+        expect(controller.params).to eq({:first => '1', :second => '2', :third => '3'})
+      end
+    end
+
+    describe '#toolbar_button' do
+      context "with permission" do
+        before { allow(helper).to receive(:can?).and_return(true) }
+
+        it "renders a toolbar button" do
+          expect(helper.toolbar_button(
+            url: admin_dashboard_path
+          )).to match /<div.+class="button_with_label/
+        end
+      end
+
+      context "without permission" do
+        before { allow(helper).to receive(:can?).and_return(false) }
+
+        it "returns empty string" do
+          expect(helper.toolbar_button(
+            url: admin_dashboard_path
+          )).to be_empty
+        end
+      end
+
+      context "with disabled permission check" do
+        before { allow(helper).to receive(:can?).and_return(false) }
+
+        it "returns the button" do
+          expect(helper.toolbar_button(
+            url: admin_dashboard_path,
+            skip_permission_check: true
+          )).to match /<div.+class="button_with_label/
+        end
+      end
+
+      context "with empty permission option" do
+        before { allow(helper).to receive(:can?).and_return(true) }
+
+        it "returns reads the permission from url" do
+          expect(helper).to receive(:permission_array_from_url)
+          expect(helper.toolbar_button(
+            url: admin_dashboard_path,
+            if_permitted_to: ''
+          )).not_to be_empty
+        end
+      end
+
+      context "with overlay option set to false" do
+        before do
+          allow(helper).to receive(:can?).and_return(true)
+          expect(helper).to receive(:permission_array_from_url)
+        end
+
+        it "renders a normal link" do
+          button = helper.toolbar_button(
+            url: admin_dashboard_path,
+            overlay: false
+          )
+          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
+        allow(Alchemy::I18n).to receive(:available_locales).and_return([:de, :en, :cz, :it])
+        expect(helper.translations_for_select.size).to eq(4)
+      end
+    end
+
+    describe '#clipboard_select_tag_options' do
+      let(:page) { build_stubbed(:page) }
+      before { helper.instance_variable_set('@page', page) }
+
+      context 'with element items' do
+        let(:element) { build_stubbed(:element) }
+        let(:clipboard_items) { [element] }
+
+        it "should include select options with the display name and preview text" do
+          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 { allow(page).to receive(:can_have_cells?).and_return(true) }
+          it "should group the elements in the clipboard by cell" do
+            expect(helper).to receive(:grouped_elements_for_select).and_return({})
+            helper.clipboard_select_tag_options(clipboard_items)
+          end
+        end
+      end
+
+      context 'with page items' do
+        let(:page_in_clipboard) { build_stubbed(:page, name: 'Page name') }
+        let(:clipboard_items) { [page_in_clipboard] }
+
+        it "should include select options with page names" do
+          expect(helper.clipboard_select_tag_options(clipboard_items)).to have_selector('option', text: 'Page name')
+        end
+      end
+    end
+
+    describe '#button_with_confirm' do
+      subject { button_with_confirm }
+
+      it "renders a button tag with a data attribute for confirm dialog" do
+        is_expected.to have_selector('button[data-alchemy-confirm]')
+      end
+    end
+
+    describe '#delete_button' do
+      subject { delete_button('/admin/pages') }
+
+      it "renders a button tag" do
+        is_expected.to have_selector('button')
+      end
+
+      it "returns a form tag with method=delete" do
+        is_expected.to have_selector('form input[name="_method"][value="delete"]')
+      end
+    end
+
+    describe '#alchemy_datepicker' do
+      subject { alchemy_datepicker(essence, :date, {value: now}) }
+
+      let(:essence) { EssenceDate.new() }
+      let(:now)     { Time.now }
+
+      it "renders a date field" do
+        is_expected.to have_selector("input[type='date']")
+      end
+
+      it "sets default date as value" do
+        is_expected.to have_selector("input[value='#{::I18n.l(now, format: :datepicker)}']")
+      end
+
+      context 'with date stored on object' do
+        let(:date)    { Time.parse('1976-10-07 00:00 Z') }
+        let(:essence) { EssenceDate.new(date: date) }
+
+        it "sets this date as value" do
+          is_expected.to have_selector("input[value='#{::I18n.l(date, format: :datepicker)}']")
+        end
+      end
+    end
+
+    describe '#current_alchemy_user_name' do
+      subject { helper.current_alchemy_user_name }
+
+      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
+          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 { is_expected.to be_nil }
+      end
+    end
+
+    describe '#link_url_regexp' do
+      subject { helper.link_url_regexp }
+
+      it "returns the regular expression for external link urls" do
+        expect(subject).to be_a(Regexp)
+      end
+
+      context 'if the expression from config is nil' do
+        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
+        end
+      end
+    end
+  end
+end

data/spec/helpers/admin/contents_helper_spec.rb

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

data/spec/helpers/admin/elements_helper_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+module Alchemy
+  describe Admin::ElementsHelper do
+    let(:page)    { build_stubbed(:public_page) }
+    let(:element) { build_stubbed(:element, page: page) }
+
+    context "partial rendering" do
+      it "should render an element editor partial" do
+        expect(helper).to receive(:render_element).with(element, :editor)
+        helper.render_editor(element)
+      end
+
+      it "should render a picture gallery editor partial" do
+        expect(render_picture_gallery_editor(element)).to match(/class=".+picture_gallery_editor"/)
+      end
+    end
+
+    describe "#grouped_elements_for_select" do
+      let(:elements) do
+        [
+          mock_model('Element', name: '1', display_name: '1'),
+          mock_model('Element', name: '2', display_name: '2')
+        ]
+      end
+      let(:element_definitions) { [{"name" => "1"}, {"name" => "2"}] }
+      let(:cell_definitions) { [] }
+      let(:page_definition) { {} }
+
+      before do
+        allow(page).to receive(:definition).and_return(page_definition)
+        allow(Cell).to receive(:definitions).and_return(cell_definitions)
+        allow(Element).to receive(:definitions).and_return(element_definitions)
+        helper.instance_variable_set('@page', page)
+      end
+
+      context "with empty elements array given" do
+        it "return an empty array" do
+          expect(helper.grouped_elements_for_select([])).to eq([])
+        end
+      end
+
+      context "with an element collection given" do
+        let(:page_definition) do
+          {'name' => "foo", 'cells' => ["foo_cell"], 'elements' => []}
+        end
+
+        let(:cell_definitions) do
+          [{'name' => "foo_cell", 'elements' => ["1", "2"]}]
+        end
+
+        it "returns an array of elements grouped by cell for select_tag helper" do
+          expect(helper.grouped_elements_for_select(elements)).to eq("Foo cell" => [["1", "1#foo_cell"], ["2", "2#foo_cell"]])
+        end
+
+        context "without cells key in page definition" do
+          let(:page_definition) do
+            {'name' => "foo", "elements" => ["1", "2"]}
+          end
+
+          it "returns an empty array" do
+            expect(helper.grouped_elements_for_select(elements)).to eq([])
+          end
+        end
+
+        context "with empty cells in page definition" do
+          let(:page_definition) do
+            {"name" => "foo", "cells" => [], "elements" => ["1", "2"]}
+          end
+
+          it "returns an empty array" do
+            expect(helper.grouped_elements_for_select(elements)).to eq([])
+          end
+        end
+
+        context "with a cell containing no elements" do
+          let(:cell_definitions) do
+            [{"name" => "empty_cell", "elements" => []}]
+          end
+
+          let(:page_definition) do
+            {"name" => "foo", "cells" => ["empty_cell"], "elements" => ["1", "2"]}
+          end
+
+          it "does not include that cell" do
+            expect(helper.grouped_elements_for_select(elements)).to eq("Main content" => [["1", "1"], ["2", "2"]])
+          end
+        end
+
+        context "with an element in a cell only" do
+          let(:elements) do
+            [mock_model('Element', name: 'in_cell', display_name: 'In Cell')]
+          end
+
+          let(:page_definition) do
+            {'name' => "foo", 'cells' => ["foo_cell"], 'elements' => []}
+          end
+
+          let(:cell_definitions) do
+            [{'name' => "foo_cell", 'elements' => ["in_cell"]}]
+          end
+
+          it "returns an option for the element in the cell only" do
+            expect(helper.grouped_elements_for_select(elements)).to include("Foo cell" => [["In cell", "in_cell#foo_cell"]])
+          end
+        end
+
+        context "with the same element in both cell and page" do
+          let(:element_definitions) do
+            [{"name" => "in_cell_and_page"}]
+          end
+
+          let(:elements) do
+            [mock_model('Element', name: 'in_cell_and_page', display_name: 'In Cell and Page')]
+          end
+
+          let(:page_definition) do
+            {
+              'name' => "foo",
+              'cells' => ["foo_cell"],
+              'elements' => ["in_cell_and_page"]
+            }
+          end
+
+          let(:cell_definitions) do
+            [{
+              'name' => "foo_cell",
+              'elements' => ["in_cell_and_page"]
+            }]
+          end
+
+          it "returns two options of same element, one for the cell and one for the page" do
+            expect(helper.grouped_elements_for_select(elements)).to eq({
+              "Main content" => [["In cell and page", "in_cell_and_page"]],
+              "Foo cell" => [["In cell and page", "in_cell_and_page#foo_cell"]]
+            })
+          end
+        end
+      end
+    end
+
+    describe "#elements_for_select" do
+      context "passing element instances" do
+        let(:element_objects) do
+          [
+            mock_model('Element', name: 'element_1', display_name: 'Element 1'),
+            mock_model('Element', name: 'element_2', display_name: 'Element 2')
+          ]
+        end
+
+        it "should return a array for option tags" do
+          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
+
+      context "passing a hash with element descriptions" do
+        let(:element_descriptions) do
+          [{
+            'name' => 'headline',
+            'contents' => []
+          }]
+        end
+
+        subject { helper.elements_for_select(element_descriptions) }
+
+        it "should return a array for option tags" do
+          expect(subject).to include(['Headline', 'headline'])
+        end
+
+        it "should render the elements display name" do
+          expect(Element).to receive(:display_name_for).with('headline')
+          subject
+        end
+      end
+    end
+  end
+end