alchemy_cms 3.0.4 → 3.1.0.beta1

data/spec/helpers/picture_url_helpers_spec.rb

@@ -4,32 +4,32 @@ describe "Picture url helpers" do
 
   it "should generate a url string for cropped picture" do
     p = show_picture_path(:id => 3, :crop => "crop", :size => "100x33", :name => "kitten", :format => "jpg")
-    p.should == "/pictures/3/show/100x33/crop/kitten.jpg"
+    expect(p).to eq("/pictures/3/show/100x33/crop/kitten.jpg")
   end
 
   it "should generate a url string for cropped and masked picture" do
     p = show_picture_path(:id => 3, :crop => "crop", :crop_from => "0x0", :crop_size => "900x300", :size => "100x33", :name => "kitten", :format => :jpg)
-    p.should == "/pictures/3/show/100x33/crop/0x0/900x300/kitten.jpg"
+    expect(p).to eq("/pictures/3/show/100x33/crop/0x0/900x300/kitten.jpg")
   end
 
   it "should generate a url string for cropped thumbnail" do
     p = thumbnail_path(:id => 3, :crop => "crop", :size => "100x33", :name => "kitten", :format => :jpg)
-    p.should == "/pictures/3/thumbnails/100x33/crop/kitten.jpg"
+    expect(p).to eq("/pictures/3/thumbnails/100x33/crop/kitten.jpg")
   end
 
   it "should generate a url string for thumbnail with default name and format" do
     p = thumbnail_path(:id => 3, :size => "100x33")
-    p.should == "/pictures/3/thumbnails/100x33/thumbnail.png"
+    expect(p).to eq("/pictures/3/thumbnails/100x33/thumbnail.png")
   end
 
   it "should generate a url string for cropped and masked thumbnail" do
     p = thumbnail_path(:id => 3, :crop_from => "0x0", :crop_size => "900x300", :size => "100x33", :name => "kitten", :format => :jpg)
-    p.should == "/pictures/3/thumbnails/100x33/0x0/900x300/kitten.jpg"
+    expect(p).to eq("/pictures/3/thumbnails/100x33/0x0/900x300/kitten.jpg")
   end
 
   it "should generate a url string for zoomed image" do
     p = zoom_picture_path(:id => 3, :name => "kitten", :format => :jpg)
-    p.should == "/pictures/3/zoom/kitten.jpg"
+    expect(p).to eq("/pictures/3/zoom/kitten.jpg")
   end
 
 end

data/spec/helpers/url_helper_spec.rb

@@ -12,33 +12,33 @@ module Alchemy
         context "when multi_language" do
 
           before do
-            helper.stub(:multi_language?).and_return(true)
+            allow(helper).to receive(:multi_language?).and_return(true)
           end
 
           it "should return a Hash with urlname and language_id parameter" do
-            helper.stub(:multi_language?).and_return(true)
-            helper.show_page_path_params(page).should include(urlname: 'testpage', lang: 'en')
+            allow(helper).to receive(:multi_language?).and_return(true)
+            expect(helper.show_page_path_params(page)).to include(urlname: 'testpage', lang: 'en')
           end
 
           it "should return a Hash with urlname, language_id and query parameter" do
-            helper.stub(:multi_language?).and_return(true)
-            helper.show_page_path_params(page, {query: 'test'}).should include(urlname: 'testpage', lang: 'en', query: 'test')
+            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')
           end
         end
 
         context "not multi_language" do
           before do
-            helper.stub(:multi_language?).and_return(false)
+            allow(helper).to receive(:multi_language?).and_return(false)
           end
 
           it "should return a Hash with the urlname but without language_id parameter" do
-            helper.show_page_path_params(page).should include(urlname: 'testpage')
-            helper.show_page_path_params(page).should_not include(lang: 'en')
+            expect(helper.show_page_path_params(page)).to include(urlname: 'testpage')
+            expect(helper.show_page_path_params(page)).not_to include(lang: 'en')
           end
 
           it "should return a Hash with urlname and query parameter" do
-            helper.show_page_path_params(page, {query: 'test'}).should include(urlname: 'testpage', query: 'test')
-            helper.show_page_path_params(page).should_not include(lang: 'en')
+            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')
           end
         end
       end
@@ -47,29 +47,29 @@ module Alchemy
         context "when multi_language" do
 
           before do
-            helper.stub(:multi_language?).and_return(true)
+            allow(helper).to receive(:multi_language?).and_return(true)
           end
 
           it "should return the correct relative path string" do
-            helper.show_alchemy_page_path(page).should == "/#{page.language_code}/testpage"
+            expect(helper.show_alchemy_page_path(page)).to eq("/#{page.language_code}/testpage")
           end
 
           it "should return the correct relative path string with additional parameters" do
-            helper.show_alchemy_page_path(page, {query: 'test'}).should == "/#{page.language_code}/testpage?query=test"
+            expect(helper.show_alchemy_page_path(page, {query: 'test'})).to eq("/#{page.language_code}/testpage?query=test")
           end
         end
 
         context "not multi_language" do
           before do
-            helper.stub(:multi_language?).and_return(false)
+            allow(helper).to receive(:multi_language?).and_return(false)
           end
 
           it "should return the correct relative path string" do
-            helper.show_alchemy_page_path(page).should == "/testpage"
+            expect(helper.show_alchemy_page_path(page)).to eq("/testpage")
           end
 
           it "should return the correct relative path string with additional parameter" do
-            helper.show_alchemy_page_path(page, {query: 'test'}).should == "/testpage?query=test"
+            expect(helper.show_alchemy_page_path(page, {query: 'test'})).to eq("/testpage?query=test")
           end
         end
       end
@@ -78,29 +78,29 @@ module Alchemy
         context "when multi_language" do
 
           before do
-            helper.stub(:multi_language?).and_return(true)
+            allow(helper).to receive(:multi_language?).and_return(true)
           end
 
           it "should return the correct url string" do
-            helper.show_alchemy_page_url(page).should == "http://#{helper.request.host}/#{page.language_code}/testpage"
+            expect(helper.show_alchemy_page_url(page)).to eq("http://#{helper.request.host}/#{page.language_code}/testpage")
           end
 
           it "should return the correct url string with additional parameters" do
-            helper.show_alchemy_page_url(page, {query: 'test'}).should == "http://#{helper.request.host}/#{page.language_code}/testpage?query=test"
+            expect(helper.show_alchemy_page_url(page, {query: 'test'})).to eq("http://#{helper.request.host}/#{page.language_code}/testpage?query=test")
           end
         end
 
         context "not multi_language" do
           before do
-            helper.stub(:multi_language?).and_return(false)
+            allow(helper).to receive(:multi_language?).and_return(false)
           end
 
           it "should return the correct url string" do
-            helper.show_alchemy_page_url(page).should == "http://#{helper.request.host}/testpage"
+            expect(helper.show_alchemy_page_url(page)).to eq("http://#{helper.request.host}/testpage")
           end
 
           it "should return the correct url string with additional parameter" do
-            helper.show_alchemy_page_url(page, {query: 'test'}).should == "http://#{helper.request.host}/testpage?query=test"
+            expect(helper.show_alchemy_page_url(page, {query: 'test'})).to eq("http://#{helper.request.host}/testpage?query=test")
           end
         end
       end
@@ -111,35 +111,35 @@ module Alchemy
 
       describe '#show_alchemy_picture_path' do
         it "should return the correct relative path string" do
-          helper.show_alchemy_picture_path(picture).should =~ Regexp.new("/pictures/42/show/cute_kitten.jpg")
+          expect(helper.show_alchemy_picture_path(picture)).to match(Regexp.new("/pictures/42/show/cute_kitten.jpg"))
         end
       end
 
       describe '#show_alchemy_picture_url' do
         it "should return the correct url string" do
-          helper.show_alchemy_picture_url(picture).should =~ Regexp.new("http://#{helper.request.host}/pictures/42/show/cute_kitten.jpg")
+          expect(helper.show_alchemy_picture_url(picture)).to match(Regexp.new("http://#{helper.request.host}/pictures/42/show/cute_kitten.jpg"))
         end
       end
 
       describe '#show_picture_path_params' do
         it "should return the correct params for rendering a picture" do
-          helper.show_picture_path_params(picture).should include(name: 'cute_kitten', format: 'jpg')
+          expect(helper.show_picture_path_params(picture)).to include(name: 'cute_kitten', format: 'jpg')
         end
 
         it "should include the secure hash parameter" do
-          helper.show_picture_path_params(picture).keys.should include(:sh)
-          helper.show_picture_path_params(picture)[:sh].should_not be_empty
+          expect(helper.show_picture_path_params(picture).keys).to include(:sh)
+          expect(helper.show_picture_path_params(picture)[:sh]).not_to be_empty
         end
 
         context "with additional params" do
           it "should include these params" do
-            helper.show_picture_path_params(picture, {format: 'png'}).should include(name: 'cute_kitten', format: 'png')
+            expect(helper.show_picture_path_params(picture, {format: 'png'})).to include(name: 'cute_kitten', format: 'png')
           end
         end
 
         context "with additional params crop set to true" do
           it "should include crop as parameter" do
-            helper.show_picture_path_params(picture, {crop: true}).should include(name: 'cute_kitten', crop: 'crop')
+            expect(helper.show_picture_path_params(picture, {crop: true})).to include(name: 'cute_kitten', crop: 'crop')
           end
         end
       end
@@ -149,11 +149,11 @@ module Alchemy
       let(:attachment) { mock_model(Attachment, urlname: 'test-attachment.pdf') }
 
       it 'should return the correct relative path to download an attachment' do
-        helper.download_alchemy_attachment_path(attachment).should == "/attachment/#{attachment.id}/download/#{attachment.urlname}"
+        expect(helper.download_alchemy_attachment_path(attachment)).to eq("/attachment/#{attachment.id}/download/#{attachment.urlname}")
       end
 
       it 'should return the correct url to download an attachment' do
-        helper.download_alchemy_attachment_url(attachment).should == "http://#{helper.request.host}/attachment/#{attachment.id}/download/#{attachment.urlname}"
+        expect(helper.download_alchemy_attachment_url(attachment)).to eq("http://#{helper.request.host}/attachment/#{attachment.id}/download/#{attachment.urlname}")
       end
     end
 
@@ -164,7 +164,7 @@ module Alchemy
       let(:current_server) { '' }
 
       it "returns the url to this element" do
-        should == "#{current_server}/#{element.page.urlname}##{element_dom_id(element)}"
+        is_expected.to eq("#{current_server}/#{element.page.urlname}##{element_dom_id(element)}")
       end
     end
   end

data/spec/libraries/config_spec.rb

@@ -5,12 +5,12 @@ module Alchemy
 
     describe ".get" do
       it "should call #show" do
-        Config.should_receive(:show).and_return({})
+        expect(Config).to receive(:show).and_return({})
         Config.get(:mailer)
       end
 
       it "should return the requested part of the config" do
-        Config.should_receive(:show).and_return({'mailer' => {'setting' => 'true'}})
+        expect(Config).to receive(:show).and_return({'mailer' => {'setting' => 'true'}})
         expect(Config.get(:mailer)).to eq({'setting' => 'true'})
       end
     end
@@ -19,7 +19,7 @@ module Alchemy
       let(:main_app_config_path) { "#{Rails.root}/config/alchemy/config.yml" }
 
       it "should call and return .read_file with the correct config path" do
-        Config.should_receive(:read_file).with(main_app_config_path).once.and_return({setting: 'true'})
+        expect(Config).to receive(:read_file).with(main_app_config_path).once.and_return({setting: 'true'})
         expect(Config.send(:main_app_config)).to eq({setting: 'true'})
       end
     end
@@ -28,7 +28,7 @@ module Alchemy
       let(:env_specific_config_path) { "#{Rails.root}/config/alchemy/#{Rails.env}.config.yml" }
 
       it "should call and return .read_file with the correct config path" do
-        Config.should_receive(:read_file).with(env_specific_config_path).once.and_return({setting: 'true'})
+        expect(Config).to receive(:read_file).with(env_specific_config_path).once.and_return({setting: 'true'})
         expect(Config.send(:env_specific_config)).to eq({setting: 'true'})
       end
     end
@@ -38,7 +38,7 @@ module Alchemy
         before { Config.instance_variable_set("@config", nil) }
 
         it "should call and return .merge_configs!" do
-          Config.should_receive(:merge_configs!).once.and_return({setting: 'true'})
+          expect(Config).to receive(:merge_configs!).once.and_return({setting: 'true'})
           expect(Config.show).to eq({setting: 'true'})
         end
       end
@@ -55,17 +55,17 @@ module Alchemy
 
     describe '.read_file' do
       context 'when given path to yml file exists' do
-        before { File.stub(:exists?).and_return(true) }
+        before { allow(File).to receive(:exists?).and_return(true) }
 
         it 'should call YAML.load_file with the given config path' do
-          YAML.should_receive(:load_file).once.with('path/to/config.yml').and_return({})
+          expect(YAML).to receive(:load_file).once.with('path/to/config.yml').and_return({})
           Config.send(:read_file, 'path/to/config.yml')
         end
 
         context 'but its empty' do
           before do
-            File.stub(:exists?).with('empty_file.yml').and_return(true)
-            YAML.stub(:load_file).and_return(false) # YAML.load_file returns false if file is empty.
+            allow(File).to receive(:exists?).with('empty_file.yml').and_return(true)
+            allow(YAML).to receive(:load_file).and_return(false) # YAML.load_file returns false if file is empty.
           end
 
           it "should return an empty Hash" do

data/spec/libraries/controller_actions_spec.rb

@@ -18,7 +18,7 @@ describe 'Alchemy::ControllerActions', type: 'controller' do
   describe "#current_alchemy_user" do
     context "with default current_user_method" do
       it "calls current_user by default" do
-        controller.should_receive :current_user
+        expect(controller).to receive :current_user
         controller.send :current_alchemy_user
       end
     end
@@ -29,7 +29,7 @@ describe 'Alchemy::ControllerActions', type: 'controller' do
       end
 
       it "calls the custom method" do
-        controller.should_receive :current_admin
+        expect(controller).to receive :current_admin
         controller.send :current_alchemy_user
       end
     end
@@ -63,7 +63,7 @@ describe 'Alchemy::ControllerActions', type: 'controller' do
     context "with a Language argument" do
       it "should set the language to the passed Language instance" do
         controller.send :set_alchemy_language, klingonian
-        assigns(:language).should == klingonian
+        expect(assigns(:language)).to eq(klingonian)
         expect(Alchemy::Language.current).to eq(klingonian)
       end
     end
@@ -71,7 +71,7 @@ describe 'Alchemy::ControllerActions', type: 'controller' do
     context "with a language id argument" do
       it "should set the language to the language specified by the passed id" do
         controller.send :set_alchemy_language, klingonian.id
-        assigns(:language).should == klingonian
+        expect(assigns(:language)).to eq(klingonian)
         expect(Alchemy::Language.current).to eq(klingonian)
       end
     end
@@ -79,16 +79,16 @@ describe 'Alchemy::ControllerActions', type: 'controller' do
     context "with a language code argument" do
       it "should set the language to the language specified by the passed code" do
         controller.send :set_alchemy_language, klingonian.code
-        assigns(:language).should == klingonian
+        expect(assigns(:language)).to eq(klingonian)
         expect(Alchemy::Language.current).to eq(klingonian)
       end
     end
 
     context "with no lang param" do
       it "should set the default language" do
-        controller.stub(:params).and_return({})
+        allow(controller).to receive(:params).and_return({})
         controller.send :set_alchemy_language
-        assigns(:language).should == default_language
+        expect(assigns(:language)).to eq(default_language)
         expect(Alchemy::Language.current).to eq(default_language)
         expect(controller.session).to include_language_information_for(default_language)
       end
@@ -96,34 +96,34 @@ describe 'Alchemy::ControllerActions', type: 'controller' do
 
     context "with language in the session" do
       before do
-        controller.stub(:session).and_return(alchemy_language_id: klingonian.id)
-        Alchemy::Language.stub(current: klingonian)
+        allow(controller).to receive(:session).and_return(alchemy_language_id: klingonian.id)
+        allow(Alchemy::Language).to receive(:current).and_return(klingonian)
       end
 
       it "should use the language from the session" do
         controller.send :set_alchemy_language
-        assigns(:language).should == klingonian
+        expect(assigns(:language)).to eq(klingonian)
         expect(Alchemy::Language.current).to eq(klingonian)
       end
     end
 
     context "with lang param" do
       it "should set the language" do
-        controller.stub(:params).and_return(lang: klingonian.code)
+        allow(controller).to receive(:params).and_return(lang: klingonian.code)
         controller.send :set_alchemy_language
-        assigns(:language).should == klingonian
+        expect(assigns(:language)).to eq(klingonian)
         expect(Alchemy::Language.current).to eq(klingonian)
         expect(controller.session).to include_language_information_for(klingonian)
       end
 
       context "for language that does not exist" do
         before do
-          controller.stub(:params).and_return(lang: 'fo')
+          allow(controller).to receive(:params).and_return(lang: 'fo')
           controller.send :set_alchemy_language
         end
 
         it "should set the language to default" do
-          assigns(:language).should == default_language
+          expect(assigns(:language)).to eq(default_language)
           expect(Alchemy::Language.current).to eq(default_language)
           expect(controller.session).to include_language_information_for(default_language)
         end

data/spec/libraries/i18n_spec.rb

@@ -4,19 +4,19 @@ module Alchemy
   describe I18n do
     describe '.translation_files' do
       subject { I18n.translation_files }
-      it      { should be_a Array }
-      it      { should be_any { |f| f =~ /alchemy.*.yml/ } }
+      it      { is_expected.to be_a Array }
+      it      { is_expected.to be_any { |f| f =~ /alchemy.*.yml/ } }
     end
 
     describe '.available_locales' do
       subject { I18n.available_locales }
-      before  { I18n.stub(translation_files: ['alchemy.kl.yml']) }
-      it      { should be_a Array }
-      it      { should include :kl }
+      before  { allow(I18n).to receive(:translation_files).and_return(['alchemy.kl.yml']) }
+      it      { is_expected.to be_a Array }
+      it      { is_expected.to include :kl }
 
       context 'when locales are already set in @@available_locales' do
         before { I18n.class_variable_set(:@@available_locales, [:kl, :jp]) }
-        it     { should eq([:kl, :jp]) }
+        it     { is_expected.to eq([:kl, :jp]) }
       end
     end
 

data/spec/libraries/kaminari/scoped_pagination_url_helper_spec.rb

@@ -11,8 +11,8 @@ describe Kaminari::Helpers::Tag do
       let(:options) { {scope: scope} }
 
       it "calls url_for on that url proxy scope." do
-        template.should_not_receive(:url_for)
-        scope.should_receive(:url_for)
+        expect(template).not_to receive(:url_for)
+        expect(scope).to receive(:url_for)
         subject.page_url_for(1)
       end
     end
@@ -21,8 +21,8 @@ describe Kaminari::Helpers::Tag do
       let(:options) { {} }
 
       it "calls url_for on the template." do
-        template.should_receive(:url_for)
-        scope.should_not_receive(:url_for)
+        expect(template).to receive(:url_for)
+        expect(scope).not_to receive(:url_for)
         subject.page_url_for(1)
       end
     end

data/spec/libraries/modules_spec.rb

@@ -18,7 +18,7 @@ module Alchemy
         let(:name) { 'dashboard' }
 
         it "returns the module definition" do
-          should == dashboard_module
+          is_expected.to eq(dashboard_module)
         end
       end
 
@@ -27,14 +27,14 @@ module Alchemy
         let(:name)            { {controller: controller_name, action: 'index'} }
 
         it "returns the module definition" do
-          should == dashboard_module
+          is_expected.to eq(dashboard_module)
         end
 
         context 'with leading slash in controller name' do
           let(:controller_name) { '/alchemy/admin/dashboard' }
 
           it "returns the module definition" do
-            should == dashboard_module
+            is_expected.to eq(dashboard_module)
           end
         end
       end
@@ -60,7 +60,7 @@ module Alchemy
 
       it "registers a module definition into global list of modules" do
         Modules.register_module(alchemy_module)
-        Modules.alchemy_modules.should include(alchemy_module)
+        expect(Modules.alchemy_modules).to include(alchemy_module)
       end
     end
   end