alchemy_cms 3.2.0.beta → 3.2.0.rc1

data/spec/features/admin/picture_library_integration_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 RSpec.feature "Picture Library" do
   before do
-    authorize_as_admin
+    authorize_user(:as_admin)
   end
 
   describe "Tagging" do

data/spec/features/admin/resources_integration_spec.rb

@@ -4,7 +4,7 @@ describe "Resources" do
   let(:event)        { FactoryGirl.create(:event) }
   let(:second_event) { FactoryGirl.create(:event, :name => 'My second Event', :entrance_fee => 12.32) }
 
-  before { authorize_as_admin }
+  before { authorize_user(:as_admin) }
 
   describe "index view" do
 

data/spec/features/admin/site_select_feature_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe 'Site select' do
+
+  before do
+    authorize_user(:as_admin)
+  end
+
+  it "does not display the site change" do
+    visit admin_dashboard_path
+    expect(page).not_to have_select('change_site')
+  end
+
+  context "multiple sites" do
+    let!(:a_site) { FactoryGirl.create(:site) }
+
+    it "contains all sites in a selectbox" do
+      visit admin_dashboard_path
+      expect(page).to have_select('change_site', options: [Alchemy::Site.default.name, a_site.name], selected: Alchemy::Site.default.name)
+    end
+
+    context 'when requesting non-default site' do
+      it "provides the correct site" do
+        visit admin_pages_path(site_id: a_site.id)
+        expect(page).to have_select('change_site', selected: a_site.name)
+
+        visit admin_dashboard_path
+        expect(page).to have_select('change_site', selected: a_site.name)
+      end
+    end
+  end
+end

data/spec/features/admin/tinymce_feature_spec.rb

@@ -1,11 +1,9 @@
 require 'spec_helper'
 
 describe 'TinyMCE Editor' do
-  let(:user) { DummyUser.new }
 
   before do
-    user.update(alchemy_roles: %w(admin), name: "Joe User", id: 1)
-    authorize_as_admin(user)
+    authorize_user(:as_admin)
   end
 
   it 'base path should be set to tinymce asset folder' do

data/spec/features/page_feature_spec.rb

@@ -3,14 +3,14 @@ require 'spec_helper'
 module Alchemy
   describe 'Page' do
     let(:default_language)      { Language.default }
-    let(:default_language_root) { FactoryGirl.create(:language_root_page, :language => default_language, :name => 'Home') }
-    let(:public_page_1)         { FactoryGirl.create(:public_page, :visible => true, :name => 'Page 1') }
-    let(:public_child)          { FactoryGirl.create(:public_page, :name => 'Public Child', :parent_id => public_page_1.id) }
+    let(:default_language_root) { create(:language_root_page, :language => default_language, :name => 'Home') }
+    let(:public_page_1)         { create(:public_page, :visible => true, :name => 'Page 1') }
+    let(:public_child)          { create(:public_page, :name => 'Public Child', :parent_id => public_page_1.id) }
 
     before { default_language_root }
 
     it "should include all its elements and contents" do
-      p = FactoryGirl.create(:public_page, :do_not_autogenerate => false)
+      p = create(:public_page, :do_not_autogenerate => false)
       article = p.elements.find_by_name('article')
       article.content_by_name('intro').essence.update_attributes(:body => 'Welcome to Peters Petshop', :public => true)
       visit "/#{p.urlname}"
@@ -19,8 +19,8 @@ module Alchemy
 
     it "should show the navigation with all visible pages" do
       pages = [
-        FactoryGirl.create(:public_page, :visible => true, :name => 'Page 1'),
-        FactoryGirl.create(:public_page, :visible => true, :name => 'Page 2')
+        create(:public_page, :visible => true, :name => 'Page 1'),
+        create(:public_page, :visible => true, :name => 'Page 2')
       ]
       visit '/'
       within('div#navigation ul') { expect(page).to have_selector('li a[href="/page-1"], li a[href="/page-2"]') }
@@ -33,7 +33,7 @@ module Alchemy
           allow_any_instance_of(PagesController).to receive(:multi_language?).and_return(true)
         end
 
-        let(:second_page) { FactoryGirl.create(:public_page, name: 'Second Page') }
+        let(:second_page) { create(:public_page, name: 'Second Page') }
         let(:legacy_url)  { LegacyPageUrl.create(urlname: 'index.php?option=com_content&view=article&id=48&Itemid=69', page: second_page) }
 
         it "should redirect legacy url with unknown format & query string" do
@@ -100,16 +100,18 @@ module Alchemy
           before { allow(Alchemy.user_class).to receive(:admins).and_return([1, 2]) }
 
           it "should render 404 if urlname and lang parameter do not belong to same page" do
-            FactoryGirl.create(:klingonian)
-            visit "/kl/#{public_page_1.urlname}"
-            expect(page.status_code).to eq(404)
+            create(:klingonian)
+            expect {
+              visit "/kl/#{public_page_1.urlname}"
+            }.to raise_error(ActionController::RoutingError)
           end
 
           it "should render 404 if requested language does not exist" do
             public_page_1
             LegacyPageUrl.delete_all
-            visit "/fo/#{public_page_1.urlname}"
-            expect(page.status_code).to eq(404)
+            expect {
+              visit "/fo/#{public_page_1.urlname}"
+            }.to raise_error(ActionController::RoutingError)
           end
         end
       end
@@ -120,7 +122,7 @@ module Alchemy
           allow(Config).to receive(:get) { |arg| arg == :url_nesting ? false : Config.parameter(arg) }
         end
 
-        let(:second_page) { FactoryGirl.create(:public_page, name: 'Second Page') }
+        let(:second_page) { create(:public_page, name: 'Second Page') }
         let(:legacy_url) { LegacyPageUrl.create(urlname: 'index.php?option=com_content&view=article&id=48&Itemid=69', page: second_page) }
 
         it "should redirect legacy url with unknown format & query string" do
@@ -158,7 +160,7 @@ module Alchemy
         end
 
         it "should keep additional params" do
-          visit "/de/#{public_page_1.urlname}?query=Peter"
+          visit "/en/#{public_page_1.urlname}?query=Peter"
           expect(page.current_url).to match(/\?query=Peter/)
         end
       end
@@ -166,12 +168,14 @@ module Alchemy
 
     describe "Handling of non-existing pages" do
       before do
-        allow(Alchemy.user_class).to receive(:admins).and_return([1, 2]) # We need a admin user or the signup page will show up
-        visit "/non-existing-page"
+        # We need a admin user or the signup page will show up
+        allow(Alchemy.user_class).to receive(:admins).and_return([1, 2])
       end
 
       it "should render public/404.html" do
-        expect(page.status_code).to eq(404)
+        expect {
+          visit "/non-existing-page"
+        }.to raise_error(ActionController::RoutingError)
       end
     end
 
@@ -191,7 +195,7 @@ module Alchemy
 
       context "rendering for members" do
         it "is prohibited" do
-          authorize_as_admin(mock_model('DummyUser', alchemy_roles: %w(member), language: 'en'))
+          authorize_user(build(:alchemy_dummy_user))
           visit "/#{public_page_1.urlname}"
           within('body') { expect(page).not_to have_selector('#alchemy_menubar') }
         end
@@ -199,7 +203,7 @@ module Alchemy
 
       context "rendering for authors" do
         it "is allowed" do
-          authorize_as_admin(mock_model('DummyUser', alchemy_roles: %w(author), language: 'en', cache_key: 'aaa'))
+          authorize_user(:as_author)
           visit "/#{public_page_1.urlname}"
           within('body') { expect(page).to have_selector('#alchemy_menubar') }
         end
@@ -207,7 +211,7 @@ module Alchemy
 
       context "rendering for editors" do
         it "is allowed" do
-          authorize_as_admin(mock_model('DummyUser', alchemy_roles: %w(editor), language: 'en', cache_key: 'aaa'))
+          authorize_user(:as_editor)
           visit "/#{public_page_1.urlname}"
           within('body') { expect(page).to have_selector('#alchemy_menubar') }
         end
@@ -215,7 +219,7 @@ module Alchemy
 
       context "rendering for admins" do
         it "is allowed" do
-          authorize_as_admin(mock_model('DummyUser', alchemy_roles: %w(admin), language: 'en', cache_key: 'aaa'))
+          authorize_user(:as_admin)
           visit "/#{public_page_1.urlname}"
           within('body') { expect(page).to have_selector('#alchemy_menubar') }
         end
@@ -223,20 +227,26 @@ module Alchemy
 
       context "contains" do
         before do
-          authorize_as_admin(mock_model('DummyUser', alchemy_roles: %w(admin), language: 'en', cache_key: 'aaa'))
+          authorize_user(:as_admin)
           visit "/#{public_page_1.urlname}"
         end
 
         it "a link to the admin area" do
-          within('#alchemy_menubar') { expect(page).to have_selector("li a[href='#{alchemy.admin_dashboard_path}']") }
+          within('#alchemy_menubar') do
+            expect(page).to have_selector("li a[href='#{alchemy.admin_dashboard_path}']")
+          end
         end
 
         it "a link to edit the current page" do
-          within('#alchemy_menubar') { expect(page).to have_selector("li a[href='#{alchemy.edit_admin_page_path(public_page_1)}']") }
+          within('#alchemy_menubar') do
+            expect(page).to have_selector("li a[href='#{alchemy.edit_admin_page_path(public_page_1)}']")
+          end
         end
 
         it "a form and button to logout of alchemy" do
-          within('#alchemy_menubar') { expect(page).to have_selector("li form[action='#{Alchemy.logout_path}'], li button[type='submit']") }
+          within('#alchemy_menubar') do
+            expect(page).to have_selector("li form[action='#{Alchemy.logout_path}'], li button[type='submit']")
+          end
         end
       end
     end
@@ -265,7 +275,7 @@ module Alchemy
       end
 
       context 'as a member user' do
-        before { authorize_as_admin(create(:member_user)) }
+        before { authorize_user(create(:alchemy_dummy_user)) }
 
         it "I am able to visit the page" do
           visit restricted_page.urlname
@@ -273,6 +283,5 @@ module Alchemy
         end
       end
     end
-
   end
 end

data/spec/features/security_spec.rb

@@ -13,7 +13,7 @@ describe "Security." do
       allow_any_instance_of(Alchemy::BaseController)
         .to receive(:ssl_required?)
         .and_return(true)
-      authorize_as_admin(DummyUser.new(alchemy_roles: %w(admin)))
+      authorize_user(:as_admin)
     end
 
     it "redirects every request to https." do

data/spec/features/translation_integration_spec.rb

@@ -2,9 +2,9 @@ require 'spec_helper'
 
 describe "Translation integration" do
   context "in admin backend" do
-    let(:dummy_user) { mock_model('DummyUser', alchemy_roles: %w(admin), language: 'de') }
+    let(:dummy_user) { mock_model(Alchemy.user_class, alchemy_roles: %w(admin), language: 'de') }
 
-    before { authorize_as_admin(dummy_user) }
+    before { authorize_user(dummy_user) }
 
     it "should be possible to set the locale of the admin backend via params" do
       visit admin_dashboard_path(locale: 'nl')
@@ -38,7 +38,7 @@ describe "Translation integration" do
       end
 
       context "if user has no preferred locale" do
-        let(:dummy_user) { mock_model('DummyUser', alchemy_roles: %w(admin), language: nil) }
+        let(:dummy_user) { mock_model(Alchemy.user_class, alchemy_roles: %w(admin), language: nil) }
 
         it "should use the browsers language setting" do
           page.driver.header 'ACCEPT-LANGUAGE', 'es-ES'

data/spec/helpers/admin/elements_helper_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 
 module Alchemy
   describe Admin::ElementsHelper do
-
     let(:page)    { build_stubbed(:public_page) }
     let(:element) { build_stubbed(:element, page: page) }
 
@@ -18,46 +17,124 @@ module Alchemy
     end
 
     describe "#grouped_elements_for_select" do
-      let(:elements) {
+      let(:elements) do
         [
           mock_model('Element', name: '1', display_name: '1'),
           mock_model('Element', name: '2', display_name: '2')
         ]
-      }
+      end
+      let(:element_definitions) { [{"name" => "1"}, {"name" => "2"}] }
+      let(:cell_definitions) { [] }
+      let(:page_definition) { {} }
 
       before do
-        allow(page).to receive(:layout_description).and_return({
-          'name' => "foo",
-          'cells' => ["foo_cell"]
-        })
-        cell_descriptions = [{
-          'name' => "foo_cell",
-          'elements' => ["1", "2"]
-        }]
-        allow(Cell).to receive(:definitions).and_return(cell_descriptions)
+        allow(page).to receive(:definition).and_return(page_definition)
+        allow(Cell).to receive(:definitions).and_return(cell_definitions)
+        allow(Element).to receive(:definitions).and_return(element_definitions)
         helper.instance_variable_set('@page', page)
       end
 
-      it "should return array of elements grouped by cell for select_tag helper" do
-        expect(helper.grouped_elements_for_select(elements)).to include("Foo cell" => [["1", "1#foo_cell"], ["2", "2#foo_cell"]])
+      context "with empty elements array given" do
+        it "return an empty array" do
+          expect(helper.grouped_elements_for_select([])).to eq([])
+        end
       end
 
-      context "with empty elements array" do
-        it "should return an empty string" do
-          expect(helper.grouped_elements_for_select([])).to eq("")
+      context "with an element collection given" do
+        let(:page_definition) do
+          {'name' => "foo", 'cells' => ["foo_cell"], 'elements' => []}
         end
-      end
 
-      context "with empty cell definitions" do
-        it "should return an empty string" do
-          allow(page).to receive(:layout_description).and_return({'name' => "foo"})
-          expect(helper.grouped_elements_for_select(elements)).to eq("")
+        let(:cell_definitions) do
+          [{'name' => "foo_cell", 'elements' => ["1", "2"]}]
+        end
+
+        it "returns an array of elements grouped by cell for select_tag helper" do
+          expect(helper.grouped_elements_for_select(elements)).to eq("Foo cell" => [["1", "1#foo_cell"], ["2", "2#foo_cell"]])
+        end
+
+        context "without cells key in page definition" do
+          let(:page_definition) do
+            {'name' => "foo", "elements" => ["1", "2"]}
+          end
+
+          it "returns an empty array" do
+            expect(helper.grouped_elements_for_select(elements)).to eq([])
+          end
+        end
+
+        context "with empty cells in page definition" do
+          let(:page_definition) do
+            {"name" => "foo", "cells" => [], "elements" => ["1", "2"]}
+          end
+
+          it "returns an empty array" do
+            expect(helper.grouped_elements_for_select(elements)).to eq([])
+          end
+        end
+
+        context "with a cell containing no elements" do
+          let(:cell_definitions) do
+            [{"name" => "empty_cell", "elements" => []}]
+          end
+
+          let(:page_definition) do
+            {"name" => "foo", "cells" => ["empty_cell"], "elements" => ["1", "2"]}
+          end
+
+          it "does not include that cell" do
+            expect(helper.grouped_elements_for_select(elements)).to eq("Main content" => [["1", "1"], ["2", "2"]])
+          end
+        end
+
+        context "with an element in a cell only" do
+          let(:elements) do
+            [mock_model('Element', name: 'in_cell', display_name: 'In Cell')]
+          end
+
+          let(:page_definition) do
+            {'name' => "foo", 'cells' => ["foo_cell"], 'elements' => []}
+          end
+
+          let(:cell_definitions) do
+            [{'name' => "foo_cell", 'elements' => ["in_cell"]}]
+          end
+
+          it "returns an option for the element in the cell only" do
+            expect(helper.grouped_elements_for_select(elements)).to include("Foo cell" => [["In cell", "in_cell#foo_cell"]])
+          end
         end
-      end
 
-      context "with cell having no elements" do
-        it "should remove that cell from hash" do
-          expect(helper.grouped_elements_for_select(elements)['Empty cell']).to be_nil
+        context "with the same element in both cell and page" do
+          let(:element_definitions) do
+            [{"name" => "in_cell_and_page"}]
+          end
+
+          let(:elements) do
+            [mock_model('Element', name: 'in_cell_and_page', display_name: 'In Cell and Page')]
+          end
+
+          let(:page_definition) do
+            {
+              'name' => "foo",
+              'cells' => ["foo_cell"],
+              'elements' => ["in_cell_and_page"]
+            }
+          end
+
+          let(:cell_definitions) do
+            [{
+              'name' => "foo_cell",
+              'elements' => ["in_cell_and_page"]
+            }]
+          end
+
+          it "returns two options of same element, one for the cell and one for the page" do
+            expect(helper.grouped_elements_for_select(elements)).to eq({
+              "Main content" => [["In cell and page", "in_cell_and_page"]],
+              "Foo cell" => [["In cell and page", "in_cell_and_page#foo_cell"]]
+            })
+          end
         end
       end
     end

data/spec/helpers/admin/pages_helper_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Alchemy::Admin::PagesHelper do
 
   describe '#sitemap_folder_link' do
-    let(:user) { admin_user }
+    let(:user) { build(:alchemy_dummy_user, :as_admin) }
 
     before { allow(helper).to receive(:current_alchemy_user).and_return(user) }
 
@@ -61,4 +61,35 @@ describe Alchemy::Admin::PagesHelper do
     end
   end
 
+  describe '#page_layout_label' do
+    let(:page) { build(:page) }
+
+    subject { helper.page_layout_label(page) }
+
+    context 'when page is not yet persisted' do
+      it 'displays text only' do
+        is_expected.to eq(Alchemy::I18n.t(:page_type))
+      end
+    end
+
+    context 'when page is persited' do
+      before { page.save! }
+
+      context 'with page layout existing' do
+        it 'displays text only' do
+          is_expected.to eq(Alchemy::I18n.t(:page_type))
+        end
+      end
+
+      context 'with page layout description missing' do
+        before do
+          expect(page).to receive(:layout_description).and_return([])
+        end
+
+        it 'displays icon with warning' do
+          is_expected.to match /warning icon/
+        end
+      end
+    end
+  end
 end