alchemy_cms 2.6.3 → 2.7.0

data/spec/helpers/admin/essences_helper_spec.rb

@@ -1,57 +1,71 @@
 require 'spec_helper'
 
 describe Alchemy::Admin::EssencesHelper do
+  include Alchemy::Admin::ElementsHelper
 
   let(:element) { FactoryGirl.create(:element, :name => 'article', :create_contents_after_create => true) }
 
-  before do
-    element.content_by_name('intro').essence.update_attributes(:body => 'hello!')
-  end
+  describe 'essence rendering' do
+    before do
+      element.content_by_name('intro').essence.update_attributes(:body => 'hello!')
+    end
 
-  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!/)
-  end
+    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!/)
+    end
 
-  it "should render an essence editor by name" do
-    helper.render_essence_editor_by_name(element, 'intro').should match(/input.+type="text".+value="hello!/)
-  end
+    it "should render an essence editor by name" do
+      helper.render_essence_editor_by_name(element, 'intro').should match(/input.+type="text".+value="hello!/)
+    end
 
-  it "should render an essence editor by type" do
-    helper.render_essence_editor_by_type(element, 'EssenceText').should match(/input.+type="text".+value="hello!/)
+    it "should render an essence editor by type" do
+      helper.render_essence_editor_by_type(element, 'EssenceText').should match(/input.+type="text".+value="hello!/)
+    end
   end
 
-  describe '#page_selector' do
-
-    let(:contact_form)  { FactoryGirl.create(:element, :name => 'contactform', :create_contents_after_create => true) }
-    let(:contact_page)  { FactoryGirl.create(:public_page, :page_layout => 'contact', :name => 'Contact') }
-    let(:page_a)        { FactoryGirl.create(:public_page, :name => 'Page A') }
-    let(:page_b)        { FactoryGirl.create(:public_page, :name => 'Page B') }
-    let(:page_c)        { FactoryGirl.create(:public_page, :name => 'Page C') }
+  describe '#pages_for_select' do
+    let(:contact_form) { FactoryGirl.create(:element, :name => 'contactform', :create_contents_after_create => true) }
+    let(:page_a) { FactoryGirl.create(:public_page, :name => 'Page A') }
+    let(:page_b) { FactoryGirl.create(:public_page, :name => 'Page B') }
+    let(:page_c) { FactoryGirl.create(:public_page, :name => 'Page C', :parent_id => page_b.id) }
 
     before do
-      helper.session[:language_id] = 1
-      contact_page
+      # to be shure the ordering is alphabetic
       page_b
-      page_c
       page_a
+      helper.session[:language_id] = 1
     end
 
-    context "with only option set to 'standard'" 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)
+      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)
+      end
+    end
 
-      it "should render select tag with standard pages only" do
-        output = helper.page_selector(contact_form, 'success_page', :only => 'standard')
-        output.should match(/select.*Page A/m)
-        output.should_not match(/select.*Contact/m)
+    context "with pages passed in" do
+      before do
+        @pages = []
+        3.times { @pages << FactoryGirl.create(:public_page) }
       end
 
-      it "should render select tag with pages ordered by name" do
-        output = helper.page_selector(contact_form, 'success_page', :only => 'standard')
-        output.should match(/select.*Page A.*Page B.*Page C/m)
+      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)
       end
 
+      it "should not nest the page names" do
+        output = helper.pages_for_select(@pages)
+        output.should_not match(/option.*&nbsp;/m)
+      end
     end
-
   end
 
 end

data/spec/helpers/admin/navigation_helper_spec.rb

@@ -0,0 +1,204 @@
+require 'spec_helper'
+
+describe Alchemy::Admin::NavigationHelper do
+  let(:alchemy_module) { {
+    'name' => 'dashboard',
+    'engine_name' => 'alchemy',
+    'navigation' => {
+      'name' => 'modules.dashboard',
+      'controller' => 'alchemy/admin/dashboard',
+      'action' => 'index',
+      'icon' => 'dashboard',
+      'sub_navigation' => [{
+        'controller' => 'alchemy/admin/layoutpages',
+        'action' => 'index'
+      }]
+    }
+  } }
+
+  let(:event_module) { {
+    'navigation' => {
+      'controller' => 'admin/events',
+      'action' => 'index',
+      'sub_navigation' => [{
+        'controller' => 'admin/events',
+        'action' => 'index'
+      }]
+    }
+  } }
+
+  let(:navigation) { alchemy_module['navigation'] }
+
+  describe '#alchemy_main_navigation_entry' do
+    before {
+      helper.stub(:url_for_module).and_return('')
+      helper.stub(:_t).and_return(alchemy_module['name'])
+    }
+
+    context "with permission" do
+      before {
+        helper.stub(:permitted_to?).and_return(true)
+      }
+
+      it "renders the main navigation entry partial" do
+        helper.alchemy_main_navigation_entry(alchemy_module).should match /<a.+class="main_navi_entry/
+      end
+    end
+
+    context "without permission" do
+      before {
+        helper.stub(:permitted_to?).and_return(false)
+      }
+
+      it "returns empty string" do
+        helper.alchemy_main_navigation_entry(alchemy_module).should be_empty
+      end
+    end
+  end
+
+  describe '#admin_subnavigation' do
+    before {
+      helper.stub(:current_alchemy_module).and_return(alchemy_module)
+      helper.stub(:url_for_module_sub_navigation).and_return('')
+      helper.stub(:_t).and_return(alchemy_module['name'])
+    }
+
+    context "with permission" do
+      before {
+        helper.stub(:permitted_to?).and_return(true)
+      }
+
+      it "renders the sub navigation for current module" do
+        helper.admin_subnavigation.should match /<div.+class="subnavi_tab/
+      end
+    end
+
+    context "without permission" do
+      before {
+        helper.stub(:permitted_to?).and_return(false)
+      }
+
+      it "renders the sub navigation for current module" do
+        helper.admin_subnavigation.should be_empty
+      end
+    end
+
+    context "without a module present" do
+      before {
+        helper.stub(:current_alchemy_module).and_return(nil)
+      }
+
+      it "returns nil" do
+        helper.admin_subnavigation.should be_nil
+      end
+    end
+  end
+
+  describe '#navigate_module' do
+    it "returns array with symbolized controller and action name" do
+      helper.navigate_module(navigation).should == [:index, :alchemy_admin_dashboard]
+    end
+  end
+
+  describe '#main_navigation_css_classes' do
+    it "returns string with css classes for main navigation entry" do
+      helper.main_navigation_css_classes(navigation).should == "main_navi_entry"
+    end
+
+    context "with active entry" do
+      before {
+        helper.stub(:params).and_return({controller: 'alchemy/admin/dashboard', action: 'index'})
+      }
+
+      it "includes active class" do
+        helper.main_navigation_css_classes(navigation).should == "main_navi_entry active"
+      end
+    end
+  end
+
+  describe '#entry_active?' do
+    let(:entry) {
+      {'controller' => 'alchemy/admin/dashboard', 'action' => 'index'}
+    }
+
+    context "with active entry" do
+      before {
+        helper.stub(:params).and_return({controller: 'alchemy/admin/dashboard', action: 'index'})
+      }
+
+      it "returns true" do
+        helper.entry_active?(entry).should be_true
+      end
+
+      context "and with leading slash in controller name" do
+        before { entry['controller'] = '/alchemy/admin/dashboard' }
+
+        it "returns true" do
+          helper.entry_active?(entry).should be_true
+        end
+      end
+
+      context "but with action listed in nested_actions key" do
+        before {
+          entry['action'] = nil
+          entry['nested_actions'] = %w(index)
+        }
+
+        it "returns true" do
+          helper.entry_active?(entry).should be_true
+        end
+      end
+    end
+
+    context "with inactive entry" do
+      before {
+        helper.stub(:params).and_return({controller: 'alchemy/admin/users', action: 'index'})
+      }
+
+      it "returns false" do
+        helper.entry_active?(entry).should be_false
+      end
+    end
+  end
+
+  describe '#url_for_module' do
+    context "with module within an engine" do
+      it "returns correct url string" do
+        helper.url_for_module(alchemy_module).should == '/admin/dashboard'
+      end
+    end
+
+    context "with module within host app" do
+      it "returns correct url string" do
+        helper.url_for_module(event_module).should == '/admin/events'
+      end
+    end
+  end
+
+  describe '#url_for_module_sub_navigation' do
+    context "with module within an engine" do
+      let(:navigation) { alchemy_module['navigation']['sub_navigation'].first }
+
+      before {
+        helper.stub(:module_definition_for).and_return(alchemy_module)
+      }
+
+      it "returns correct url string" do
+        helper.url_for_module_sub_navigation(navigation).should == '/admin/layoutpages'
+      end
+    end
+
+    context "with module within host app" do
+      let(:navigation) { event_module['navigation']['sub_navigation'].first }
+
+      before {
+        helper.stub(:module_definition_for).and_return(event_module)
+      }
+
+      it "returns correct url string" do
+        helper.url_for_module_sub_navigation(navigation).should == '/admin/events'
+      end
+    end
+  end
+
+end

data/spec/helpers/admin/pages_helper_spec.rb

@@ -2,15 +2,33 @@ require 'spec_helper'
 
 describe Alchemy::Admin::PagesHelper do
 
-  describe '#tinymce_javascript_tags' do
-    it "renders script tag for tinymce initalization" do
-      helper.tinymce_javascript_tags.squish.should match(/script.+Alchemy\.Tinymce/)
+  describe '#sitemap_folder_link' do
+    let(:user) { FactoryGirl.build_stubbed(:admin_user) }
+    before { helper.stub(:current_user).and_return(user) }
+    subject { helper.sitemap_folder_link(page) }
+
+    context "with folded page" do
+      let(:page) { mock_model(Alchemy::Page, folded?: true) }
+
+      it "renders a link with folded class" do
+        should match /class="page_folder folded spinner"/
+      end
+
+      it "renders a link with hide title" do
+        should match /title="Show childpages"/
+      end
     end
-  end
 
-  describe '#custom_tinymce_javascript_tags' do
-    it "renders script tag for custom tinymce initalization" do
-      helper.custom_tinymce_javascript_tags.squish.should match(/Alchemy\.Tinymce\.customInits/)
+    context "with collapsed page" do
+      let(:page) { mock_model(Alchemy::Page, folded?: false) }
+
+      it "renders a link with collapsed class" do
+        should match /class="page_folder collapsed spinner"/
+      end
+
+      it "renders a link with hide title" do
+        should match /title="Hide childpages"/
+      end
     end
   end
 
@@ -20,12 +38,4 @@ describe Alchemy::Admin::PagesHelper do
     end
   end
 
-  describe '#combined_page_status' do
-    let(:page) { FactoryGirl.build(:page, public: true, visible: true, restricted: false, locked: false)}
-
-    it "returns the translated page status" do
-      helper.combined_page_status(page).should == 'Page is visible in navigation.<br>Page is published.<br>Page is not restricted.'
-    end
-  end
-
 end

data/spec/helpers/admin/tags_helper_spec.rb

@@ -3,8 +3,68 @@ require 'spec_helper'
 module Alchemy
   describe Admin::TagsHelper do
 
-    let(:tag) do
-      mock_model(ActsAsTaggableOn::Tag, :name => "foo")
+    let(:tag)    { mock_model(ActsAsTaggableOn::Tag, name: 'foo', count: 1) }
+    let(:tag2)   { mock_model(ActsAsTaggableOn::Tag, name: 'abc', count: 1) }
+    let(:params) { {controller: 'admin/attachments', action: 'index', use_route: 'alchemy', tagged_with: 'foo'} }
+
+    describe '#render_tag_list' do
+      context "with tagged objects" do
+        before { Attachment.stub!(:tag_counts).and_return([tag, tag2]) }
+
+        it "returns a tag list as <li> tags" do
+          helper.render_tag_list('Alchemy::Attachment', params).should match(/li/)
+        end
+
+        it "has the tags name in the li's name attribute" do
+          helper.render_tag_list('Alchemy::Attachment', params).should match(/li.+name="#{tag.name}"/)
+        end
+
+        it "has active class if tag is present in params" do
+          helper.render_tag_list('Alchemy::Attachment', params).should match(/li.+class="active"/)
+        end
+
+        it "tags are sorted alphabetically" do
+          helper.render_tag_list('Alchemy::Attachment', params).should match(/li.+name="#{tag2.name}.+li.+name="#{tag.name}/)
+        end
+
+        context "with lowercase and uppercase tag names mixed" do
+          let(:tag) { mock_model(ActsAsTaggableOn::Tag, name: 'Foo', count: 1) }
+
+          it "tags are sorted alphabetically correctly" do
+            helper.render_tag_list('Alchemy::Attachment', params).should match(/li.+name="#{tag2.name}.+li.+name="#{tag.name}/)
+          end
+        end
+
+        it "output is html_safe" do
+          helper.render_tag_list('Alchemy::Attachment', params).html_safe?.should be_true
+        end
+      end
+
+      context "without any tagged objects" do
+        it "returns empty string" do
+          render_tag_list('Alchemy::Attachment', params).should be_empty
+        end
+      end
+
+      context "with nil given as class_name parameter" do
+        it "raises argument error" do
+          expect { render_tag_list(nil, params) }.to raise_error(ArgumentError)
+        end
+      end
+    end
+
+    describe '#tag_list_tag_active?' do
+      context "the tag is in params" do
+        it "returns true" do
+          tag_list_tag_active?(tag, params).should be_true
+        end
+      end
+
+      context "params[:tagged_with] is not present" do
+        it "returns false" do
+          tag_list_tag_active?(tag, {}).should be_false
+        end
+      end
     end
 
     describe "#filtered_by_tag?" do

data/spec/helpers/elements_helper_spec.rb

@@ -2,210 +2,274 @@ require 'spec_helper'
 
 include Alchemy::BaseHelper
 
-describe Alchemy::ElementsHelper do
-
-  before(:each) do
-    @page = FactoryGirl.create(:public_page)
-    @element = FactoryGirl.create(:element, :page => @page)
-    session[:language_id] = @page.language_id
-  end
-
-  it "should render an element view partial" do
-    helper.render_element(@element).should match(/id="#{@element.name}_#{@element.id}"/)
-  end
-
-  it "should render a unique dom id for element" do
-    helper.element_dom_id(@element).should == "#{@element.name}_#{@element.id}"
-  end
-
-  describe "#render_elements" do
+module Alchemy
+  describe ElementsHelper do
 
     before(:each) do
-      helper.stub!(:configuration).and_return(true)
+      @page = FactoryGirl.create(:public_page)
+      @element = FactoryGirl.create(:element, :page => @page)
+      session[:language_id] = @page.language_id
     end
 
-    context "with no certain option given" do
-      it "should render all elements from @page" do
-        @another_element = FactoryGirl.create(:element, :page => @page)
-        # m for regex means line breaks are like every character
-        helper.render_elements.should match(/id="#{@element.name}_#{@element.id.to_s}.*id="#{@another_element.name}_#{@another_element.id.to_s}"/m)
-      end
+    it "should render an element view partial" do
+      helper.render_element(@element).should match(/id="#{@element.name}_#{@element.id}"/)
+    end
 
-      it "should not render elements that are in a cell" do
-        cell = FactoryGirl.create(:cell)
-        @another_element = FactoryGirl.create(:element, :page => @page, :cell_id => cell.id)
-        helper.render_elements.should_not match(/id="#{@another_element.name}_#{@another_element.id}"/)
-      end
+    it "should render a unique dom id for element" do
+      helper.element_dom_id(@element).should == "#{@element.name}_#{@element.id}"
     end
 
-    context "with except option" do
-      it "should render all elements except a certain one" do
-        @another_element = FactoryGirl.create(:element, :page => @page)
-        helper.render_elements(:except => @another_element.name).should_not match(/id="#{@another_element.name}_\d*"/)
+    describe "#render_elements" do
+
+      before(:each) do
+        helper.stub!(:configuration).and_return(true)
       end
-    end
 
-    context "with only option" do
-      it "should render one certain element" do
-        @another_element = FactoryGirl.create(:element, :name => 'headline', :page => @page)
-        helper.render_elements(:only => @element.name).should_not match(/id="#{@another_element.name}_\d*"/)
+      context "with no certain option given" do
+        it "should render all elements from @page" do
+          @another_element = FactoryGirl.create(:element, :page => @page)
+          # m for regex means line breaks are like every character
+          helper.render_elements.should match(/id="#{@element.name}_#{@element.id.to_s}.*id="#{@another_element.name}_#{@another_element.id.to_s}"/m)
+        end
+
+        it "should not render elements that are in a cell" do
+          cell = FactoryGirl.create(:cell)
+          @another_element = FactoryGirl.create(:element, :page => @page, :cell_id => cell.id)
+          helper.render_elements.should_not match(/id="#{@another_element.name}_#{@another_element.id}"/)
+        end
       end
-    end
 
-    context "with from_page option" do
-      it "should render all elements from a certain page" do
-        @another_page = FactoryGirl.create(:public_page)
-        @element_on_other_page = FactoryGirl.create(:element, :name => 'headline', :page => @another_page)
-        helper.render_elements(:from_page => @another_page).should match(/id="#{@element_on_other_page.name}_\d*"/)
+      context "with except option" do
+        it "should render all elements except a certain one" do
+          @another_element = FactoryGirl.create(:element, :page => @page)
+          helper.render_elements(:except => @another_element.name).should_not match(/id="#{@another_element.name}_\d*"/)
+        end
       end
 
-      it "should not render any elements in a cell from the given page" do
-        @another_page = FactoryGirl.create(:public_page)
-        @cell = FactoryGirl.create(:cell, :name => "Celltest", :page => @another_page)
-        @element_not_in_cell = FactoryGirl.create(:element, :name => 'headline', :page => @another_page)
-        @element_in_cell = FactoryGirl.create(:element, :name => 'article', :cell => @cell, :page => @another_page)
-        helper.render_elements(:from_page => @another_page).should_not match(/id="#{@element_in_cell.name}_#{@element_in_cell.id}*"/)
+      context "with only option" do
+        it "should render one certain element" do
+          @another_element = FactoryGirl.create(:element, :name => 'headline', :page => @page)
+          helper.render_elements(:only => @element.name).should_not match(/id="#{@another_element.name}_\d*"/)
+        end
       end
 
-      context "and from_cell option" do
-        it "should render all elements from the page's cell" do
+      context "with from_page option" do
+        it "should render all elements from a certain page" do
+          @another_page = FactoryGirl.create(:public_page)
+          @element_on_other_page = FactoryGirl.create(:element, :name => 'headline', :page => @another_page)
+          helper.render_elements(:from_page => @another_page).should match(/id="#{@element_on_other_page.name}_\d*"/)
+        end
+
+        it "should not render any elements in a cell from the given page" do
           @another_page = FactoryGirl.create(:public_page)
           @cell = FactoryGirl.create(:cell, :name => "Celltest", :page => @another_page)
           @element_not_in_cell = FactoryGirl.create(:element, :name => 'headline', :page => @another_page)
           @element_in_cell = FactoryGirl.create(:element, :name => 'article', :cell => @cell, :page => @another_page)
-          helper.render_elements(:from_page => @another_page, :from_cell => "Celltest").should match(/id="#{@element_in_cell.name}_#{@element_in_cell.id}*"/)
+          helper.render_elements(:from_page => @another_page).should_not match(/id="#{@element_in_cell.name}_#{@element_in_cell.id}*"/)
         end
-      end
 
-    end
+        context "and from_cell option" do
+          it "should render all elements from the page's cell" do
+            @another_page = FactoryGirl.create(:public_page)
+            @cell = FactoryGirl.create(:cell, :name => "Celltest", :page => @another_page)
+            @element_not_in_cell = FactoryGirl.create(:element, :name => 'headline', :page => @another_page)
+            @element_in_cell = FactoryGirl.create(:element, :name => 'article', :cell => @cell, :page => @another_page)
+            helper.render_elements(:from_page => @another_page, :from_cell => "Celltest").should match(/id="#{@element_in_cell.name}_#{@element_in_cell.id}*"/)
+          end
+        end
 
-    context "with from_cell option" do
-      it "should render all elements from a certain cell" do
-        cell = FactoryGirl.create(:cell)
-        @another_element = FactoryGirl.create(:element, :page => @page, :cell_id => cell.id)
-        helper.render_elements(:from_cell => cell).should match(/id="#{@another_element.name}_#{@another_element.id}"/)
       end
 
-      context "with from_cell and only option" do
-        it "should render certain elements from a certain cell" do
+      context "with from_cell option" do
+        it "should render all elements from a certain cell" do
           cell = FactoryGirl.create(:cell)
           @another_element = FactoryGirl.create(:element, :page => @page, :cell_id => cell.id)
-          @another_element2 = FactoryGirl.create(:element, :page => @page)
-          helper.render_elements(:from_cell => cell, :only => @another_element.name).should_not match(/id="#{@another_element2.name}_#{@another_element2.id}"/)
+          helper.render_elements(:from_cell => cell).should match(/id="#{@another_element.name}_#{@another_element.id}"/)
+        end
+
+        context "with from_cell and only option" do
+          it "should render certain elements from a certain cell" do
+            cell = FactoryGirl.create(:cell)
+            @another_element = FactoryGirl.create(:element, :page => @page, :cell_id => cell.id)
+            @another_element2 = FactoryGirl.create(:element, :page => @page)
+            helper.render_elements(:from_cell => cell, :only => @another_element.name).should_not match(/id="#{@another_element2.name}_#{@another_element2.id}"/)
+          end
         end
+
+        context "with from_cell and except option" do
+          it "should render all elements except certain ones from a certain cell" do
+            cell = FactoryGirl.create(:cell)
+            @another_element = FactoryGirl.create(:element, :page => @page, :cell_id => cell.id)
+            @another_element2 = FactoryGirl.create(:element, :page => @page, :cell_id => cell.id)
+            helper.render_elements(:from_cell => cell, :except => @another_element.name).should_not match(/id="#{@another_element.name}_#{@another_element.id}"/)
+          end
+        end
+
       end
 
-      context "with from_cell and except option" do
-        it "should render all elements except certain ones from a certain cell" do
-          cell = FactoryGirl.create(:cell)
-          @another_element = FactoryGirl.create(:element, :page => @page, :cell_id => cell.id)
-          @another_element2 = FactoryGirl.create(:element, :page => @page, :cell_id => cell.id)
-          helper.render_elements(:from_cell => cell, :except => @another_element.name).should_not match(/id="#{@another_element.name}_#{@another_element.id}"/)
+      context "with count option" do
+        it "should render just one element because of the count option" do
+          @page.elements.delete_all
+          @another_element_1 = FactoryGirl.create(:element, :page => @page)
+          @another_element_2 = FactoryGirl.create(:element, :page => @page)
+          @another_element_3 = FactoryGirl.create(:element, :page => @page)
+          helper.render_elements(:count => 1).should match(/id="#{@another_element_1.name}_#{@another_element_1.id}"/)
         end
       end
 
-    end
+      context "with offset option" do
+        it "should render all elements beginning with the second." do
+          @page.elements.delete_all
+          @another_page = FactoryGirl.create(:public_page)
+          @another_element_1 = FactoryGirl.create(:element, :page => @page)
+          @another_element_2 = FactoryGirl.create(:element, :page => @page)
+          @another_element_3 = FactoryGirl.create(:element, :page => @page)
+          helper.render_elements(:offset => 1).should_not match(/id="#{@another_element_1.name}_#{@another_element_1.id}"/)
+        end
+      end
 
-    context "with count option" do
-      it "should render just one element because of the count option" do
-        @page.elements.delete_all
-        @another_element_1 = FactoryGirl.create(:element, :page => @page)
-        @another_element_2 = FactoryGirl.create(:element, :page => @page)
-        @another_element_3 = FactoryGirl.create(:element, :page => @page)
-        helper.render_elements(:count => 1).should match(/id="#{@another_element_1.name}_#{@another_element_1.id}"/)
+      context "with option fallback" do
+        before do
+          @another_page = FactoryGirl.create(:public_page, :name => 'Another Page', :page_layout => 'news')
+          @another_element_1 = FactoryGirl.create(:element, :page => @another_page, :name => 'news')
+        end
+
+        it "should render the fallback element, when no element with the given name is found" do
+          helper.render_elements(
+            :fallback => {:for => 'higgs', :with => 'news', :from => 'news'}
+          ).should match(/id="news_#{@another_element_1.id}"/)
+        end
+
+        it "should also take a page object as fallback from" do
+          helper.render_elements(
+            :fallback => {:for => 'higgs', :with => 'news', :from => @another_page}
+          ).should match(/id="news_#{@another_element_1.id}"/)
+        end
       end
+
     end
 
-    context "with offset option" do
-      it "should render all elements beginning with the second." do
-        @page.elements.delete_all
-        @another_page = FactoryGirl.create(:public_page)
-        @another_element_1 = FactoryGirl.create(:element, :page => @page)
-        @another_element_2 = FactoryGirl.create(:element, :page => @page)
-        @another_element_3 = FactoryGirl.create(:element, :page => @page)
-        helper.render_elements(:offset => 1).should_not match(/id="#{@another_element_1.name}_#{@another_element_1.id}"/)
+    describe "#render_cell_elements" do
+      it "should render elements for a cell" do
+        cell = FactoryGirl.create(:cell)
+        @element_in_cell = FactoryGirl.create(:element, :cell_id => cell.id)
+        helper.stub(:configuration).and_return(true)
+        helper.render_cell_elements(cell).should match(/id="#{@element_in_cell.name}_#{@element_in_cell.id}"/)
       end
     end
 
-    context "with option fallback" do
-      before do
-        @another_page = FactoryGirl.create(:public_page, :name => 'Another Page', :page_layout => 'news')
-        @another_element_1 = FactoryGirl.create(:element, :page => @another_page, :name => 'news')
-      end
+    context "in preview mode" do
+      describe '#element_preview_code_attributes' do
+        it "should return the data-alchemy-element HTML attribute for element" do
+          @preview_mode = true
+          helper.element_preview_code_attributes(@element).should == {:'data-alchemy-element' => @element.id}
+        end
 
-      it "should render the fallback element, when no element with the given name is found" do
-        helper.render_elements(
-          :fallback => {:for => 'higgs', :with => 'news', :from => 'news'}
-        ).should match(/id="news_#{@another_element_1.id}"/)
+        it "should return an empty hash if not in preview_mode" do
+          helper.element_preview_code_attributes(@element).should == {}
+        end
       end
 
-      it "should also take a page object as fallback from" do
-        helper.render_elements(
-          :fallback => {:for => 'higgs', :with => 'news', :from => @another_page}
-        ).should match(/id="news_#{@another_element_1.id}"/)
+      describe '#element_preview_code' do
+        it "should return the data-alchemy-element HTML attribute for element" do
+          assign(:preview_mode, true)
+          helper.element_preview_code(@element).should == " data-alchemy-element=\"#{@element.id}\""
+        end
+
+        it "should not return the data-alchemy-element HTML attribute if not in preview_mode" do
+          helper.element_preview_code(@element).should_not == " data-alchemy-element=\"#{@element.id}\""
+        end
       end
     end
 
-  end
+    describe '#element_tags' do
 
-  describe "#render_cell_elements" do
-    it "should render elements for a cell" do
-      cell = FactoryGirl.create(:cell)
-      @element_in_cell = FactoryGirl.create(:element, :cell_id => cell.id)
-      helper.stub(:configuration).and_return(true)
-      helper.render_cell_elements(cell).should match(/id="#{@element_in_cell.name}_#{@element_in_cell.id}"/)
-    end
-  end
+      context "element having tags" do
+        before { @element.tag_list = "peter, lustig"; @element.save! }
+
+        context "with no formatter lambda given" do
+          it "should return tag list as HTML data attribute" do
+            helper.element_tags(@element).should == " data-element-tags=\"peter lustig\""
+          end
+        end
 
-  context "in preview mode" do
-    describe '#element_preview_code_attributes' do
-      it "should return the data-alchemy-element HTML attribute for element" do
-        @preview_mode = true
-        helper.element_preview_code_attributes(@element).should == {:'data-alchemy-element' => @element.id}
+        context "with a formatter lambda given" do
+          it "should return a properly formatted HTML data attribute" do
+            helper.element_tags(@element, :formatter => lambda { |tags| tags.join ", " }).
+              should == " data-element-tags=\"peter, lustig\""
+          end
+        end
       end
 
-      it "should return an empty hash if not in preview_mode" do
-        helper.element_preview_code_attributes(@element).should == {}
+      context "element not having tags" do
+        it "should return empty string" do
+          helper.element_tags(@element).should be_blank
+        end
       end
+
     end
 
-    describe '#element_preview_code' do
-      it "should return the data-alchemy-element HTML attribute for element" do
-        assign(:preview_mode, true)
-        helper.element_preview_code(@element).should == " data-alchemy-element=\"#{@element.id}\""
+    describe '#all_elements_by_name' do
+      let(:page) { mock_model('Page') }
+      let(:element) { mock_model('Element') }
+
+      it "should return all public elements found by name" do
+        Element.stub_chain(:published, :where, :limit).and_return([element])
+        expect(helper.all_elements_by_name('el_name')).to eq([element])
+      end
+
+      it "should return an empty collection if element not found" do
+        expect(helper.all_elements_by_name('not_existing_name')).to eq([])
       end
 
-      it "should not return the data-alchemy-element HTML attribute if not in preview_mode" do
-        helper.element_preview_code(@element).should_not == " data-alchemy-element=\"#{@element.id}\""
+      context "options[:from_page] is passed" do
+        before do
+          Page.stub_chain(:with_language, :find_by_page_layout).and_return(page)
+          page.stub_chain(:elements, :published, :where, :limit).and_return([element])
+        end
+
+        context "as a String" do
+          it "should return all elements associated with the page found by the given layout name" do
+            expect(helper.all_elements_by_name('el_name', from_page: 'layout_name')).to eq([element])
+          end
+        end
+
+        context "as a Page object" do
+          it "should return all elements associated with this given page" do
+            expect(helper.all_elements_by_name('el_name', from_page: page)).to eq([element])
+          end
+        end        
       end
     end
-  end
 
-  describe '#element_tags' do
+    describe '#element_from_page' do
+      let(:page) { mock_model('Page', urlname: 'page-1') }
+      let(:element) { mock_model('Element', name: 'el_name') }
 
-    context "element having tags" do
-      before { @element.tag_list = "peter, lustig"; @element.save! }
+      before do
+        page.stub_chain(:elements, :published, :find_by_name).and_return(element)
+      end
 
-      context "with no formatter lambda given" do
-        it "should return tag list as HTML data attribute" do
-          helper.element_tags(@element).should == " data-element-tags=\"peter lustig\""
+      context "options[:page_urlname] and options[:element_name] is passed" do
+        before do
+          Page.stub_chain(:published, :find_by_urlname).and_return(page)
         end
-      end
 
-      context "with a formatter lambda given" do
-        it "should return a properly formatted HTML data attribute" do
-          helper.element_tags(@element, :formatter => lambda { |tags| tags.join ", " }).
-            should == " data-element-tags=\"peter, lustig\""
+        it "should return the element with the given name" do
+          expect(helper.element_from_page(element_name: element.name, page_urlname: page.urlname)).to eq(element)
         end
       end
-    end
 
-    context "element not having tags" do
-      it "should return empty string" do
-        helper.element_tags(@element).should be_blank
+      context "options[:page_id] and options[:element_name] is passed" do
+        before do
+          Page.stub_chain(:published, :find_by_id).and_return(page)
+        end
+
+        it "should return the element with the given name" do
+          expect(helper.element_from_page(element_name: element.name, page_id: page.id)).to eq(element)
+        end
       end
     end
 
   end
-
 end