alchemy_cms 2.9.1 → 3.0.0.rc5

data/spec/controllers/admin/essence_files_controller_spec.rb

@@ -7,36 +7,29 @@ module Alchemy
       sign_in(admin_user)
     end
 
-    let(:content) { mock_model('Content', essence: essence_file) }
+    let(:content)      { mock_model('Content', essence: essence_file) }
     let(:essence_file) { mock_model('EssenceFile', :attachment= => nil) }
-    let(:attachment) { mock_model('Attachment') }
-    
+    let(:attachment)   { mock_model('Attachment') }
+
     describe '#edit' do
       before do
-        Content.stub!(:find).with(content.id.to_s).and_return(content)
+        Content.stub(find: content)
       end
 
       it "should assign @content with the Content found by id" do
-        get :edit, id: content.id
+        get :edit, content_id: content.id
         expect(assigns(:content)).to eq(content)
       end
 
       it "should assign @essence_file with content's essence" do
-        get :edit, id: content.id
+        get :edit, content_id: content.id
         expect(assigns(:essence_file)).to eq(content.essence)
       end
-
-      context 'xhr request' do
-        it "should not render a layout" do
-          xhr :get, :edit, id: content.id
-          expect(@layouts).to be_empty
-        end
-      end
     end
 
     describe '#update' do
       before do
-        EssenceFile.stub!(:find).with(essence_file.id.to_s).and_return(essence_file)
+        EssenceFile.stub(find: essence_file)
       end
 
       it "should update the attributes of essence_file" do
@@ -47,18 +40,18 @@ module Alchemy
 
     describe '#assign' do
       before do
-        Content.stub!(:find_by_id).with(content.id.to_s).and_return(content)
-        Attachment.stub!(:find_by_id).and_return(attachment)
+        Content.stub(find_by: content)
+        Attachment.stub(find_by: attachment)
       end
 
       it "should assign @attachment with the Attachment found by attachment_id" do
-        xhr :put, :assign, id: content.id, attachment_id: attachment.id
+        xhr :put, :assign, content_id: content.id, attachment_id: attachment.id
         expect(assigns(:attachment)).to eq(attachment)
       end
 
       it "should assign @content.essence.attachment with the attachment found by id" do
         content.essence.should_receive(:attachment=).with(attachment)
-        xhr :put, :assign, id: content.id, attachment_id: attachment.id
+        xhr :put, :assign, content_id: content.id, attachment_id: attachment.id
       end
 
     end

data/spec/controllers/admin/essence_pictures_controller_spec.rb

@@ -41,7 +41,7 @@ module Alchemy
         before do
           picture.image_file_width = 300
           picture.image_file_height = 250
-          essence.should_receive(:picture).any_number_of_times.and_return(picture)
+          essence.should_receive(:picture).and_return(picture)
         end
 
         context 'with no render_size present in essence' do
@@ -67,30 +67,14 @@ module Alchemy
         end
 
         context 'with render_size present in essence' do
-          it "sets sizes from these values" do
+          before do
             essence.stub(:render_size).and_return('30x25')
-
-            get :crop, id: 1
-            expect(assigns(:size_x)).to eq(30)
-            expect(assigns(:size_y)).to eq(25)
           end
 
-          context 'when width or height is not fixed' do
-            it 'infers the height from the image file preserving the aspect ratio' do
-              essence.stub(:render_size).and_return('30')
-
-              get :crop, id: 1
-              expect(assigns(:size_x)).to eq(30)
-              expect(assigns(:size_y)).to eq(25)
-            end
-
-            it 'infers the height from the image file preserving the aspect ratio' do
-              essence.stub(:render_size).and_return('x25')
-
-              get :crop, id: 1
-              expect(assigns(:size_x)).to eq(30)
-              expect(assigns(:size_y)).to eq(25)
-            end
+          it "sets sizes from these values" do
+            get :crop, id: 1
+            expect(assigns(:size_x)).to eq('30')
+            expect(assigns(:size_y)).to eq('25')
           end
         end
 
@@ -154,9 +138,16 @@ module Alchemy
         Content.should_receive(:find).and_return(content)
       end
 
+      let(:attributes) { {render_size: '1x1', alt_tag: 'Alt Tag', caption: 'Caption', css_class: 'CSS Class', title: 'Title'} }
+
       it "updates the essence attributes" do
-        essence.should_receive(:update_attributes).and_return(true)
-        xhr :put, :update, id: 1, essence_picture: {render_size: '1x1'}
+        essence.should_receive(:update).and_return(true)
+        xhr :put, :update, id: 1, essence_picture: attributes
+      end
+
+      it "saves the cropping mask" do
+        essence.should_receive(:update).and_return(true)
+        xhr :put, :update, id: 1, essence_picture: {render_size: '1x1', crop_from: '0x0', crop_size: '100x100'}
       end
     end
 

data/spec/controllers/admin/languages_controller_spec.rb

@@ -13,18 +13,25 @@ describe Alchemy::Admin::LanguagesController do
 
     context "when default_language.page_layout is set" do
       it "should use it as page_layout-default for the new language" do
-        Alchemy::Config.should_receive(:get).with(:default_language) { {'page_layout' => "new_standard"} }
+        # FML :/
+        Alchemy::Config.stub(:get) do |arg|
+          if arg == :default_language
+            {'page_layout' => "new_standard"}
+          else
+            Alchemy::Config.show[arg.to_s]
+          end
+        end
         get :new
         assigns(:language).page_layout.should eql("new_standard")
       end
     end
 
     context "when default_language or page_layout aren't configured" do
-      it "should fallback to 'intro'" do
+      it "should fallback to one configured in config.yml" do
         get :new
-        assigns(:language).page_layout.should eql("intro")
+        assigns(:language).page_layout.should eql("index")
       end
     end
 
   end
-end
+end

data/spec/controllers/admin/layoutpages_controller_spec.rb

@@ -19,9 +19,8 @@ module Alchemy
       end
 
       it "should assign @languages" do
-        Language.stub!(:all).and_return([])
         get :index
-        expect(assigns(:languages)).to eq([])
+        expect(assigns(:languages).first).to be_a(Language)
       end
     end
   end

data/spec/controllers/admin/pages_controller_spec.rb

@@ -7,37 +7,62 @@ module Alchemy
     before { sign_in(user) }
 
     describe '#index' do
-      let(:language_root) { FactoryGirl.build_stubbed(:language_root_page) }
+      let(:language)      { build_stubbed(:language) }
+      let(:language_root) { build_stubbed(:language_root_page) }
 
-      it "assigns @page_root variable" do
-        Page.should_receive(:language_root_for).with(1).and_return(language_root)
-        get :index
-        assigns(:page_root).should be(language_root)
+      context 'with existing language root page' do
+        before do
+          Language.should_receive(:current_root_page).and_return(language_root)
+        end
+
+        it "assigns @page_root variable" do
+          get :index
+          assigns(:page_root).should be(language_root)
+        end
+      end
+
+      context 'without language root page' do
+        before do
+          Language.should_receive(:current_root_page).and_return(nil)
+          Language.stub(find_by: language)
+          Language.stub(all: [language])
+          Language.stub(with_root_page: [language])
+        end
+
+        it "it assigns current language" do
+          get :index
+          assigns(:language).should be(language)
+        end
       end
     end
 
     describe "#flush" do
+      let(:language) { mock_model('Language', code: 'en', pages: double(flushables: [page_1, page_2])) }
+      let(:page_1)   { build_stubbed(:page) }
+      let(:page_2)   { build_stubbed(:page) }
 
-      it "should remove the cache of all pages" do
-        post :flush, format: :js
-        response.status.should == 200
+      before do
+        Language.stub(current: language)
       end
 
+      it "should remove the cache of all pages" do
+        page_1.should_receive(:publish!)
+        page_2.should_receive(:publish!)
+        xhr :post, :flush
+      end
     end
 
     describe '#new' do
       context "pages in clipboard" do
-
         let(:clipboard) { session[:clipboard] = Clipboard.new }
         let(:page) { mock_model(Alchemy::Page, name: 'Foobar') }
 
         before { clipboard[:pages] = [{id: page.id, action: 'copy'}] }
 
         it "should load all pages from clipboard" do
-          get :new, {page_id: page.id, format: :js}
+          xhr :get, :new, {page_id: page.id}
           assigns(:clipboard_items).should be_kind_of(Array)
         end
-
       end
     end
 
@@ -54,116 +79,20 @@ module Alchemy
         expect(assigns(:preview_mode)).to eq(true)
       end
 
+      it "should store page as current preview" do
+        Page.current_preview = nil
+        get :show, id: page.id
+        Page.current_preview.should == page
+      end
+
       it "should set the I18n locale to the pages language code" do
         get :show, id: page.id
         expect(::I18n.locale).to eq(:nl)
       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
-
-        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
-
-          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
-
-          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
 
-        context 'with page having number as slug' do
-          let(:page_item_2) do
-            {
-              id: page_2.id,
-              slug: 42,
-              children: [page_item_3]
-            }
-          end
-
-          it "does not raise error" do
-            expect {
-              xhr :post, :order, set: set_of_pages.to_json
-            }.to_not raise_error(TypeError)
-            [page_1, page_2, page_3].map(&:reload)
-            expect(page_3.urlname).to eq("#{page_1.slug}/#{page_2.slug}/#{page_3.slug}")
-          end
-        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 "renders the application layout" do
+        get :show, id: page.id
+        expect(response).to render_template(layout: 'application')
       end
     end
 
@@ -175,34 +104,41 @@ module Alchemy
 
         it "should always show the slug" do
           Page.stub(:find).and_return(page)
-          get :configure, {id: page.id, format: :js}
+          xhr :get, :configure, {id: page.id}
           response.body.should match /value="foobar"/
         end
       end
     end
 
     describe '#create' do
-      let(:language) { mock_model('Language', code: 'kl') }
-      let(:parent) { mock_model(Alchemy::Page, language: language) }
+      let(:language)    { mock_model('Language', code: 'kl') }
+      let(:parent)      { mock_model('Page', language: language) }
       let(:page_params) { {parent_id: parent.id, name: 'new Page'} }
 
       context "a new page" do
         before do
-          Page.any_instance.stub(:set_language_from_parent_or_default_language)
-          Page.any_instance.stub(:save).and_return(true)
+          Page.any_instance.stub(:set_language_from_parent_or_default)
+          Page.any_instance.stub(save: true)
         end
 
         it "is nested under given parent" do
           controller.stub(:edit_admin_page_path).and_return('bla')
-          post :create, {page: page_params, format: :js}
+          xhr :post, :create, {page: page_params}
           expect(assigns(:page).parent_id).to eq(parent.id)
         end
 
+        it "redirects to edit page template" do
+          page = mock_model('Page')
+          controller.should_receive(:edit_admin_page_path).and_return('bla')
+          post :create, page: page_params
+          response.should redirect_to('bla')
+        end
+
         context "if new page can not be saved" do
-          it "should redirect to admin_pages_path" do
+          it "renders the create form" do
             Page.any_instance.stub(:save).and_return(false)
-            post :create, page: {}
-            response.should redirect_to(admin_pages_path)
+            post :create, page: {name: 'page'}
+            response.should render_template('new')
           end
         end
 
@@ -217,10 +153,12 @@ module Alchemy
           end
 
           context "but new page can not be saved" do
-            it "should redirect to admin_pages_path" do
+            render_views
+
+            it "should render the `new` template" do
               Page.any_instance.stub(:save).and_return(false)
-              post :create, page: {}, redirect_to: Alchemy.login_path
-              response.should redirect_to(admin_pages_path)
+              xhr :post, :create, page: {name: 'page'}, redirect_to: admin_pictures_path
+              response.body.should match /form.+action=\"\/admin\/pages\"/
             end
           end
         end
@@ -238,75 +176,81 @@ module Alchemy
         let(:page_in_clipboard) { mock_model(Alchemy::Page) }
 
         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)
+          Page.stub(:find_by).with(id: "#{parent.id}").and_return(parent)
+          Page.stub(:find).with("#{page_in_clipboard.id}").and_return(page_in_clipboard)
         end
 
-        it "should call Page#paste_from_clipboard" do
-          Page.should_receive(:paste_from_clipboard).with(
+        it "should call Page#copy_and_paste" do
+          Page.should_receive(:copy_and_paste).with(
             page_in_clipboard,
             parent,
             'pasted Page'
           ).and_return(
             mock_model('Page', save: true, name: 'pasted Page', redirects_to_external?: false)
           )
-          post :create, {paste_from_clipboard: page_in_clipboard.id, page: {parent_id: parent.id, name: 'pasted Page'}, format: :js}
+          xhr :post, :create, {paste_from_clipboard: page_in_clipboard.id, page: {parent_id: parent.id, name: 'pasted Page'}}
         end
       end
     end
 
     describe '#copy_language_tree' do
+      let(:params)                     { {languages: {new_lang_id: '2', old_lang_id: '1'}} }
+      let(:language_root_to_copy_from) { build_stubbed(:language_root_page) }
+      let(:copy_of_language_root)      { build_stubbed(:language_root_page) }
+      let(:root_page)                  { mock_model('Page') }
 
-      let(:language) { Language.get_default }
-      let(:new_language) { FactoryGirl.create(:klingonian) }
-      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')
-        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}}
+      before do
+        Page.stub(copy: copy_of_language_root)
+        Page.stub(root: root_page)
+        Page.stub(language_root_for: language_root_to_copy_from)
+        Page.any_instance.stub(:move_to_child_of)
+        Page.any_instance.stub(:copy_children_to)
+        controller.stub(:store_current_language)
+        Language.stub(:current).and_return(mock_model('Language', language_code: 'it', code: 'it'))
       end
 
-      it "should copy all pages" do
-        new_lang_root.should_not be_nil
-        new_lang_root.descendants.count.should == 4
-        new_lang_root.descendants.collect(&:name).should == ["Level 1 (Copy)", "Level 2 (Copy)", "Level 3 (Copy)", "Level 4 (Copy)"]
+      it "should copy the language root page over to the other language" do
+        Page.should_receive(:copy).with(language_root_to_copy_from, {language_id: '2', language_code: 'it'})
+        post :copy_language_tree, params
       end
 
-      it "should not set layoutpage attribute to nil" do
-        new_lang_root.layoutpage.should_not be_nil
+      it "should move the newly created language-root-page below the absolute root page" do
+        copy_of_language_root.should_receive(:move_to_child_of).with(root_page)
+        post :copy_language_tree, params
       end
 
-      it "should not set layoutpage attribute to true" do
-        new_lang_root.layoutpage.should_not be_true
+      it "should copy all childs of the original page over to the new created one" do
+        controller.stub(language_root_to_copy_from: language_root_to_copy_from)
+        controller.stub(copy_of_language_root: copy_of_language_root)
+        language_root_to_copy_from.should_receive(:copy_children_to).with(copy_of_language_root)
+        post :copy_language_tree, params
       end
 
+      it "should redirect to admin_pages_path" do
+        controller.stub(:copy_of_language_root)
+        controller.stub_chain(:language_root_to_copy_from, :copy_children_to)
+        post :copy_language_tree, params
+        expect(response).to redirect_to(admin_pages_path)
+      end
     end
 
     describe '#destroy' do
-
       let(:clipboard) { session[:clipboard] = Clipboard.new }
       let(:page) { FactoryGirl.create(:public_page) }
 
       before { clipboard[:pages] = [{id: page.id}] }
 
       it "should also remove the page from clipboard" do
-        post :destroy, {id: page.id, _method: :delete, format: 'js'}
+        xhr :post, :destroy, {id: page.id, _method: :delete}
         clipboard[:pages].should be_empty
       end
-
     end
 
     describe '#publish' do
-
       let(:page) { stub_model(Page, published_at: nil, public: false, name: "page", parent_id: 1, urlname: "page", language: stub_model(Language), page_layout: "bla") }
+
       before do
-        @controller.stub!(:load_page).and_return(page)
+        @controller.stub(:load_page).and_return(page)
         @controller.instance_variable_set("@page", page)
       end
 
@@ -314,16 +258,15 @@ module Alchemy
         page.should_receive(:publish!)
         post :publish, { id: page.id }
       end
-
     end
 
     describe '#visit' do
       let(:page) { mock_model(Alchemy::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)
+        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
@@ -340,7 +283,7 @@ module Alchemy
 
         it "should fold the page" do
           page.should_receive(:fold!).with(user.id, true).and_return(true)
-          post :fold, id: page.id, format: :js
+          xhr :post, :fold, id: page.id
         end
       end
 
@@ -349,7 +292,7 @@ module Alchemy
 
         it "should unfold the page" do
           page.should_receive(:fold!).with(user.id, false).and_return(true)
-          post :fold, id: page.id, format: :js
+          xhr :post, :fold, id: page.id
         end
       end
     end
@@ -358,7 +301,7 @@ module Alchemy
       before { Page.stub(:language_root_for).and_return(mock_model(Alchemy::Page)) }
 
       it "should assign @sorting with true" do
-        get :sort, format: :js
+        xhr :get, :sort
         expect(assigns(:sorting)).to eq(true)
       end
     end
@@ -373,7 +316,7 @@ module Alchemy
       end
 
       it "should unlock the page" do
-        post :unlock, id: "#{page.id}", format: :js
+        xhr :post, :unlock, id: "#{page.id}"
       end
 
       context 'requesting for html format' do
@@ -389,5 +332,32 @@ module Alchemy
       end
     end
 
+    describe "#switch_language" do
+      let(:language) { build_stubbed(:klingonian)}
+
+      before do
+        Language.stub(:find_by).and_return(language)
+      end
+
+      it "should store the current language in session" do
+        get :switch_language, {language_id: language.id}
+        expect(session[:alchemy_language_id]).to eq(language.id)
+      end
+
+      it "should redirect to sitemap" do
+        expect(get :switch_language, {language_id: language.id}).to redirect_to(admin_pages_path)
+      end
+
+      context "coming from layoutpages" do
+        before {
+          request.stub(:referer).and_return('admin/layoutpages')
+        }
+
+        it "should redirect to layoutpages" do
+          expect(get :switch_language, {language_id: language.id}).to redirect_to(admin_layoutpages_path)
+        end
+      end
+    end
+
   end
 end