alchemy_cms 2.9.1 → 3.0.0.rc5

data/spec/helpers/base_helper_spec.rb

@@ -3,31 +3,23 @@ require 'spec_helper'
 module Alchemy
   describe BaseHelper do
 
-    describe "#render_icon" do
-      subject { render_icon(:user) }
-
-      it "renders an span with icon and the icon name as class name" do
-        should have_selector('span.icon.user')
-      end
-    end
-
     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/)
+          helper.render_message{ content_tag(:p, "my notice") }.should 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">/)
+          helper.render_message(:error){ content_tag(:p, "my notice") }.should 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})
+        Config.stub(:show).and_return({"some_option" => true})
         helper.configuration(:some_option).should == true
       end
     end
@@ -49,7 +41,7 @@ module Alchemy
     end
 
     describe '#breadcrumb' do
-      let(:lang_root) { Page.language_root_for(Language.get_default.id) }
+      let(:lang_root) { Page.language_root_for(Language.default.id) }
       let(:parent)    { FactoryGirl.create(:public_page) }
       let(:page)      { FactoryGirl.create(:public_page, parent_id: parent.id) }
 
@@ -80,7 +72,7 @@ module Alchemy
 
         context 'of an existing page' do
           it "should return the page object" do
-            session[:language_id] = page.language_id
+            session[:alchemy_language_id] = page.language_id
             expect(helper.page_or_find(page.page_layout)).to eq(page)
           end
         end
@@ -91,6 +83,7 @@ module Alchemy
           expect(helper.page_or_find(page)).to eq(page)
         end
       end
+
     end
 
   end

data/spec/helpers/elements_block_helper_spec.rb

@@ -71,7 +71,7 @@ module Alchemy
     end
 
     describe ElementsBlockHelper::ElementViewHelper do
-      let(:scope) { mock }
+      let(:scope) { double }
       subject { ElementsBlockHelper::ElementViewHelper.new(scope, element: element) }
 
       it 'should have a reference to the specified element' do
@@ -109,7 +109,7 @@ module Alchemy
       describe '#essence' do
         it "should provide the specified content essence" do
           subject.should_receive(:content).with(:title).
-            and_return(mock('content', :essence => mock('essence')))
+            and_return(mock_model('Content', :essence => mock_model('EssenceText')))
 
           subject.essence :title
         end
@@ -117,7 +117,7 @@ module Alchemy
     end
 
     describe ElementsBlockHelper::ElementEditorHelper do
-      let(:scope) { mock }
+      let(:scope) { double }
       subject { ElementsBlockHelper::ElementEditorHelper.new(scope, element: element) }
 
       it 'should have a reference to the specified element' do

data/spec/helpers/elements_helper_spec.rb

@@ -1,272 +1,308 @@
 require 'spec_helper'
-
 include Alchemy::BaseHelper
 
 module Alchemy
   describe ElementsHelper do
+    let(:page)    { build_stubbed(:public_page) }
+    let(:element) { build_stubbed(:element, name: 'headline', page: page) }
 
-    before(:each) do
-      @page = FactoryGirl.create(:public_page)
-      @element = FactoryGirl.create(:element, :page => @page)
-      session[:language_id] = @page.language_id
+    before do
+      assign(:page, page)
+      Element.any_instance.stub(store_page: true)
     end
 
-    it "should render an element view partial" do
-      helper.render_element(@element).should match(/id="#{@element.name}_#{@element.id}"/)
-    end
+    describe '#render_element' do
+      subject { render_element(element, part) }
 
-    it "should render a unique dom id for element" do
-      helper.element_dom_id(@element).should == "#{@element.name}_#{@element.id}"
-    end
+      context 'with nil element' do
+        let(:element) { nil }
+        let(:part)    { :view }
+        it { should be_nil }
+      end
 
-    describe "#render_elements" do
+      context 'with view as part given' do
+        let(:part) {:view}
 
-      before(:each) do
-        helper.stub!(:configuration).and_return(true)
+        it "renders the element's view partial" do
+          should 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/)
+          end
+        end
       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)
+      context 'with editor as part given' do
+        let(:part) {:editor}
+
+        it "renders the element's editor partial" do
+          helper.should_receive(:render_essence_editor_by_name)
+          subject
         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}"/)
+        context 'with element editor partial not found' do
+          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')
+          end
         end
       end
+    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*"/)
-        end
+    describe '#element_dom_id' do
+      subject { helper.element_dom_id(element) }
+
+      it "should render a unique dom id for element" do
+        should == "#{element.name}_#{element.id}"
       end
+    end
+
+    describe "#render_elements" do
+      subject { helper.render_elements(options) }
+
+      let(:another_element) { build_stubbed(:element, page: page) }
+      let(:elements)        { [element, another_element] }
 
-      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 'without any options' do
+        let(:options) { {} }
+
+        before do
+          page.should_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}")
         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*"/)
-        end
+        context 'is a page object' do
+          let(:another_page) { build_stubbed(:public_page) }
+          let(:options)      { {from_page: another_page} }
 
-        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}*"/)
-        end
+          before do
+            another_page.should_receive(:find_elements).and_return(elements)
+          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}*"/)
+          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}")
           end
         end
 
-      end
+        context 'is a string' do
+          let(:another_page)    { build_stubbed(:public_page) }
+          let(:another_element) { build_stubbed(:element, page: another_page) }
+          let(:other_elements)  { [another_element] }
+          let(:options)         { {from_page: 'news'} }
 
-      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
+          before do
+            Language.stub_chain(:current, :pages, :where).and_return(pages)
+            another_page.should_receive(:find_elements).and_return(other_elements)
+          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}"/)
+          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}")
+            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 'and an array of pages has been found' do
+            let(:pages) { [page, another_page] }
+
+            before do
+              page.should_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}")
+            end
           end
         end
+      end
 
+      context 'if page is nil' do
+        let(:options) { {from_page: nil} }
+        it { should be_blank }
       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 sort_by option given' do
+        let(:options)         { {sort_by: 'title'} }
+        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)
         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}"/)
+        it "renders the elements in the order of given content name" do
+          should_not be_blank
         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
+        let(:another_page)    { build_stubbed(:public_page, name: 'Another Page', page_layout: 'news') }
+        let(:another_element) { build_stubbed(:element, page: another_page, name: 'news') }
+        let(:elements)        { [another_element] }
+
+        context 'with string given as :fallback_from' do
+          let(:options) { {fallback: {for: 'higgs', with: 'news', from: 'news'}} }
 
-        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}"/)
+          before do
+            Language.stub_chain(:current, :pages, :find_by).and_return(another_page)
+            another_page.stub_chain(:elements, :named).and_return(elements)
+          end
+
+          it "renders the fallback element" do
+            should have_selector("#news_#{another_element.id}")
+          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}"/)
+        context 'with page given as :fallback_from' do
+          let(:options) { {fallback: {for: 'higgs', with: 'news', from: another_page}} }
+
+          before do
+            another_page.stub_chain(:elements, :named).and_return(elements)
+          end
+
+          it "renders the fallback element" do
+            should have_selector("#news_#{another_element.id}")
+          end
         end
       end
 
-    end
+      context 'with option separator given' do
+        let(:options) { {separator: '<hr>'} }
 
-    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}"/)
+        before do
+          page.should_receive(:find_elements).and_return(elements)
+        end
+
+        it "joins element partials with given string" do
+          should have_selector('hr')
+        end
       end
     end
 
-    context "in preview mode" do
-      describe '#element_preview_code_attributes' do
+    describe '#element_preview_code_attributes' do
+      subject { helper.element_preview_code_attributes(element) }
+
+      context 'in preview_mode' do
+        before { assign(:preview_mode, true) }
+
         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}
+          should == {:'data-alchemy-element' => element.id}
         end
+      end
 
-        it "should return an empty hash if not in preview_mode" do
-          helper.element_preview_code_attributes(@element).should == {}
+      context 'not in preview_mode' do
+        it "should return an empty hash" do
+          should == {}
         end
       end
+    end
+
+    describe '#element_preview_code' do
+      subject { helper.element_preview_code(element) }
+
+      context 'in preview_mode' do
+        before { assign(:preview_mode, true) }
 
-      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}\""
+          should == " data-alchemy-element=\"#{element.id}\""
         end
+      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 'not in preview_mode' do
+        it "should not return the data-alchemy-element HTML attribute" do
+          should_not == " data-alchemy-element=\"#{element.id}\""
         end
       end
     end
 
     describe '#element_tags' do
+      subject { element_tags(element, options) }
+
+      let(:element) { build_stubbed(:element) }
+      let(:options) { {} }
 
       context "element having tags" do
-        before { @element.tag_list = "peter, lustig"; @element.save! }
+        before { element.tag_list = "peter, lustig" }
 
         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\""
+            should == " data-element-tags=\"peter lustig\""
           end
         end
 
         context "with a formatter lambda given" do
+          let(:options) { {formatter: ->(tags) { tags.join ", " }} }
+
           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\""
+            should == " data-element-tags=\"peter, lustig\""
           end
         end
       end
 
       context "element not having tags" do
-        it "should return empty string" do
-          helper.element_tags(@element).should be_blank
-        end
+        it { should be_blank }
       end
-
     end
 
-    describe '#all_elements_by_name' do
-      let(:page) { mock_model('Page') }
-      let(:element) { mock_model('Element') }
+    describe '#sort_elements_by_content' do
+      subject { sort_elements_by_content(elements, 'headline') }
 
-      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
+      let(:element_1)    { build_stubbed(:element) }
+      let(:element_2)    { build_stubbed(:element) }
+      let(:element_3)    { build_stubbed(:element) }
+      let(:ingredient_a) { double(ingredient: 'a') }
+      let(:ingredient_b) { double(ingredient: 'b') }
+      let(:ingredient_c) { double(ingredient: 'c') }
+      let(:elements)     { [element_1, element_2, element_3] }
 
-      it "should return an empty collection if element not found" do
-        expect(helper.all_elements_by_name('not_existing_name')).to eq([])
+      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)
       end
 
-      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        
+      it "sorts the elements by content" do
+        should eq [element_3, element_1, element_2]
       end
-    end
 
-    describe '#element_from_page' do
-      let(:page) { mock_model('Page', urlname: 'page-1') }
-      let(:element) { mock_model('Element', name: 'el_name') }
+      context 'with element not having this content' do
+        let(:element_4) { build_stubbed(:element) }
+        let(:elements)  { [element_1, element_2, element_3, element_4] }
 
-      before do
-        page.stub_chain(:elements, :published, :find_by_name).and_return(element)
-      end
-
-      context "options[:page_urlname] and options[:element_name] is passed" do
         before do
-          Page.stub_chain(:published, :find_by_urlname).and_return(page)
+          element_4.should_receive(:content_by_name).and_return(nil)
         end
 
-        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)
+        it "puts it at first place" do
+          should eq [element_4, element_3, element_1, element_2]
         end
       end
 
-      context "options[:page_id] and options[:element_name] is passed" do
+      context 'with element having content with nil as ingredient' do
+        let(:element_4) { build_stubbed(:element) }
+        let(:elements)  { [element_1, element_2, element_3, element_4] }
+
         before do
-          Page.stub_chain(:published, :find_by_id).and_return(page)
+          element_4.should_receive(:content_by_name).and_return(double(ingredient: nil))
         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)
+        it "puts it at first place" do
+          should eq [element_4, element_3, element_1, element_2]
         end
       end
     end