alchemy_cms 3.0.4 → 3.1.0.beta1

data/spec/helpers/admin/navigation_helper_spec.rb

@@ -49,95 +49,98 @@ describe Alchemy::Admin::NavigationHelper do
 
   describe '#alchemy_main_navigation_entry' do
     before do
-      helper.stub(:url_for_module).and_return('')
-      helper.stub(:_t).and_return(alchemy_module['name'])
+      allow(helper).to receive(:url_for_module).and_return('')
+      allow(helper).to receive(:_t).and_return(alchemy_module['name'])
     end
 
     context "with permission" do
       before do
-        helper.stub(:can?).and_return(true)
+        expect(helper).to receive(:can?).and_return(true)
       end
 
       it "renders the main navigation entry partial" do
-        helper.alchemy_main_navigation_entry(alchemy_module).should match /<a.+class="main_navi_entry/
+        expect(helper.alchemy_main_navigation_entry(alchemy_module)).to match /<a.+class="main_navi_entry/
       end
     end
 
     context "without permission" do
       before do
-        helper.stub(:can?).and_return(false)
+        allow(helper).to receive(:can?).and_return(false)
       end
 
       it "returns empty string" do
-        helper.alchemy_main_navigation_entry(alchemy_module).should be_empty
+        expect(helper.alchemy_main_navigation_entry(alchemy_module)).to be_empty
       end
     end
   end
 
   describe '#admin_subnavigation' do
     before do
-      helper.stub(:current_alchemy_module).and_return(alchemy_module)
-      helper.stub(:url_for_module_sub_navigation).and_return('')
-      helper.stub(:_t).and_return(alchemy_module['name'])
+      allow(helper).to receive(:current_alchemy_module).and_return(alchemy_module)
+      allow(helper).to receive(:url_for_module_sub_navigation).and_return('')
+      allow(helper).to receive(:_t).and_return(alchemy_module['name'])
     end
 
     context "with permission" do
       before do
-        helper.stub(:can?).and_return(true)
+        expect(helper).to receive(:can?).and_return(true)
       end
 
       it "renders the sub navigation for current module" do
-        helper.admin_subnavigation.should match /<div.+class="subnavi_tab/
+        expect(helper.admin_subnavigation).to match /<div.+class="subnavi_tab/
       end
     end
 
     context "without permission" do
       before do
-        helper.stub(:can?).and_return(false)
+        expect(helper).to receive(:can?).and_return(false)
       end
 
       it "renders the sub navigation for current module" do
-        helper.admin_subnavigation.should be_empty
+        expect(helper.admin_subnavigation).to be_empty
       end
     end
 
     context "without a module present" do
       before do
-        helper.stub(:current_alchemy_module).and_return(nil)
+        expect(helper).to receive(:current_alchemy_module).and_return(nil)
       end
 
       it "returns nil" do
-        helper.admin_subnavigation.should be_nil
+        expect(helper.admin_subnavigation).to be_nil
       end
     end
   end
 
   describe '#navigate_module' do
     it "returns array with symbolized action and controller name" do
-      helper.navigate_module(navigation).should == [:index, :alchemy_admin_dashboard]
+      expect(helper.navigate_module(navigation)).to eq([:index, :alchemy_admin_dashboard])
     end
 
     it "stringifies keys" do
-      helper.navigate_module({action: 'index', controller: 'alchemy/admin/pictures'}).should == [:index, :alchemy_admin_pictures]
+      expect(helper.navigate_module({action: 'index', controller: 'alchemy/admin/pictures'})).to eq([:index, :alchemy_admin_pictures])
     end
 
     it "removes leading slash" do
-      helper.navigate_module({action: 'index', controller: '/admin/pictures'}).should == [:index, :admin_pictures]
+      expect(helper.navigate_module({action: 'index', controller: '/admin/pictures'})).to eq([:index, :admin_pictures])
     end
   end
 
   describe '#main_navigation_css_classes' do
     it "returns string with css classes for main navigation entry" do
-      helper.main_navigation_css_classes(navigation).should == "main_navi_entry"
+      expect(helper.main_navigation_css_classes(navigation)).to eq("main_navi_entry")
     end
 
     context "with active entry" do
       before do
-        helper.stub(:params).and_return({controller: 'alchemy/admin/dashboard', action: 'index'})
+        allow(helper).to receive(:params).and_return({
+          controller: 'alchemy/admin/dashboard',
+          action: 'index'
+        })
       end
 
       it "includes active class" do
-        helper.main_navigation_css_classes(navigation).should == "main_navi_entry active"
+        expect(helper.main_navigation_css_classes(navigation)).to eq("main_navi_entry active")
       end
     end
   end
@@ -149,18 +152,21 @@ describe Alchemy::Admin::NavigationHelper do
 
     context "with active entry" do
       before do
-        helper.stub(:params).and_return({controller: 'alchemy/admin/dashboard', action: 'index'})
+        allow(helper).to receive(:params).and_return({
+          controller: 'alchemy/admin/dashboard',
+          action: 'index'
+        })
       end
 
       it "returns true" do
-        helper.entry_active?(entry).should be_true
+        expect(helper.entry_active?(entry)).to be_truthy
       end
 
       context "and with leading slash in controller name" do
         before { entry['controller'] = '/alchemy/admin/dashboard' }
 
         it "returns true" do
-          helper.entry_active?(entry).should be_true
+          expect(helper.entry_active?(entry)).to be_truthy
         end
       end
 
@@ -171,18 +177,21 @@ describe Alchemy::Admin::NavigationHelper do
         end
 
         it "returns true" do
-          helper.entry_active?(entry).should be_true
+          expect(helper.entry_active?(entry)).to be_truthy
         end
       end
     end
 
     context "with inactive entry" do
       before do
-        helper.stub(:params).and_return({controller: 'alchemy/admin/users', action: 'index'})
+        expect(helper).to receive(:params).and_return({
+          controller: 'alchemy/admin/users',
+          action: 'index'
+        })
       end
 
       it "returns false" do
-        helper.entry_active?(entry).should be_false
+        expect(helper.entry_active?(entry)).to be_falsey
       end
     end
   end
@@ -190,17 +199,17 @@ describe Alchemy::Admin::NavigationHelper do
   describe '#url_for_module' do
     context "with module within an engine" do
       it "returns correct url string" do
-        helper.url_for_module(alchemy_module).should == '/admin/dashboard'
+        expect(helper.url_for_module(alchemy_module)).to eq('/admin/dashboard')
       end
     end
 
     context "with module within host app" do
       it "returns correct url string" do
-        helper.url_for_module(event_module).should == '/admin/events'
+        expect(helper.url_for_module(event_module)).to eq('/admin/events')
       end
 
       it "returns correct url string with params" do
-        helper.url_for_module(event_module_with_params).should == '/admin/events?key=value'
+        expect(helper.url_for_module(event_module_with_params)).to eq('/admin/events?key=value')
       end
     end
   end
@@ -211,40 +220,42 @@ describe Alchemy::Admin::NavigationHelper do
     let(:current_module) { alchemy_module }
     let(:navigation)     { current_module['navigation']['sub_navigation'].first }
 
-    before do
-      helper.stub(module_definition_for: current_module)
-    end
+    context 'with module found' do
+      before do
+        expect(helper).to receive(:module_definition_for).and_return current_module
+      end
 
-    context "with module within an engine" do
-      let(:current_module) { alchemy_module }
+      context "with module within an engine" do
+        let(:current_module) { alchemy_module }
 
-      it "returns correct url string" do
-        should == '/admin/layoutpages'
+        it "returns correct url string" do
+          is_expected.to eq('/admin/layoutpages')
+        end
       end
-    end
 
-    context "with module within host app" do
-      let(:current_module) { event_module }
+      context "with module within host app" do
+        let(:current_module) { event_module }
 
-      it "returns correct url string" do
-        should == '/admin/events'
+        it "returns correct url string" do
+          is_expected.to eq('/admin/events')
+        end
       end
-    end
 
-    context "with module within host app with params" do
-      let(:current_module) { event_module_with_params }
+      context "with module within host app with params" do
+        let(:current_module) { event_module_with_params }
 
-      it "returns correct url string with params" do
-        should == '/admin/events?key2=value2&key=value'
+        it "returns correct url string with params" do
+          is_expected.to eq('/admin/events?key2=value2&key=value')
+        end
       end
     end
 
     context 'without module found' do
       before do
-        helper.stub(module_definition_for: nil)
+        expect(helper).to receive(:module_definition_for).and_return nil
       end
 
-      it { should be_nil }
+      it { is_expected.to be_nil }
     end
   end
 
@@ -255,24 +266,23 @@ describe Alchemy::Admin::NavigationHelper do
       before do
         alchemy_module['position'] = 1
         event_module['position'] = 2
-        helper.stub(alchemy_modules: [event_module, alchemy_module])
+        expect(helper).to receive(:alchemy_modules).and_return [event_module, alchemy_module]
       end
 
       it "returns sorted alchemy modules" do
-        should eq([alchemy_module, event_module])
+        is_expected.to eq([alchemy_module, event_module])
       end
     end
 
     context 'with no position attribute on one module' do
       before do
         event_module['position'] = 2
-        helper.stub(alchemy_modules: [alchemy_module, event_module])
+        expect(helper).to receive(:alchemy_modules).and_return [alchemy_module, event_module]
       end
 
       it "appends this module at the end" do
-        should eq([event_module, alchemy_module])
+        is_expected.to eq([event_module, alchemy_module])
       end
     end
   end
-
 end

data/spec/helpers/admin/pages_helper_spec.rb

@@ -5,7 +5,7 @@ describe Alchemy::Admin::PagesHelper do
   describe '#sitemap_folder_link' do
     let(:user) { admin_user }
 
-    before { helper.stub(:current_alchemy_user).and_return(user) }
+    before { allow(helper).to receive(:current_alchemy_user).and_return(user) }
 
     subject { helper.sitemap_folder_link(page) }
 
@@ -13,11 +13,11 @@ describe Alchemy::Admin::PagesHelper do
       let(:page) { mock_model(Alchemy::Page, folded?: true) }
 
       it "renders a link with folded class" do
-        should match /class="page_folder folded spinner"/
+        is_expected.to match /class="page_folder folded spinner"/
       end
 
       it "renders a link with hide title" do
-        should match /title="Show childpages"/
+        is_expected.to match /title="Show childpages"/
       end
     end
 
@@ -25,18 +25,18 @@ describe Alchemy::Admin::PagesHelper do
       let(:page) { mock_model(Alchemy::Page, folded?: false) }
 
       it "renders a link with collapsed class" do
-        should match /class="page_folder collapsed spinner"/
+        is_expected.to match /class="page_folder collapsed spinner"/
       end
 
       it "renders a link with hide title" do
-        should match /title="Hide childpages"/
+        is_expected.to match /title="Hide childpages"/
       end
     end
   end
 
   describe '#preview_sizes_for_select' do
     it "returns a options string of preview screen sizes for select tag" do
-      helper.preview_sizes_for_select.should include('option', 'auto', '240', '320', '480', '768', '1024', '1280')
+      expect(helper.preview_sizes_for_select).to include('option', 'auto', '240', '320', '480', '768', '1024', '1280')
     end
   end
 
@@ -45,19 +45,19 @@ describe Alchemy::Admin::PagesHelper do
     subject { helper.combined_page_status(page) }
 
     context 'when page is locked' do
-      it { should_not match(/locked/) } # We don't want the locked status in the return string
+      it { is_expected.not_to match(/locked/) } # We don't want the locked status in the return string
     end
 
     context 'when page is restricted' do
-      it { should match(/is restricted/) }
+      it { is_expected.to match(/is restricted/) }
     end
 
     context 'when page is visible in navigation' do
-      it { should match(/is visible/) }
+      it { is_expected.to match(/is visible/) }
     end
 
     context 'when page is published' do
-      it { should match(/is published/) }
+      it { is_expected.to match(/is published/) }
     end
   end
 

data/spec/helpers/admin/tags_helper_spec.rb

@@ -9,40 +9,40 @@ module Alchemy
 
     describe '#render_tag_list' do
       context "with tagged objects" do
-        before { Attachment.stub(:tag_counts).and_return([tag, tag2]) }
+        before { allow(Attachment).to receive(:tag_counts).and_return([tag, tag2]) }
 
         it "returns a tag list as <li> tags" do
-          helper.render_tag_list('Alchemy::Attachment', params).should match(/li/)
+          expect(helper.render_tag_list('Alchemy::Attachment', params)).to match(/li/)
         end
 
         it "has the tags name in the li's name attribute" do
-          helper.render_tag_list('Alchemy::Attachment', params).should match(/li.+name="#{tag.name}"/)
+          expect(helper.render_tag_list('Alchemy::Attachment', params)).to match(/li.+name="#{tag.name}"/)
         end
 
         it "has active class if tag is present in params" do
-          helper.render_tag_list('Alchemy::Attachment', params).should match(/li.+class="active"/)
+          expect(helper.render_tag_list('Alchemy::Attachment', params)).to match(/li.+class="active"/)
         end
 
         it "tags are sorted alphabetically" do
-          helper.render_tag_list('Alchemy::Attachment', params).should match(/li.+name="#{tag2.name}.+li.+name="#{tag.name}/)
+          expect(helper.render_tag_list('Alchemy::Attachment', params)).to match(/li.+name="#{tag2.name}.+li.+name="#{tag.name}/)
         end
 
         context "with lowercase and uppercase tag names mixed" do
           let(:tag) { mock_model(ActsAsTaggableOn::Tag, name: 'Foo', count: 1) }
 
           it "tags are sorted alphabetically correctly" do
-            helper.render_tag_list('Alchemy::Attachment', params).should match(/li.+name="#{tag2.name}.+li.+name="#{tag.name}/)
+            expect(helper.render_tag_list('Alchemy::Attachment', params)).to match(/li.+name="#{tag2.name}.+li.+name="#{tag.name}/)
           end
         end
 
         it "output is html_safe" do
-          helper.render_tag_list('Alchemy::Attachment', params).html_safe?.should be_true
+          expect(helper.render_tag_list('Alchemy::Attachment', params).html_safe?).to be_truthy
         end
       end
 
       context "without any tagged objects" do
         it "returns empty string" do
-          render_tag_list('Alchemy::Attachment', params).should be_empty
+          expect(render_tag_list('Alchemy::Attachment', params)).to be_empty
         end
       end
 
@@ -56,13 +56,13 @@ module Alchemy
     describe '#tag_list_tag_active?' do
       context "the tag is in params" do
         it "returns true" do
-          tag_list_tag_active?(tag, params).should be_true
+          expect(tag_list_tag_active?(tag, params)).to be_truthy
         end
       end
 
       context "params[:tagged_with] is not present" do
         it "returns false" do
-          tag_list_tag_active?(tag, {}).should be_false
+          expect(tag_list_tag_active?(tag, {})).to be_falsey
         end
       end
     end
@@ -70,26 +70,26 @@ module Alchemy
     describe "#filtered_by_tag?" do
       it "should return true if the filterlist contains the given tag" do
         controller.params[:tagged_with] = "foo,bar,baz"
-        helper.filtered_by_tag?(tag).should == true
+        expect(helper.filtered_by_tag?(tag)).to eq(true)
       end
 
       it "should return false if the filterlist does not contain the given tag" do
         controller.params[:tagged_with] = "bar,baz"
-        helper.filtered_by_tag?(tag).should == false
+        expect(helper.filtered_by_tag?(tag)).to eq(false)
       end
     end
 
     describe "#add_to_tag_filter" do
       context "if params[:tagged_with] is not present" do
         it "should return an Array with the given tag name" do
-          helper.add_to_tag_filter(tag).should == ["foo"]
+          expect(helper.add_to_tag_filter(tag)).to eq(["foo"])
         end
       end
 
       context "if params[:tagged_with] contains some tag names" do
         it "should return an Array of tag names including the given one" do
           controller.params[:tagged_with] = "bar,baz"
-          helper.add_to_tag_filter(tag).should == ["bar", "baz", "foo"]
+          expect(helper.add_to_tag_filter(tag)).to eq(["bar", "baz", "foo"])
         end
       end
     end
@@ -97,14 +97,14 @@ module Alchemy
     describe "#remove_from_tag_filter" do
       context "if params[:tagged_with] is not present" do
         it "should return an empty Array" do
-          helper.remove_from_tag_filter(tag).should be_empty
+          expect(helper.remove_from_tag_filter(tag)).to be_empty
         end
       end
 
       context "if params[:tagged_with] contains some tag names" do
         it "should return an Array of tag names without the given one" do
           controller.params[:tagged_with] = "bar,baz,foo"
-          helper.remove_from_tag_filter(tag).should == ["bar", "baz"]
+          expect(helper.remove_from_tag_filter(tag)).to eq(["bar", "baz"])
         end
       end
     end