alchemy_cms 3.0.4 → 3.1.0.beta1

data/spec/libraries/mount_point_spec.rb

@@ -6,31 +6,31 @@ describe Alchemy::MountPoint do
   describe '.get' do
 
     it "returns the path of alchemy's mount point" do
-      Alchemy::MountPoint.stub(:mount_point).and_return('/cms')
-      Alchemy::MountPoint.get.should == '/cms'
+      allow(Alchemy::MountPoint).to receive(:mount_point).and_return('/cms')
+      expect(Alchemy::MountPoint.get).to eq('/cms')
     end
 
     it "removes the leading slash if root mount point" do
-      Alchemy::MountPoint.stub(:mount_point).and_return('/')
-      Alchemy::MountPoint.get.should == ''
+      allow(Alchemy::MountPoint).to receive(:mount_point).and_return('/')
+      expect(Alchemy::MountPoint.get).to eq('')
     end
 
     context "with remove_leading_slash_if_blank set to false" do
       before {
-        Alchemy::MountPoint.stub(:mount_point).and_return('/')
+        allow(Alchemy::MountPoint).to receive(:mount_point).and_return('/')
       }
 
       it "does not remove the leading white slash of path" do
-        Alchemy::MountPoint.get(false).should == '/'
+        expect(Alchemy::MountPoint.get(false)).to eq('/')
       end
 
       context "and with mount point not root" do
         before {
-          Alchemy::MountPoint.stub(:mount_point).and_return('/cms')
+          allow(Alchemy::MountPoint).to receive(:mount_point).and_return('/cms')
         }
 
         it "does not remove the leading white slash of path" do
-          Alchemy::MountPoint.get(false).should == '/cms'
+          expect(Alchemy::MountPoint.get(false)).to eq('/cms')
         end
       end
     end
@@ -38,23 +38,23 @@ describe Alchemy::MountPoint do
 
   describe '.routes' do
     it "returns the routes object from alchemy engine" do
-      Alchemy::MountPoint.routes.should be_instance_of(ActionDispatch::Journey::Route)
+      expect(Alchemy::MountPoint.routes).to be_instance_of(ActionDispatch::Journey::Route)
     end
   end
 
   describe '.mount_point' do
     it 'returns the raw mount point path from routes' do
-      Alchemy::MountPoint.stub(:routes).and_return(OpenStruct.new(path: OpenStruct.new(spec: '/cms')))
-      Alchemy::MountPoint.mount_point.should == '/cms'
+      allow(Alchemy::MountPoint).to receive(:routes).and_return(OpenStruct.new(path: OpenStruct.new(spec: '/cms')))
+      expect(Alchemy::MountPoint.mount_point).to eq('/cms')
     end
 
     context "Alchemy routes could not be found" do
       before {
-        Alchemy::MountPoint.stub(:routes).and_return(nil)
+        allow(Alchemy::MountPoint).to receive(:routes).and_return(nil)
       }
 
       it "falls back to root path" do
-        Alchemy::MountPoint.mount_point.should == '/'
+        expect(Alchemy::MountPoint.mount_point).to eq('/')
       end
     end
   end

data/spec/libraries/page_layout_spec.rb

@@ -10,20 +10,20 @@ module Alchemy
       subject { PageLayout.all }
 
       it "should return all page_layouts" do
-        should be_instance_of(Array)
-        subject.collect { |l| l['name'] }.should include('standard')
+        is_expected.to be_instance_of(Array)
+        expect(subject.collect { |l| l['name'] }).to include('standard')
       end
 
       context "with empty layouts file" do
-        before { YAML.should_receive(:load_file).and_return(false) }
+        before { expect(YAML).to receive(:load_file).and_return(false) }
 
         it "returns empty array" do
-          should == []
+          is_expected.to eq([])
         end
       end
 
       context "with missing layouts file" do
-        before { File.should_receive(:exists?).and_return(false) }
+        before { expect(File).to receive(:exists?).and_return(false) }
 
         it "raises error empty array" do
           expect { subject }.to raise_error(LoadError)
@@ -34,19 +34,19 @@ module Alchemy
     describe '.add' do
       it "adds a definition to all definitions" do
         PageLayout.add({'name' => 'foo'})
-        PageLayout.all.should include({'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'}])
-        PageLayout.all.should include({'name' => 'foo'})
-        PageLayout.all.should include({'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
-        PageLayout.stub(:all).and_return([{'name' => 'default'}, {'name' => 'contact'}])
+        allow(PageLayout).to receive(:all).and_return([{'name' => 'default'}, {'name' => 'contact'}])
         expect(PageLayout.get('default')).to eq({'name' => 'default'})
       end
     end
@@ -55,7 +55,7 @@ module Alchemy
       it "should not hold a layout twice" do
         layouts = PageLayout.layouts_with_own_for_select('standard', 1, false)
         layouts = layouts.collect(&:last)
-        layouts.select { |l| l == "standard" }.length.should == 1
+        expect(layouts.select { |l| l == "standard" }.length).to eq(1)
       end
     end
 
@@ -65,35 +65,35 @@ module Alchemy
       subject { PageLayout.selectable_layouts(language.id) }
 
       it "should not display hidden page layouts" do
-        subject.each { |l| l['hide'].should_not == true }
+        subject.each { |l| expect(l['hide']).not_to eq(true) }
       end
 
       context "with already taken layouts" do
-        before {
-          PageLayout.stub(:all).and_return([{'unique' => true}])
-          Page.stub_chain(:where, :pluck).and_return([1])
-        }
+        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| l['unique'].should_not == true }
+          subject.each { |l| expect(l['unique']).not_to eq(true) }
         end
       end
 
       context "with sites layouts present" do
         let(:site) { Site.new }
         let(:definitions) { [{'name' => 'default_site', 'page_layouts' => %w(intro)}] }
-        before { Site.stub(:layout_definitions).and_return(definitions) }
+        before { allow(Site).to receive(:layout_definitions).and_return(definitions) }
 
         it "should only return layouts for site" do
-          subject.length.should == 1
-          subject.first['name'].should == 'intro'
+          expect(subject.length).to eq(1)
+          expect(subject.first['name']).to eq('intro')
         end
       end
     end
 
     describe ".element_names_for" do
       it "should return all element names for the given pagelayout" do
-        PageLayout.stub(:get).with('default').and_return({'name' => 'default', 'elements' => ['element_1', 'element_2']})
+        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
 
@@ -105,7 +105,7 @@ module Alchemy
 
       context "when page_layout description does not contain the elements key" do
         it "should return an empty array" do
-          PageLayout.stub(:get).with('layout_without_elements_key').and_return({'name' => 'layout_without_elements_key'})
+          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
@@ -117,15 +117,15 @@ module Alchemy
 
       context "with no translation present" do
         it "returns the name capitalized" do
-          should == 'Contact'
+          is_expected.to eq('Contact')
         end
       end
 
       context "with translation present" do
-        before { I18n.should_receive(:t).and_return('Kontakt') }
+        before { expect(I18n).to receive(:t).and_return('Kontakt') }
 
         it "returns the translated name" do
-          should == 'Kontakt'
+          is_expected.to eq('Kontakt')
         end
       end
     end

data/spec/libraries/permissions_spec.rb

@@ -15,45 +15,58 @@ describe Alchemy::Permissions do
   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, public: true, page: public_page) }
-  let(:restricted_element)      { mock_model(Alchemy::Element, public: true, page: restricted_page) }
+  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
-      should be_able_to(:download, attachment)
-      should_not be_able_to(:download, restricted_attachment)
+      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
-      should be_able_to(:show, attachment)
-      should_not be_able_to(:show, restricted_attachment)
+      is_expected.to be_able_to(:show, attachment)
+      is_expected.not_to be_able_to(:show, restricted_attachment)
     end
 
     it "can only download not restricted pictures" do
-      should be_able_to(:download, picture)
-      should_not be_able_to(:download, restricted_picture)
+      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
-      should be_able_to(:show, picture)
-      should_not be_able_to(:show, restricted_picture)
+      is_expected.to be_able_to(:show, picture)
+      is_expected.not_to be_able_to(:show, restricted_picture)
     end
 
     it "can only visit not restricted pages" do
-      should be_able_to(:show, public_page)
-      should_not be_able_to(:show, restricted_page)
+      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
-      should be_able_to(:see, visible_page)
-      should_not be_able_to(:see, not_visible_page)
+      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
-      should be_able_to(:show, published_element)
-      should_not be_able_to(:show, restricted_element)
+      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
 
@@ -61,42 +74,53 @@ describe Alchemy::Permissions do
     let(:user) { member_user }
 
     it "can download all attachments" do
-      should be_able_to(:download, attachment)
-      should be_able_to(:download, restricted_attachment)
+      is_expected.to be_able_to(:download, attachment)
+      is_expected.to be_able_to(:download, restricted_attachment)
     end
 
     it "can see all attachments" do
-      should be_able_to(:show, attachment)
-      should be_able_to(:show, restricted_attachment)
+      is_expected.to be_able_to(:show, attachment)
+      is_expected.to be_able_to(:show, restricted_attachment)
     end
 
     it "can download all pictures" do
-      should be_able_to(:download, picture)
-      should be_able_to(:download, restricted_picture)
+      is_expected.to be_able_to(:download, picture)
+      is_expected.to be_able_to(:download, restricted_picture)
     end
 
     it "can see all pictures" do
-      should be_able_to(:show, picture)
-      should be_able_to(:show, restricted_picture)
+      is_expected.to be_able_to(:show, picture)
+      is_expected.to be_able_to(:show, restricted_picture)
     end
 
     it "can visit restricted pages" do
-      should be_able_to(:show, public_page)
-      should be_able_to(:show, restricted_page)
+      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
-      should be_able_to(:see, visible_page)
-      should be_able_to(:see, visible_restricted_page)
+      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
-      should_not be_able_to(:see, not_visible_page)
+      is_expected.not_to be_able_to(:see, not_visible_page)
     end
 
     it "can see public restricted elements" do
-      should be_able_to(:show, published_element)
-      should be_able_to(:show, restricted_element)
+      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
 
@@ -104,68 +128,65 @@ describe Alchemy::Permissions do
     let(:user) { author_user }
 
     it "can visit the dashboard" do
-      should be_able_to(:index, :alchemy_admin_dashboard)
-      should be_able_to(:info, :alchemy_admin_dashboard)
+      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
-      should be_able_to(:thumbnail, Alchemy::Picture)
+      is_expected.to be_able_to(:thumbnail, Alchemy::Picture)
     end
 
     it "can edit page content" do
-      should be_able_to(:show, unpublic_page)
-      should be_able_to(:index, Alchemy::Page)
-      should be_able_to(:info, Alchemy::Page)
-      should be_able_to(:configure, Alchemy::Page)
-      should be_able_to(:update, Alchemy::Page)
-      should be_able_to(:fold, Alchemy::Page)
-      should be_able_to(:link, Alchemy::Page)
-      should be_able_to(:visit, Alchemy::Page)
-      should be_able_to(:unlock, Alchemy::Page)
-    end
-
-    it "can not publish pages" do
-      should_not be_able_to(:publish, Alchemy::Page)
+      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)
+      is_expected.to be_able_to(:publish, Alchemy::Page)
     end
 
     it "can manage elements" do
-      should be_able_to(:manage, Alchemy::Element)
+      is_expected.to be_able_to(:manage, Alchemy::Element)
     end
 
     it "can see all attachments" do
-      should be_able_to(:read, Alchemy::Attachment)
-      should be_able_to(:download, Alchemy::Attachment)
+      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
-      should be_able_to(:read, Alchemy::Picture)
-      should be_able_to(:info, Alchemy::Picture)
+      is_expected.to be_able_to(:read, Alchemy::Picture)
+      is_expected.to be_able_to(:info, Alchemy::Picture)
     end
 
     it "can manage contents" do
-      should be_able_to(:manage, Alchemy::Content)
+      is_expected.to be_able_to(:manage, Alchemy::Content)
     end
 
     it "can manage essences" do
-      should be_able_to(:manage, Alchemy::EssencePicture)
-      should be_able_to(:manage, Alchemy::EssenceFile)
+      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
-      should be_able_to(:index, :trash)
+      is_expected.to be_able_to(:index, :trash)
     end
 
     it "can manage the clipboard" do
-      should be_able_to(:manage, :alchemy_admin_clipboard)
+      is_expected.to be_able_to(:manage, :alchemy_admin_clipboard)
     end
 
     it "can see tags" do
-      should be_able_to(:read, Alchemy::Tag)
-      should be_able_to(:autocomplete, Alchemy::Tag)
+      is_expected.to be_able_to(:read, Alchemy::Tag)
+      is_expected.to be_able_to(:autocomplete, Alchemy::Tag)
     end
 
     it "can index layoutpages" do
-      should be_able_to(:index, :alchemy_admin_layoutpages)
+      is_expected.to be_able_to(:index, :alchemy_admin_layoutpages)
     end
   end
 
@@ -173,38 +194,34 @@ describe Alchemy::Permissions do
     let(:user) { editor_user }
 
     it "can manage pages" do
-      should be_able_to(:copy, Alchemy::Page)
-      should be_able_to(:copy_language_tree, Alchemy::Page)
-      should be_able_to(:create, Alchemy::Page)
-      should be_able_to(:destroy, Alchemy::Page)
-      should be_able_to(:flush, Alchemy::Page)
-      should be_able_to(:order, Alchemy::Page)
-      should be_able_to(:sort, Alchemy::Page)
-      should be_able_to(:switch_language, Alchemy::Page)
-    end
-
-    it "can publish pages" do
-      should be_able_to(:publish, Alchemy::Page)
+      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 not see invisible pages" do
-      should_not be_able_to(:see, not_visible_page)
+      is_expected.not_to be_able_to(:see, not_visible_page)
     end
 
     it "can clear the trash" do
-      should be_able_to(:clear, :trash)
+      is_expected.to be_able_to(:clear, :trash)
     end
 
     it "can manage attachments" do
-      should be_able_to(:manage, Alchemy::Attachment)
+      is_expected.to be_able_to(:manage, Alchemy::Attachment)
     end
 
     it "can manage pictures" do
-      should be_able_to(:manage, Alchemy::Picture)
+      is_expected.to be_able_to(:manage, Alchemy::Picture)
     end
 
     it "can manage tags" do
-      should be_able_to(:manage, Alchemy::Tag)
+      is_expected.to be_able_to(:manage, Alchemy::Tag)
     end
   end
 
@@ -212,15 +229,15 @@ describe Alchemy::Permissions do
     let(:user) { admin_user }
 
     it "can check for alchemy updates" do
-      should be_able_to(:update_check, :alchemy_admin_dashboard)
+      is_expected.to be_able_to(:update_check, :alchemy_admin_dashboard)
     end
 
     it "can manage languages" do
-      should be_able_to(:manage, Alchemy::Language)
+      is_expected.to be_able_to(:manage, Alchemy::Language)
     end
 
     it "can manage sites" do
-      should be_able_to(:manage, Alchemy::Site)
+      is_expected.to be_able_to(:manage, Alchemy::Site)
     end
   end
 end