alchemy_cms 2.6.3 → 2.7.0

data/spec/controllers/admin/layoutpages_controller_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+module Alchemy
+  describe Admin::LayoutpagesController do
+
+    before(:each) do
+      sign_in(admin_user)
+    end
+
+    describe "#index" do
+      it "should assign @locked_pages" do
+        get :index
+        expect(assigns(:locked_pages)).to eq([])
+      end
+
+      it "should assign @layout_root" do
+        get :index
+        expect(assigns(:layout_root)).to be_a(Page)
+      end
+
+      it "should assign @languages" do
+        Language.stub!(:all).and_return([])
+        get :index
+        expect(assigns(:languages)).to eq([])
+      end
+    end
+  end
+end

data/spec/controllers/admin/pages_controller_spec.rb

@@ -5,124 +5,53 @@ module Alchemy
   describe Admin::PagesController do
 
     before do
-      sign_in :user, FactoryGirl.create(:admin_user)
+      sign_in(admin_user)
     end
 
     describe "#flush" do
 
       it "should remove the cache of all pages" do
-        post :flush, {:format => :js}
+        post :flush, format: :js
         response.status.should == 200
       end
 
     end
 
     describe '#new' do
-
       context "pages in clipboard" do
 
         let(:clipboard) { session[:clipboard] = Clipboard.new }
-        let(:page) { mock_model('Page', {:id => 10, :name => 'Foobar', :parent_id => 1}) }
+        let(:page) { mock_model('Page', name: 'Foobar') }
 
-        before(:each) do
-          clipboard[:pages] = [{:id => page.id, :action => 'copy'}]
+        before do
+          clipboard[:pages] = [{id: page.id, action: 'copy'}]
         end
 
         it "should load all pages from clipboard" do
-          get :new, {:page_id => page.id, :format => :js}
+          get :new, {page_id: page.id, format: :js}
           assigns(:clipboard_items).should be_kind_of(Array)
         end
 
       end
-
     end
 
-    describe '#order' do
-      let(:page_1)       { FactoryGirl.create(:page, visible: true) }
-      let(:page_2)       { FactoryGirl.create(:page, visible: true) }
-      let(:page_3)       { FactoryGirl.create(:page, visible: true) }
-      let(:page_item_1)  { {id: page_1.id, slug: page_1.slug, restricted: false, external: page_1.redirects_to_external?, visible: page_1.visible?, children: [page_item_2]} }
-      let(:page_item_2)  { {id: page_2.id, slug: page_2.slug, restricted: false, external: page_2.redirects_to_external?, visible: page_2.visible?, children: [page_item_3]} }
-      let(:page_item_3)  { {id: page_3.id, slug: page_3.slug, restricted: false, external: page_3.redirects_to_external?, visible: page_3.visible? } }
-      let(:set_of_pages) { [page_item_1] }
-
-      it "stores the new order" do
-        xhr :post, :order, set: set_of_pages.to_json
-        page_1.reload
-        expect(page_1.descendants).to eq([page_2, page_3])
-      end
-
-      context 'with url nesting enabled' do
-        before { Alchemy::Config.stub(get: true) }
-
-        it "updates the pages urlnames" do
-          xhr :post, :order, set: set_of_pages.to_json
-          [page_1, page_2, page_3].map(&:reload)
-          expect(page_1.urlname).to eq("#{page_1.slug}")
-          expect(page_2.urlname).to eq("#{page_1.slug}/#{page_2.slug}")
-          expect(page_3.urlname).to eq("#{page_1.slug}/#{page_2.slug}/#{page_3.slug}")
-        end
-
-        context 'with invisible page in tree' do
-          let(:page_item_2) do
-            {
-              id: page_2.id,
-              slug: page_2.slug,
-              children: [page_item_3],
-              visible: false
-            }
-          end
-
-          it "does not use this pages slug in urlnames of descendants" do
-            xhr :post, :order, set: set_of_pages.to_json
-            [page_1, page_2, page_3].map(&:reload)
-            expect(page_1.urlname).to eq("#{page_1.slug}")
-            expect(page_2.urlname).to eq("#{page_1.slug}/#{page_2.slug}")
-            expect(page_3.urlname).to eq("#{page_1.slug}/#{page_3.slug}")
-          end
-        end
+    describe '#show' do
 
-        context 'with external page in tree' do
-          let(:page_item_2) do
-            {
-              id: page_2.id,
-              slug: page_2.slug,
-              children: [page_item_3],
-              external: true
-            }
-          end
+      let(:page) { mock_model('Page', language_code: 'nl') }
 
-          it "does not use this pages slug in urlnames of descendants" do
-            xhr :post, :order, set: set_of_pages.to_json
-            [page_1, page_2, page_3].map(&:reload)
-            expect(page_3.urlname).to eq("#{page_1.slug}/#{page_3.slug}")
-          end
-        end
-
-        context 'with restricted page in tree' do
-          let(:page_2) { FactoryGirl.create(:page, restricted: true) }
-          let(:page_item_2) do
-            {
-              id: page_2.id,
-              slug: page_2.slug,
-              children: [page_item_3],
-              restricted: true
-            }
-          end
+      before do
+        Page.stub!(:find).with("#{page.id}").and_return(page)
+        Page.stub!(:language_root_for).and_return(mock_model('Page'))
+      end
 
-          it "updates restricted status of descendants" do
-            xhr :post, :order, set: set_of_pages.to_json
-            page_3.reload
-            expect(page_3.restricted).to be_true
-          end
-        end
+      it "should assign @preview_mode with true" do
+        post :show, id: page.id
+        expect(assigns(:preview_mode)).to eq(true)
+      end
 
-        it "creates legacy urls" do
-          xhr :post, :order, set: set_of_pages.to_json
-          [page_2, page_3].map(&:reload)
-          expect(page_2.legacy_urls.size).to eq(1)
-          expect(page_3.legacy_urls.size).to eq(1)
-        end
+      it "should set the I18n locale to the pages language code" do
+        post :show, id: page.id
+        expect(::I18n.locale).to eq(:nl)
       end
     end
 
@@ -134,44 +63,78 @@ module Alchemy
 
         it "should always show the slug" do
           Page.stub!(:find).and_return(page)
-          get :configure, {:id => page.id, :format => :js}
+          get :configure, {id: page.id, format: :js}
           response.body.should match /value="foobar"/
         end
       end
     end
 
     describe '#create' do
+      let(:language) { mock_model('Language', code: 'kl') }
+      let(:parent) { mock_model('Page', language: language) }
+      let(:page_params) do
+        {parent_id: parent.id, name: 'new Page'} 
+      end
 
-      let(:parent) { FactoryGirl.create(:public_page) }
-
-      context "with paste_from_clipboard in parameters" do
-        render_views
-
-        let(:clipboard) { session[:clipboard] = Clipboard.new }
-        let(:page_in_clipboard) { FactoryGirl.create(:public_page) }
+      context "" do
+        before do
+          Page.any_instance.stub(:set_language_from_parent_or_default_language)
+          Page.any_instance.stub(:save).and_return(true)
+        end
 
-        before(:each) do
-          clipboard[:pages] = [{:id => page_in_clipboard.id, :action => 'cut'}]
+        it "nests a new page under given parent" do
+          controller.stub!(:edit_admin_page_path).and_return('bla')
+          post :create, {page: page_params, format: :js}
+          expect(assigns(:page).parent_id).to eq(parent.id)
         end
 
-        it "should create a page from clipboard" do
-          post :create, {:paste_from_clipboard => page_in_clipboard.id, :page => {:parent_id => parent.id}, :format => :js}
-          response.status.should == 200
-          response.body.should match /window.location.*admin.*pages/
+        context "if new page can not be saved" do
+          it "should redirect to admin_pages_path" do
+            Page.any_instance.stub(:save).and_return(false)
+            post :create, page: {}
+            response.should redirect_to(admin_pages_path)
+          end
         end
 
+        context "with redirect_to in params" do
+          let(:page_params) do
+            {name: "Foobar", page_layout: 'standard', parent_id: parent.id}
+          end
+
+          it "should redirect to given url" do
+            post :create, page: page_params, redirect_to: admin_users_path
+            response.should redirect_to(admin_users_path)
+          end
+
+          context "but new page can not be saved" do
+            it "should redirect to admin_pages_path" do
+              Page.any_instance.stub(:save).and_return(false)
+              post :create, page: {}, redirect_to: admin_users_path
+              response.should redirect_to(admin_pages_path)
+            end
+          end
+        end
       end
 
-      context "with redirect_to in the parameters" do
+      context "with paste_from_clipboard in parameters" do
+        let(:page_in_clipboard) { mock_model('Page') }
 
-        let(:page_params) do
-          {:name => "Foobar", :page_layout => 'standard', :parent_id => parent.id}
+        before do
+          Page.stub!(:find_by_id).with(parent.id).and_return(parent)
+          Page.stub!(:find).with(page_in_clipboard.id).and_return(page_in_clipboard)
         end
 
-        it "should redirect to given url" do
-          post :create, :page => page_params, :redirect_to => admin_users_path
-          response.should redirect_to(admin_users_path)
+        it "should call Page#paste_from_clipboard" do
+          Page.should_receive(:paste_from_clipboard).with(
+            page_in_clipboard,
+            parent,
+            'pasted Page'
+          ).and_return(
+            mock_model('Page', save: true, name: 'pasted Page')
+          )
+          post :create, {paste_from_clipboard: page_in_clipboard.id, page: {parent_id: parent.id, name: 'pasted Page'}, format: :js}
         end
+
       end
 
     end
@@ -180,17 +143,17 @@ module Alchemy
 
       let(:language) { Language.get_default }
       let(:new_language) { FactoryGirl.create(:klingonian) }
-      let(:language_root) { FactoryGirl.create(:language_root_page, :language => language) }
+      let(:language_root) { FactoryGirl.create(:language_root_page, language: language) }
       let(:new_lang_root) { Page.language_root_for(new_language.id) }
 
       before(:each) do
-        level_1 = FactoryGirl.create(:public_page, :parent_id => language_root.id, :visible => true, :name => 'Level 1')
-        level_2 = FactoryGirl.create(:public_page, :parent_id => level_1.id, :visible => true, :name => 'Level 2')
-        level_3 = FactoryGirl.create(:public_page, :parent_id => level_2.id, :visible => true, :name => 'Level 3')
-        level_4 = FactoryGirl.create(:public_page, :parent_id => level_3.id, :visible => true, :name => 'Level 4')
+        level_1 = FactoryGirl.create(:public_page, parent_id: language_root.id, visible: true, name: 'Level 1')
+        level_2 = FactoryGirl.create(:public_page, parent_id: level_1.id, visible: true, name: 'Level 2')
+        level_3 = FactoryGirl.create(:public_page, parent_id: level_2.id, visible: true, name: 'Level 3')
+        level_4 = FactoryGirl.create(:public_page, parent_id: level_3.id, visible: true, name: 'Level 4')
         session[:language_code] = new_language.code
         session[:language_id] = new_language.id
-        post :copy_language_tree, {:languages => {:new_lang_id => new_language.id, :old_lang_id => language.id}}
+        post :copy_language_tree, {languages: {new_lang_id: new_language.id, old_lang_id: language.id}}
       end
 
       it "should copy all pages" do
@@ -215,11 +178,11 @@ module Alchemy
       let(:page) { FactoryGirl.create(:public_page) }
 
       before do
-        clipboard[:pages] = [{:id => page.id}]
+        clipboard[:pages] = [{id: page.id}]
       end
 
       it "should also remove the page from clipboard" do
-        post :destroy, {:id => page.id, :_method => :delete}
+        post :destroy, {id: page.id, _method: :delete}
         clipboard[:pages].should be_empty
       end
 
@@ -240,5 +203,88 @@ module Alchemy
 
     end
 
+    describe '#visit' do
+      let(:page) { mock_model('Page', urlname: 'home') }
+
+      before do
+        Page.stub!(:find).with("#{page.id}").and_return(page)
+        page.stub!(:unlock!).and_return(true)
+        @controller.stub!(:multi_language?).and_return(false)
+      end
+
+      it "should redirect to the page path" do
+        expect(post :visit, id: page.id).to redirect_to(show_page_path(urlname: 'home'))
+      end
+    end
+
+    describe '#fold' do
+      let(:page) { mock_model('Page') }
+
+      before do
+        Page.stub!(:find).with(page.id).and_return(page)
+      end
+
+      context "if page is currently not folded" do
+        before do
+          page.stub!(:folded?).and_return(false)
+        end
+
+        it "should fold the page" do
+          page.should_receive(:fold!).with(controller.current_user.id, true).and_return(true)
+          post :fold, id: page.id, format: :js
+        end
+      end
+
+      context "if page is already folded" do
+        before do
+          page.stub!(:folded?).and_return(true)
+        end
+
+        it "should unfold the page" do
+          page.should_receive(:fold!).with(controller.current_user.id, false).and_return(true)
+          post :fold, id: page.id, format: :js
+        end
+      end
+    end
+
+    describe '#sort' do
+      before do
+        Page.stub!(:language_root_for).and_return(mock_model('Page'))
+      end
+
+      it "should assign @sorting with true" do
+        get :sort, format: :js
+        expect(assigns(:sorting)).to eq(true)
+      end
+    end
+
+    describe '#unlock' do
+      let(:page) { mock_model('Page', name: 'Best practices') }
+
+      before do
+        page.stub!(:unlock!).and_return(true)
+        Page.stub!(:find).with("#{page.id}").and_return(page)
+        Page.stub_chain(:from_current_site, :all_locked_by).and_return(nil)
+      end
+
+      it "should unlock the page" do
+        page.should_receive(:unlock!)
+        post :unlock, id: "#{page.id}", format: :js
+      end
+
+      context 'requesting for html format' do
+        it "should redirect to admin_pages_path" do
+          expect(post :unlock, id: page.id).to redirect_to(admin_pages_path)
+        end
+
+        context 'if passing :redirect_to through params' do
+          it "should redirect to the given path" do
+            expect(post :unlock, id: page.id, redirect_to: 'this/path').to redirect_to('this/path')
+          end
+        end
+      end
+      
+    end
+
   end
 end

data/spec/controllers/admin/pictures_controller_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+module Alchemy
+  describe Admin::PicturesController do
+
+    before do
+      sign_in(admin_user)
+    end
+    
+    describe "#index" do
+      it "should always paginate the records" do
+        Picture.should_receive(:find_paginated)
+        get :index
+      end
+
+      context "when params[:filter] is set" do
+        it "should filter the pictures collection by the given filter string." do
+          Picture.should_receive(:filtered_by).with('recent').and_return(Picture.scoped)
+          get :index, filter: 'recent'
+        end
+      end
+
+      context "when params[:tagged_with] is set" do
+        it "should filter the records by tags" do
+          Picture.should_receive(:tagged_with).and_return(Picture.scoped)
+          get :index, tagged_with: "red"
+        end
+      end
+
+      context "when params[:content_id]" do
+        render_views
+
+        context "is set" do
+          it "should render the archive_overlay partial" do
+            Element.stub!(:find).with('1', {:select => 'id'}).and_return(mock_model(Element))
+            get :index, {element_id: 1, format: :html}
+            expect(response).to render_template(partial: '_archive_overlay')
+          end
+        end
+
+        context "is not set" do
+          it "should render the default index view" do
+            get :index
+            expect(response).to render_template(:index)
+          end
+        end
+
+      end
+    end
+
+    describe "#delete_multiple" do
+      let(:deletable_picture) { mock_model('Picture', name: 'pic of the pig', deletable?: true) }
+      let(:not_deletable_picture) { mock_model('Picture', name: 'pic of the chick', deletable?: false) }
+
+      context "no picture_ids given" do
+        it "should give a warning about not deleting any pictures" do
+          delete :delete_multiple, picture_ids: ''
+          expect(flash[:warn]).to match('Could not delete Pictures')
+        end
+      end
+
+      context "picture_ids given" do
+        context "all are deletable" do
+          before do
+            Picture.stub!(:find).and_return([deletable_picture])
+          end
+
+          it "should delete the pictures give a notice about deleting them" do
+            delete :delete_multiple, picture_ids: "#{deletable_picture.id}"
+            expect(flash[:notice]).to match('successfully')
+          end
+        end
+
+        context "deletable and not deletable" do
+          before do
+            Picture.stub!(:find).and_return([deletable_picture, not_deletable_picture])
+          end
+
+          it "should give a warning for the non deletable pictures and delete the others" do
+            deletable_picture.should_receive(:destroy)
+            delete :delete_multiple, picture_ids: "#{deletable_picture.id},#{not_deletable_picture.id}"
+            expect(flash[:warn]).to match('could not be deleted')
+          end
+        end
+      end
+    end
+
+  end
+end