alchemy_cms 2.6.3 → 2.7.0

data/spec/controllers/admin/trash_controller_spec.rb

@@ -2,23 +2,16 @@ require 'spec_helper'
 
 module Alchemy
   module Admin
-
     describe TrashController do
-
       render_views
 
-      let(:alchemy_page) do
-        FactoryGirl.create(:page, :parent_id => Page.rootpage.id)
-      end
+      let(:alchemy_page) { FactoryGirl.create(:public_page) }
+      let(:element) { FactoryGirl.create(:element, :public => false, :page => alchemy_page) }
 
-      let(:element) do
-        FactoryGirl.create(:element, :public => false, :page => alchemy_page)
-      end
-
-      before do
-        sign_in :user, FactoryGirl.create(:admin_user)
+      before {
+        sign_in(admin_user)
         element.trash
-      end
+      }
 
       it "should hold trashed elements" do
         get :index, :page_id => alchemy_page.id
@@ -32,44 +25,41 @@ module Alchemy
       end
 
       context "with unique elements inside the trash" do
-
-        before do
-          Element.stub!(:all_definitions_for).and_return([
-            {'name' => element.name, 'unique' => true}
-          ])
-        end
+        let(:trashed) { FactoryGirl.build_stubbed(:unique_element, position: nil, public: false, folded: true, page: alchemy_page) }
+        before { Element.stub(:trashed).and_return([trashed]) }
 
         context "and no unique elements on the page" do
+          before { alchemy_page.stub_chain(:elements, :not_trashed, :pluck).and_return([]) }
 
           it "unique elements should be draggable" do
-            get :index, :page_id => alchemy_page.id
-            response.body.should have_selector("#element_#{element.id}.element_editor.draggable")
+            get :index, page_id: alchemy_page.id
+            response.body.should have_selector("#element_#{trashed.id}.element_editor.draggable")
           end
-
         end
 
         context "and with an unique element on the page" do
+          let(:unique) { FactoryGirl.build_stubbed(:unique_element) }
+          let(:page) { FactoryGirl.build_stubbed(:public_page) }
+          before {
+            Page.stub(:find).and_return(page)
+            page.stub_chain(:elements, :not_trashed, :pluck).and_return([unique.name])
+          }
 
           it "unique elements should not be draggable" do
-            FactoryGirl.create(:element, :page => alchemy_page, :public => false)
-            get :index, :page_id => alchemy_page.id
-            response.body.should have_selector("#element_#{element.id}.element_editor.not-draggable")
+            get :index, page_id: page.id
+            response.body.should have_selector("#element_#{trashed.id}.element_editor.not-draggable")
           end
-
         end
-
       end
 
-      context "#clear" do
-
+      describe "#clear" do
         it "should destroy all containing elements" do
-          post :clear, {:page_id => alchemy_page.id, :format => :js}
+          Element.trashed.should_not be_empty
+          xhr :post, :clear, page_id: alchemy_page.id
           Element.trashed.should be_empty
         end
-
       end
 
     end
-
   end
 end

data/spec/controllers/admin/users_controller_spec.rb

@@ -1,103 +1,132 @@
 require 'spec_helper'
 
-describe Alchemy::Admin::UsersController do
-  let(:admin) { FactoryGirl.create(:admin_user, email: 'admin@admin.com', login: 'admin') }
-  before { sign_in :user, admin }
+module Alchemy
+  describe Admin::UsersController do
 
-  describe '#new' do
-    render_views
+      let(:admin) { FactoryGirl.build_stubbed(:admin_user) }
 
-    it "has send_credentials checkbox activated" do
-      get :new
-      response.body.should match /<input checked="checked" id="user_send_credentials" name="user\[send_credentials\]" type="checkbox"/
-    end
-  end
-
-  describe '#edit' do
-    render_views
-
-    it "has send_credentials checkbox deactivated" do
-      get :edit, id: admin.id
-      response.body.should match /<input id="user_send_credentials" name="user\[send_credentials\]" type="checkbox"/
-    end
-  end
-
-  describe '#create' do
-    before { ActionMailer::Base.deliveries = [] }
-
-    it "creates an user record" do
-      post :create, user: FactoryGirl.attributes_for(:user).merge(send_credentials: true)
-      Alchemy::User.count.should == 2
-    end
-
-    context "with send_credentials set to true" do
-      it "should send an email notification" do
-        post :create, user: FactoryGirl.attributes_for(:user).merge(send_credentials: true)
-        ActionMailer::Base.deliveries.should_not be_empty
-      end
-    end
-
-    context "with send_credentials left blank" do
-      it "should not send an email notification" do
-        post :create, user: FactoryGirl.attributes_for(:user)
-        ActionMailer::Base.deliveries.should be_empty
+      before do
+        controller.stub!(:store_user_request_time)
+        User.stub!(:find).and_return(admin)
+        admin.stub!(:update_without_password).and_return(true)
+        admin.stub!(:update_attributes).and_return(true)
+        sign_in(admin)
       end
-    end
-  end
-
-  describe '#update' do
-    let(:user) { FactoryGirl.create(:user) }
-
-    before { ActionMailer::Base.deliveries = [] }
 
-    it "assigns user to @user" do
-      post :update, :id => user.id, :user => {}, :format => :js
-      assigns(:user).should eq(user)
-    end
+      describe '#new' do
+        render_views
 
-    context "with empty password passed" do
-      it "should update the user" do
-        post :update, :id => user.id, :user => {:firstname => 'Johnny', :password => '', :password_confirmation => ''}, :format => :js
-        assigns(:user).should be_valid
+        it "has send_credentials checkbox activated" do
+          get :new
+          response.body.should match /<input checked="checked" id="user_send_credentials" name="user\[send_credentials\]" type="checkbox"/
+        end
       end
-    end
 
-    context "with new password passed" do
-      it "should update the user" do
-        post :update, :id => user.id, :user => {:firstname => 'Johnny', :password => 'newpassword', :password_confirmation => 'newpassword'}, :format => :js
-        assigns(:user).password.should == 'newpassword'
-      end
-    end
+      describe '#edit' do
+        render_views
 
-    context "with send_credentials set to true" do
-      it "should send an email notification" do
-        post :update, id: user.id, user: {send_credentials: true}
-        ActionMailer::Base.deliveries.should_not be_empty
+        it "has send_credentials checkbox deactivated" do
+          get :edit, id: admin.id
+          response.body.should match /<input id="user_send_credentials" name="user\[send_credentials\]" type="checkbox"/
+        end
       end
-    end
 
-    context "with send_credentials left blank" do
-      it "should not send an email notification" do
-        post :update, :id => user.id, :user => {}
-        ActionMailer::Base.deliveries.should be_empty
+      describe '#create' do
+        before { ActionMailer::Base.deliveries = [] }
+
+        it "creates an user record" do
+          post :create, user: FactoryGirl.attributes_for(:user).merge(send_credentials: '1')
+          Alchemy::User.count.should == 1
+        end
+
+        context "with send_credentials set to '1'" do
+          it "should send an email notification" do
+            post :create, user: FactoryGirl.attributes_for(:user).merge(send_credentials: '1')
+            ActionMailer::Base.deliveries.should_not be_empty
+          end
+        end
+
+        context "with send_credentials set to true" do
+          it "should not send an email notification" do
+            post :create, user: FactoryGirl.attributes_for(:user).merge(send_credentials: true)
+            ActionMailer::Base.deliveries.should be_empty
+          end
+        end
+
+        context "with send_credentials left blank" do
+          it "should not send an email notification" do
+            post :create, user: FactoryGirl.attributes_for(:user)
+            ActionMailer::Base.deliveries.should be_empty
+          end
+        end
       end
-    end
 
-    context "if user is permitted to update roles" do
-      it "updates the user including role" do
-        controller.stub(:permitted_to?).with(:update_roles).and_return { true }
-        Alchemy::User.any_instance.should_receive(:update_attributes).with({'roles' => ['Administrator']})
-        post :update, :id => user.id, :user => {:roles => ['Administrator']}, :format => :js
-      end
-    end
+      describe '#update' do
+        before do
+          ActionMailer::Base.deliveries = []
+        end
+
+        it "assigns user to @user" do
+          post :update, id: admin.id, user: {}, format: :js
+          assigns(:user).should eq(admin)
+        end
+
+        context "with empty password passed" do
+          it "should update the user" do
+            params_hash = {'firstname' => 'Johnny', 'password' => '', 'password_confirmation' => ''}
+            admin.should_receive(:update_without_password).with(params_hash).and_return(true)
+            post :update, id: admin.id, user: params_hash, format: :js
+          end
+        end
+
+        context "with new password passed" do
+          it "should update the user" do
+            params_hash = {'firstname' => 'Johnny', 'password' => 'newpassword', 'password_confirmation' => 'newpassword'}
+            admin.should_receive(:update_attributes).with(params_hash)
+            post :update, id: admin.id, user: params_hash, format: :js
+          end
+        end
+
+        context "with send_credentials set to '1'" do
+          let(:user) { FactoryGirl.build(:user) }
+          before { User.stub!(:find).and_return(user) }
+
+          it "should send an email notification" do
+            post :update, id: user.id, user: {send_credentials: '1'}
+            ActionMailer::Base.deliveries.should_not be_empty
+          end
+        end
+
+        context "with send_credentials left blank" do
+          it "should not send an email notification" do
+            post :update, id: admin.id, user: {}, format: :js
+            ActionMailer::Base.deliveries.should be_empty
+          end
+        end
+
+        context "if user is permitted to update roles" do
+          before do
+            controller.stub!(:permitted_to?).with(:update_roles).and_return(true)
+          end
+
+          it "updates the user including role" do
+            admin.should_receive(:update_without_password).with({'roles' => ['Administrator']})
+            post :update, id: admin.id, user: {roles: ['Administrator']}, format: :js
+          end
+        end
+
+        context "if the user is not permitted to update roles" do
+          before do
+            controller.stub!(:permitted_to?).with(:update_roles).and_return(false)
+          end
+
+          it "updates user without role" do
+            admin.should_receive(:update_without_password).with({})
+            post :update, id: admin.id, user: {'roles' => ['Administrator']}, format: :js
+          end
+        end
 
-    context "if the user is not permitted to update roles" do
-      it "updates user without role" do
-        controller.stub(:permitted_to?).with(:update_roles).and_return { false }
-        Alchemy::User.any_instance.should_receive(:update_attributes).with({})
-        post :update, :id => user.id, :user => {'roles' => ['Administrator']}, :format => :js
       end
-    end
-  end
 
+  end
 end

data/spec/controllers/attachments_controller_spec.rb

@@ -24,10 +24,14 @@ module Alchemy
       response.should redirect_to(login_path)
     end
 
+    it "should raise ActiveRecord::RecordNotFound for requesting not existing attachments" do
+      expect { get :download, id: 0 }.to raise_error(ActiveRecord::RecordNotFound)
+    end
+
     context "as registered user" do
 
       before do
-        sign_in :user, FactoryGirl.create(:registered_user)
+        sign_in(registered_user)
       end
 
       it "should be possible to download attachments from restricted pages" do
@@ -46,7 +50,7 @@ module Alchemy
     context "as registered user" do
 
       before do
-        sign_in :user, FactoryGirl.create(:registered_user)
+        sign_in(registered_user)
       end
 
       it "should be possible to see attachments from restricted pages" do

data/spec/controllers/base_controller_spec.rb

@@ -119,6 +119,28 @@ module Alchemy
       end
 
     end
+    
+    describe "#layout_for_page" do
+      it "should return false if params[:layout] is set to false" do
+        controller.stub!(:params).and_return(layout: 'false')
+        expect(controller.send(:layout_for_page)).to be_false
+      end
+
+      it "should return false if params[:layout] is set to none" do
+        controller.stub!(:params).and_return(layout: 'none')
+        expect(controller.send(:layout_for_page)).to be_false
+      end
+
+      it "should return the layout name set through params[:layout]" do
+        controller.stub!(:params).and_return(layout: 'my_layout')
+        expect(controller.send(:layout_for_page)).to eq('my_layout')
+      end
+
+      it "should return 'application' if params[:layout] is not set" do
+        controller.stub!(:params).and_return({})
+        expect(controller.send(:layout_for_page)).to eq('application')
+      end
+    end
 
   end
 end

data/spec/controllers/elements_controller_spec.rb

@@ -33,7 +33,7 @@ module Alchemy
 
       context "for registered user" do
         before do
-          sign_in :user, FactoryGirl.create(:registered_user)
+          sign_in(registered_user)
         end
 
         it "should render elements of restricted pages" do

data/spec/controllers/messages_controller_spec.rb

@@ -0,0 +1,200 @@
+require 'spec_helper'
+
+module Alchemy
+  describe MessagesController do
+
+    before do
+      controller.instance_variable_set(:@page, page)
+      controller.stub!(:get_page).and_return(page)
+    end
+
+    describe "#index" do
+
+      let(:page) { mock_model('Page', {urlname: 'contact', page_layout: 'contact'}) }
+
+      it "should redirect to @page" do
+        expect(get :index).to redirect_to(show_page_path(urlname: page.urlname))
+      end
+    end
+
+    describe "#new" do
+
+      it "should render the alchemy/pages/show template" do
+        get :new
+        expect(get :new).to render_template('alchemy/pages/show')
+      end
+
+      it "should call #layout_for_page to render the correct layout" do
+        controller.should_receive(:layout_for_page)
+        get :new
+      end
+    end
+
+    describe "#create" do
+
+      before { controller.stub!(:params).and_return({message: {email: ''}}) }
+
+      let(:page) { mock_model('Page', get_language_root: mock_model('Page')) }
+      let(:element) { mock_model('Element', page: page, ingredient: '') }
+      let(:message) { Message.new }
+
+      it "should raise ActiveRecord::RecordNotFound if element of contactform could not be found" do
+        expect { get :create }.to raise_error(ActiveRecord::RecordNotFound)
+      end
+
+      context "if validation of message" do
+
+        before do
+          Element.stub!(:find_by_id).and_return(element)
+          Message.any_instance.stub(:contact_form_id).and_return(1)
+        end
+
+        context "is false" do
+          before { Message.any_instance.stub(:valid?).and_return(false) }
+
+          it "should render 'alchemy/pages/show' template" do
+            expect(get :create).to render_template('alchemy/pages/show')
+          end
+        end
+
+        context "is true" do
+          before do
+            Message.any_instance.stub(:valid?).and_return(true)
+            Messages.stub_chain(:contact_form_mail, :deliver).and_return(true)
+          end
+
+          it "Messages should call Messages#contact_form_mail to send the email" do
+            Messages.should_receive(:contact_form_mail)
+            get :create
+          end
+
+          describe '#mail_to' do
+            context "with element having mail_to ingredient" do
+              before {
+                element.stub(:ingredient).with(:mail_to).and_return('peter@schroeder.de')
+                message
+                Message.stub(:new).and_return(message)
+              }
+
+              it "returns the ingredient" do
+                Messages.should_receive(:contact_form_mail).with(message, 'peter@schroeder.de', '', '')
+                get :create
+              end
+            end
+
+            context "with element having no mail_to ingredient" do
+              before {
+                element.stub(:ingredient).with(:mail_to).and_return(nil)
+                message
+                Message.stub(:new).and_return(message)
+              }
+
+              it "returns the config value" do
+                Messages.should_receive(:contact_form_mail).with(message, 'your.mail@your-domain.com', '', '')
+                get :create
+              end
+            end
+          end
+
+          describe '#mail_from' do
+            context "with element having mail_from ingredient" do
+              before {
+                element.stub(:ingredient).with(:mail_from).and_return('peter@schroeder.de')
+                message
+                Message.stub(:new).and_return(message)
+              }
+
+              it "returns the ingredient" do
+                Messages.should_receive(:contact_form_mail).with(message, '', 'peter@schroeder.de', '')
+                get :create
+              end
+            end
+
+            context "with element having no mail_from ingredient" do
+              before {
+                element.stub(:ingredient).with(:mail_from).and_return(nil)
+                message
+                Message.stub(:new).and_return(message)
+              }
+
+              it "returns the config value" do
+                Messages.should_receive(:contact_form_mail).with(message, '', 'your.mail@your-domain.com', '')
+                get :create
+              end
+            end
+          end
+
+          describe '#subject' do
+            context "with element having subject ingredient" do
+              before {
+                element.stub(:ingredient).with(:subject).and_return('A new message')
+                message
+                Message.stub(:new).and_return(message)
+              }
+
+              it "returns the ingredient" do
+                Messages.should_receive(:contact_form_mail).with(message, '', '', 'A new message')
+                get :create
+              end
+            end
+
+            context "with element having no subject ingredient" do
+              before {
+                element.stub(:ingredient).with(:subject).and_return(nil)
+                message
+                Message.stub(:new).and_return(message)
+              }
+
+              it "returns the config value" do
+                Messages.should_receive(:contact_form_mail).with(message, '', '', 'A new contact form message')
+                get :create
+              end
+            end
+          end
+
+          describe "#redirect_to_success_page" do
+
+            context "if 'success_page' ingredient of element is set with urlname" do
+              before { element.stub!(:ingredient).with('success_page').and_return('success-page') }
+
+              it "should redirect to the given urlname" do
+                expect(get :create).to redirect_to(show_page_path(urlname: 'success-page'))
+              end
+            end
+
+            context "if 'success_page' ingredient of element is not set" do
+              before { element.stub!(:ingredient).with('success_page').and_return(nil) }
+
+              context "but mailer_config['forward_to_page'] is true and mailer_config['mail_success_page'] is set" do
+                before do
+                  controller.stub!(:mailer_config).and_return({'forward_to_page' => true, 'mail_success_page' => 'mailer-config-success-page'})
+                  Page.stub_chain(:find_by_urlname, :urlname).and_return('mailer-config-success-page')
+                end
+
+                it "redirect to the given success page" do
+                  expect(get :create).to redirect_to(show_page_path(urlname: 'mailer-config-success-page'))
+                end
+              end
+
+              context "and mailer_config has no instructions for success_page" do
+                before do
+                  controller.stub!(:mailer_config).and_return({})
+                end
+
+                it "should redirect to the language root page" do
+                  Page.stub_chain(:language_root_for, :urlname).and_return('lang-root')
+                  expect(get :create).to redirect_to(show_page_path(urlname: 'lang-root'))
+                end
+              end
+
+            end
+
+          end
+        end
+
+      end
+
+    end
+
+  end
+end