alchemy_cms 3.0.4 → 3.1.0.beta1

data/spec/libraries/template_tracker_spec.rb

@@ -8,37 +8,37 @@ module Alchemy
       describe '#dependencies' do
         context 'with alchemy/pages/show given as template name' do
           let(:name) { 'alchemy/pages/show' }
-          before { PageLayout.stub(:all).and_return([{'name' => 'intro'}, {'name' => 'contact'}]) }
+          before { allow(PageLayout).to receive(:all).and_return([{'name' => 'intro'}, {'name' => 'contact'}]) }
 
           it "returns all page layout view partial names" do
-            should include('alchemy/page_layouts/_intro', 'alchemy/page_layouts/_contact')
+            is_expected.to include('alchemy/page_layouts/_intro', 'alchemy/page_layouts/_contact')
           end
         end
 
         context 'with a page layout given as template name' do
           let(:name) { 'alchemy/page_layouts/_intro' }
           let(:page_layout) { {'name' => 'intro', 'elements' => ['text']} }
-          before { PageLayout.stub(:get).and_return(page_layout) }
+          before { allow(PageLayout).to receive(:get).and_return(page_layout) }
 
           it "returns all element layout view partial names for that layout" do
-            should include('alchemy/elements/_text_view')
+            is_expected.to include('alchemy/elements/_text_view')
           end
 
           context 'and page layout having cells' do
             let(:page_layout) { {'name' => 'intro', 'elements' => ['text'], 'cells' => ['header']} }
 
             it "returns all cell view partial names for that layout" do
-              should include('alchemy/cells/_header')
+              is_expected.to include('alchemy/cells/_header')
             end
           end
         end
 
         context 'with a cell given as template name' do
           let(:name) { 'alchemy/cells/_header' }
-          before { Cell.stub(:definition_for).and_return({'name' => 'header', 'elements' => ['text']}) }
+          before { allow(Cell).to receive(:definition_for).and_return({'name' => 'header', 'elements' => ['text']}) }
 
           it "returns all element layout view partial names for that cell" do
-            should include('alchemy/elements/_text_view')
+            is_expected.to include('alchemy/elements/_text_view')
           end
         end
 
@@ -47,17 +47,17 @@ module Alchemy
           let(:elements) { [{'name' => 'text', 'contents' => [{'type' => 'EssenceText'}]}] }
 
           context 'that is having a description' do
-            before { Element.stub(:descriptions).and_return(elements) }
+            before { allow(Element).to receive(:descriptions).and_return(elements) }
 
             it "returns all essence layout view partial names for that element" do
-              should include('alchemy/essences/_essence_text_view')
+              is_expected.to include('alchemy/essences/_essence_text_view')
             end
 
             context 'and element has picture_gallery enabled' do
               let(:elements) { [{'name' => 'text', 'picture_gallery' => true}] }
 
               it "has EssencePicture as template dependency" do
-                should include('alchemy/essences/_essence_picture_view')
+                is_expected.to include('alchemy/essences/_essence_picture_view')
               end
             end
 
@@ -65,16 +65,16 @@ module Alchemy
               let(:elements) { [{'name' => 'text', 'available_contents' => ['type' => 'EssenceFile']}] }
 
               it "has these essences as template dependency" do
-                should include('alchemy/essences/_essence_file_view')
+                is_expected.to include('alchemy/essences/_essence_file_view')
               end
             end
           end
 
           context 'that has no description' do
-            before { Element.stub(:descriptions).and_return([]) }
+            before { allow(Element).to receive(:descriptions).and_return([]) }
 
             it "returns empty array" do
-              should be_empty
+              is_expected.to be_empty
             end
           end
         end
@@ -83,7 +83,7 @@ module Alchemy
           let(:name) { 'shop/cart' }
 
           it "calls rails template tracker" do
-            ActionView::DependencyTracker::ERBTracker.should_receive(:call).with(name, nil)
+            expect(ActionView::DependencyTracker::ERBTracker).to receive(:call).with(name, nil)
             subject
           end
         end

data/spec/libraries/tinymce_spec.rb

@@ -7,7 +7,7 @@ module Alchemy
       subject { Tinymce.init }
 
       it "returns the default config" do
-        should eq(Tinymce.class_variable_get('@@init'))
+        is_expected.to eq(Tinymce.class_variable_get('@@init'))
       end
     end
 
@@ -16,7 +16,7 @@ module Alchemy
 
       it "merges the default config with given config" do
         Tinymce.init = another_config
-        Tinymce.init.should include(another_config)
+        expect(Tinymce.init).to include(another_config)
       end
     end
 
@@ -28,26 +28,26 @@ module Alchemy
         subject { Tinymce.custom_config_contents }
 
         before do
-          Element.stub(:definitions).and_return([element_definition])
+          allow(Element).to receive(:definitions).and_return([element_definition])
           # Preventing memoization
           Tinymce.class_variable_set('@@custom_config_contents', nil)
         end
 
         it "returns an array of content definitions that contain custom tinymce config and element name" do
-          should be_an(Array)
-          should include({'element' => element_definition['name']}.merge(content_definition))
+          is_expected.to be_an(Array)
+          is_expected.to include({'element' => element_definition['name']}.merge(content_definition))
         end
 
         context 'with no contents having custom tinymce config' do
           let(:content_definition) { {'name' => 'text'} }
-          it { should eq([]) }
+          it { is_expected.to eq([]) }
         end
 
         context 'with element definition having nil as contents value' do
           let(:element_definition) { {'name' => 'element', 'contents' => nil} }
 
           it "returns empty array" do
-            should eq([])
+            is_expected.to eq([])
           end
         end
 
@@ -57,7 +57,7 @@ module Alchemy
 
           it "only returns custom tinymce config for elements of that page" do
             expect(page).to receive(:element_definitions).and_return([element_definition])
-            should include({'element' => element_definition['name']}.merge(content_definition))
+            is_expected.to include({'element' => element_definition['name']}.merge(content_definition))
           end
         end
       end

data/spec/libraries/userstamp_spec.rb

@@ -3,8 +3,8 @@ require 'spec_helper'
 describe 'Alchemy::AuthAccessors' do
   describe '.user_class' do
     it "injects userstamp class methods" do
-      Alchemy.user_class.should respond_to(:stamper_class_name)
-      Alchemy.user_class.stamper_class_name.should eq(:DummyUser)
+      expect(Alchemy.user_class).to respond_to(:stamper_class_name)
+      expect(Alchemy.user_class.stamper_class_name).to eq(:DummyUser)
     end
   end
 end

data/spec/mailers/messages_spec.rb

@@ -7,16 +7,16 @@ module Alchemy
     let(:mail) { Messages.contact_form_mail(message, 'admin@page.com', 'contact@page.com', 'Subject') }
 
     it "delivers a mail to owner" do
-      mail.to.should == ['admin@page.com']
-      mail.subject.should == 'Subject'
+      expect(mail.to).to eq(['admin@page.com'])
+      expect(mail.subject).to eq('Subject')
     end
 
     it "reply_to should be set to senders email" do
-      mail.reply_to.should == [message.email]
+      expect(mail.reply_to).to eq([message.email])
     end
 
     it "mail body includes message" do
-      mail.body.should match /#{message.message}/
+      expect(mail.body).to match /#{message.message}/
     end
 
   end

data/spec/models/attachment_spec.rb

@@ -9,7 +9,7 @@ module Alchemy
     describe 'after assign' do
       it "stores the file mime type into database" do
         attachment.update(file: file)
-        attachment.file_mime_type.should_not be_blank
+        expect(attachment.file_mime_type).not_to be_blank
       end
     end
 
@@ -17,11 +17,11 @@ module Alchemy
       before { attachment.save! }
 
       it "should have a humanized name" do
-        attachment.name.should == "image with spaces"
+        expect(attachment.name).to eq("image with spaces")
       end
 
       it "should have a valid file_name" do
-        attachment.file_name.should == "image-with-spaces.png"
+        expect(attachment.file_name).to eq("image-with-spaces.png")
       end
 
       after { attachment.destroy }
@@ -31,19 +31,19 @@ module Alchemy
       it "should sanitize url characters in the filename" do
         attachment.file_name = 'f#%&cking cute kitten pic.png'
         attachment.save!
-        attachment.urlname.should == 'f-cking-cute-kitten-pic.png'
+        expect(attachment.urlname).to eq('f-cking-cute-kitten-pic.png')
       end
 
       it "should sanitize lot of dots in the name" do
         attachment.file_name = 'cute.kitten.pic.png'
         attachment.save!
-        attachment.urlname.should == 'cute-kitten-pic.png'
+        expect(attachment.urlname).to eq('cute-kitten-pic.png')
       end
 
       it "should sanitize umlauts in the name" do
         attachment.file_name = 'süßes katzenbild.png'
         attachment.save!
-        attachment.urlname.should == 'suesses-katzenbild.png'
+        expect(attachment.urlname).to eq('suesses-katzenbild.png')
       end
 
       after { attachment.destroy }
@@ -52,18 +52,18 @@ module Alchemy
     describe 'validations' do
 
       context "having a png, but only pdf allowed" do
-        before { Config.stub(:get).and_return({'allowed_filetypes' => {'attachments' => ['pdf']}}) }
+        before { allow(Config).to receive(:get).and_return({'allowed_filetypes' => {'attachments' => ['pdf']}}) }
 
         it "should not be valid" do
-          attachment.should_not be_valid
+          expect(attachment).not_to be_valid
         end
       end
 
       context "having a png and everything allowed" do
-        before { Config.stub(:get).and_return({'allowed_filetypes' => {'attachments' => ['*']}}) }
+        before { allow(Config).to receive(:get).and_return({'allowed_filetypes' => {'attachments' => ['*']}}) }
 
         it "should be valid" do
-          attachment.should be_valid
+          expect(attachment).to be_valid
         end
       end
 
@@ -71,73 +71,129 @@ module Alchemy
 
     context 'PNG image' do
       subject { stub_model(Attachment, file_name: 'kitten.png') }
-      its(:extension) { should == "png" }
+
+      describe '#extension' do
+        subject { super().extension }
+        it { is_expected.to eq("png") }
+      end
     end
 
     describe 'css classes' do
       context 'mp3 file' do
         subject { stub_model(Attachment, file_mime_type: 'audio/mpeg') }
-        its(:icon_css_class) { should == "audio" }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("audio") }
+        end
       end
 
       context 'video file' do
         subject { stub_model(Attachment, file_mime_type: 'video/mpeg') }
-        its(:icon_css_class) { should == "video" }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("video") }
+        end
       end
 
       context 'png file' do
         subject { stub_model(Attachment, file_mime_type: 'image/png') }
-        its(:icon_css_class) { should == "image" }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("image") }
+        end
       end
 
       context 'vcf file' do
         subject { stub_model(Attachment, file_mime_type: 'application/vcard') }
-        its(:icon_css_class) { should == "vcard" }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("vcard") }
+        end
       end
 
       context 'zip file' do
         subject { stub_model(Attachment, file_mime_type: 'application/zip') }
-        its(:icon_css_class) { should == "archive" }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("archive") }
+        end
       end
 
       context 'flash file' do
         subject { stub_model(Attachment, file_mime_type: 'application/x-shockwave-flash') }
-        its(:icon_css_class) { should == "flash" }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("flash") }
+        end
       end
 
       context 'photoshop file' do
         subject { stub_model(Attachment, file_mime_type: 'image/x-psd') }
-        its(:icon_css_class) { should == "psd" }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("psd") }
+        end
       end
 
       context 'text file' do
         subject { stub_model(Attachment, file_mime_type: 'text/plain') }
-        its(:icon_css_class) { should == "text" }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("text") }
+        end
       end
 
       context 'rtf file' do
         subject { stub_model(Attachment, file_mime_type: 'application/rtf') }
-        its(:icon_css_class) { should == "rtf" }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("rtf") }
+        end
       end
 
       context 'pdf file' do
         subject { stub_model(Attachment, file_mime_type: 'application/pdf') }
-        its(:icon_css_class) { should == "pdf" }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("pdf") }
+        end
       end
 
       context 'word file' do
         subject { stub_model(Attachment, file_mime_type: 'application/msword') }
-        its(:icon_css_class) { should == "word" }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("word") }
+        end
       end
 
       context 'excel file' do
         subject { stub_model(Attachment, file_mime_type: 'application/vnd.ms-excel') }
-        its(:icon_css_class) { should == "excel" }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("excel") }
+        end
       end
 
       context 'unknown file' do
         subject { stub_model(Attachment, file_mime_type: '') }
-        its(:icon_css_class) { should == "file" }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("file") }
+        end
       end
     end
 
@@ -147,11 +203,11 @@ module Alchemy
       context 'if only on restricted pages' do
         before do
           pages = double(any?: true)
-          pages.should_receive(:not_restricted).and_return([])
-          attachment.should_receive(:pages).twice.and_return(pages)
+          expect(pages).to receive(:not_restricted).and_return([])
+          expect(attachment).to receive(:pages).twice.and_return(pages)
         end
 
-        it { should be_true }
+        it { is_expected.to be_truthy }
       end
 
       context 'if not only on restricted pages' do
@@ -159,11 +215,11 @@ module Alchemy
 
         before do
           pages = double(any?: true)
-          pages.should_receive(:not_restricted).and_return([page])
-          attachment.should_receive(:pages).twice.and_return(pages)
+          expect(pages).to receive(:not_restricted).and_return([page])
+          expect(attachment).to receive(:pages).twice.and_return(pages)
         end
 
-        it { should be_false }
+        it { is_expected.to be_falsey }
       end
     end
 

data/spec/models/cell_spec.rb

@@ -30,7 +30,7 @@ module Alchemy
 
     describe ".definitions_for_element" do
       before do
-        Cell.stub(:definitions).and_return([
+        allow(Cell).to receive(:definitions).and_return([
           {'name' => 'cell_1', 'elements' => ['target', 'other']},
           {'name' => 'cell_2', 'elements' => ['other', 'other']},
           {'name' => 'cell_3', 'elements' => ['other', 'target']}
@@ -58,15 +58,15 @@ module Alchemy
     describe "#available_elements" do
       context "without assigned elements" do
         it "should return an empty Array" do
-          cell.stub(:definition).and_return({})
-          cell.available_elements.should == []
+          allow(cell).to receive(:definition).and_return({})
+          expect(cell.available_elements).to eq([])
         end
       end
 
       context "with assigned elements" do
         it "should return an Array of element names" do
-          cell.stub(:definition).and_return({'elements' => ['test_element', 'test_element_2']})
-          cell.available_elements.should == ['test_element', 'test_element_2']
+          allow(cell).to receive(:definition).and_return({'elements' => ['test_element', 'test_element_2']})
+          expect(cell.available_elements).to eq(['test_element', 'test_element_2'])
         end
       end
     end
@@ -74,22 +74,22 @@ module Alchemy
     describe "#definition" do
       context "without a definition for the expected cellname" do
         it "should return an empty Hash" do
-          Cell.stub(:definition_for).and_return({})
-          cell.definition.should == {}
+          allow(Cell).to receive(:definition_for).and_return({})
+          expect(cell.definition).to eq({})
         end
       end
 
       context "with a definition for the expected cellname found" do
         it "should return its definition Hash" do
-          Cell.stub(:definition_for).and_return({'name' => 'test_cell', 'elements' => ['test_element', 'test_element_2']})
-          cell.definition.should == {'name' => 'test_cell', 'elements' => ['test_element', 'test_element_2']}
+          allow(Cell).to receive(:definition_for).and_return({'name' => 'test_cell', 'elements' => ['test_element', 'test_element_2']})
+          expect(cell.definition).to eq({'name' => 'test_cell', 'elements' => ['test_element', 'test_element_2']})
         end
       end
     end
 
     describe "#name_for_label" do
       it "should call translated_label_for" do
-        Cell.should_receive(:translated_label_for).with(cell.name)
+        expect(Cell).to receive(:translated_label_for).with(cell.name)
         cell.name_for_label
       end
     end