alchemy_cms 3.2.1 → 3.3.0.rc1

data/spec/helpers/alchemy/essences_helper_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe Alchemy::EssencesHelper do
+  let(:element) { build_stubbed(:alchemy_element) }
+  let(:content) { build_stubbed(:alchemy_content, element: element, ingredient: 'hello!') }
+  let(:essence) { mock_model('EssenceText', link: nil, partial_name: 'essence_text', ingredient: 'hello!') }
+
+  before do
+    allow_message_expectations_on_nil
+    allow(content).to receive(:essence).and_return(essence)
+  end
+
+  describe 'render_essence' do
+    subject { render_essence(content) }
+
+    it "renders an essence view partial" do
+      is_expected.to have_content 'hello!'
+    end
+
+    context 'with editor given as view part' do
+      subject { helper.render_essence(content, :editor) }
+
+      before do
+        allow(helper).to receive(:content_label)
+        allow(content).to receive(:settings).and_return({})
+      end
+
+      it "renders an essence editor partial" do
+        expect(content).to receive(:form_field_name)
+        is_expected.to have_selector 'input[type="text"]'
+      end
+    end
+
+    context 'if content is nil' do
+      let(:content) { nil }
+
+      it "returns empty string" do
+        is_expected.to eq('')
+      end
+
+      context 'editor given as part' do
+        subject { helper.render_essence(content, :editor) }
+
+        before { allow(Alchemy).to receive(:t).and_return('') }
+
+        it "displays warning" do
+          expect(helper).to receive(:warning).and_return('')
+          is_expected.to eq('')
+        end
+      end
+    end
+
+    context 'if essence is nil' do
+      let(:essence) { nil }
+
+      it "returns empty string" do
+        is_expected.to eq('')
+      end
+
+      context 'editor given as part' do
+        subject { helper.render_essence(content, :editor) }
+
+        before { allow(Alchemy).to receive(:t).and_return('') }
+
+        it "displays warning" do
+          expect(helper).to receive(:warning).and_return('')
+          is_expected.to eq('')
+        end
+      end
+    end
+  end
+
+  describe 'render_essence_view' do
+    it "renders an essence view partial" do
+      expect(render_essence_view(content)).to have_content 'hello!'
+    end
+  end
+
+  describe "render_essence_view_by_name" do
+    it "renders an essence view partial by content name" do
+      expect(element).to receive(:content_by_name).and_return(content)
+      expect(render_essence_view_by_name(element, 'intro')).to have_content 'hello!'
+    end
+  end
+end

data/spec/helpers/{pages_helper_spec.rb → alchemy/pages_helper_spec.rb}

@@ -3,20 +3,19 @@ require 'spec_helper'
 
 module Alchemy
   describe PagesHelper do
-
     # Fixtures
-    let(:language)                 { mock_model('Language', :code => 'en') }
+    let(:language)                 { mock_model('Language', code: 'en') }
     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) }
-    let(:restricted_page)          { FactoryGirl.create(:public_page, :visible => true, :restricted => true) }
-    let(:level_2_page)             { FactoryGirl.create(:public_page, :parent_id => visible_page.id, :visible => true, :name => 'Level 2') }
-    let(:level_3_page)             { FactoryGirl.create(:public_page, :parent_id => level_2_page.id, :visible => true, :name => 'Level 3') }
-    let(:level_4_page)             { FactoryGirl.create(:public_page, :parent_id => level_3_page.id, :visible => true, :name => 'Level 4') }
-    let(:klingonian)               { FactoryGirl.create(:klingonian) }
-    let(:klingonian_language_root) { FactoryGirl.create(:language_root_page, :language => klingonian) }
-    let(:klingonian_public_page)   { FactoryGirl.create(:public_page, :language => klingonian, :parent_id => klingonian_language_root.id) }
+    let(:language_root)            { create(:alchemy_page, :language_root) }
+    let(:public_page)              { create(:alchemy_page, :public) }
+    let(:visible_page)             { create(:alchemy_page, :public, visible: true) }
+    let(:restricted_page)          { create(:alchemy_page, :public, visible: true, restricted: true) }
+    let(:level_2_page)             { create(:alchemy_page, :public, parent_id: visible_page.id, visible: true, name: 'Level 2') }
+    let(:level_3_page)             { create(:alchemy_page, :public, parent_id: level_2_page.id, visible: true, name: 'Level 3') }
+    let(:level_4_page)             { create(:alchemy_page, :public, parent_id: level_3_page.id, visible: true, name: 'Level 4') }
+    let(:klingon)                  { create(:alchemy_language, :klingon) }
+    let(:klingon_language_root)    { create(:alchemy_page, :language_root, language: klingon) }
+    let(:klingon_public_page)      { create(:alchemy_page, :public, language: klingon, parent_id: klingon_language_root.id) }
 
     before do
       helper.controller.class_eval { include Alchemy::ConfigurationMethods }
@@ -57,12 +56,12 @@ module Alchemy
       end
 
       it "should render only visible pages" do
-        not_visible_page = FactoryGirl.create(:page, visible: false)
+        not_visible_page = create(:alchemy_page, visible: false)
         expect(helper.render_navigation).not_to match(/#{not_visible_page.name}/)
       end
 
       it "should render visible unpublished pages" do
-        unpublished_visible_page = FactoryGirl.create(:page, visible: true, public: false)
+        unpublished_visible_page = create(:alchemy_page, visible: true, public: false)
         expect(helper.render_navigation).to match(/#{unpublished_visible_page.name}/)
       end
 
@@ -87,7 +86,7 @@ module Alchemy
           before { restricted_page }
 
           it "should render also restricted pages" do
-            not_restricted_page = FactoryGirl.create(:public_page, restricted: false, visible: true)
+            not_restricted_page = create(:alchemy_page, :public, restricted: false, visible: true)
             expect(helper.render_navigation).to match(/#{restricted_page.name}/)
             expect(helper.render_navigation).to match(/#{not_restricted_page.name}/)
           end
@@ -100,18 +99,18 @@ module Alchemy
           end
 
           it "should render nested page links" do
-            expect(helper.render_navigation(:all_sub_menues => true)).to have_selector("ul li a[href=\"/#{level_3_page.urlname}\"]")
+            expect(helper.render_navigation(all_sub_menues: true)).to 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
-          expect(helper.render_navigation({}, {:id => 'foobar_id'})).to have_selector("ul[id='foobar_id']")
+          expect(helper.render_navigation({}, {id: 'foobar_id'})).to have_selector("ul[id='foobar_id']")
         end
 
         it "should replace the default css class from the generated ul tag" do
-          expect(helper.render_navigation({}, {:class => 'foobar_class'})).to have_selector("ul[class='foobar_class']")
+          expect(helper.render_navigation({}, {class: 'foobar_class'})).to have_selector("ul[class='foobar_class']")
         end
       end
 
@@ -129,7 +128,7 @@ module Alchemy
         before { visible_page }
 
         context "with two pages on same level" do
-          before { FactoryGirl.create(:public_page, visible: true) }
+          before { create(:alchemy_page, :public, visible: true) }
 
           it "should render the given spacer" do
             expect(helper.render_navigation(spacer: '•')).to match(/•/)
@@ -220,15 +219,15 @@ module Alchemy
 
         context "beginning with level 3" do
           it "should render the navigation beginning from its parent" do
-            expect(helper.render_subnavigation(:level => 3)).to have_selector("ul > li > ul > li > a[href='/#{level_4_page.urlname}']")
+            expect(helper.render_subnavigation(level: 3)).to 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) { create(:alchemy_page, :public, visible: true) }
+      let(:page)   { create(:alchemy_page, :public, parent_id: parent.id, visible: true) }
       let(:user)   { nil }
 
       before do
@@ -289,29 +288,79 @@ module Alchemy
     end
 
     describe "#render_meta_data" do
+      let(:page) do
+        mock_model('Page',
+          language: language,
+          title: 'A Public Page',
+          meta_keywords: '',
+          meta_description: '',
+          robot_index?: false,
+          robot_follow?: false,
+          contains_feed?: false,
+          updated_at: '2011-11-29-23:00:00'
+        )
+      end
+
+      let(:root_page) { Page.new }
+
+      before { helper.instance_variable_set('@page', page) }
+
+      subject { helper.render_meta_data }
+
       context "@page is not set" do
+        before { helper.instance_variable_set('@page', nil) }
+
         it "should return nil" do
           expect(helper.render_meta_data).to eq(nil)
         end
       end
 
-      context "@page is set" do
-        let(:page) { mock_model('Page', language: language, title: 'A Public Page', meta_description: 'blah blah', meta_keywords: 'keyword1, keyword2', robot_index?: false, robot_follow?: false, contains_feed?: false, updated_at: '2011-11-29-23:00:00') }
-        before { helper.instance_variable_set('@page', page) }
-        subject { helper.render_meta_data }
+      context "when the current page's meta keywords are set" do
+        before { allow(page).to receive_messages(meta_keywords: 'keyword1, keyword2') }
 
-        it "should render meta keywords of current page" do
+        it "should render them" do
           is_expected.to match /meta name="keywords" content="keyword1, keyword2"/
         end
+      end
 
-        it "should render meta description 'blah blah' of current page" do
+      context "when the current page's meta description is set" do
+        before { allow(page).to receive_messages(meta_description: 'blah blah') }
+
+        it "should render it" do
           is_expected.to match /meta name="description" content="blah blah"/
         end
       end
+
+      context 'when the current page is missing its meta description' do
+        before { allow(Language).to receive(:current_root_page).and_return(root_page) }
+
+        it "should use the the one from the language root's page" do
+          root_page.meta_description = "root page's description"
+          is_expected.to match /meta name="description" content="root page's description"/
+        end
+
+        it "should not be set when language root's page is also missing one" do
+          is_expected.not_to match /meta name="description"/
+        end
+      end
+
+      context 'when the current page is missing its meta keywords' do
+        before { allow(Language).to receive(:current_root_page).and_return(root_page) }
+
+        it "should use the the one from the language root's page" do
+          root_page.meta_keywords = "root page's keywords"
+          is_expected.to match /meta name="keywords" content="root page's keywords"/
+        end
+
+        it "should not be set when language root's page is also missing one" do
+          is_expected.not_to match /meta name="keywords"/
+        end
+      end
     end
 
     describe "#render_title_tag" do
       let(:page) { mock_model('Page', title: 'A Public Page') }
+
       before { helper.instance_variable_set('@page', page) }
 
       it "should render a title tag for current page" do
@@ -326,7 +375,7 @@ module Alchemy
     describe "#language_links" do
       context "with two public languages" do
         # Always create second language
-        before { klingonian }
+        before { klingon }
 
         context "with only one language root page" do
           it "should return nil" do
@@ -335,36 +384,36 @@ module Alchemy
         end
 
         context "with two language root pages" do
-          # Always create a language root page for klingonian
-          before { klingonian_language_root }
+          # Always create a language root page for klingon
+          before { klingon_language_root }
 
           it "should render two language links" do
-            expect(helper.language_links).to have_selector('a', :count => 2)
+            expect(helper.language_links).to have_selector('a', count: 2)
           end
 
           it "should render language links referring to their language root page" do
-            code = klingonian_language_root.language_code
-            urlname = klingonian_language_root.urlname
+            code = klingon_language_root.language_code
+            urlname = klingon_language_root.urlname
             expect(helper.language_links).to have_selector("a.#{code}[href='/#{code}/#{urlname}']")
           end
 
           context "with options[:linkname]" do
             context "set to 'name'" do
               it "should render the name of the language" do
-                expect(helper.language_links(linkname: 'name')).to have_selector("span[contains('#{klingonian_language_root.language.name}')]")
+                expect(helper.language_links(linkname: 'name')).to have_selector("span[contains('#{klingon_language_root.language.name}')]")
               end
             end
 
             context "set to 'code'" do
               it "should render the code of the language" do
-                expect(helper.language_links(linkname: 'code')).to have_selector("span[contains('#{klingonian_language_root.language.code}')]")
+                expect(helper.language_links(linkname: 'code')).to have_selector("span[contains('#{klingon_language_root.language.code}')]")
               end
             end
           end
 
           context "spacer set to '\o/'" do
             it "should render the given string as a spacer" do
-              expect(helper.language_links(spacer: '<span>\o/</span>')).to have_selector('span[contains("\o/")]', :count => 1)
+              expect(helper.language_links(spacer: '<span>\o/</span>')).to have_selector('span[contains("\o/")]', count: 1)
             end
           end
 
@@ -385,7 +434,7 @@ module Alchemy
           context "with options[:show_title]" do
             context "set to true" do
               it "should render the language links with titles" do
-                allow(helper).to receive(:_t).and_return("my title")
+                allow(Alchemy).to receive(:t).and_return("my title")
                 expect(helper.language_links(show_title: true)).to have_selector('a[title="my title"]')
               end
             end
@@ -400,6 +449,44 @@ module Alchemy
       end
     end
 
+    describe "#cell_empty" do
+      let(:cell)    { create(:alchemy_cell, name: 'test_cell', page: public_page) }
+      let(:element) { create(:alchemy_element) }
+
+      before { @page = public_page }
+
+      context "with elements" do
+        before do
+          cell.elements << element
+          cell.save!
+        end
+
+        it "should return true" do
+          expect(helper.cell_empty?('test_cell')).to eq(false)
+        end
+      end
+
+      context "with zero elements" do
+        it "should return true" do
+          expect(helper.cell_empty?('test_cell')).to eq(true)
+        end
+      end
+
+      context "with trashed elements" do
+        before do
+          cell.elements << element
+          cell.save!
+
+          element.trash!
+          element.save!
+        end
+
+        it "should return true" do
+          expect(helper.cell_empty?('test_cell')).to eq(true)
+        end
+      end
+    end
+
     describe "#picture_essence_caption" do
       let(:essence) { mock_model('EssencePicture', caption: 'my caption') }
       let(:content) { mock_model('Content', essence: essence) }
@@ -408,6 +495,5 @@ module Alchemy
         expect(helper.picture_essence_caption(content)).to eq "my caption"
       end
     end
-
   end
 end

data/spec/helpers/alchemy/picture_url_helpers_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe "Picture url helpers" do
+  describe "for cropped picture" do
+    let(:path) do
+      show_picture_path(id: 3, crop: "crop", size: "100x33", name: "kitten", format: "jpg")
+    end
+
+    it "should generate a url string" do
+      expect(path).to eq("/pictures/3/show/100x33/crop/kitten.jpg")
+    end
+  end
+
+  describe "for cropped and masked picture" do
+    let(:path) do
+      show_picture_path(
+        id: 3,
+        crop: "crop",
+        crop_from: "0x0",
+        crop_size: "900x300",
+        size: "100x33",
+        name: "kitten",
+        format: :jpg
+      )
+    end
+
+    it "should generate a url string" do
+      expect(path).to eq("/pictures/3/show/100x33/crop/0x0/900x300/kitten.jpg")
+    end
+  end
+
+  describe "for cropped thumbnail" do
+    let(:path) do
+      thumbnail_path(id: 3, crop: "crop", size: "100x33", name: "kitten", format: :jpg)
+    end
+
+    it "should generate a url string" do
+      expect(path).to eq("/pictures/3/thumbnails/100x33/crop/kitten.jpg")
+    end
+  end
+
+  describe "for thumbnail with default name and format" do
+    let(:path) do
+      thumbnail_path(id: 3, size: "100x33")
+    end
+
+    it "should generate a url string" do
+      expect(path).to eq("/pictures/3/thumbnails/100x33/thumbnail.png")
+    end
+  end
+
+  describe "for cropped and masked thumbnail" do
+    let(:path) do
+      thumbnail_path(
+        id: 3,
+        crop_from: "0x0",
+        crop_size: "900x300",
+        size: "100x33",
+        name: "kitten",
+        format: :jpg
+      )
+    end
+
+    it "should generate a url string" do
+      expect(path).to eq("/pictures/3/thumbnails/100x33/0x0/900x300/kitten.jpg")
+    end
+  end
+
+  describe "for zoomed image" do
+    let(:path) do
+      zoom_picture_path(id: 3, name: "kitten", format: :jpg)
+    end
+
+    it "should generate a url string" do
+      expect(path).to eq("/pictures/3/zoom/kitten.jpg")
+    end
+  end
+end