jro_apps/redmine Commit - r4385:0a2ec6ef0472

Extracts user groups assignment from controller....

Jean-Philippe Lang -

r4385:0a2ec6ef0472

parent child

Context file:

r4385:0a2ec6ef0472

Collapse all files

app/controllers/users_controller.rb 0 -1

             # Redmine - project management software
             # Copyright (C) 2006-2010  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class UsersController < ApplicationController
               layout 'admin'
               before_filter :require_admin, :except => :show
               accept_key_auth :index, :show, :create, :update
               helper :sort
               include SortHelper
               helper :custom_fields
               include CustomFieldsHelper
               def index
                 sort_init 'login', 'asc'
                 sort_update %w(login firstname lastname mail admin created_on last_login_on)
                 case params[:format]
                 when 'xml', 'json'
                   @offset, @limit = api_offset_and_limit
                 else
                   @limit = per_page_option
                 end
                 @status = params[:status] ? params[:status].to_i : 1
                 c = ARCondition.new(@status == 0 ? "status <> 0" : ["status = ?", @status])
                 unless params[:name].blank?
                   name = "%#{params[:name].strip.downcase}%"
                   c << ["LOWER(login) LIKE ? OR LOWER(firstname) LIKE ? OR LOWER(lastname) LIKE ? OR LOWER(mail) LIKE ?", name, name, name, name]
                 end
                 @user_count = User.count(:conditions => c.conditions)
                 @user_pages = Paginator.new self, @user_count, @limit, params['page']
                 @offset ||= @user_pages.current.offset
                 @users =  User.find :all,
                                     :order => sort_clause,
                                     :conditions => c.conditions,
                                     :limit  =>  @limit,
                                     :offset =>  @offset
             		respond_to do |format|
             		  format.html { render :layout => !request.xhr? }
                   format.api
             		end
               end
               def show
                 @user = User.find(params[:id])
                 # show projects based on current user visibility
                 @memberships = @user.memberships.all(:conditions => Project.visible_by(User.current))
                 events = Redmine::Activity::Fetcher.new(User.current, :author => @user).events(nil, nil, :limit => 10)
                 @events_by_day = events.group_by(&:event_date)
                 unless User.current.admin?
                   if !@user.active? || (@user != User.current  && @memberships.empty? && events.empty?)
                     render_404
                     return
                   end
                 end
                 respond_to do |format|
                   format.html { render :layout => 'base' }
                   format.api
                 end
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def new
                 @user = User.new(:language => Setting.default_language, :mail_notification => Setting.default_notification_option)
                 @auth_sources = AuthSource.find(:all)
               end
               verify :method => :post, :only => :create, :render => {:nothing => true, :status => :method_not_allowed }
               def create
                 @user = User.new(:language => Setting.default_language, :mail_notification => Setting.default_notification_option)
                 @user.safe_attributes = params[:user]
                 @user.admin = params[:user][:admin] || false
                 @user.login = params[:user][:login]
                 @user.password, @user.password_confirmation = params[:user][:password], params[:user][:password_confirmation] unless @user.auth_source_id
                 # TODO: Similar to My#account
                 @user.pref.attributes = params[:pref]
                 @user.pref[:no_self_notified] = (params[:no_self_notified] == '1')
                 if @user.save
                   @user.pref.save
                   @user.notified_project_ids = (@user.mail_notification == 'selected' ? params[:notified_project_ids] : [])
                   Mailer.deliver_account_information(@user, params[:password]) if params[:send_information]
                   respond_to do |format|
                     format.html {
                       flash[:notice] = l(:notice_successful_create)
                       redirect_to(params[:continue] ?
                         {:controller => 'users', :action => 'new'} :
                         {:controller => 'users', :action => 'edit', :id => @user}
                       )
                     }
                     format.api  { render :action => 'show', :status => :created, :location => user_url(@user) }
                   end
                 else
                   @auth_sources = AuthSource.find(:all)
                   # Clear password input
                   @user.password = @user.password_confirmation = nil
                   respond_to do |format|
                     format.html { render :action => 'new' }
                     format.api  { render_validation_errors(@user) }
                   end
                 end
               end
               def edit
                 @user = User.find(params[:id])
                 @auth_sources = AuthSource.find(:all)
                 @membership ||= Member.new
               end
               verify :method => :put, :only => :update, :render => {:nothing => true, :status => :method_not_allowed }
               def update
                 @user = User.find(params[:id])
                 @user.admin = params[:user][:admin] if params[:user][:admin]
                 @user.login = params[:user][:login] if params[:user][:login]
                 if params[:user][:password].present? && (@user.auth_source_id.nil? || params[:user][:auth_source_id].blank?)
                   @user.password, @user.password_confirmation = params[:user][:password], params[:user][:password_confirmation]
                 end
-                @user.group_ids = params[:user][:group_ids] if params[:user][:group_ids]
                 @user.safe_attributes = params[:user]
                 # Was the account actived ? (do it before User#save clears the change)
                 was_activated = (@user.status_change == [User::STATUS_REGISTERED, User::STATUS_ACTIVE])
                 # TODO: Similar to My#account
                 @user.pref.attributes = params[:pref]
                 @user.pref[:no_self_notified] = (params[:no_self_notified] == '1')
                 if @user.save
                   @user.pref.save
                   @user.notified_project_ids = (@user.mail_notification == 'selected' ? params[:notified_project_ids] : [])
                   if was_activated
                     Mailer.deliver_account_activated(@user)
                   elsif @user.active? && params[:send_information] && !params[:user][:password].blank? && @user.auth_source_id.nil?
                     Mailer.deliver_account_information(@user, params[:user][:password])
                   end
                   respond_to do |format|
                     format.html {
                       flash[:notice] = l(:notice_successful_update)
                       redirect_to :back
                     }
                     format.api  { head :ok }
                   end
                 else
                   @auth_sources = AuthSource.find(:all)
                   @membership ||= Member.new
                   # Clear password input
                   @user.password = @user.password_confirmation = nil
                   respond_to do |format|
                     format.html { render :action => :edit }
                     format.api  { render_validation_errors(@user) }
                   end
                 end
               rescue ::ActionController::RedirectBackError
                 redirect_to :controller => 'users', :action => 'edit', :id => @user
               end
               def edit_membership
                 @user = User.find(params[:id])
                 @membership = Member.edit_membership(params[:membership_id], params[:membership], @user)
                 @membership.save if request.post?
                 respond_to do |format|
                   if @membership.valid?
                     format.html { redirect_to :controller => 'users', :action => 'edit', :id => @user, :tab => 'memberships' }
                     format.js {
                       render(:update) {|page|
                         page.replace_html "tab-content-memberships", :partial => 'users/memberships'
                         page.visual_effect(:highlight, "member-#{@membership.id}")
                       }
                     }
                   else
                     format.js {
                       render(:update) {|page|
                         page.alert(l(:notice_failed_to_save_members, :errors => @membership.errors.full_messages.join(', ')))
                       }
                     }
                   end
                 end
               end
               def destroy_membership
                 @user = User.find(params[:id])
                 @membership = Member.find(params[:membership_id])
                 if request.post? && @membership.deletable?
                   @membership.destroy
                 end
                 respond_to do |format|
                   format.html { redirect_to :controller => 'users', :action => 'edit', :id => @user, :tab => 'memberships' }
                   format.js { render(:update) {|page| page.replace_html "tab-content-memberships", :partial => 'users/memberships'} }
                 end
               end
             end

app/models/user.rb +4 -1

             # Redmine - project management software
             # Copyright (C) 2006-2009  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require "digest/sha1"
             class User < Principal
               include Redmine::SafeAttributes
               # Account statuses
               STATUS_ANONYMOUS  = 0
               STATUS_ACTIVE     = 1
               STATUS_REGISTERED = 2
               STATUS_LOCKED     = 3
               USER_FORMATS = {
                 :firstname_lastname => '#{firstname} #{lastname}',
                 :firstname => '#{firstname}',
                 :lastname_firstname => '#{lastname} #{firstname}',
                 :lastname_coma_firstname => '#{lastname}, #{firstname}',
                 :username => '#{login}'
               }
               MAIL_NOTIFICATION_OPTIONS = [
                 ['all', :label_user_mail_option_all],
                 ['selected', :label_user_mail_option_selected],
                 ['only_my_events', :label_user_mail_option_only_my_events],
                 ['only_assigned', :label_user_mail_option_only_assigned],
                 ['only_owner', :label_user_mail_option_only_owner],
                 ['none', :label_user_mail_option_none]
               ]
               has_and_belongs_to_many :groups, :after_add => Proc.new {|user, group| group.user_added(user)},
                                                :after_remove => Proc.new {|user, group| group.user_removed(user)}
               has_many :issue_categories, :foreign_key => 'assigned_to_id', :dependent => :nullify
               has_many :changesets, :dependent => :nullify
               has_one :preference, :dependent => :destroy, :class_name => 'UserPreference'
               has_one :rss_token, :dependent => :destroy, :class_name => 'Token', :conditions => "action='feeds'"
               has_one :api_token, :dependent => :destroy, :class_name => 'Token', :conditions => "action='api'"
               belongs_to :auth_source
               # Active non-anonymous users scope
               named_scope :active, :conditions => "#{User.table_name}.status = #{STATUS_ACTIVE}"
               acts_as_customizable
               attr_accessor :password, :password_confirmation
               attr_accessor :last_before_login_on
               # Prevents unauthorized assignments
-              attr_protected :login, :admin, :password, :password_confirmation, :hashed_password, :group_ids
+              attr_protected :login, :admin, :password, :password_confirmation, :hashed_password
               validates_presence_of :login, :firstname, :lastname, :mail, :if => Proc.new { |user| !user.is_a?(AnonymousUser) }
               validates_uniqueness_of :login, :if => Proc.new { |user| !user.login.blank? }, :case_sensitive => false
               validates_uniqueness_of :mail, :if => Proc.new { |user| !user.mail.blank? }, :case_sensitive => false
               # Login must contain lettres, numbers, underscores only
               validates_format_of :login, :with => /^[a-z0-9_\-@\.]*$/i
               validates_length_of :login, :maximum => 30
               validates_format_of :firstname, :lastname, :with => /^[\w\s\'\-\.]*$/i
               validates_length_of :firstname, :lastname, :maximum => 30
               validates_format_of :mail, :with => /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i, :allow_nil => true
               validates_length_of :mail, :maximum => 60, :allow_nil => true
               validates_confirmation_of :password, :allow_nil => true
               validates_inclusion_of :mail_notification, :in => MAIL_NOTIFICATION_OPTIONS.collect(&:first), :allow_blank => true
               def before_create
                 self.mail_notification = Setting.default_notification_option if self.mail_notification.blank?
                 true
               end
               def before_save
                 # update hashed_password if password was set
                 self.hashed_password = User.hash_password(self.password) if self.password && self.auth_source_id.blank?
               end
               def reload(*args)
                 @name = nil
                 super
               end
               def mail=(arg)
                 write_attribute(:mail, arg.to_s.strip)
               end
               def identity_url=(url)
                 if url.blank?
                   write_attribute(:identity_url, '')
                 else
                   begin
                     write_attribute(:identity_url, OpenIdAuthentication.normalize_identifier(url))
                   rescue OpenIdAuthentication::InvalidOpenId
                     # Invlaid url, don't save
                   end
                 end
                 self.read_attribute(:identity_url)
               end
               # Returns the user that matches provided login and password, or nil
               def self.try_to_login(login, password)
                 # Make sure no one can sign in with an empty password
                 return nil if password.to_s.empty?
                 user = find_by_login(login)
                 if user
                   # user is already in local database
                   return nil if !user.active?
                   if user.auth_source
                     # user has an external authentication method
                     return nil unless user.auth_source.authenticate(login, password)
                   else
                     # authentication with local password
                     return nil unless User.hash_password(password) == user.hashed_password
                   end
                 else
                   # user is not yet registered, try to authenticate with available sources
                   attrs = AuthSource.authenticate(login, password)
                   if attrs
                     user = new(attrs)
                     user.login = login
                     user.language = Setting.default_language
                     if user.save
                       user.reload
                       logger.info("User '#{user.login}' created from external auth source: #{user.auth_source.type} - #{user.auth_source.name}") if logger && user.auth_source
                     end
                   end
                 end
                 user.update_attribute(:last_login_on, Time.now) if user && !user.new_record?
                 user
               rescue => text
                 raise text
               end
               # Returns the user who matches the given autologin +key+ or nil
               def self.try_to_autologin(key)
                 tokens = Token.find_all_by_action_and_value('autologin', key)
                 # Make sure there's only 1 token that matches the key
                 if tokens.size == 1
                   token = tokens.first
                   if (token.created_on > Setting.autologin.to_i.day.ago) && token.user && token.user.active?
                     token.user.update_attribute(:last_login_on, Time.now)
                     token.user
                   end
                 end
               end
               # Return user's full name for display
               def name(formatter = nil)
                 if formatter
                   eval('"' + (USER_FORMATS[formatter] || USER_FORMATS[:firstname_lastname]) + '"')
                 else
                   @name ||= eval('"' + (USER_FORMATS[Setting.user_format] || USER_FORMATS[:firstname_lastname]) + '"')
                 end
               end
               def active?
                 self.status == STATUS_ACTIVE
               end
               def registered?
                 self.status == STATUS_REGISTERED
               end
               def locked?
                 self.status == STATUS_LOCKED
               end
               def activate
                 self.status = STATUS_ACTIVE
               end
               def register
                 self.status = STATUS_REGISTERED
               end
               def lock
                 self.status = STATUS_LOCKED
               end
               def activate!
                 update_attribute(:status, STATUS_ACTIVE)
               end
               def register!
                 update_attribute(:status, STATUS_REGISTERED)
               end
               def lock!
                 update_attribute(:status, STATUS_LOCKED)
               end
               def check_password?(clear_password)
                 if auth_source_id.present?
                   auth_source.authenticate(self.login, clear_password)
                 else
                   User.hash_password(clear_password) == self.hashed_password
                 end
               end
               # Does the backend storage allow this user to change their password?
               def change_password_allowed?
                 return true if auth_source_id.blank?
                 return auth_source.allow_password_changes?
               end
               # Generate and set a random password.  Useful for automated user creation
               # Based on Token#generate_token_value
               #
               def random_password
                 chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
                 password = ''
 .times { |i| password << chars[rand(chars.size-1)] }
                 self.password = password
                 self.password_confirmation = password
                 self
               end
               def pref
                 self.preference ||= UserPreference.new(:user => self)
               end
               def time_zone
                 @time_zone ||= (self.pref.time_zone.blank? ? nil : ActiveSupport::TimeZone[self.pref.time_zone])
               end
               def wants_comments_in_reverse_order?
                 self.pref[:comments_sorting] == 'desc'
               end
               # Return user's RSS key (a 40 chars long string), used to access feeds
               def rss_key
                 token = self.rss_token || Token.create(:user => self, :action => 'feeds')
                 token.value
               end
               # Return user's API key (a 40 chars long string), used to access the API
               def api_key
                 token = self.api_token || self.create_api_token(:action => 'api')
                 token.value
               end
               # Return an array of project ids for which the user has explicitly turned mail notifications on
               def notified_projects_ids
                 @notified_projects_ids ||= memberships.select {|m| m.mail_notification?}.collect(&:project_id)
               end
               def notified_project_ids=(ids)
                 Member.update_all("mail_notification = #{connection.quoted_false}", ['user_id = ?', id])
                 Member.update_all("mail_notification = #{connection.quoted_true}", ['user_id = ? AND project_id IN (?)', id, ids]) if ids && !ids.empty?
                 @notified_projects_ids = nil
                 notified_projects_ids
               end
               # Only users that belong to more than 1 project can select projects for which they are notified
               def valid_notification_options
                 # Note that @user.membership.size would fail since AR ignores
                 # :include association option when doing a count
                 if memberships.length < 1
                   MAIL_NOTIFICATION_OPTIONS.delete_if {|option| option.first == 'selected'}
                 else
                   MAIL_NOTIFICATION_OPTIONS
                 end
               end
               # Find a user account by matching the exact login and then a case-insensitive
               # version.  Exact matches will be given priority.
               def self.find_by_login(login)
                 # force string comparison to be case sensitive on MySQL
                 type_cast = (ActiveRecord::Base.connection.adapter_name == 'MySQL') ? 'BINARY' : ''
                 # First look for an exact match
                 user = first(:conditions => ["#{type_cast} login = ?", login])
                 # Fail over to case-insensitive if none was found
                 user ||= first(:conditions => ["#{type_cast} LOWER(login) = ?", login.to_s.downcase])
               end
               def self.find_by_rss_key(key)
                 token = Token.find_by_value(key)
                 token && token.user.active? ? token.user : nil
               end
               def self.find_by_api_key(key)
                 token = Token.find_by_action_and_value('api', key)
                 token && token.user.active? ? token.user : nil
               end
               # Makes find_by_mail case-insensitive
               def self.find_by_mail(mail)
                 find(:first, :conditions => ["LOWER(mail) = ?", mail.to_s.downcase])
               end
               def to_s
                 name
               end
               # Returns the current day according to user's time zone
               def today
                 if time_zone.nil?
                   Date.today
                 else
                   Time.now.in_time_zone(time_zone).to_date
                 end
               end
               def logged?
                 true
               end
               def anonymous?
                 !logged?
               end
               # Return user's roles for project
               def roles_for_project(project)
                 roles = []
                 # No role on archived projects
                 return roles unless project && project.active?
                 if logged?
                   # Find project membership
                   membership = memberships.detect {|m| m.project_id == project.id}
                   if membership
                     roles = membership.roles
                   else
                     @role_non_member ||= Role.non_member
                     roles << @role_non_member
                   end
                 else
                   @role_anonymous ||= Role.anonymous
                   roles << @role_anonymous
                 end
                 roles
               end
               # Return true if the user is a member of project
               def member_of?(project)
                 !roles_for_project(project).detect {|role| role.member?}.nil?
               end
               # Return true if the user is allowed to do the specified action on a specific context
               # Action can be:
               # * a parameter-like Hash (eg. :controller => 'projects', :action => 'edit')
               # * a permission Symbol (eg. :edit_project)
               # Context can be:
               # * a project : returns true if user is allowed to do the specified action on this project
               # * a group of projects : returns true if user is allowed on every project
               # * nil with options[:global] set : check if user has at least one role allowed for this action,
               #   or falls back to Non Member / Anonymous permissions depending if the user is logged
               def allowed_to?(action, context, options={})
                 if context && context.is_a?(Project)
                   # No action allowed on archived projects
                   return false unless context.active?
                   # No action allowed on disabled modules
                   return false unless context.allows_to?(action)
                   # Admin users are authorized for anything else
                   return true if admin?
                   roles = roles_for_project(context)
                   return false unless roles
                   roles.detect {|role| (context.is_public? || role.member?) && role.allowed_to?(action)}
                 elsif context && context.is_a?(Array)
                   # Authorize if user is authorized on every element of the array
                   context.map do |project|
                     allowed_to?(action,project,options)
                   end.inject do |memo,allowed|
                     memo && allowed
                   end
                 elsif options[:global]
                   # Admin users are always authorized
                   return true if admin?
                   # authorize if user has at least one role that has this permission
                   roles = memberships.collect {|m| m.roles}.flatten.uniq
                   roles.detect {|r| r.allowed_to?(action)} || (self.logged? ? Role.non_member.allowed_to?(action) : Role.anonymous.allowed_to?(action))
                 else
                   false
                 end
               end
               # Is the user allowed to do the specified action on any project?
               # See allowed_to? for the actions and valid options.
               def allowed_to_globally?(action, options)
                 allowed_to?(action, nil, options.reverse_merge(:global => true))
               end
               safe_attributes 'login',
                 'firstname',
                 'lastname',
                 'mail',
                 'mail_notification',
                 'language',
                 'custom_field_values',
                 'custom_fields',
                 'identity_url'
               safe_attributes 'status',
                 'auth_source_id',
                 :if => lambda {|user, current_user| current_user.admin?}
+              safe_attributes 'group_ids',
+                :if => lambda {|user, current_user| current_user.admin? && !user.new_record?}
               # Utility method to help check if a user should be notified about an
               # event.
               #
               # TODO: only supports Issue events currently
               def notify_about?(object)
                 case mail_notification
                 when 'all'
                   true
                 when 'selected'
                   # Handled by the Project
                 when 'none'
                   false
                 when 'only_my_events'
                   if object.is_a?(Issue) && (object.author == self || object.assigned_to == self)
                     true
                   else
                     false
                   end
                 when 'only_assigned'
                   if object.is_a?(Issue) && object.assigned_to == self
                     true
                   else
                     false
                   end
                 when 'only_owner'
                   if object.is_a?(Issue) && object.author == self
                     true
                   else
                     false
                   end
                 else
                   false
                 end
               end
               def self.current=(user)
                 @current_user = user
               end
               def self.current
                 @current_user ||= User.anonymous
               end
               # Returns the anonymous user.  If the anonymous user does not exist, it is created.  There can be only
               # one anonymous user per database.
               def self.anonymous
                 anonymous_user = AnonymousUser.find(:first)
                 if anonymous_user.nil?
                   anonymous_user = AnonymousUser.create(:lastname => 'Anonymous', :firstname => '', :mail => '', :login => '', :status => 0)
                   raise 'Unable to create the anonymous user.' if anonymous_user.new_record?
                 end
                 anonymous_user
               end
               protected
               def validate
                 # Password length validation based on setting
                 if !password.nil? && password.size < Setting.password_min_length.to_i
                   errors.add(:password, :too_short, :count => Setting.password_min_length.to_i)
                 end
               end
               private
               # Return password digest
               def self.hash_password(clear_password)
                 Digest::SHA1.hexdigest(clear_password || "")
               end
             end
             class AnonymousUser < User
               def validate_on_create
                 # There should be only one AnonymousUser in the database
                 errors.add_to_base 'An anonymous user already exists.' if AnonymousUser.find(:first)
               end
               def available_custom_fields
                 []
               end
               # Overrides a few properties
               def logged?; false end
               def admin; false end
               def name(*args); I18n.t(:label_user_anonymous) end
               def mail; nil end
               def time_zone; nil end
               def rss_key; nil end
             end

test/functional/my_controller_test.rb +9 -2

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.dirname(__FILE__) + '/../test_helper'
             require 'my_controller'
             # Re-raise errors caught by the controller.
             class MyController; def rescue_action(e) raise e end; end
             class MyControllerTest < ActionController::TestCase
               fixtures :users, :user_preferences, :roles, :projects, :issues, :issue_statuses, :trackers, :enumerations, :custom_fields
               def setup
                 @controller = MyController.new
                 @request    = ActionController::TestRequest.new
                 @request.session[:user_id] = 2
                 @response   = ActionController::TestResponse.new
               end
               def test_index
                 get :index
                 assert_response :success
                 assert_template 'page'
               end
               def test_page
                 get :page
                 assert_response :success
                 assert_template 'page'
               end
               def test_my_account_should_show_editable_custom_fields
                 get :account
                 assert_response :success
                 assert_template 'account'
                 assert_equal User.find(2), assigns(:user)
                 assert_tag :input, :attributes => { :name => 'user[custom_field_values][4]'}
               end
               def test_my_account_should_not_show_non_editable_custom_fields
                 UserCustomField.find(4).update_attribute :editable, false
                 get :account
                 assert_response :success
                 assert_template 'account'
                 assert_equal User.find(2), assigns(:user)
                 assert_no_tag :input, :attributes => { :name => 'user[custom_field_values][4]'}
               end
               def test_update_account
-                post :account, :user => {:firstname => "Joe",
+                post :account,
+                  :user => {
+                    :firstname => "Joe",
                     :login => "root",
                     :admin => 1,
-                                         :custom_field_values => {"4" => "0100562500"}}
+                    :group_ids => ['10'],
+                    :custom_field_values => {"4" => "0100562500"}
+                  }
                 assert_redirected_to '/my/account'
                 user = User.find(2)
                 assert_equal user, assigns(:user)
                 assert_equal "Joe", user.firstname
                 assert_equal "jsmith", user.login
                 assert_equal "0100562500", user.custom_value_for(4).value
+                # ignored
                 assert !user.admin?
+                assert user.groups.empty?
               end
               def test_change_password
                 get :password
                 assert_response :success
                 assert_template 'password'
                 # non matching password confirmation
                 post :password, :password => 'jsmith',
                                 :new_password => 'hello',
                                 :new_password_confirmation => 'hello2'
                 assert_response :success
                 assert_template 'password'
                 assert_tag :tag => "div", :attributes => { :class => "errorExplanation" }
                 # wrong password
                 post :password, :password => 'wrongpassword',
                                 :new_password => 'hello',
                                 :new_password_confirmation => 'hello'
                 assert_response :success
                 assert_template 'password'
                 assert_equal 'Wrong password', flash[:error]
                 # good password
                 post :password, :password => 'jsmith',
                                 :new_password => 'hello',
                                 :new_password_confirmation => 'hello'
                 assert_redirected_to '/my/account'
                 assert User.try_to_login('jsmith', 'hello')
               end
               def test_page_layout
                 get :page_layout
                 assert_response :success
                 assert_template 'page_layout'
               end
               def test_add_block
                 xhr :post, :add_block, :block => 'issuesreportedbyme'
                 assert_response :success
                 assert User.find(2).pref[:my_page_layout]['top'].include?('issuesreportedbyme')
               end
               def test_remove_block
                 xhr :post, :remove_block, :block => 'issuesassignedtome'
                 assert_response :success
                 assert !User.find(2).pref[:my_page_layout].values.flatten.include?('issuesassignedtome')
               end
               def test_order_blocks
                 xhr :post, :order_blocks, :group => 'left', 'list-left' => ['documents', 'calendar', 'latestnews']
                 assert_response :success
                 assert_equal ['documents', 'calendar', 'latestnews'], User.find(2).pref[:my_page_layout]['left']
               end
               context "POST to reset_rss_key" do
                 context "with an existing rss_token" do
                   setup do
                     @previous_token_value = User.find(2).rss_key # Will generate one if it's missing
                     post :reset_rss_key
                   end
                   should "destroy the existing token" do
                     assert_not_equal @previous_token_value, User.find(2).rss_key
                   end
                   should "create a new token" do
                     assert User.find(2).rss_token
                   end
                   should_set_the_flash_to /reset/
                   should_redirect_to('my account') {'/my/account' }
                 end
                 context "with no rss_token" do
                   setup do
                     assert_nil User.find(2).rss_token
                     post :reset_rss_key
                   end
                   should "create a new token" do
                     assert User.find(2).rss_token
                   end
                   should_set_the_flash_to /reset/
                   should_redirect_to('my account') {'/my/account' }
                 end
               end
               context "POST to reset_api_key" do
                 context "with an existing api_token" do
                   setup do
                     @previous_token_value = User.find(2).api_key # Will generate one if it's missing
                     post :reset_api_key
                   end
                   should "destroy the existing token" do
                     assert_not_equal @previous_token_value, User.find(2).api_key
                   end
                   should "create a new token" do
                     assert User.find(2).api_token
                   end
                   should_set_the_flash_to /reset/
                   should_redirect_to('my account') {'/my/account' }
                 end
                 context "with no api_token" do
                   setup do
                     assert_nil User.find(2).api_token
                     post :reset_api_key
                   end
                   should "create a new token" do
                     assert User.find(2).api_token
                   end
                   should_set_the_flash_to /reset/
                   should_redirect_to('my account') {'/my/account' }
                 end
               end
             end

test/functional/users_controller_test.rb +7 0

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.dirname(__FILE__) + '/../test_helper'
             require 'users_controller'
             # Re-raise errors caught by the controller.
             class UsersController; def rescue_action(e) raise e end; end
             class UsersControllerTest < ActionController::TestCase
               include Redmine::I18n
               fixtures :users, :projects, :members, :member_roles, :roles, :auth_sources, :custom_fields, :custom_values
               def setup
                 @controller = UsersController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 User.current = nil
                 @request.session[:user_id] = 1 # admin
               end
               def test_index
                 get :index
                 assert_response :success
                 assert_template 'index'
               end
               def test_index
                 get :index
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:users)
                 # active users only
                 assert_nil assigns(:users).detect {|u| !u.active?}
               end
               def test_index_with_name_filter
                 get :index, :name => 'john'
                 assert_response :success
                 assert_template 'index'
                 users = assigns(:users)
                 assert_not_nil users
                 assert_equal 1, users.size
                 assert_equal 'John', users.first.firstname
               end
               def test_show
                 @request.session[:user_id] = nil
                 get :show, :id => 2
                 assert_response :success
                 assert_template 'show'
                 assert_not_nil assigns(:user)
                 assert_tag 'li', :content => /Phone number/
               end
               def test_show_should_not_display_hidden_custom_fields
                 @request.session[:user_id] = nil
                 UserCustomField.find_by_name('Phone number').update_attribute :visible, false
                 get :show, :id => 2
                 assert_response :success
                 assert_template 'show'
                 assert_not_nil assigns(:user)
                 assert_no_tag 'li', :content => /Phone number/
               end
               def test_show_should_not_fail_when_custom_values_are_nil
                 user = User.find(2)
                 # Create a custom field to illustrate the issue
                 custom_field = CustomField.create!(:name => 'Testing', :field_format => 'text')
                 custom_value = user.custom_values.build(:custom_field => custom_field).save!
                 get :show, :id => 2
                 assert_response :success
               end
               def test_show_inactive
                 @request.session[:user_id] = nil
                 get :show, :id => 5
                 assert_response 404
               end
               def test_show_should_not_reveal_users_with_no_visible_activity_or_project
                 @request.session[:user_id] = nil
                 get :show, :id => 9
                 assert_response 404
               end
               def test_show_inactive_by_admin
                 @request.session[:user_id] = 1
                 get :show, :id => 5
                 assert_response 200
                 assert_not_nil assigns(:user)
               end
               def test_show_displays_memberships_based_on_project_visibility
                 @request.session[:user_id] = 1
                 get :show, :id => 2
                 assert_response :success
                 memberships = assigns(:memberships)
                 assert_not_nil memberships
                 project_ids = memberships.map(&:project_id)
                 assert project_ids.include?(2) #private project admin can see
               end
               context "GET :new" do
                 setup do
                   get :new
                 end
                 should_assign_to :user
                 should_respond_with :success
                 should_render_template :new
               end
               context "POST :create" do
                 context "when successful" do
                   setup do
                     post :create, :user => {
                       :firstname => 'John',
                       :lastname => 'Doe',
                       :login => 'jdoe',
                       :password => 'test',
                       :password_confirmation => 'test',
                       :mail => 'jdoe@gmail.com',
                       :mail_notification => 'none'
                     }
                   end
                   should_assign_to :user
                   should_respond_with :redirect
                   should_redirect_to('user edit') { {:controller => 'users', :action => 'edit', :id => User.find_by_login('jdoe')}}
                   should 'set the users mail notification' do
                     user = User.last
                     assert_equal 'none', user.mail_notification
                   end
                   should 'set the password' do
                     user = User.first(:order => 'id DESC')
                     assert user.check_password?('test')
                   end
                 end
                 context "when unsuccessful" do
                   setup do
                     post :create, :user => {}
                   end
                   should_assign_to :user
                   should_respond_with :success
                   should_render_template :new
                 end
               end
               def test_update
                 ActionMailer::Base.deliveries.clear
                 put :update, :id => 2, :user => {:firstname => 'Changed', :mail_notification => 'only_assigned'}, :pref => {:hide_mail => '1', :comments_sorting => 'desc'}
                 user = User.find(2)
                 assert_equal 'Changed', user.firstname
                 assert_equal 'only_assigned', user.mail_notification
                 assert_equal true, user.pref[:hide_mail]
                 assert_equal 'desc', user.pref[:comments_sorting]
                 assert ActionMailer::Base.deliveries.empty?
               end
+              def test_update_with_group_ids_should_assign_groups
+                put :update, :id => 2, :user => {:group_ids => ['10']}
+                user = User.find(2)
+                assert_equal [10], user.group_ids
+              end
               def test_update_with_activation_should_send_a_notification
                 u = User.new(:firstname => 'Foo', :lastname => 'Bar', :mail => 'foo.bar@somenet.foo', :language => 'fr')
                 u.login = 'foo'
                 u.status = User::STATUS_REGISTERED
                 u.save!
                 ActionMailer::Base.deliveries.clear
                 Setting.bcc_recipients = '1'
                 put :update, :id => u.id, :user => {:status => User::STATUS_ACTIVE}
                 assert u.reload.active?
                 mail = ActionMailer::Base.deliveries.last
                 assert_not_nil mail
                 assert_equal ['foo.bar@somenet.foo'], mail.bcc
                 assert mail.body.include?(ll('fr', :notice_account_activated))
               end
               def test_update_with_password_change_should_send_a_notification
                 ActionMailer::Base.deliveries.clear
                 Setting.bcc_recipients = '1'
                 put :update, :id => 2, :user => {:password => 'newpass', :password_confirmation => 'newpass'}, :send_information => '1'
                 u = User.find(2)
                 assert u.check_password?('newpass')
                 mail = ActionMailer::Base.deliveries.last
                 assert_not_nil mail
                 assert_equal [u.mail], mail.bcc
                 assert mail.body.include?('newpass')
               end
               test "put :update with a password change to an AuthSource user switching to Internal authentication" do
                 # Configure as auth source
                 u = User.find(2)
                 u.auth_source = AuthSource.find(1)
                 u.save!
                 put :update, :id => u.id, :user => {:auth_source_id => '', :password => 'newpass'}, :password_confirmation => 'newpass'
                 assert_equal nil, u.reload.auth_source
                 assert u.check_password?('newpass')
               end
               def test_edit_membership
                 post :edit_membership, :id => 2, :membership_id => 1,
                                        :membership => { :role_ids => [2]}
                 assert_redirected_to :action => 'edit', :id => '2', :tab => 'memberships'
                 assert_equal [2], Member.find(1).role_ids
               end
               def test_destroy_membership
                 post :destroy_membership, :id => 2, :membership_id => 1
                 assert_redirected_to :action => 'edit', :id => '2', :tab => 'memberships'
                 assert_nil Member.find_by_id(1)
               end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages