alchemy_cms 3.3.0.rc1 → 3.3.0.rc2

data/spec/libraries/mount_point_spec.rb

@@ -1,77 +0,0 @@
-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/page_layout_spec.rb

@@ -1,150 +0,0 @@
-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(:exist?).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 definition 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 ".get_all_by_attributes" do
-      subject { PageLayout.get_all_by_attributes(unique: true) }
-
-      it "should return all page layout with the given attribute" do
-        expect(subject.map { |page_layout| page_layout['name'] }.to_a).to eq(['index', 'news', 'contact', 'erb_layout'])
-      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(: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 definition 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(Alchemy).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/paths_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe 'Paths' do
-    describe 'defaults' do
-      it 'has default value for Alchemy.admin_path' do
-        expect(Alchemy.admin_path).to eq('/admin')
-      end
-
-      it 'has default value for Alchemy.admin_constraints' do
-        expect(Alchemy.admin_constraints).to eq({})
-      end
-    end
-  end
-end

data/spec/libraries/permissions_spec.rb

@@ -1,260 +0,0 @@
-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(:alchemy_page, :public, restricted: false) }
-  let(:unpublic_page)           { build_stubbed(:alchemy_page, public: false) }
-  let(:visible_page)            { build_stubbed(:alchemy_page, restricted: false, visible: true) }
-  let(:not_visible_page)        { build_stubbed(:alchemy_page, :public, restricted: false, visible: false) }
-  let(:restricted_page)         { build_stubbed(:alchemy_page, :public, public: true, restricted: true) }
-  let(:visible_restricted_page) { build_stubbed(:alchemy_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)
-    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