alchemy_cms 3.0.4 → 3.1.0.beta1

data/spec/controllers/admin/dashboard_controller_spec.rb

@@ -8,8 +8,8 @@ module Alchemy
 
     describe '#index' do
       before do
-        Page.stub_chain(:from_current_site, :all_last_edited_from).and_return([])
-        Page.stub_chain(:from_current_site, :all_locked).and_return([])
+        expect(Page).to receive(:from_current_site).and_return(double(all_last_edited_from: []))
+        expect(Page).to receive(:from_current_site).and_return(double(all_locked: []))
       end
 
       it "assigns @last_edited_pages" do
@@ -27,7 +27,7 @@ module Alchemy
           let(:another_user) { mock_model('DummyUser') }
 
           before do
-            Alchemy.user_class.should_receive(:logged_in).and_return([another_user])
+            expect(Alchemy.user_class).to receive(:logged_in).and_return([another_user])
           end
 
           it "assigns @online_users" do
@@ -46,8 +46,8 @@ module Alchemy
 
       context 'user having signed in before' do
         before do
-          user.should_receive(:sign_in_count).and_return(5)
-          user.should_receive(:last_sign_in_at).and_return(Time.now)
+          expect(user).to receive(:sign_in_count).and_return(5)
+          expect(user).to receive(:last_sign_in_at).and_return(Time.now)
         end
 
         it "assigns @first_time" do
@@ -72,8 +72,8 @@ module Alchemy
     describe '#update_check' do
       context "if current Alchemy version equals the latest released version or it is newer" do
         before {
-          controller.stub(:latest_alchemy_version).and_return('2.6')
-          Alchemy.stub(:version).and_return("2.6")
+          allow(controller).to receive(:latest_alchemy_version).and_return('2.6')
+          allow(Alchemy).to receive(:version).and_return("2.6")
         }
 
         it "should render 'false'" do
@@ -84,8 +84,8 @@ module Alchemy
 
       context "if current Alchemy version is older than latest released version" do
         before {
-          controller.stub(:latest_alchemy_version).and_return('2.6')
-          Alchemy.stub(:version).and_return("2.5")
+          allow(controller).to receive(:latest_alchemy_version).and_return('2.6')
+          allow(Alchemy).to receive(:version).and_return("2.5")
         }
 
         it "should render 'true'" do
@@ -96,10 +96,10 @@ module Alchemy
 
       context "requesting rubygems.org" do
         before {
-          Net::HTTP.any_instance.stub(:request).and_return(
+          allow_any_instance_of(Net::HTTP).to receive(:request).and_return(
             OpenStruct.new({code: '200', body: '[{"number": "2.6"}, {"number": "2.5"}]'})
           )
-          Alchemy.stub(:version).and_return("2.6")
+          allow(Alchemy).to receive(:version).and_return("2.6")
         }
 
         it "should have response code of 200" do
@@ -110,8 +110,8 @@ module Alchemy
 
       context "requesting github.com" do
         before {
-          controller.stub(:query_rubygems).and_return(OpenStruct.new({code: '503'}))
-          Net::HTTP.any_instance.stub(:request).and_return(
+          allow(controller).to receive(:query_rubygems).and_return(OpenStruct.new({code: '503'}))
+          allow_any_instance_of(Net::HTTP).to receive(:request).and_return(
             OpenStruct.new({code: '200', body: '[{"name": "2.6"}, {"name": "2.5"}]'})
           )
         }
@@ -124,7 +124,7 @@ module Alchemy
 
       context "rubygems.org and github.com are unavailable" do
         before {
-          Net::HTTP.any_instance.stub(:request).and_return(
+          allow_any_instance_of(Net::HTTP).to receive(:request).and_return(
             OpenStruct.new({code: '503'})
           )
         }

data/spec/controllers/admin/elements_controller_spec.rb

@@ -13,26 +13,30 @@ module Alchemy
       let(:alchemy_page) { build_stubbed(:page) }
 
       before do
-        Page.stub(find: alchemy_page)
+        expect(Page).to receive(:find).and_return alchemy_page
       end
 
       context 'with cells' do
         let(:cell) { build_stubbed(:cell, page: alchemy_page) }
 
-        before { alchemy_page.stub(cells: [cell]) }
+        before do
+          expect(alchemy_page).to receive(:cells).and_return [cell]
+        end
 
         it "groups elements by cell" do
-          alchemy_page.should_receive(:elements_grouped_by_cells)
+          expect(alchemy_page).to receive(:elements_grouped_by_cells)
           get :index, {page_id: alchemy_page.id}
-          assigns(:cells).should eq([cell])
+          expect(assigns(:cells)).to eq([cell])
         end
       end
 
       context 'without cells' do
-        before { alchemy_page.stub(cells: []) }
+        before do
+          expect(alchemy_page).to receive(:cells).and_return []
+        end
 
         it "assigns page elements" do
-          alchemy_page.should_receive(:elements).and_return(double(not_trashed: []))
+          expect(alchemy_page).to receive(:elements).and_return(double(not_trashed: []))
           get :index, {page_id: alchemy_page.id}
         end
       end
@@ -41,13 +45,9 @@ module Alchemy
     describe '#list' do
       let(:alchemy_page) { build_stubbed(:page) }
 
-      before do
-        Page.stub(find: alchemy_page)
-      end
-
       context 'without page_id, but with page_urlname' do
         it "loads page from urlname" do
-          Language.stub(:current).and_return(double(code: 'en', pages: double(find_by: double(id: 1001))))
+          expect(Language).to receive(:current).at_least(:once).and_return(double(code: 'en', pages: double(find_by: double(id: 1001))))
           xhr :get, :list, {page_urlname: 'contact'}
         end
 
@@ -56,7 +56,7 @@ module Alchemy
 
           it "should return a select tag with elements" do
             xhr :get, :list, {page_urlname: alchemy_page.urlname}
-            response.body.should match(/select(.*)elements_from_page_selector(.*)option/)
+            expect(response.body).to match(/select(.*)elements_from_page_selector(.*)option/)
           end
         end
       end
@@ -64,7 +64,7 @@ module Alchemy
       context 'with page_id' do
         it "loads page from urlname" do
           xhr :get, :list, {page_id: alchemy_page.id}
-          assigns(:page_id).should eq(alchemy_page.id.to_s)
+          expect(assigns(:page_id)).to eq(alchemy_page.id.to_s)
         end
       end
     end
@@ -93,22 +93,22 @@ module Alchemy
           expect(assigns(:trashed_elements).to_a).to eq [trashed_element.id]
         end
 
-        it "should set a new position to the element" do
+        it "sets a new position to the element" do
           xhr :post, :order, element_ids: [trashed_element.id]
           trashed_element.reload
-          trashed_element.position.should_not == nil
+          expect(trashed_element.position).to_not be_nil
         end
 
         it "should assign the (new) page_id to the element" do
           xhr :post, :order, element_ids: [trashed_element.id], page_id: 1, cell_id: nil
           trashed_element.reload
-          trashed_element.page_id.should == 1
+          expect(trashed_element.page_id).to be 1
         end
 
         it "should assign the (new) cell_id to the element" do
           xhr :post, :order, element_ids: [trashed_element.id], page_id: 1, cell_id: 5
           trashed_element.reload
-          trashed_element.cell_id.should == 5
+          expect(trashed_element.cell_id).to be 5
         end
       end
     end
@@ -116,10 +116,12 @@ module Alchemy
     describe '#new' do
       let(:alchemy_page) { build_stubbed(:page) }
 
-      before { Page.stub(:find_by_id).and_return(alchemy_page) }
+      before do
+        expect(Page).to receive(:find_by_id).and_return(alchemy_page)
+      end
 
       it "assign variable for all available element definitions" do
-        alchemy_page.should_receive(:available_element_definitions)
+        expect(alchemy_page).to receive(:available_element_definitions)
         get :new, {page_id: alchemy_page.id}
       end
 
@@ -129,9 +131,9 @@ module Alchemy
         before { clipboard['elements'] = clipboard_items }
 
         it "should load all elements from clipboard" do
-          Element.should_receive(:all_from_clipboard_for_page).and_return(clipboard_items)
+          expect(Element).to receive(:all_from_clipboard_for_page).and_return(clipboard_items)
           get :new, {page_id: alchemy_page.id}
-          assigns(:clipboard_items).should == clipboard_items
+          expect(assigns(:clipboard_items)).to eq(clipboard_items)
         end
       end
     end
@@ -142,13 +144,13 @@ module Alchemy
 
         it "should insert the element at bottom of list" do
           xhr :post, :create, {element: {name: 'news', page_id: alchemy_page.id}}
-          alchemy_page.elements.count.should == 2
-          alchemy_page.elements.last.name.should == 'news'
+          expect(alchemy_page.elements.count).to eq(2)
+          expect(alchemy_page.elements.last.name).to eq('news')
         end
 
         context "on a page with a setting for insert_elements_at of top" do
           before do
-            PageLayout.stub(:get).and_return({
+            expect(PageLayout).to receive(:get).at_least(:once).and_return({
               'name' => 'news',
               'elements' => ['news'],
               'insert_elements_at' => 'top'
@@ -157,107 +159,120 @@ module Alchemy
 
           it "should insert the element at top of list" do
             xhr :post, :create, {element: {name: 'news', page_id: alchemy_page.id}}
-            alchemy_page.elements.count.should == 2
-            alchemy_page.elements.first.name.should == 'news'
+            expect(alchemy_page.elements.count).to eq(2)
+            expect(alchemy_page.elements.first.name).to eq('news')
           end
         end
       end
 
       context "if page has cells" do
-        context "" do
-          before do
-            @page = create(:public_page, :do_not_autogenerate => false)
-            @cell = create(:cell, :name => 'header', :page => @page)
-            PageLayout.stub(:get).and_return({
-              'name' => 'standard',
-              'elements' => ['article'],
-              'cells' => ['header']
-            })
-            Cell.stub(:definition_for).and_return({'name' => 'header', 'elements' => ['article']})
-          end
+        let(:page) { create(:public_page, do_not_autogenerate: false) }
+        let(:cell) { page.cells.first }
 
+        context "not pasting from clipboard" do
           context "and cell name in element name" do
+            before do
+              expect(PageLayout).to receive(:get).at_least(:once).and_return({
+                'name' => 'standard',
+                'elements' => ['article'],
+                'cells' => ['header']
+              })
+              expect(Cell).to receive(:definition_for).and_return({
+                'name' => 'header',
+                'elements' => ['article']
+              })
+            end
+
             it "should put the element in the correct cell" do
-              xhr :post, :create, {:element => {:name => "article#header", :page_id => @page.id}}
-              @cell.elements.first.should be_an_instance_of(Element)
+              xhr :post, :create, {element: {name: "article#header", page_id: page.id}}
+              expect(cell.elements.first).to be_an_instance_of(Element)
             end
           end
 
           context "and no cell name in element name" do
             it "should put the element in the main cell" do
-              xhr :post, :create, {:element => {:name => "article", :page_id => @page.id}}
-              @page.elements.not_in_cell.first.should be_an_instance_of(Element)
+              xhr :post, :create, {element: {name: "article", page_id: page.id}}
+              expect(page.elements.not_in_cell.first).to be_an_instance_of(Element)
             end
           end
         end
 
-        context "with paste_from_clipboard in parameters" do
-          context "" do
+        context "pasting from clipboard" do
+          context "with default element insert position" do
             before do
-              @page = create(:public_page, :do_not_autogenerate => false)
-              @cell = create(:cell, :name => 'header', :page => @page)
-              PageLayout.stub(:get).and_return({
+              expect(PageLayout).to receive(:get).at_least(:once).and_return({
                 'name' => 'standard',
                 'elements' => ['article'],
                 'cells' => ['header']
               })
-              Cell.stub(:definition_for).and_return({'name' => 'header', 'elements' => ['article']})
               clipboard['elements'] = [{'id' => element_in_clipboard.id.to_s}]
             end
 
             context "and cell name in element name" do
+              before do
+                expect(Cell).to receive(:definition_for).at_least(:once).and_return({
+                  'name' => 'header',
+                  'elements' => ['article']
+                })
+              end
+
               it "should create the element in the correct cell" do
-                xhr :post, :create, {:element => {:page_id => @page.id}, :paste_from_clipboard => "#{element_in_clipboard.id}##{@cell.name}"}
-                @cell.elements.first.should be_an_instance_of(Element)
+                xhr :post, :create, {element: {page_id: page.id}, paste_from_clipboard: "#{element_in_clipboard.id}##{cell.name}"}
+                expect(cell.elements.first).to be_an_instance_of(Element)
               end
-            end
 
-            context "and no cell name in element name" do
-              it "should create the element in the nil cell" do
-                xhr :post, :create, {:element => {:page_id => @page.id}, :paste_from_clipboard => "#{element_in_clipboard.id}"}
-                @page.elements.first.cell.should == nil
+              context "with elements already in cell" do
+                before do
+                  cell.elements.create(page_id: page.id, name: "article", create_contents_after_create: false)
+                end
+
+                it "should set the correct position for the element" do
+                  xhr :post, :create, {element: {page_id: page.id}, paste_from_clipboard: "#{element_in_clipboard.id}##{cell.name}"}
+                  expect(cell.elements.last.position).to eq(cell.elements.count)
+                end
               end
             end
 
-            context "" do
-              before { @cell.elements.create(:page_id => @page.id, :name => "article", :create_contents_after_create => false) }
-
-              it "should set the correct position for the element" do
-                xhr :post, :create, {:element => {:page_id => @page.id}, :paste_from_clipboard => "#{element_in_clipboard.id}##{@cell.name}"}
-                @cell.elements.last.position.should == @cell.elements.count
+            context "and no cell name in element name" do
+              it "should create the element in the nil cell" do
+                xhr :post, :create, {element: {page_id: page.id}, paste_from_clipboard: "#{element_in_clipboard.id}"}
+                expect(page.elements.first.cell).to eq(nil)
               end
             end
           end
 
           context "on a page with a setting for insert_elements_at of top" do
-            let(:alchemy_page)         { create(:public_page, :name => 'News') }
-            let(:element_in_clipboard) { create(:element, :page => alchemy_page, :name => 'news') }
-            let(:cell)                 { alchemy_page.cells.first }
-            let(:element)              { create(:element, :name => 'news', :page => alchemy_page, :cell => cell) }
+            let!(:alchemy_page)         { create(:public_page, name: 'News') }
+            let!(:element_in_clipboard) { create(:element, page: alchemy_page, name: 'news') }
+            let!(:cell)                 { create(:cell, name: 'news', page: alchemy_page) }
+            let!(:element)              { create(:element, name: 'news', page: alchemy_page, cell: cell) }
 
             before do
-              PageLayout.stub(:get).and_return({
+              expect(PageLayout).to receive(:get).at_least(:once).and_return({
                 'name' => 'news',
                 'elements' => ['news'],
                 'insert_elements_at' => 'top',
                 'cells' => ['news']
               })
-              Cell.stub(:definition_for).and_return({'name' => 'news', 'elements' => ['news']})
+              expect(Cell).to receive(:definition_for).and_return({
+                'name' => 'news',
+                'elements' => ['news']
+              })
               clipboard['elements'] = [{'id' => element_in_clipboard.id.to_s}]
               cell.elements << element
             end
 
             it "should insert the element at top of list" do
-              xhr :post, :create, {:element => {:name => 'news', :page_id => alchemy_page.id}, :paste_from_clipboard => "#{element_in_clipboard.id}##{cell.name}"}
-              cell.elements.count.should == 2
-              cell.elements.first.name.should == 'news'
-              cell.elements.first.should_not == element
+              xhr :post, :create, {element: {name: 'news', page_id: alchemy_page.id}, paste_from_clipboard: "#{element_in_clipboard.id}##{cell.name}"}
+              expect(cell.elements.count).to eq(2)
+              expect(cell.elements.first.name).to eq('news')
+              expect(cell.elements.first).not_to eq(element)
             end
           end
         end
       end
 
-      context "with paste_from_clipboard in parameters" do
+      context "pasting from clipboard" do
         render_views
 
         before do
@@ -266,14 +281,14 @@ module Alchemy
 
         it "should create an element from clipboard" do
           xhr :post, :create, {paste_from_clipboard: element_in_clipboard.id, element: {page_id: alchemy_page.id}}
-          response.status.should == 200
-          response.body.should match(/Successfully added new element/)
+          expect(response.status).to eq(200)
+          expect(response.body).to match(/Successfully added new element/)
         end
 
         context "and with cut as action parameter" do
           it "should also remove the element id from clipboard" do
             xhr :post, :create, {paste_from_clipboard: element_in_clipboard.id, element: {page_id: alchemy_page.id}}
-            session[:alchemy_clipboard]['elements'].detect { |item| item['id'] == element_in_clipboard.id.to_s }.should be_nil
+            expect(session[:alchemy_clipboard]['elements'].detect { |item| item['id'] == element_in_clipboard.id.to_s }).to be_nil
           end
         end
       end
@@ -281,7 +296,9 @@ module Alchemy
       context 'if element could not be saved' do
         subject { post :create, {element: {page_id: alchemy_page.id}} }
 
-        before { Element.any_instance.stub(save: false) }
+        before do
+          expect_any_instance_of(Element).to receive(:save).and_return false
+        end
 
         it "renders the new template" do
           expect(subject).to render_template(:new)
@@ -291,13 +308,16 @@ module Alchemy
 
     describe '#find_or_create_cell' do
       before do
-        Cell.stub(:definition_for).and_return({'name' => 'header', 'elements' => ['header']})
         controller.instance_variable_set(:@page, alchemy_page)
       end
 
       context "with element name and cell name in the params" do
         before do
-          controller.stub(params: {element: {name: 'header#header'}})
+          expect(Cell).to receive(:definition_for).and_return({
+            'name' => 'header',
+            'elements' => ['header']
+          })
+          expect(controller).to receive(:params).and_return({element: {name: 'header#header'}})
         end
 
         context "with cell not existing" do
@@ -323,18 +343,18 @@ module Alchemy
 
       context "with only the element name in the params" do
         before do
-          controller.stub(params: {element: {name: 'header'}})
+          expect(controller).to receive(:params).and_return({element: {name: 'header'}})
         end
 
         it "should return nil" do
-          controller.send(:find_or_create_cell).should be_nil
+          expect(controller.send(:find_or_create_cell)).to be_nil
         end
       end
 
       context 'with cell definition not found' do
         before do
-          controller.stub(params: {element: {name: 'header#header'}})
-          Cell.stub(definition_for: nil)
+          expect(controller).to receive(:params).and_return({element: {name: 'header#header'}})
+          expect(Cell).to receive(:definition_for).and_return nil
         end
 
         it "raises error" do
@@ -350,27 +370,27 @@ module Alchemy
       let(:element_parameters) { ActionController::Parameters.new(tag_list: 'Tag 1', public: false) }
 
       before do
-        Element.stub(:find).and_return element
-        controller.should_receive(:contents_params).and_return(contents_parameters)
+        expect(Element).to receive(:find).and_return element
+        expect(controller).to receive(:contents_params).and_return(contents_parameters)
       end
 
       it "updates all contents in element" do
-        element.should_receive(:update_contents).with(contents_parameters)
+        expect(element).to receive(:update_contents).with(contents_parameters)
         xhr :put, :update, {id: element.id}
       end
 
       it "updates the element" do
-        controller.should_receive(:element_params).and_return(element_parameters)
-        element.should_receive(:update_contents).and_return(true)
-        element.should_receive(:update_attributes!).with(element_parameters).and_return(true)
+        expect(controller).to receive(:element_params).and_return(element_parameters)
+        expect(element).to receive(:update_contents).and_return(true)
+        expect(element).to receive(:update_attributes!).with(element_parameters).and_return(true)
         xhr :put, :update, {id: element.id}
       end
 
       context "failed validations" do
         it "displays validation failed notice" do
-          element.should_receive(:update_contents).and_return(false)
+          expect(element).to receive(:update_contents).and_return(false)
           xhr :put, :update, {id: element.id}
-          assigns(:element_validated).should be_false
+          expect(assigns(:element_validated)).to be_falsey
         end
       end
     end
@@ -380,14 +400,14 @@ module Alchemy
         let(:parameters) { ActionController::Parameters.new(contents: {1 => {ingredient: 'Title'}}) }
 
         specify ":contents is required" do
-          controller.params.should_receive(:fetch).and_return(parameters)
+          expect(controller.params).to receive(:fetch).and_return(parameters)
           controller.send :contents_params
         end
 
         specify "everything is permitted" do
-          controller.should_receive(:params).and_return(parameters)
-          parameters.should_receive(:fetch).and_return(parameters)
-          parameters.should_receive(:permit!)
+          expect(controller).to receive(:params).and_return(parameters)
+          expect(parameters).to receive(:fetch).and_return(parameters)
+          expect(parameters).to receive(:permit!)
           controller.send :contents_params
         end
       end
@@ -396,14 +416,14 @@ module Alchemy
         let(:parameters) { ActionController::Parameters.new(element: {public: true}) }
 
         specify ":element is required" do
-          controller.params.should_receive(:require).with(:element).and_return(parameters)
+          expect(controller.params).to receive(:require).with(:element).and_return(parameters)
           controller.send :element_params
         end
 
         specify ":public and :tag_list is permitted" do
-          controller.should_receive(:params).and_return(parameters)
-          parameters.should_receive(:require).with(:element).and_return(parameters)
-          parameters.should_receive(:permit).with(:public, :tag_list)
+          expect(controller).to receive(:params).and_return(parameters)
+          expect(parameters).to receive(:require).with(:element).and_return(parameters)
+          expect(parameters).to receive(:permit).with(:public, :tag_list)
           controller.send :element_params
         end
       end
@@ -414,10 +434,10 @@ module Alchemy
 
       let(:element) { build_stubbed(:element) }
 
-      before { Element.stub(find: element) }
+      before { expect(Element).to receive(:find).and_return element }
 
       it "trashes the element instead of deleting it" do
-        element.should_receive(:trash!).and_return(true)
+        expect(element).to receive(:trash!).and_return(true)
         subject
       end
     end
@@ -428,24 +448,24 @@ module Alchemy
       let(:element) { build_stubbed(:element) }
 
       before do
-        element.stub(save: true)
-        Element.stub(find: element)
+        expect(element).to receive(:save).and_return true
+        expect(Element).to receive(:find).and_return element
       end
 
       context 'if element is folded' do
-        before { element.stub(folded: true) }
+        before { expect(element).to receive(:folded).and_return true }
 
         it "sets folded to false." do
-          element.should_receive(:folded=).with(false).and_return(true)
+          expect(element).to receive(:folded=).with(false).and_return(true)
           subject
         end
       end
 
       context 'if element is not folded' do
-        before { element.stub(folded: false) }
+        before { expect(element).to receive(:folded).and_return false }
 
         it "sets folded to true." do
-          element.should_receive(:folded=).with(true).and_return(true)
+          expect(element).to receive(:folded=).with(true).and_return(true)
           subject
         end
       end