alchemy_cms 2.9.1 → 3.0.0.rc5

data/spec/helpers/essences_helper_spec.rb

@@ -1,29 +1,83 @@
 require 'spec_helper'
 
 describe Alchemy::EssencesHelper do
-
-  let(:element) { FactoryGirl.create(:element, :create_contents_after_create => true) }
+  let(:element) { build_stubbed(:element) }
+  let(:content) { build_stubbed(:content, element: element, ingredient: 'hello!') }
+  let(:essence) { mock_model('EssenceText', link: nil, partial_name: 'essence_text', ingredient: 'hello!')}
 
   before do
-    element.content_by_name('intro').essence.update_attributes(:body => 'hello!')
+    allow_message_expectations_on_nil
+    content.stub(:essence).and_return(essence)
   end
 
-  it "should render an essence" do
-    content = element.content_by_name('intro')
-    render_essence(content).should match(/hello!/)
-  end
+  describe 'render_essence' do
+    subject { render_essence(content) }
 
-  it "should render an essence view" do
-    content = element.content_by_name('intro')
-    render_essence_view(content).should match(/hello!/)
-  end
+    it "renders an essence view partial" do
+      should have_content 'hello!'
+    end
+
+    context 'with editor given as view part' do
+      subject { helper.render_essence(content, :editor) }
+
+      before do
+        helper.stub(:label_and_remove_link)
+        content.stub(:settings).and_return({})
+      end
+
+      it "renders an essence editor partial" do
+        content.should_receive(:form_field_name)
+        should have_selector 'input[type="text"]'
+      end
+    end
+
+    context 'if content is nil' do
+      let(:content) { nil }
 
-  it "should render an essence view by name" do
-    render_essence_view_by_name(element, 'intro').should match(/hello!/)
+      it "returns empty string" do
+        should == ''
+      end
+
+      context 'editor given as part' do
+        subject { helper.render_essence(content, :editor) }
+        before { helper.stub(_t: '') }
+
+        it "displays warning" do
+          helper.should_receive(:warning).and_return('')
+          should == ''
+        end
+      end
+    end
+
+    context 'if essence is nil' do
+      let(:essence) { nil }
+
+      it "returns empty string" do
+        should == ''
+      end
+
+      context 'editor given as part' do
+        subject { helper.render_essence(content, :editor) }
+        before { helper.stub(_t: '') }
+
+        it "displays warning" do
+          helper.should_receive(:warning).and_return('')
+          should == ''
+        end
+      end
+    end
   end
 
-  it "should render an essence view by type" do
-    render_essence_view_by_type(element, 'EssenceText').should match(/hello!/)
+  describe 'render_essence_view' do
+    it "renders an essence view partial" do
+      render_essence_view(content).should have_content 'hello!'
+    end
   end
 
+  describe "render_essence_view_by_name" do
+    it "renders an essence view partial by content name" do
+      element.should_receive(:content_by_name).and_return(content)
+      render_essence_view_by_name(element, 'intro').should have_content 'hello!'
+    end
+  end
 end

data/spec/helpers/pages_helper_spec.rb

@@ -8,7 +8,7 @@ module Alchemy
 
     # Fixtures
     let(:language)                  { mock_model('Language', :code => 'en') }
-    let(:default_language)          { Language.get_default }
+    let(:default_language)          { Language.default }
     let(:language_root)             { FactoryGirl.create(:language_root_page) }
     let(:public_page)               { FactoryGirl.create(:public_page) }
     let(:visible_page)              { FactoryGirl.create(:public_page, :visible => true) }
@@ -36,21 +36,26 @@ module Alchemy
       let(:default_site) { Alchemy::Site.default }
 
       it "renders the partial for current site" do
-        helper.should_receive(:current_site).and_return(default_site)
+        helper.should_receive(:current_alchemy_site).and_return(default_site)
         helper.should_receive(:render).with(default_site)
         helper.render_site_layout
       end
 
       context "with missing partial" do
         it "returns empty string and logges warning" do
-          helper.should_receive(:current_site).twice.and_return(default_site)
+          helper.should_receive(:current_alchemy_site).twice.and_return(default_site)
           expect(helper.render_site_layout).to eq("")
         end
       end
     end
 
     describe "#render_navigation" do
-      before { visible_page }
+      let(:user) { nil }
+
+      before do
+        visible_page
+        helper.stub(:current_ability).and_return(Alchemy::Permissions.new(user))
+      end
 
       it "should render only visible pages" do
         not_visible_page = FactoryGirl.create(:page, visible: false)
@@ -77,27 +82,19 @@ module Alchemy
           end
         end
 
-        context "as registered user" do
-          let(:user) { mock_model('User', alchemy_roles: %w(registered), role_symbols: [:registered]) }
+        context "as member user" do
+          let(:user) { member_user }
 
-          before do
-            restricted_page
-            Authorization.current_user = user
-          end
+          before { restricted_page }
 
           it "should render also restricted pages" do
             not_restricted_page = FactoryGirl.create(:public_page, restricted: false, visible: true)
             helper.render_navigation.should match(/#{restricted_page.name}/)
             helper.render_navigation.should match(/#{not_restricted_page.name}/)
           end
-
-          after do
-            Authorization.current_user = nil
-          end
         end
 
         context "with enabled url nesting" do
-
           before do
             helper.stub(:configuration).and_return(true)
             level_3_page
@@ -106,13 +103,10 @@ module Alchemy
           it "should render nested page links" do
             helper.render_navigation(:all_sub_menues => true).should have_selector("ul li a[href=\"/#{level_3_page.urlname}\"]")
           end
-
         end
-
       end
 
       context "with id and class in the html options" do
-
         it "should append id to the generated ul tag" do
           helper.render_navigation({}, {:id => 'foobar_id'}).should have_selector("ul[id='foobar_id']")
         end
@@ -120,7 +114,6 @@ module Alchemy
         it "should replace the default css class from the generated ul tag" do
           helper.render_navigation({}, {:class => 'foobar_class'}).should have_selector("ul[class='foobar_class']")
         end
-
       end
 
       context "with options[:deepness] set" do
@@ -176,23 +169,22 @@ module Alchemy
             expect(helper.render_navigation(from_page: 'news')).to be_nil
           end
         end
-
       end
-
     end
 
     describe '#render_subnavigation' do
+      let(:user) { nil }
 
-      before do
+      before {
         helper.stub(:multi_language?).and_return(false)
-      end
+        helper.stub(:current_ability).and_return(Alchemy::Permissions.new(user))
+      }
 
       it "should return nil if no @page is set" do
         helper.render_subnavigation.should be(nil)
       end
 
       context "showing a page with level 2" do
-
         before { @page = level_2_page }
 
         it "should render the navigation from current page" do
@@ -202,11 +194,9 @@ module Alchemy
         it "should set current page active" do
           helper.render_subnavigation.should have_selector("a[href='/#{level_2_page.urlname}'].active")
         end
-
       end
 
       context "showing a page with level 3" do
-
         before { @page = level_3_page }
 
         it "should render the navigation from current pages parent" do
@@ -216,11 +206,9 @@ module Alchemy
         it "should set current page active" do
           helper.render_subnavigation.should have_selector("a[href='/#{level_3_page.urlname}'].active")
         end
-
       end
 
       context "showing a page with level 4" do
-
         before { @page = level_4_page }
 
         it "should render the navigation from current pages parents parent" do
@@ -232,32 +220,30 @@ module Alchemy
         end
 
         context "beginning with level 3" do
-
           it "should render the navigation beginning from its parent" do
             helper.render_subnavigation(:level => 3).should have_selector("ul > li > ul > li > a[href='/#{level_4_page.urlname}']")
           end
-
         end
-
       end
-
     end
 
     describe "#render_breadcrumb" do
-      let(:parent)    { FactoryGirl.create(:public_page, visible: true) }
-      let(:page)      { FactoryGirl.create(:public_page, parent_id: parent.id, visible: true) }
+      let(:parent) { FactoryGirl.create(:public_page, visible: true) }
+      let(:page)   { FactoryGirl.create(:public_page, parent_id: parent.id, visible: true) }
+      let(:user)   { nil }
 
       before do
         helper.stub(:multi_language?).and_return(false)
+        helper.stub(:current_ability).and_return(Alchemy::Permissions.new(user))
       end
 
       it "should render a breadcrumb to current page" do
         helper.render_breadcrumb(page: page).should have_selector(".active.last[contains('#{page.name}')]")
       end
 
-      context "with options[:seperator] given" do
-        it "should render a breadcrumb with an alternative seperator" do
-          helper.render_breadcrumb(page: page, seperator: '<span>###</span>').should have_selector('span[contains("###")]')
+      context "with options[:separator] given" do
+        it "should render a breadcrumb with an alternative separator" do
+          helper.render_breadcrumb(page: page, separator: '<span>###</span>').should have_selector('span[contains("###")]')
         end
       end
 
@@ -268,18 +254,12 @@ module Alchemy
       end
 
       context "with options[:restricted_only] set to true" do
-        before do
-          Authorization.current_user = mock_model('User', alchemy_roles: %w(registered), role_symbols: [:registered])
-        end
+        let(:user) { member_user }
 
         it "should render a breadcrumb of restricted pages only" do
           page.update_attributes!(restricted: true, urlname: 'a-restricted-public-page', name: 'A restricted Public Page', title: 'A restricted Public Page')
           helper.render_breadcrumb(page: page, restricted_only: true).strip.should match(/^(<span(.[^>]+)>)A restricted Public Page/)
         end
-
-        after do
-          Authorization.current_user = nil
-        end
       end
 
       it "should render a breadcrumb of visible pages only" do
@@ -308,7 +288,6 @@ module Alchemy
     end
 
     describe "#render_meta_data" do
-
       context "@page is not set" do
         it "should reutrn nil" do
           expect(helper.render_meta_data.should).to eq(nil)
@@ -338,10 +317,9 @@ module Alchemy
         helper.render_title_tag.should match /<title>A Public Page<\/title>/
       end
 
-      it "should render a title tag for current page with a prefix and a seperator" do
-        helper.render_title_tag(prefix: 'Peters Petshop', seperator: ' ### ').should match /<title>Peters Petshop ### A Public Page<\/title>/
+      it "should render a title tag for current page with a prefix and a separator" do
+        helper.render_title_tag(prefix: 'Peters Petshop', separator: ' ### ').should match /<title>Peters Petshop ### A Public Page<\/title>/
       end
-
     end
 
     describe "#language_links" do
@@ -392,13 +370,13 @@ module Alchemy
           context "with options[:reverse]" do
             context "set to false" do
               it "should render the language links in an ascending order" do
-                expect(helper.language_links(reverse: false)).to have_selector("a.de + a.kl")
+                expect(helper.language_links(reverse: false)).to have_selector("a.en + a.kl")
               end
             end
 
             context "set to true" do
               it "should render the language links in a descending order" do
-                expect(helper.language_links(reverse: true)).to have_selector("a.kl + a.de")
+                expect(helper.language_links(reverse: true)).to have_selector("a.kl + a.en")
               end
             end
           end
@@ -430,21 +408,5 @@ module Alchemy
       end
     end
 
-    describe "#language_switches" do
-      it "should return a deprecation warning" do
-        ActiveSupport::Deprecation.should_receive(:warn)
-        helper.should_receive(:language_links).and_return(nil)
-        helper.language_switches
-      end
-    end
-
-    describe "#language_switcher" do
-      it "should return a deprecation warning" do
-        ActiveSupport::Deprecation.should_receive(:warn)
-        helper.should_receive(:language_links).and_return(nil)
-        helper.language_switcher
-      end
-    end
-
   end
 end

data/spec/helpers/url_helper_spec.rb

@@ -1,161 +1,129 @@
 require 'spec_helper'
 
 include Alchemy::BaseHelper
+include Alchemy::ElementsHelper
 
 module Alchemy
   describe UrlHelper do
+    let(:page) { mock_model(Page, urlname: 'testpage', language_code: 'en') }
 
     context 'page path helpers' do
-
-      before do
-        @page = mock_model(Page, :urlname => 'testpage', :language_code => 'en')
-      end
-
       describe "#show_page_path_params" do
-
         context "when multi_language" do
 
           before do
-            helper.stub!(:multi_language?).and_return(true)
+            helper.stub(:multi_language?).and_return(true)
           end
 
           it "should return a Hash with urlname and language_id parameter" do
-            helper.stub!(:multi_language?).and_return(true)
-            helper.show_page_path_params(@page).should include(:urlname => 'testpage', :lang => 'en')
+            helper.stub(:multi_language?).and_return(true)
+            helper.show_page_path_params(page).should include(urlname: 'testpage', lang: 'en')
           end
 
           it "should return a Hash with urlname, language_id and query parameter" do
-            helper.stub!(:multi_language?).and_return(true)
-            helper.show_page_path_params(@page, {:query => 'test'}).should include(:urlname => 'testpage', :lang => 'en', :query => 'test')
+            helper.stub(:multi_language?).and_return(true)
+            helper.show_page_path_params(page, {query: 'test'}).should include(urlname: 'testpage', lang: 'en', query: 'test')
           end
-
         end
 
         context "not multi_language" do
-
           before do
-            helper.stub!(:multi_language?).and_return(false)
+            helper.stub(:multi_language?).and_return(false)
           end
 
           it "should return a Hash with the urlname but without language_id parameter" do
-            helper.show_page_path_params(@page).should include(:urlname => 'testpage')
-            helper.show_page_path_params(@page).should_not include(:lang => 'en')
+            helper.show_page_path_params(page).should include(urlname: 'testpage')
+            helper.show_page_path_params(page).should_not include(lang: 'en')
           end
 
           it "should return a Hash with urlname and query parameter" do
-            helper.show_page_path_params(@page, {:query => 'test'}).should include(:urlname => 'testpage', :query => 'test')
-            helper.show_page_path_params(@page).should_not include(:lang => 'en')
+            helper.show_page_path_params(page, {query: 'test'}).should include(urlname: 'testpage', query: 'test')
+            helper.show_page_path_params(page).should_not include(lang: 'en')
           end
-
         end
-
       end
 
       describe "#show_alchemy_page_path" do
-
         context "when multi_language" do
 
           before do
-            helper.stub!(:multi_language?).and_return(true)
+            helper.stub(:multi_language?).and_return(true)
           end
 
           it "should return the correct relative path string" do
-            helper.show_alchemy_page_path(@page).should == "/#{@page.language_code}/testpage"
+            helper.show_alchemy_page_path(page).should == "/#{page.language_code}/testpage"
           end
 
           it "should return the correct relative path string with additional parameters" do
-            helper.show_alchemy_page_path(@page, {:query => 'test'}).should == "/#{@page.language_code}/testpage?query=test"
+            helper.show_alchemy_page_path(page, {query: 'test'}).should == "/#{page.language_code}/testpage?query=test"
           end
-
         end
 
         context "not multi_language" do
-
           before do
-            helper.stub!(:multi_language?).and_return(false)
+            helper.stub(:multi_language?).and_return(false)
           end
 
           it "should return the correct relative path string" do
-            helper.show_alchemy_page_path(@page).should == "/testpage"
+            helper.show_alchemy_page_path(page).should == "/testpage"
           end
 
           it "should return the correct relative path string with additional parameter" do
-            helper.show_alchemy_page_path(@page, {:query => 'test'}).should == "/testpage?query=test"
+            helper.show_alchemy_page_path(page, {query: 'test'}).should == "/testpage?query=test"
           end
-
-        end
-
-      end
-
-      describe "#page_path_for" do
-        it "is deprecated" do
-          ActiveSupport::Deprecation.should_receive(:warn)
-          helper.page_path_for
         end
       end
 
       describe "#show_alchemy_page_url" do
-
         context "when multi_language" do
 
           before do
-            helper.stub!(:multi_language?).and_return(true)
+            helper.stub(:multi_language?).and_return(true)
           end
 
           it "should return the correct url string" do
-            helper.show_alchemy_page_url(@page).should == "http://#{helper.request.host}/#{@page.language_code}/testpage"
+            helper.show_alchemy_page_url(page).should == "http://#{helper.request.host}/#{page.language_code}/testpage"
           end
 
           it "should return the correct url string with additional parameters" do
-            helper.show_alchemy_page_url(@page, {:query => 'test'}).should == "http://#{helper.request.host}/#{@page.language_code}/testpage?query=test"
+            helper.show_alchemy_page_url(page, {query: 'test'}).should == "http://#{helper.request.host}/#{page.language_code}/testpage?query=test"
           end
-
         end
 
         context "not multi_language" do
-
           before do
-            helper.stub!(:multi_language?).and_return(false)
+            helper.stub(:multi_language?).and_return(false)
           end
 
           it "should return the correct url string" do
-            helper.show_alchemy_page_url(@page).should == "http://#{helper.request.host}/testpage"
+            helper.show_alchemy_page_url(page).should == "http://#{helper.request.host}/testpage"
           end
 
           it "should return the correct url string with additional parameter" do
-            helper.show_alchemy_page_url(@page, {:query => 'test'}).should == "http://#{helper.request.host}/testpage?query=test"
+            helper.show_alchemy_page_url(page, {query: 'test'}).should == "http://#{helper.request.host}/testpage?query=test"
           end
-
         end
-
       end
-
     end
 
     context 'picture path helpers' do
-
-      let(:picture) { stub_model(Picture, :urlname => 'cute_kitten', :id => 42) }
+      let(:picture) { stub_model(Picture, urlname: 'cute_kitten', id: 42) }
 
       describe '#show_alchemy_picture_path' do
-
         it "should return the correct relative path string" do
           helper.show_alchemy_picture_path(picture).should =~ Regexp.new("/pictures/42/show/cute_kitten.jpg")
         end
-
       end
 
       describe '#show_alchemy_picture_url' do
-
         it "should return the correct url string" do
           helper.show_alchemy_picture_url(picture).should =~ Regexp.new("http://#{helper.request.host}/pictures/42/show/cute_kitten.jpg")
         end
-
       end
 
       describe '#show_picture_path_params' do
-
         it "should return the correct params for rendering a picture" do
-          helper.show_picture_path_params(picture).should include(:name => 'cute_kitten', :format => 'jpg')
+          helper.show_picture_path_params(picture).should include(name: 'cute_kitten', format: 'jpg')
         end
 
         it "should include the secure hash parameter" do
@@ -164,40 +132,40 @@ module Alchemy
         end
 
         context "with additional params" do
-
           it "should include these params" do
-            helper.show_picture_path_params(picture, {:format => 'png'}).should include(:name => 'cute_kitten', :format => 'png')
+            helper.show_picture_path_params(picture, {format: 'png'}).should include(name: 'cute_kitten', format: 'png')
           end
-
         end
 
         context "with additional params crop set to true" do
-
           it "should include crop as parameter" do
-            helper.show_picture_path_params(picture, {:crop => true}).should include(:name => 'cute_kitten', :crop => 'crop')
+            helper.show_picture_path_params(picture, {crop: true}).should include(name: 'cute_kitten', crop: 'crop')
           end
-
         end
-
       end
-
     end
 
     context 'attachment path helpers' do
-
-      before do
-        @attachment = mock_model(Attachment, :urlname => 'test-attachment.pdf')
-      end
+      let(:attachment) { mock_model(Attachment, urlname: 'test-attachment.pdf') }
 
       it 'should return the correct relative path to download an attachment' do
-        helper.download_alchemy_attachment_path(@attachment).should == "/attachment/#{@attachment.id}/download/#{@attachment.urlname}"
+        helper.download_alchemy_attachment_path(attachment).should == "/attachment/#{attachment.id}/download/#{attachment.urlname}"
       end
 
       it 'should return the correct url to download an attachment' do
-        helper.download_alchemy_attachment_url(@attachment).should == "http://#{helper.request.host}/attachment/#{@attachment.id}/download/#{@attachment.urlname}"
+        helper.download_alchemy_attachment_url(attachment).should == "http://#{helper.request.host}/attachment/#{attachment.id}/download/#{attachment.urlname}"
       end
-
     end
 
+    describe '#full_url_for_element' do
+      subject { full_url_for_element(element) }
+
+      let(:element) { build_stubbed(:element, name: 'headline', page: page) }
+      let(:current_server) { '' }
+
+      it "returns the url to this element" do
+        should == "#{current_server}/#{element.page.urlname}##{element_dom_id(element)}"
+      end
+    end
   end
 end