lc_alchemy_cms 3.2.0

data/spec/libraries/mount_point_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Alchemy::MountPoint do
+  describe '.get' do
+    it "returns the path of alchemy's mount point" do
+      allow(Alchemy::MountPoint).to receive(:path).and_return('/cms')
+      expect(Alchemy::MountPoint.get).to eq('/cms')
+    end
+
+    it "removes the leading slash if root mount point" do
+      allow(Alchemy::MountPoint).to receive(:path).and_return('/')
+      expect(Alchemy::MountPoint.get).to eq('')
+    end
+
+    context "with remove_leading_slash_if_blank set to false" do
+      before do
+        allow(Alchemy::MountPoint)
+          .to receive(:path)
+          .and_return('/')
+      end
+
+      it "does not remove the leading white slash of path" do
+        expect(Alchemy::MountPoint.get(false)).to eq('/')
+      end
+
+      context "and with mount point not root" do
+        before do
+          allow(Alchemy::MountPoint)
+            .to receive(:path)
+            .and_return('/cms')
+        end
+
+        it "does not remove the leading white slash of path" do
+          expect(Alchemy::MountPoint.get(false)).to eq('/cms')
+        end
+      end
+    end
+  end
+
+  describe '.path' do
+    before do
+      allow(File)
+        .to receive(:read)
+        .and_return("mount Alchemy::Engine => '/cms'")
+    end
+
+    it 'returns the mount point path from routes.' do
+      expect(Alchemy::MountPoint.path).to eq('/cms')
+    end
+
+    context "Alchemy mount point could not be found" do
+      before do
+        allow(File)
+        .to receive(:read)
+        .and_return("")
+      end
+
+      it "raises an exception" do
+        expect {
+          Alchemy::MountPoint.path
+        }.to raise_error(Alchemy::NotMountedError)
+      end
+    end
+
+    context 'Mount point using double quotes string' do
+      before do
+        allow(File)
+          .to receive(:read)
+          .and_return('mount Alchemy::Engine => "/cms"')
+      end
+
+      it 'returns the mount point path from routes.' do
+        expect(Alchemy::MountPoint.path).to eq('/cms')
+      end
+    end
+  end
+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

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+module Alchemy
+  describe PageLayout do
+
+    describe ".all" do
+      # skip memoization
+      before { PageLayout.instance_variable_set("@definitions", nil) }
+
+      subject { PageLayout.all }
+
+      it "should return all page_layouts" do
+        is_expected.to be_instance_of(Array)
+        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).and_return(false) }
+
+        it "returns empty array" do
+          is_expected.to eq([])
+        end
+      end
+
+      context "with missing layouts file" do
+        before { expect(File).to receive(:exists?).and_return(false) }
+
+        it "raises error empty array" do
+          expect { subject }.to raise_error(LoadError)
+        end
+      end
+    end
+
+    describe '.add' do
+      it "adds a definition to all definitions" do
+        PageLayout.add({'name' => 'foo'})
+        expect(PageLayout.all).to include({'name' => 'foo'})
+      end
+
+      it "adds a array of definitions to all definitions" do
+        PageLayout.add([{'name' => 'foo'}, {'name' => 'bar'}])
+        expect(PageLayout.all).to include({'name' => 'foo'})
+        expect(PageLayout.all).to include({'name' => 'bar'})
+      end
+    end
+
+    describe ".get" do
+      it "should return the page_layout description found by given name" do
+        allow(PageLayout).to receive(:all).and_return([{'name' => 'default'}, {'name' => 'contact'}])
+        expect(PageLayout.get('default')).to eq({'name' => 'default'})
+      end
+    end
+
+    describe '.layouts_with_own_for_select' do
+      it "should not hold a layout twice" do
+        layouts = PageLayout.layouts_with_own_for_select('standard', 1, false)
+        layouts = layouts.collect(&:last)
+        expect(layouts.select { |l| l == "standard" }.length).to eq(1)
+      end
+    end
+
+    describe '.selectable_layouts' do
+      let(:language) { Language.default }
+      before { language }
+      subject { PageLayout.selectable_layouts(language.id) }
+
+      it "should not display hidden page layouts" do
+        subject.each { |l| expect(l['hide']).not_to eq(true) }
+      end
+
+      context "with already taken layouts" do
+        before do
+          allow(PageLayout).to receive(:all).and_return([{'unique' => true}])
+          allow(Page).to receive(:where).and_return double(pluck: [1])
+        end
+
+        it "should not include unique layouts" do
+          subject.each { |l| expect(l['unique']).not_to eq(true) }
+        end
+      end
+
+      context "with sites layouts present" do
+        let(:site) { Site.new }
+
+        let(:definitions) do
+          [{'name' => 'default_site', 'page_layouts' => %w(index)}]
+        end
+
+        before do
+          allow(Site).to receive(:layout_definitions).and_return(definitions)
+        end
+
+        it "should only return layouts for site" do
+          expect(subject.length).to eq(1)
+          expect(subject.first['name']).to eq('index')
+        end
+      end
+    end
+
+    describe ".element_names_for" do
+      it "should return all element names for the given pagelayout" do
+        allow(PageLayout).to receive(:get).with('default').and_return({'name' => 'default', 'elements' => ['element_1', 'element_2']})
+        expect(PageLayout.element_names_for('default')).to eq(['element_1', 'element_2'])
+      end
+
+      context "when given page_layout name does not exist" do
+        it "should return an empty array" do
+          expect(PageLayout.element_names_for('layout_does_not_exist!')).to eq([])
+        end
+      end
+
+      context "when page_layout description does not contain the elements key" do
+        it "should return an empty array" do
+          allow(PageLayout).to receive(:get).with('layout_without_elements_key').and_return({'name' => 'layout_without_elements_key'})
+          expect(PageLayout.element_names_for('layout_without_elements_key')).to eq([])
+        end
+      end
+    end
+
+    describe '.human_layout_name' do
+      let(:layout) { {'name' => 'contact'} }
+      subject { PageLayout.human_layout_name(layout['name']) }
+
+      context "with no translation present" do
+        it "returns the name capitalized" do
+          is_expected.to eq('Contact')
+        end
+      end
+
+      context "with translation present" do
+        before { expect(I18n).to receive(:t).and_return('Kontakt') }
+
+        it "returns the translated name" do
+          is_expected.to eq('Kontakt')
+        end
+      end
+    end
+
+  end
+end

data/spec/libraries/permissions_spec.rb

@@ -0,0 +1,261 @@
+require 'spec_helper'
+require 'cancan/matchers'
+
+describe Alchemy::Permissions do
+  subject { ability }
+
+  let(:ability)                 { Alchemy::Permissions.new(user) }
+  let(:attachment)              { mock_model(Alchemy::Attachment, restricted?: false) }
+  let(:restricted_attachment)   { mock_model(Alchemy::Attachment, restricted?: true) }
+  let(:picture)                 { mock_model(Alchemy::Picture, restricted?: false) }
+  let(:restricted_picture)      { mock_model(Alchemy::Picture, restricted?: true) }
+  let(:public_page)             { build_stubbed(:public_page, restricted: false) }
+  let(:unpublic_page)           { build_stubbed(:page, public: false) }
+  let(:visible_page)            { build_stubbed(:page, restricted: false, visible: true) }
+  let(:not_visible_page)        { build_stubbed(:public_page, restricted: false, visible: false) }
+  let(:restricted_page)         { build_stubbed(:public_page, public: true, restricted: true) }
+  let(:visible_restricted_page) { build_stubbed(:page, visible: true, restricted: true) }
+  let(:published_element)       { mock_model(Alchemy::Element, restricted?: false, public?: true, trashed?: false) }
+  let(:restricted_element)      { mock_model(Alchemy::Element, restricted?: true, public?: true, trashed?: false) }
+  let(:published_content)       { mock_model(Alchemy::Content, restricted?: false, public?: true, trashed?: false) }
+  let(:restricted_content)      { mock_model(Alchemy::Content, restricted?: true, public?: true, trashed?: false) }
+
+  context "A guest user" do
+    let(:user) { nil }
+
+    it "can only download not restricted attachments" do
+      is_expected.to be_able_to(:download, attachment)
+      is_expected.not_to be_able_to(:download, restricted_attachment)
+    end
+
+    it "can only see not restricted attachments" do
+      is_expected.to be_able_to(:show, attachment)
+      is_expected.not_to be_able_to(:show, restricted_attachment)
+    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
+      is_expected.to be_able_to(:show, public_page)
+      is_expected.not_to be_able_to(:show, restricted_page)
+      is_expected.to be_able_to(:index, public_page)
+      is_expected.not_to be_able_to(:index, restricted_page)
+    end
+
+    it "can only see visible not restricted pages" do
+      is_expected.to be_able_to(:see, visible_page)
+      is_expected.not_to be_able_to(:see, not_visible_page)
+    end
+
+    it "can only see public not restricted elements" do
+      is_expected.to be_able_to(:show, published_element)
+      is_expected.not_to be_able_to(:show, restricted_element)
+      is_expected.to be_able_to(:index, published_element)
+      is_expected.not_to be_able_to(:index, restricted_element)
+    end
+
+    it "can only see public not restricted contents" do
+      is_expected.to be_able_to(:show, published_content)
+      is_expected.not_to be_able_to(:show, restricted_content)
+      is_expected.to be_able_to(:index, published_content)
+      is_expected.not_to be_able_to(:index, restricted_content)
+    end
+  end
+
+  context "A member" do
+    let(:user) { build(:alchemy_dummy_user) }
+
+    it "can download all attachments" do
+      is_expected.to be_able_to(:download, attachment)
+      is_expected.to be_able_to(:download, restricted_attachment)
+    end
+
+    it "can see all attachments" do
+      is_expected.to be_able_to(:show, attachment)
+      is_expected.to be_able_to(:show, restricted_attachment)
+    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
+      is_expected.to be_able_to(:show, public_page)
+      is_expected.to be_able_to(:show, restricted_page)
+      is_expected.to be_able_to(:index, public_page)
+      is_expected.to be_able_to(:index, restricted_page)
+    end
+
+    it "can see visible restricted pages" do
+      is_expected.to be_able_to(:see, visible_page)
+      is_expected.to be_able_to(:see, visible_restricted_page)
+    end
+
+    it "can not see invisible pages" do
+      is_expected.not_to be_able_to(:see, not_visible_page)
+    end
+
+    it "can see public restricted elements" do
+      is_expected.to be_able_to(:show, published_element)
+      is_expected.to be_able_to(:show, restricted_element)
+      is_expected.to be_able_to(:index, published_element)
+      is_expected.to be_able_to(:index, restricted_element)
+    end
+
+    it "can see public restricted contents" do
+      is_expected.to be_able_to(:show, published_content)
+      is_expected.to be_able_to(:show, restricted_content)
+      is_expected.to be_able_to(:index, published_content)
+      is_expected.to be_able_to(:index, restricted_content)
+    end
+  end
+
+  context "An author" do
+    let(:user) { build(:alchemy_dummy_user, :as_author) }
+
+    it "can leave the admin area" do
+      is_expected.to be_able_to(:leave, :alchemy_admin)
+    end
+
+    it "can visit the dashboard" do
+      is_expected.to be_able_to(:index, :alchemy_admin_dashboard)
+      is_expected.to be_able_to(:info, :alchemy_admin_dashboard)
+    end
+
+    it "can see picture thumbnails" do
+      is_expected.to be_able_to(:thumbnail, Alchemy::Picture)
+    end
+
+    it "can edit page content" do
+      is_expected.to be_able_to(:show, unpublic_page)
+      is_expected.to be_able_to(:index, Alchemy::Page)
+      is_expected.to be_able_to(:info, Alchemy::Page)
+      is_expected.to be_able_to(:configure, Alchemy::Page)
+      is_expected.to be_able_to(:update, Alchemy::Page)
+      is_expected.to be_able_to(:fold, Alchemy::Page)
+      is_expected.to be_able_to(:link, Alchemy::Page)
+      is_expected.to be_able_to(:visit, Alchemy::Page)
+      is_expected.to be_able_to(:unlock, Alchemy::Page)
+    end
+
+    it "can not publish pages" do
+      is_expected.to_not be_able_to(:publish, Alchemy::Page)
+    end
+
+    it "can manage elements" do
+      is_expected.to be_able_to(:manage, Alchemy::Element)
+    end
+
+    it "can see all attachments" do
+      is_expected.to be_able_to(:read, Alchemy::Attachment)
+      is_expected.to be_able_to(:download, Alchemy::Attachment)
+    end
+
+    it "can see all pictures" do
+      is_expected.to be_able_to(:read, Alchemy::Picture)
+      is_expected.to be_able_to(:info, Alchemy::Picture)
+    end
+
+    it "can manage contents" do
+      is_expected.to be_able_to(:manage, Alchemy::Content)
+    end
+
+    it "can manage essences" do
+      is_expected.to be_able_to(:manage, Alchemy::EssencePicture)
+      is_expected.to be_able_to(:manage, Alchemy::EssenceFile)
+    end
+
+    it "can see the trash" do
+      is_expected.to be_able_to(:index, :trash)
+    end
+
+    it "can manage the clipboard" do
+      is_expected.to be_able_to(:manage, :alchemy_admin_clipboard)
+    end
+
+    it "can see tags" do
+      is_expected.to be_able_to(:read, Alchemy::Tag)
+      is_expected.to be_able_to(:autocomplete, Alchemy::Tag)
+    end
+
+    it "can index layoutpages" do
+      is_expected.to be_able_to(:index, :alchemy_admin_layoutpages)
+    end
+  end
+
+  context "An editor" do
+    let(:user) { build(:alchemy_dummy_user, :as_editor) }
+
+    it "can manage pages" do
+      is_expected.to be_able_to(:copy, Alchemy::Page)
+      is_expected.to be_able_to(:copy_language_tree, Alchemy::Page)
+      is_expected.to be_able_to(:create, Alchemy::Page)
+      is_expected.to be_able_to(:destroy, Alchemy::Page)
+      is_expected.to be_able_to(:flush, Alchemy::Page)
+      is_expected.to be_able_to(:order, Alchemy::Page)
+      is_expected.to be_able_to(:sort, Alchemy::Page)
+      is_expected.to be_able_to(:switch_language, Alchemy::Page)
+    end
+
+    it "can publish pages" do
+      is_expected.to be_able_to(:publish, Alchemy::Page)
+    end
+
+    it "can not see invisible pages" do
+      is_expected.not_to be_able_to(:see, not_visible_page)
+    end
+
+    it "can clear the trash" do
+      is_expected.to be_able_to(:clear, :trash)
+    end
+
+    it "can manage attachments" do
+      is_expected.to be_able_to(:manage, Alchemy::Attachment)
+    end
+
+    it "can manage pictures" do
+      is_expected.to be_able_to(:manage, Alchemy::Picture)
+    end
+
+    it "can manage tags" do
+      is_expected.to be_able_to(:manage, Alchemy::Tag)
+    end
+  end
+
+  context "An admin" do
+    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)
+    end
+
+    it "can manage languages" do
+      is_expected.to be_able_to(:manage, Alchemy::Language)
+    end
+
+    it "can manage sites" do
+      is_expected.to be_able_to(:manage, Alchemy::Site)
+    end
+  end
+
+  context "A logged in user without a role" do
+    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)
+      is_expected.not_to be_able_to(:see, not_visible_page)
+    end
+  end
+end