alchemy_cms 3.2.0.beta → 3.2.0.rc1

data/spec/helpers/base_helper_spec.rb

@@ -17,49 +17,6 @@ module Alchemy
       end
     end
 
-    describe "#configuration" do
-      it "should return certain configuration options" do
-        allow(Config).to receive(:show).and_return({"some_option" => true})
-        expect(helper.configuration(:some_option)).to eq(true)
-      end
-    end
-
-    describe "#multi_language?" do
-      context "if more than one published language exists" do
-        it "should return true" do
-          allow(Alchemy::Language).to receive(:published).and_return double(count: 2)
-          expect(helper.multi_language?).to eq(true)
-        end
-      end
-
-      context "if less than two published languages exists" do
-        it "should return false" do
-          allow(Alchemy::Language).to receive(:published).and_return double(count: 1)
-          expect(helper.multi_language?).to eq(false)
-        end
-      end
-    end
-
-    describe '#breadcrumb' do
-      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) }
-
-      it "returns an array of all parents including self" do
-        expect(helper.breadcrumb(page)).to eq([lang_root, parent, page])
-      end
-
-      it "does not include the root page" do
-        expect(helper.breadcrumb(page)).not_to include(Page.root)
-      end
-
-      context "with current page nil" do
-        it "should return an empty array" do
-          expect(helper.breadcrumb(nil)).to eq([])
-        end
-      end
-    end
-
     describe '#page_or_find' do
       let(:page) { FactoryGirl.create(:public_page) }
 
@@ -83,8 +40,6 @@ module Alchemy
           expect(helper.page_or_find(page)).to eq(page)
         end
       end
-
     end
-
   end
 end

data/spec/helpers/pages_helper_spec.rb

@@ -1,26 +1,25 @@
 # encoding: utf-8
 require 'spec_helper'
 
-include Alchemy::BaseHelper
-
 module Alchemy
   describe PagesHelper do
 
     # Fixtures
-    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)                 { 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) }
 
     before do
+      helper.controller.class_eval { include Alchemy::ConfigurationMethods }
       allow(Config).to receive(:get) { |arg| arg == :url_nesting ? true : Config.parameter(arg) }
       @root_page = language_root # We need this instance variable in the helpers
     end
@@ -83,7 +82,7 @@ module Alchemy
         end
 
         context "as member user" do
-          let(:user) { member_user }
+          let(:user) { build(:alchemy_dummy_user) }
 
           before { restricted_page }
 
@@ -254,11 +253,13 @@ module Alchemy
       end
 
       context "with options[:restricted_only] set to true" do
-        let(:user) { member_user }
+        let(:user) { build(:alchemy_dummy_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')
-          expect(helper.render_breadcrumb(page: page, restricted_only: true).strip).to match(/^(<span(.[^>]+)>)A restricted Public Page/)
+          result = helper.render_breadcrumb(page: page, restricted_only: true).strip
+          expect(result).to have_selector("*[contains(\"#{page.name}\")]")
+          expect(result).to_not have_selector("*[contains(\"#{parent.name}\")]")
         end
       end
 

data/spec/helpers/url_helper_spec.rb

@@ -1,12 +1,15 @@
 require 'spec_helper'
 
-include Alchemy::BaseHelper
 include Alchemy::ElementsHelper
 
 module Alchemy
   describe UrlHelper do
     let(:page) { mock_model(Page, urlname: 'testpage', language_code: 'en') }
 
+    before do
+      helper.controller.class_eval { include Alchemy::ConfigurationMethods }
+    end
+
     context 'page path helpers' do
       describe "#show_page_path_params" do
         context "when multi_language" do
@@ -17,12 +20,12 @@ module Alchemy
 
           it "should return a Hash with urlname and language_id parameter" do
             allow(helper).to receive(:multi_language?).and_return(true)
-            expect(helper.show_page_path_params(page)).to include(urlname: 'testpage', lang: 'en')
+            expect(helper.show_page_path_params(page)).to include(urlname: 'testpage', locale: 'en')
           end
 
           it "should return a Hash with urlname, language_id and query parameter" do
             allow(helper).to receive(:multi_language?).and_return(true)
-            expect(helper.show_page_path_params(page, {query: 'test'})).to include(urlname: 'testpage', lang: 'en', query: 'test')
+            expect(helper.show_page_path_params(page, {query: 'test'})).to include(urlname: 'testpage', locale: 'en', query: 'test')
           end
         end
 
@@ -33,12 +36,12 @@ module Alchemy
 
           it "should return a Hash with the urlname but without language_id parameter" do
             expect(helper.show_page_path_params(page)).to include(urlname: 'testpage')
-            expect(helper.show_page_path_params(page)).not_to include(lang: 'en')
+            expect(helper.show_page_path_params(page)).not_to include(locale: 'en')
           end
 
           it "should return a Hash with urlname and query parameter" do
             expect(helper.show_page_path_params(page, {query: 'test'})).to include(urlname: 'testpage', query: 'test')
-            expect(helper.show_page_path_params(page)).not_to include(lang: 'en')
+            expect(helper.show_page_path_params(page)).not_to include(locale: 'en')
           end
         end
       end

data/spec/libraries/controller_actions_spec.rb

@@ -109,7 +109,7 @@ describe 'Alchemy::ControllerActions', type: 'controller' do
 
     context "with lang param" do
       it "should set the language" do
-        allow(controller).to receive(:params).and_return(lang: klingonian.code)
+        allow(controller).to receive(:params).and_return(locale: klingonian.code)
         controller.send :set_alchemy_language
         expect(assigns(:language)).to eq(klingonian)
         expect(Alchemy::Language.current).to eq(klingonian)
@@ -118,7 +118,7 @@ describe 'Alchemy::ControllerActions', type: 'controller' do
 
       context "for language that does not exist" do
         before do
-          allow(controller).to receive(:params).and_return(lang: 'fo')
+          allow(controller).to receive(:params).and_return(locale: 'fo')
           controller.send :set_alchemy_language
         end
 

data/spec/libraries/on_page_layout_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+RSpec.describe Alchemy::PagesController, 'OnPageLayout mixin', type: :controller do
+  before(:all) do
+    ApplicationController.send(:extend, Alchemy::OnPageLayout)
+  end
+
+  let(:page) { create(:public_page, page_layout: 'standard') }
+
+  describe 'defines .on_page_layout class method' do
+    context 'with :all as parameter' do
+      context 'and block given' do
+        before do
+          ApplicationController.class_eval do
+            on_page_layout(:all) do
+              @successful_for_all = true
+              @the_page_instance = @page
+            end
+          end
+        end
+
+        it 'runs on all page layouts' do
+          alchemy_get :show, urlname: page.urlname
+          expect(assigns(:successful_for_all)).to be_truthy
+        end
+
+        it 'has @page instance' do
+          alchemy_get :show, urlname: page.urlname
+          expect(assigns(:the_page_instance)).to eq(page)
+        end
+      end
+
+      context 'and method name instead of block given' do
+        before do
+          ApplicationController.class_eval do
+            on_page_layout :all, :my_all_callback_method
+
+            def my_all_callback_method
+              @successful_for_all_callback_method = true
+              @the_all_page_instance = @page
+            end
+          end
+        end
+
+        it 'runs on all page layouts' do
+          alchemy_get :show, urlname: page.urlname
+          expect(assigns(:successful_for_all_callback_method)).to be_truthy
+        end
+
+        it 'has @page instance' do
+          alchemy_get :show, urlname: page.urlname
+          expect(assigns(:the_all_page_instance)).to eq(page)
+        end
+      end
+    end
+
+    context 'with :standard as parameter' do
+      before do
+        ApplicationController.class_eval do
+          on_page_layout(:standard) do
+            @successful_for_standard = true
+          end
+        end
+      end
+
+      context 'and page having standard layout' do
+        it 'runs callback' do
+          alchemy_get :show, urlname: page.urlname
+          expect(assigns(:successful_for_standard)).to be_truthy
+        end
+      end
+
+      context 'and page not having standard layout' do
+        let(:page) { create(:public_page, page_layout: 'news') }
+
+        it "doesn't run callback" do
+          alchemy_get :show, urlname: page.urlname
+          expect(assigns(:successful_for_standard)).to be_falsey
+        end
+      end
+    end
+  end
+end
+
+RSpec.describe ApplicationController, 'OnPageLayout mixin', type: :controller do
+  before(:all) do
+    ApplicationController.send(:extend, Alchemy::OnPageLayout)
+  end
+
+  controller do
+    def index
+      @another_controller = true
+      render nothing: true
+    end
+  end
+
+  context 'in another controller' do
+    before do
+      ApplicationController.class_eval do
+        on_page_layout(:standard) do
+          @successful_for_another_controller = true
+        end
+      end
+    end
+
+    it 'callback does not run' do
+      get :index
+      expect(assigns(:another_controller)).to be_truthy
+      expect(assigns(:successful_for_another_controller)).to be_falsey
+    end
+  end
+end

data/spec/libraries/page_layout_spec.rb

@@ -14,8 +14,12 @@ module Alchemy
         expect(subject.collect { |l| l['name'] }).to include('standard')
       end
 
+      it "should allow erb generated layouts" do
+        expect(subject.collect { |l| l['name'] }).to include('erb_layout')
+      end
+
       context "with empty layouts file" do
-        before { expect(YAML).to receive(:load_file).and_return(false) }
+        before { expect(YAML).to receive(:load).and_return(false) }
 
         it "returns empty array" do
           is_expected.to eq([])

data/spec/libraries/permissions_spec.rb

@@ -33,14 +33,13 @@ describe Alchemy::Permissions do
       is_expected.not_to be_able_to(:show, restricted_attachment)
     end
 
-    it "can only download not restricted pictures" do
-      is_expected.to be_able_to(:download, picture)
-      is_expected.not_to be_able_to(:download, restricted_picture)
-    end
-
     it "can only see not restricted pictures" do
       is_expected.to be_able_to(:show, picture)
+      is_expected.to be_able_to(:thumbnail, picture)
+      is_expected.to be_able_to(:zoom, picture)
       is_expected.not_to be_able_to(:show, restricted_picture)
+      is_expected.not_to be_able_to(:thumbnail, restricted_picture)
+      is_expected.not_to be_able_to(:zoom, restricted_picture)
     end
 
     it "can only visit not restricted pages" do
@@ -71,7 +70,7 @@ describe Alchemy::Permissions do
   end
 
   context "A member" do
-    let(:user) { member_user }
+    let(:user) { build(:alchemy_dummy_user) }
 
     it "can download all attachments" do
       is_expected.to be_able_to(:download, attachment)
@@ -83,14 +82,13 @@ describe Alchemy::Permissions do
       is_expected.to be_able_to(:show, restricted_attachment)
     end
 
-    it "can download all pictures" do
-      is_expected.to be_able_to(:download, picture)
-      is_expected.to be_able_to(:download, restricted_picture)
-    end
-
     it "can see all pictures" do
       is_expected.to be_able_to(:show, picture)
+      is_expected.to be_able_to(:thumbnail, picture)
+      is_expected.to be_able_to(:zoom, picture)
       is_expected.to be_able_to(:show, restricted_picture)
+      is_expected.to be_able_to(:thumbnail, restricted_picture)
+      is_expected.to be_able_to(:zoom, restricted_picture)
     end
 
     it "can visit restricted pages" do
@@ -125,7 +123,7 @@ describe Alchemy::Permissions do
   end
 
   context "An author" do
-    let(:user) { author_user }
+    let(:user) { build(:alchemy_dummy_user, :as_author) }
 
     it "can leave the admin area" do
       is_expected.to be_able_to(:leave, :alchemy_admin)
@@ -198,7 +196,7 @@ describe Alchemy::Permissions do
   end
 
   context "An editor" do
-    let(:user) { editor_user }
+    let(:user) { build(:alchemy_dummy_user, :as_editor) }
 
     it "can manage pages" do
       is_expected.to be_able_to(:copy, Alchemy::Page)
@@ -237,7 +235,7 @@ describe Alchemy::Permissions do
   end
 
   context "An admin" do
-    let(:user) { admin_user }
+    let(:user) { build(:alchemy_dummy_user, :as_admin) }
 
     it "can check for alchemy updates" do
       is_expected.to be_able_to(:update_check, :alchemy_admin_dashboard)
@@ -253,7 +251,7 @@ describe Alchemy::Permissions do
   end
 
   context "A logged in user without a role" do
-    let(:user) { mock_user([]) }
+    let(:user) { mock_model(Alchemy.user_class, alchemy_roles: []) }
 
     it "can only see visible not restricted pages (like the guest role)" do
       is_expected.to be_able_to(:see, visible_page)

data/spec/models/cell_spec.rb

@@ -10,6 +10,10 @@ module Alchemy
       it "should return an Array" do
         expect(Cell.definitions).to be_a(Array)
       end
+
+      it "should allow erb generated definitions" do
+        expect(Cell.definitions.collect { |d| d['name']} ).to include('erb_cell')
+      end
     end
 
     describe '.definition_for' do

data/spec/models/content_spec.rb

@@ -22,6 +22,12 @@ module Alchemy
           expect(Content.normalize_essence_type('EssenceText')).to eq("Alchemy::EssenceText")
         end
       end
+
+      context "passing non-namespaced essence type for an existing non-namespaced essence" do
+        it "should not add alchemy namespace" do
+          expect(Content.normalize_essence_type('DummyModel')).to eq("DummyModel")
+        end
+      end
     end
 
     describe '#normalized_essence_type' do

data/spec/models/dummy_model_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe 'A User-defined Essence' do
+
+  describe DummyModel do
+    it_behaves_like "an essence" do
+      let(:essence)          { DummyModel.new  }
+      let(:ingredient_value) { "Some String" }
+    end
+  end
+end

data/spec/models/element_spec.rb

@@ -33,6 +33,10 @@ module Alchemy
     end
 
     describe '.definitions' do
+      it "should allow erb generated elements" do
+        expect(Element.definitions.collect { |el| el['name']} ).to include('erb_element')
+      end
+
       context "without existing yml files" do
         before { allow(File).to receive(:exists?).and_return(false) }
 
@@ -42,7 +46,8 @@ module Alchemy
       end
 
       context "without any definitions in elements.yml" do
-        before { allow(YAML).to receive(:load_file).and_return(false) } # Yes, YAML.load_file returns false if an empty file exists.
+        # Yes, YAML.load returns false if an empty file exists.
+        before { allow(YAML).to receive(:load).and_return(false) }
 
         it "should return an empty array" do
           expect(Element.definitions).to eq([])