alchemy_cms 2.9.1 → 3.0.0.rc5

data/spec/controllers/admin/clipboard_controller_spec.rb

@@ -2,37 +2,35 @@ require 'spec_helper'
 
 module Alchemy
   describe Admin::ClipboardController do
-
-    let(:public_page)     { FactoryGirl.create(:public_page) }
-    let(:element)         { FactoryGirl.create(:element, :page => public_page) }
-    let(:another_element) { FactoryGirl.create(:element, :page => public_page) }
+    let(:public_page)     { build_stubbed(:public_page) }
+    let(:element)         { build_stubbed(:element, page: public_page) }
+    let(:another_element) { build_stubbed(:element, page: public_page) }
 
     before do
       sign_in(admin_user)
       session[:clipboard] = Clipboard.new
+      Element.stub(find: element)
     end
 
     describe "#insert" do
-
       it "should hold element ids" do
-        post(:insert, {:remarkable_type => :elements, :remarkable_id => element.id, :format => :js})
-        session[:clipboard][:elements].should == [{:id => element.id, :action => 'copy'}]
+        xhr :post, :insert, {remarkable_type: :elements, remarkable_id: element.id}
+        session[:clipboard][:elements].should == [{id: element.id, action: 'copy'}]
       end
 
       it "should not have the same element twice" do
-        session[:clipboard][:elements] = {:id => element.id, :action => 'copy'}
-        post(:insert, {:remarkable_type => :elements, :remarkable_id => element.id, :format => :js})
+        session[:clipboard][:elements] = {id: element.id, action: 'copy'}
+        xhr :post, :insert, {remarkable_type: :elements, remarkable_id: element.id}
         session[:clipboard][:elements].collect { |e| e[:id] }.should_not == [element.id, element.id]
       end
-
     end
 
     describe "#delete" do
       it "should remove element ids from clipboard" do
-        session[:clipboard][:elements] = {:id => element.id, :action => 'copy'}
-        session[:clipboard][:elements] << {:id => another_element.id, :action => 'copy'}
-        delete(:remove, {:remarkable_type => :elements, :remarkable_id => another_element.id, :format => :js})
-        session[:clipboard][:elements].should == [{:id => element.id, :action => 'copy'}]
+        session[:clipboard][:elements] = {id: element.id, action: 'copy'}
+        session[:clipboard][:elements] << {id: another_element.id, action: 'copy'}
+        xhr :delete, :remove, {remarkable_type: :elements, remarkable_id: another_element.id}
+        session[:clipboard][:elements].should == [{id: element.id, action: 'copy'}]
       end
     end
 
@@ -40,16 +38,16 @@ module Alchemy
 
       context "with elements as remarkable_type" do
         it "should clear the elements clipboard" do
-          session[:clipboard][:elements] = {:id => element.id}
-          delete(:clear, {:remarkable_type => :elements, :format => :js})
+          session[:clipboard][:elements] = {id: element.id}
+          xhr :delete, :clear, {remarkable_type: :elements}
           session[:clipboard].should be_empty
         end
       end
 
       context "with pages as remarkable_type" do
         it "should clear the pages clipboard" do
-          session[:clipboard][:pages] = {:id => public_page.id}
-          delete(:clear, {:remarkable_type => :pages, :format => :js})
+          session[:clipboard][:pages] = {id: public_page.id}
+          xhr :delete, :clear, {remarkable_type: :pages}
           session[:clipboard].should be_empty
         end
       end

data/spec/controllers/admin/contents_controller_spec.rb

@@ -1,23 +1,27 @@
 require 'spec_helper'
 
-describe Alchemy::Admin::ContentsController do
-  before { sign_in(admin_user) }
+module Alchemy
+  describe Admin::ContentsController do
+    let(:element) { build_stubbed(:element) }
+    let(:content) { build_stubbed(:content, element: element) }
 
-  let(:element) { FactoryGirl.create(:element, create_contents_after_create: true) }
+    before do
+      sign_in(admin_user)
+      Element.stub(find: element)
+    end
 
-  describe '#create' do
-    let(:element) { FactoryGirl.create(:element, name: 'headline') }
+    describe '#create' do
+      let(:element) { build_stubbed(:element, name: 'headline') }
 
-    it "creates a content from name" do
-      expect {
+      it "creates a content from name" do
+        Content.should_receive(:create_from_scratch).and_return(content)
         xhr :post, :create, {content: {element_id: element.id, name: 'headline'}}
-      }.to change{element.contents.count}.by(1)
-    end
+      end
 
-    it "creates a content from essence_type" do
-      expect {
+      it "creates a content from essence_type" do
+        Content.should_receive(:create_from_scratch).and_return(content)
         xhr :post, :create, {content: {element_id: element.id, essence_type: 'EssencePicture'}}
-      }.to change{element.contents.count}.by(1)
+      end
     end
 
     context 'inside a picture gallery' do
@@ -32,29 +36,32 @@ describe Alchemy::Admin::ContentsController do
 
       context 'with picture_id given' do
         it "assigns the picture" do
-          Alchemy::Content.any_instance.should_receive(:update_essence).with(picture_id: '1')
+          Content.any_instance.should_receive(:update_essence).with(picture_id: '1')
           xhr :post, :create, attributes.merge(picture_id: '1')
         end
       end
     end
-  end
 
-  describe '#update' do
-    it "should update a content via ajax" do
-      xhr :post, :update, {id: element.contents.find_by_name('intro').id, content: {body: 'Peters Petshop'}}
-      element.ingredient('intro').should == "Peters Petshop"
+    describe '#update' do
+      before do
+        Content.stub(find: content)
+      end
+
+      it "should update a content via ajax" do
+        content.essence.should_receive(:update).with('ingredient' => 'Peters Petshop')
+        xhr :post, :update, {id: content.id, content: {ingredient: 'Peters Petshop'}}
+      end
     end
-  end
 
-  describe "#order" do
-    context "with content_ids in params" do
-      it "should reorder the contents" do
-        content_ids = element.contents.essence_texts.collect(&:id)
-        xhr :post, :order, {content_ids: content_ids.reverse}
-        response.status.should == 200
-        element.contents.essence_texts.collect(&:id).should == content_ids.reverse
+    describe "#order" do
+      context "with content_ids in params" do
+        it "should reorder the contents" do
+          content_ids = element.contents.essence_texts.pluck(:id)
+          xhr :post, :order, {content_ids: content_ids.reverse}
+          response.status.should == 200
+          element.contents.essence_texts.pluck(:id).should == content_ids.reverse
+        end
       end
     end
   end
-
 end

data/spec/controllers/admin/dashboard_controller_spec.rb

@@ -10,8 +10,6 @@ module Alchemy
       before do
         Page.stub_chain(:from_current_site, :all_last_edited_from).and_return([])
         Page.stub_chain(:from_current_site, :all_locked).and_return([])
-        User.stub(:logged_in).and_return([user])
-        user.stub(:sign_in_count).and_return(5)
       end
 
       it "assigns @last_edited_pages" do
@@ -26,7 +24,7 @@ module Alchemy
 
       context 'with user class having logged_in scope' do
         context 'with other users online' do
-          let(:another_user) { mock_model('User') }
+          let(:another_user) { mock_model('DummyUser') }
 
           before do
             Alchemy.user_class.should_receive(:logged_in).and_return([another_user])
@@ -60,7 +58,7 @@ module Alchemy
 
       it "assigns @sites" do
         get :index
-        expect(assigns(:sites)).to eq(Site.scoped)
+        expect(assigns(:sites)).to eq(Site.all)
       end
     end
 

data/spec/controllers/admin/elements_controller_spec.rb

@@ -2,256 +2,194 @@ require 'spec_helper'
 
 module Alchemy
   describe Admin::ElementsController do
+    let(:alchemy_page)         { create(:page) }
+    let(:element)              { create(:element, :page_id => alchemy_page.id) }
+    let(:element_in_clipboard) { create(:element, :page_id => alchemy_page.id) }
+    let(:clipboard)            { session[:clipboard] = Clipboard.new }
 
-    before(:each) do
-      sign_in(admin_user)
-    end
-
-    let(:alchemy_page) { FactoryGirl.create(:page, :urlname => 'lulu') }
-    let(:element) { FactoryGirl.create(:element, :page_id => alchemy_page.id) }
-    let(:element_in_clipboard) { FactoryGirl.create(:element, :page_id => alchemy_page.id) }
-    let(:clipboard) { session[:clipboard] = Clipboard.new }
-
-    describe '#create' do
+    before { sign_in(author_user) }
 
-      before { element }
+    describe '#index' do
+      let(:alchemy_page) { build_stubbed(:page) }
 
-      it "should insert the element at bottom of list" do
-        post :create, {:element => {:name => 'news', :page_id => alchemy_page.id}, :format => :js}
-        alchemy_page.elements.count.should == 2
-        alchemy_page.elements.last.name.should == 'news'
+      before do
+        Page.stub(find: alchemy_page)
       end
 
-      context "on a page with a setting for insert_elements_at of top" do
+      context 'with cells' do
+        let(:cell) { build_stubbed(:cell, page: alchemy_page) }
 
-        before do
-          PageLayout.stub(:get).and_return({
-            'name' => 'news',
-            'elements' => ['news'],
-            'insert_elements_at' => 'top'
-          })
+        before { alchemy_page.stub(cells: [cell]) }
+
+        it "groups elements by cell" do
+          alchemy_page.should_receive(:elements_grouped_by_cells)
+          get :index, {page_id: alchemy_page.id}
+          assigns(:cells).should eq([cell])
         end
+      end
 
-        it "should insert the element at top of list" do
-          post :create, {:element => {:name => 'news', :page_id => alchemy_page.id}, :format => :js}
-          alchemy_page.elements.count.should == 2
-          alchemy_page.elements.first.name.should == 'news'
+      context 'without cells' do
+        before { alchemy_page.stub(cells: []) }
+
+        it "assigns page elements" do
+          alchemy_page.should_receive(:elements).and_return(double(not_trashed: []))
+          get :index, {page_id: alchemy_page.id}
         end
       end
     end
 
-    describe '#find_or_create_cell' do
+    describe '#list' do
+      let(:alchemy_page) { build_stubbed(:page) }
 
       before do
-        Cell.stub!(:definition_for).and_return({'name' => 'header', 'elements' => ['header']})
-        controller.instance_variable_set(:@page, alchemy_page)
+        Page.stub(find: alchemy_page)
       end
 
-      context "with element name and cell name in the params" do
-
-        before do
-          controller.stub(:params).and_return({
-            :element => {:name => 'header#header'}
-          })
-        end
-
-        context "with cell not existing" do
-          it "should create the cell" do
-            expect {
-              controller.send(:find_or_create_cell)
-            }.to change(alchemy_page.cells, :count).from(0).to(1)
-          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))))
+          xhr :get, :list, {page_urlname: 'contact'}
         end
 
-        context "with the cell already present" do
-
-          before { FactoryGirl.create(:cell, :page => alchemy_page, :name => 'header') }
+        describe 'view' do
+          render_views
 
-          it "should load the cell" do
-            expect {
-              controller.send(:find_or_create_cell)
-            }.to_not change(alchemy_page.cells, :count)
+          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/)
           end
-
         end
-
       end
 
-      context "with only the element name in the params" do
-
-        before do
-          controller.stub(:params).and_return({
-            :element => {:name => 'header'}
-          })
-        end
-
-        it "should return nil" do
-          controller.send(:find_or_create_cell).should be_nil
+      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)
         end
-
       end
-
     end
 
-    describe '#list' do
+    describe '#new' do
+      let(:alchemy_page) { build_stubbed(:page) }
 
-      render_views
+      before { Page.stub(:find_by_id).and_return(alchemy_page) }
 
-      it "should return a select tag with elements" do
-        Alchemy::Page.should_receive(:find_by_urlname_and_language_id).and_return(alchemy_page)
-        Alchemy::Element.stub_chain([:published, :find_all_by_page_id]).and_return([element])
-        get :list, {:page_urlname => alchemy_page.urlname, :format => :js}
-        response.body.should match(/select(.*)elements_from_page_selector(.*)option/)
+      it "assign variable for all available element definitions" do
+        alchemy_page.should_receive(:available_element_definitions)
+        get :new, {page_id: alchemy_page.id}
       end
 
-    end
-
-    describe "#order" do
-      let(:element_1)   { FactoryGirl.create(:element) }
-      let(:element_2)   { FactoryGirl.create(:element) }
-      let(:element_3)   { FactoryGirl.create(:element) }
-      let(:element_ids) { [element_1.id, element_3.id, element_2.id] }
+      context "with elements in clipboard" do
+        let(:clipboard_items) { [{:id => element.id, :action => 'copy'}] }
 
-      it "sets new position for given element ids" do
-        xhr :post, :order, element_ids: element_ids
-        expect(Element.scoped.pluck(:id)).to eq(element_ids)
-      end
-
-      context "untrashing" do
-        let(:trashed_element) { FactoryGirl.create(:element, public: false, position: nil, page_id: 58, cell_id: 32) }
+        before { clipboard[:elements] = clipboard_items }
 
-        before do
-          # Because of a before_create filter it can not be created with a nil position and needs to be trashed here
-          trashed_element.trash!
-        end
-
-        it "sets a list of trashed element ids" do
-          xhr :post, :order, element_ids: [trashed_element.id]
-          expect(assigns(:trashed_elements).to_a).to eq [trashed_element.id]
-        end
-
-        it "should set a new position to the element" do
-          xhr :post, :order, element_ids: [trashed_element.id]
-          trashed_element.reload
-          trashed_element.position.should_not == 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
-        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
+        it "should load all elements from clipboard" do
+          Element.should_receive(:all_from_clipboard_for_page).and_return(clipboard_items)
+          get :new, {page_id: alchemy_page.id}
+          assigns(:clipboard_items).should == clipboard_items
         end
       end
     end
 
-    describe '#new' do
-
-      context "elements in clipboard" do
-
-        let(:clipboard) { session[:clipboard] = Clipboard.new }
+    describe '#create' do
+      describe 'insertion position' do
+        before { element }
 
-        before(:each) do
-          clipboard[:elements] = [{:id => element.id, :action => 'copy'}]
+        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'
         end
 
-        it "should load all elements from clipboard" do
-          get :new, {:page_id => alchemy_page.id, :format => :js}
-          assigns(:clipboard_items).should be_kind_of(Array)
-        end
+        context "on a page with a setting for insert_elements_at of top" do
+          before do
+            PageLayout.stub(:get).and_return({
+              'name' => 'news',
+              'elements' => ['news'],
+              'insert_elements_at' => 'top'
+            })
+          end
 
+          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'
+          end
+        end
       end
 
-    end
-
-    describe '#create' do
-
       context "if page has cells" do
-
         context "" do
-
           before do
-            @page = FactoryGirl.create(:public_page, :do_not_autogenerate => false)
-            @cell = FactoryGirl.create(:cell, :name => 'header', :page => @page)
+            @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']})
+            Cell.stub(:definition_for).and_return({'name' => 'header', 'elements' => ['article']})
           end
 
           context "and cell name in element name" do
-
             it "should put the element in the correct cell" do
-              post :create, {:element => {:name => "article#header", :page_id => @page.id}, :format => :js}
+              xhr :post, :create, {:element => {:name => "article#header", :page_id => @page.id}}
               @cell.elements.first.should 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
-              post :create, {:element => {:name => "article", :page_id => @page.id}, :format => :js}
+              xhr :post, :create, {:element => {:name => "article", :page_id => @page.id}}
               @page.elements.not_in_cell.first.should be_an_instance_of(Element)
             end
-
           end
-
         end
 
         context "with paste_from_clipboard in parameters" do
-
           context "" do
             before do
-              @page = FactoryGirl.create(:public_page, :do_not_autogenerate => false)
-              @cell = FactoryGirl.create(:cell, :name => 'header', :page => @page)
+              @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']})
+              Cell.stub(:definition_for).and_return({'name' => 'header', 'elements' => ['article']})
               clipboard[:elements] = [{:id => element_in_clipboard.id}]
             end
 
             context "and cell name in element name" do
               it "should create the element in the correct cell" do
-                post :create, {:element => {:page_id => @page.id}, :paste_from_clipboard => "#{element_in_clipboard.id}##{@cell.name}", :format => :js}
+                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)
               end
             end
 
             context "and no cell name in element name" do
               it "should create the element in the nil cell" do
-                post :create, {:element => {:page_id => @page.id}, :paste_from_clipboard => "#{element_in_clipboard.id}", :format => :js}
+                xhr :post, :create, {:element => {:page_id => @page.id}, :paste_from_clipboard => "#{element_in_clipboard.id}"}
                 @page.elements.first.cell.should == nil
               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
-                post :create, {:element => {:page_id => @page.id}, :paste_from_clipboard => "#{element_in_clipboard.id}##{@cell.name}", :format => :js}
+                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
               end
-
             end
           end
 
           context "on a page with a setting for insert_elements_at of top" do
-            let(:alchemy_page)                 { FactoryGirl.create(:public_page, :name => 'News') }
-            let(:element_in_clipboard) { FactoryGirl.create(:element, :page => alchemy_page, :name => 'news') }
+            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)              { FactoryGirl.create(:element, :name => 'news', :page => alchemy_page, :cell => cell) }
+            let(:element)              { create(:element, :name => 'news', :page => alchemy_page, :cell => cell) }
 
             before do
               PageLayout.stub(:get).and_return({
@@ -260,49 +198,239 @@ module Alchemy
                 'insert_elements_at' => 'top',
                 'cells' => ['news']
               })
-              Cell.stub!(:definition_for).and_return({'name' => 'news', 'elements' => ['news']})
+              Cell.stub(:definition_for).and_return({'name' => 'news', 'elements' => ['news']})
               clipboard[:elements] = [{:id => element_in_clipboard.id}]
               cell.elements << element
             end
 
             it "should insert the element at top of list" do
-              post :create, {:element => {:name => 'news', :page_id => alchemy_page.id}, :paste_from_clipboard => "#{element_in_clipboard.id}##{cell.name}", :format => :js}
+              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
             end
           end
-
         end
-
       end
 
       context "with paste_from_clipboard in parameters" do
-
         render_views
 
-        before(:each) do
-          clipboard[:elements] = [{:id => element_in_clipboard.id, :action => 'cut'}]
+        before do
+          clipboard[:elements] = [{id: element_in_clipboard.id, action: 'cut'}]
         end
 
         it "should create an element from clipboard" do
-          post :create, {:paste_from_clipboard => element_in_clipboard.id, :element => {:page_id => alchemy_page.id}, :format => :js}
+          xhr :post, :create, {paste_from_clipboard: element_in_clipboard.id, element: {page_id: alchemy_page.id}}
           response.status.should == 200
           response.body.should match(/Succesfully added new element/)
         end
 
         context "and with cut as action parameter" do
-
           it "should also remove the element id from clipboard" do
-            post :create, {:paste_from_clipboard => element_in_clipboard.id, :element => {:page_id => alchemy_page.id}, :format => :js}
+            xhr :post, :create, {paste_from_clipboard: element_in_clipboard.id, element: {page_id: alchemy_page.id}}
             session[:clipboard].contains?(:elements, element_in_clipboard.id).should_not be_true
           end
+        end
+      end
+
+      context 'if element could not be saved' do
+        subject { post :create, {element: {page_id: alchemy_page.id}} }
+
+        before { Element.any_instance.stub(save: false) }
+
+        it "renders the new template" do
+          expect(subject).to render_template(:new)
+        end
+      end
+    end
+
+    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'}})
+        end
+
+        context "with cell not existing" do
+          it "should create the cell" do
+            expect {
+              controller.send(:find_or_create_cell)
+            }.to change(alchemy_page.cells, :count).from(0).to(1)
+          end
+        end
+
+        context "with the cell already present" do
+          before do
+            create(:cell, page: alchemy_page, name: 'header')
+          end
+
+          it "should load the cell" do
+            expect {
+              controller.send(:find_or_create_cell)
+            }.to_not change(alchemy_page.cells, :count)
+          end
+        end
+      end
 
+      context "with only the element name in the params" do
+        before do
+          controller.stub(params: {element: {name: 'header'}})
         end
 
+        it "should return nil" do
+          controller.send(:find_or_create_cell).should 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)
+        end
+
+        it "raises error" do
+          expect { controller.send(:find_or_create_cell) }.to raise_error(CellDefinitionError)
+        end
+      end
     end
 
+    describe '#update' do
+      let(:page)    { build_stubbed(:page) }
+      let(:element) { build_stubbed(:element, page: page) }
+      let(:contents_parameters) { ActionController::Parameters.new(1 => {ingredient: 'Title'}) }
+      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)
+      end
+
+      it "updates all contents in element" do
+        element.should_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)
+        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)
+          xhr :put, :update, {id: element.id}
+          assigns(:element_validated).should be_false
+        end
+      end
+    end
+
+    describe 'params security' do
+      context "contents params" do
+        let(:parameters) { ActionController::Parameters.new(contents: {1 => {ingredient: 'Title'}}) }
+
+        specify ":contents is required" do
+          controller.params.should_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!)
+          controller.send :contents_params
+        end
+      end
+
+      context "element params" do
+        let(:parameters) { ActionController::Parameters.new(element: {public: true}) }
+
+        specify ":element is required" do
+          controller.params.should_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)
+          controller.send :element_params
+        end
+      end
+    end
+
+    describe '#trash' do
+      subject { xhr :delete, :trash, {id: element.id} }
+
+      let(:element) { build_stubbed(:element) }
+
+      before { Element.stub(find: element) }
+
+      it "trashes the element instead of deleting it" do
+        element.should_receive(:trash!).and_return(true)
+        subject
+      end
+    end
+
+    describe '#fold' do
+      subject { xhr :post, :fold, {id: element.id} }
+
+      let(:element) { build_stubbed(:element) }
+
+      before do
+        element.stub(save: true)
+        Element.stub(find: element)
+      end
+
+      context 'if element is folded' do
+        before { element.stub(folded: true) }
+
+        it "sets folded to false." do
+          element.should_receive(:folded=).with(false).and_return(true)
+          subject
+        end
+      end
+
+      context 'if element is not folded' do
+        before { element.stub(folded: false) }
+
+        it "sets folded to true." do
+          element.should_receive(:folded=).with(true).and_return(true)
+          subject
+        end
+      end
+    end
+
+    describe "untrashing" do
+      before do
+        @element = create(:element, :public => false, :position => nil, :page_id => 58, :cell_id => 32)
+        # Because of a before_create filter it can not be created with a nil position and needs to be trashed here
+        @element.trash!
+      end
+
+      it "should set a new position to the element" do
+        xhr :post, :order, {:element_ids => ["#{@element.id}"]}
+        @element.reload
+        @element.position.should_not == nil
+      end
+
+      it "should assign the (new) page_id to the element" do
+        xhr :post, :order, {:element_ids => ["#{@element.id}"], :page_id => 1, :cell_id => nil}
+        @element.reload
+        @element.page_id.should == 1
+      end
+
+      it "should assign the (new) cell_id to the element" do
+        xhr :post, :order, {:element_ids => ["#{@element.id}"], :page_id => 1, :cell_id => 5}
+        @element.reload
+        @element.cell_id.should == 5
+      end
+    end
   end
 end