alchemy_cms 3.3.0.rc1 → 3.3.0.rc2

data/spec/helpers/alchemy/admin/elements_helper_spec.rb

@@ -1,314 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe Admin::ElementsHelper do
-    let(:page)    { build_stubbed(:alchemy_page, :public) }
-    let(:element) { build_stubbed(:alchemy_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 definitions" do
-        let(:element_definitions) do
-          [{
-            'name' => 'headline',
-            'contents' => []
-          }]
-        end
-
-        subject { helper.elements_for_select(element_definitions) }
-
-        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
-
-    describe '#element_editor_classes' do
-      subject { element_editor_classes(element, locals) }
-
-      let(:element) { build_stubbed(:alchemy_element) }
-      let(:locals) { Hash.new }
-
-      it "returns css classes for element editor partial" do
-        is_expected.to include('element-editor')
-      end
-
-      context 'with draggable in locals set to true' do
-        let(:locals) { {draggable: true} }
-        it { is_expected.to include('draggable') }
-      end
-
-      context 'with draggable in locals set to false' do
-        let(:locals) { {draggable: false} }
-        it { is_expected.to include('not-draggable') }
-      end
-
-      context 'with draggable in locals set to nil' do
-        let(:locals) { {draggable: nil} }
-        it { is_expected.to include('draggable') }
-      end
-
-      context 'with element is folded' do
-        let(:element) { build_stubbed(:alchemy_element, folded: true) }
-        it { is_expected.to include('folded') }
-      end
-
-      context 'with element is expanded' do
-        let(:element) { build_stubbed(:alchemy_element, folded: false) }
-        it { is_expected.to include('expanded') }
-      end
-
-      context 'with element is taggable' do
-        before do
-          allow(element).to receive(:taggable?) { true }
-        end
-
-        it { is_expected.to include('taggable') }
-      end
-
-      context 'with element is not taggable' do
-        before do
-          allow(element).to receive(:taggable?) { false }
-        end
-
-        it { is_expected.to include('not-taggable') }
-      end
-
-      context 'with element having content_definitions' do
-        before do
-          allow(element).to receive(:content_definitions) { [1] }
-        end
-
-        it { is_expected.to include('with-contents') }
-      end
-
-      context 'with element not having content_definitions' do
-        before do
-          allow(element).to receive(:content_definitions) { [] }
-        end
-
-        it { is_expected.to include('without-contents') }
-      end
-
-      context 'with element having nestable_elements' do
-        before do
-          allow(element).to receive(:nestable_elements) { [1] }
-        end
-
-        it { is_expected.to include('nestable') }
-      end
-
-      context 'with element not having nestable_elements' do
-        before do
-          allow(element).to receive(:nestable_elements) { [] }
-        end
-
-        it { is_expected.to include('not-nestable') }
-      end
-    end
-
-    describe "#show_element_footer?" do
-      subject { show_element_footer?(element, nestable_elements) }
-      let(:element) { build_stubbed(:alchemy_element) }
-      let(:nestable_elements) { nil }
-
-      context "for folded element" do
-        before { allow(element).to receive(:folded?) { true } }
-        it { is_expected.to eq(false) }
-      end
-
-      context "for expanded element" do
-        before { allow(element).to receive(:folded?) { false } }
-
-        context "with nestable_elements argument" do
-          let(:nestable_elements) { true }
-
-          context "and element having contents defined" do
-            before { allow(element).to receive(:content_definitions) { [1] } }
-            it { is_expected.to eq(true) }
-          end
-
-          context "and element having no contents defined" do
-            before { allow(element).to receive(:content_definitions) { [] } }
-
-            context "and element beeing taggable" do
-              before { allow(element).to receive(:taggable?) { true } }
-              it { is_expected.to eq(true) }
-            end
-
-            context "and element not beeing taggable" do
-              before { allow(element).to receive(:taggable?) { false } }
-              it { is_expected.to eq(false) }
-            end
-          end
-        end
-
-        context "without nestable_elements argument" do
-          let(:nestable_elements) { nil }
-
-          context "and element having no nestable elements defined" do
-            before { allow(element).to receive(:nestable_elements) { [] } }
-            it { is_expected.to eq(true) }
-          end
-
-          context "and element having nestable elements defined" do
-            before { allow(element).to receive(:nestable_elements) { [1] } }
-            it { is_expected.to eq(false) }
-          end
-        end
-      end
-    end
-  end
-end

data/spec/helpers/alchemy/admin/essences_helper_spec.rb

@@ -1,201 +0,0 @@
-require 'spec_helper'
-
-describe Alchemy::Admin::EssencesHelper do
-  include Alchemy::Admin::ElementsHelper
-
-  let(:element) do
-    create(:alchemy_element, name: 'article', create_contents_after_create: true)
-  end
-
-  describe 'essence rendering' do
-    before do
-      if element
-        element.content_by_name('intro').essence.update(body: 'hello!')
-      end
-    end
-
-    describe '#render_essence_editor' do
-      it "should render an essence editor" do
-        content = element.content_by_name('intro')
-        expect(helper.render_essence_editor(content)).
-          to match(/input.+type="text".+value="hello!/)
-      end
-    end
-
-    describe '#render_essence_editor_by_name' do
-      subject { render_essence_editor_by_name(element, content) }
-
-      let(:content) { 'intro' }
-
-      it "renders an essence editor by given name" do
-        is_expected.to match(/input.+type="text".+value="hello!/)
-      end
-
-      context 'when element is nil' do
-        let(:element) { nil }
-
-        it "displays a warning" do
-          is_expected.to have_selector(".content_editor_error")
-          is_expected.to have_content("No element given.")
-        end
-      end
-
-      context 'when content is not found on element' do
-        let(:content) { 'sputz' }
-
-        it "displays a warning" do
-          is_expected.to have_selector(".content_editor.missing")
-        end
-      end
-    end
-  end
-
-  describe '#pages_for_select' do
-    let(:contact_form) do
-      create(:alchemy_element, name: 'contactform', create_contents_after_create: true)
-    end
-
-    let(:page_a) { create(:alchemy_page, :public, name: 'Page A') }
-    let(:page_b) { create(:alchemy_page, :public, name: 'Page B') }
-    let(:page_c) { create(:alchemy_page, :public, name: 'Page C', parent_id: page_b.id) }
-
-    before do
-      # to be shure the ordering is alphabetic
-      page_b
-      page_a
-      helper.session[:alchemy_language_id] = 1
-    end
-
-    context "with no arguments given" do
-      it "should return options for select with all pages ordered by lft" do
-        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
-        expect(output).to match(/option.*Startseite.*>  Page B.*>    Page C.*>  Page A/m)
-      end
-    end
-
-    context "with pages passed in" do
-      before do
-        @pages = []
-        3.times { @pages << create(:alchemy_page, :public) }
-      end
-
-      it "should return options for select with only these pages" do
-        output = helper.pages_for_select(@pages)
-        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)
-        expect(output).not_to match(/option.*&nbsp;/m)
-      end
-    end
-  end
-
-  describe '#essence_picture_thumbnail' do
-    let(:content) { build_stubbed(:alchemy_content, essence: build_stubbed(:alchemy_essence_picture)) }
-
-    it "should return an image tag" do
-      expect(helper.essence_picture_thumbnail(content, {})).to have_selector('img[src]')
-    end
-
-    context 'when given content has no ingredient' do
-      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
-
-  describe "#edit_picture_dialog_size" do
-    let(:content) { build_stubbed(:alchemy_content) }
-
-    subject { edit_picture_dialog_size(content) }
-
-    context "with content having setting caption_as_textarea being true and sizes set" do
-      before do
-        allow(content).to receive(:settings) do
-          {
-            caption_as_textarea: true,
-            sizes: ['100x100', '200x200']
-          }
-        end
-
-        it { is_expected.to eq("380x320") }
-      end
-    end
-
-    context "with content having setting caption_as_textarea being true and no sizes set" do
-      before do
-        allow(content).to receive(:settings) do
-          {
-            caption_as_textarea: true
-          }
-        end
-
-        it { is_expected.to eq("380x300") }
-      end
-    end
-
-    context "with content having setting caption_as_textarea being false and sizes set" do
-      before do
-        allow(content).to receive(:settings) do
-          {
-            caption_as_textarea: false,
-            sizes: ['100x100', '200x200']
-          }
-        end
-
-        it { is_expected.to eq("380x290") }
-      end
-    end
-
-    context "with content having setting caption_as_textarea being false and no sizes set" do
-      before do
-        allow(content).to receive(:settings) do
-          {
-            caption_as_textarea: false
-          }
-        end
-
-        it { is_expected.to eq("380x255") }
-      end
-    end
-  end
-end