jro_apps/redmine Commit - r9562:733fef458c5c

Replaced group[lastname] parameter with group[name]....

Jean-Philippe Lang -

r9562:733fef458c5c

parent child

Context file:

r9562:733fef458c5c

Collapse all files

app/models/group.rb +7 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  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 Group < Principal
               has_and_belongs_to_many :users, :after_add => :user_added,
                                               :after_remove => :user_removed
               acts_as_customizable
               validates_presence_of :lastname
               validates_uniqueness_of :lastname, :case_sensitive => false
               validates_length_of :lastname, :maximum => 30
               before_destroy :remove_references_before_destroy
               def to_s
                 lastname.to_s
               end
-              alias :name :to_s
+              def name
+                lastname
+              end
+              def name=(arg)
+                self.lastname = arg
+              end
               def user_added(user)
                 members.each do |member|
                   next if member.project.nil?
                   user_member = Member.find_by_project_id_and_user_id(member.project_id, user.id) || Member.new(:project_id => member.project_id, :user_id => user.id)
                   member.member_roles.each do |member_role|
                     user_member.member_roles << MemberRole.new(:role => member_role.role, :inherited_from => member_role.id)
                   end
                   user_member.save!
                 end
               end
               def user_removed(user)
                 members.each do |member|
                   MemberRole.find(:all, :include => :member,
                                         :conditions => ["#{Member.table_name}.user_id = ? AND #{MemberRole.table_name}.inherited_from IN (?)", user.id, member.member_role_ids]).each(&:destroy)
                 end
               end
               def self.human_attribute_name(attribute_key_name, *args)
                 attr_name = attribute_key_name.to_s
                 if attr_name == 'lastname'
                   attr_name = "name"
                 end
                 super(attr_name, *args)
               end
               private
               # Removes references that are not handled by associations
               def remove_references_before_destroy
                 return if self.id.nil?
                 Issue.update_all 'assigned_to_id = NULL', ['assigned_to_id = ?', id]
               end
             end

app/views/groups/_form.html.erb +1 -1

             <%= error_messages_for @group %>
             <div class="box tabular">
-              <p><%= f.text_field :lastname, :label => :field_name %></p>
+              <p><%= f.text_field :name %></p>
               <% @group.custom_field_values.each do |value| %>
                 <p><%= custom_field_tag_with_label :group, value %></p>
               <% end %>
             </div>

test/functional/groups_controller_test.rb +6 -5

             # Redmine - project management software
             # Copyright (C) 2006-2012  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.expand_path('../../test_helper', __FILE__)
             class GroupsControllerTest < ActionController::TestCase
               fixtures :projects, :users, :members, :member_roles, :groups_users
               def setup
                 @request.session[:user_id] = 1
               end
               def test_index
                 get :index
                 assert_response :success
                 assert_template 'index'
               end
               def test_show
                 get :show, :id => 10
                 assert_response :success
                 assert_template 'show'
               end
               def test_new
                 get :new
                 assert_response :success
                 assert_template 'new'
+                assert_select 'input[name=?]', 'group[name]'
               end
               def test_create
                 assert_difference 'Group.count' do
-                  post :create, :group => {:lastname => 'New group'}
+                  post :create, :group => {:name => 'New group'}
                 end
                 assert_redirected_to '/groups'
                 group = Group.first(:order => 'id DESC')
                 assert_equal 'New group', group.name
                 assert_equal [], group.users
               end
               def test_create_and_continue
                 assert_difference 'Group.count' do
-                  post :create, :group => {:lastname => 'New group'}, :continue => 'Create and continue'
+                  post :create, :group => {:name => 'New group'}, :continue => 'Create and continue'
                 end
                 assert_redirected_to '/groups/new'
                 group = Group.first(:order => 'id DESC')
                 assert_equal 'New group', group.name
               end
               def test_create_with_failure
                 assert_no_difference 'Group.count' do
-                  post :create, :group => {:lastname => ''}
+                  post :create, :group => {:name => ''}
                 end
                 assert_response :success
                 assert_template 'new'
               end
               def test_edit
                 get :edit, :id => 10
                 assert_response :success
                 assert_template 'edit'
                 assert_tag 'div', :attributes => {:id => 'tab-content-users'}
                 assert_tag 'div', :attributes => {:id => 'tab-content-memberships'}
               end
               def test_update
                 new_name = 'New name'
-                put :update, :id => 10, :group => {:lastname => new_name}
+                put :update, :id => 10, :group => {:name => new_name}
                 assert_redirected_to '/groups'
                 group = Group.find(10)
                 assert_equal new_name, group.name
               end
               def test_update_with_failure
-                put :update, :id => 10, :group => {:lastname => ''}
+                put :update, :id => 10, :group => {:name => ''}
                 assert_response :success
                 assert_template 'edit'
               end
               def test_destroy
                 assert_difference 'Group.count', -1 do
                   post :destroy, :id => 10
                 end
                 assert_redirected_to '/groups'
               end
               def test_add_users
                 assert_difference 'Group.find(10).users.count', 2 do
                   post :add_users, :id => 10, :user_ids => ['2', '3']
                 end
               end
               def test_xhr_add_users
                 assert_difference 'Group.find(10).users.count', 2 do
                   xhr :post, :add_users, :id => 10, :user_ids => ['2', '3']
                 end
                 assert_select_rjs :replace_html, 'tab-content-users'
               end
               def test_remove_user
                 assert_difference 'Group.find(10).users.count', -1 do
                   delete :remove_user, :id => 10, :user_id => '8'
                 end
               end
               def test_xhr_remove_user
                 assert_difference 'Group.find(10).users.count', -1 do
                   xhr :delete, :remove_user, :id => 10, :user_id => '8'
                 end
                 assert_select_rjs :replace_html, 'tab-content-users'
               end
               def test_new_membership
                 assert_difference 'Group.find(10).members.count' do
                   post :edit_membership, :id => 10, :membership => { :project_id => 2, :role_ids => ['1', '2']}
                 end
               end
               def test_xhr_new_membership
                 assert_difference 'Group.find(10).members.count' do
                   xhr :post, :edit_membership, :id => 10, :membership => { :project_id => 2, :role_ids => ['1', '2']}
                 end
                 assert_select_rjs :replace_html, 'tab-content-memberships'
               end
               def test_xhr_new_membership_with_failure
                 assert_no_difference 'Group.find(10).members.count' do
                   xhr :post, :edit_membership, :id => 10, :membership => { :project_id => 999, :role_ids => ['1', '2']}
                 end
                 assert @response.body.match(/alert/i), "Alert message not sent"
               end
               def test_edit_membership
                 assert_no_difference 'Group.find(10).members.count' do
                   post :edit_membership, :id => 10, :membership_id => 6, :membership => { :role_ids => ['1', '3']}
                 end
               end
               def test_destroy_membership
                 assert_difference 'Group.find(10).members.count', -1 do
                   post :destroy_membership, :id => 10, :membership_id => 6
                 end
               end
               def test_xhr_destroy_membership
                 assert_difference 'Group.find(10).members.count', -1 do
                   xhr :post, :destroy_membership, :id => 10, :membership_id => 6
                 end
                 assert_select_rjs :replace_html, 'tab-content-memberships'
               end
               def test_autocomplete_for_user
                 get :autocomplete_for_user, :id => 10, :q => 'mis'
                 assert_response :success
                 users = assigns(:users)
                 assert_not_nil users
                 assert users.any?
                 assert !users.include?(Group.find(10).users.first)
               end
             end

test/object_helpers.rb +1 -1

             module ObjectHelpers
               def User.generate!(attributes={})
                 @generated_user_login ||= 'user0'
                 @generated_user_login.succ!
                 user = User.new(attributes)
                 user.login = @generated_user_login if user.login.blank?
                 user.mail = "#{@generated_user_login}@example.com" if user.mail.blank?
                 user.firstname = "Bob" if user.firstname.blank?
                 user.lastname = "Doe" if user.lastname.blank?
                 yield user if block_given?
                 user.save!
                 user
               end
               def User.add_to_project(user, project, roles)
                 roles = [roles] unless roles.is_a?(Array)
                 Member.create!(:principal => user, :project => project, :roles => roles)
               end
               def Group.generate!(attributes={})
                 @generated_group_name ||= 'Group 0'
                 @generated_group_name.succ!
                 group = Group.new(attributes)
-                group.lastname = @generated_group_name if group.lastname.blank?
+                group.name = @generated_group_name if group.name.blank?
                 yield group if block_given?
                 group.save!
                 group
               end
               def Project.generate!(attributes={})
                 @generated_project_identifier ||= 'project-0000'
                 @generated_project_identifier.succ!
                 project = Project.new(attributes)
                 project.name = @generated_project_identifier if project.name.blank?
                 project.identifier = @generated_project_identifier if project.identifier.blank?
                 yield project if block_given?
                 project.save!
                 project
               end
               def Tracker.generate!(attributes={})
                 @generated_tracker_name ||= 'Tracker 0'
                 @generated_tracker_name.succ!
                 tracker = Tracker.new(attributes)
                 tracker.name = @generated_tracker_name if tracker.name.blank?
                 yield tracker if block_given?
                 tracker.save!
                 tracker
               end
               def Role.generate!(attributes={})
                 @generated_role_name ||= 'Role 0'
                 @generated_role_name.succ!
                 role = Role.new(attributes)
                 role.name = @generated_role_name if role.name.blank?
                 yield role if block_given?
                 role.save!
                 role
               end
               def Issue.generate!(attributes={})
                 issue = Issue.new(attributes)
                 issue.subject = 'Generated' if issue.subject.blank?
                 issue.author ||= User.find(2)
                 yield issue if block_given?
                 issue.save!
                 issue
               end
               # Generate an issue for a project, using its trackers
               def Issue.generate_for_project!(project, attributes={})
                 issue = Issue.new(attributes) do |issue|
                   issue.project = project
                   issue.tracker = project.trackers.first unless project.trackers.empty?
                   issue.subject = 'Generated' if issue.subject.blank?
                   issue.author ||= User.find(2)
                   yield issue if block_given?
                 end
                 issue.save!
                 issue
               end
               def Version.generate!(attributes={})
                 @generated_version_name ||= 'Version 0'
                 @generated_version_name.succ!
                 version = Version.new(attributes)
                 version.name = @generated_version_name if version.name.blank?
                 yield version if block_given?
                 version.save!
                 version
               end
               def AuthSource.generate!(attributes={})
                 @generated_auth_source_name ||= 'Auth 0'
                 @generated_auth_source_name.succ!
                 source = AuthSource.new(attributes)
                 source.name = @generated_auth_source_name if source.name.blank?
                 yield source if block_given?
                 source.save!
                 source
               end
             end

test/unit/group_test.rb +3 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  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.expand_path('../../test_helper', __FILE__)
             class GroupTest < ActiveSupport::TestCase
               fixtures :projects, :trackers, :issue_statuses, :issues,
                        :enumerations, :users, :issue_categories,
                        :projects_trackers,
                        :roles,
                        :member_roles,
                        :members,
                        :enabled_modules,
                        :workflows,
                        :groups_users
               include Redmine::I18n
               def test_create
-                g = Group.new(:lastname => 'New group')
+                g = Group.new(:name => 'New group')
                 assert g.save
+                g.reload
+                assert_equal 'New group', g.name
               end
               def test_blank_name_error_message
                 set_language_if_valid 'en'
                 g = Group.new
                 assert !g.save
                 assert_include "Name can't be blank", g.errors.full_messages
               end
               def test_blank_name_error_message_fr
                 set_language_if_valid 'fr'
                 str = "Nom doit \xc3\xaatre renseign\xc3\xa9(e)"
                 str.force_encoding('UTF-8') if str.respond_to?(:force_encoding)
                 g = Group.new
                 assert !g.save
                 assert_include str, g.errors.full_messages
               end
               def test_roles_given_to_new_user
                 group = Group.find(11)
                 user = User.find(9)
                 project = Project.first
                 Member.create!(:principal => group, :project => project, :role_ids => [1, 2])
                 group.users << user
                 assert user.member_of?(project)
               end
               def test_roles_given_to_existing_user
                 group = Group.find(11)
                 user = User.find(9)
                 project = Project.first
                 group.users << user
                 m = Member.create!(:principal => group, :project => project, :role_ids => [1, 2])
                 assert user.member_of?(project)
               end
               def test_roles_updated
                 group = Group.find(11)
                 user = User.find(9)
                 project = Project.first
                 group.users << user
                 m = Member.create!(:principal => group, :project => project, :role_ids => [1])
                 assert_equal [1], user.reload.roles_for_project(project).collect(&:id).sort
                 m.role_ids = [1, 2]
                 assert_equal [1, 2], user.reload.roles_for_project(project).collect(&:id).sort
                 m.role_ids = [2]
                 assert_equal [2], user.reload.roles_for_project(project).collect(&:id).sort
                 m.role_ids = [1]
                 assert_equal [1], user.reload.roles_for_project(project).collect(&:id).sort
               end
               def test_roles_removed_when_removing_group_membership
                 assert User.find(8).member_of?(Project.find(5))
                 Member.find_by_project_id_and_user_id(5, 10).destroy
                 assert !User.find(8).member_of?(Project.find(5))
               end
               def test_roles_removed_when_removing_user_from_group
                 assert User.find(8).member_of?(Project.find(5))
                 User.find(8).groups.clear
                 assert !User.find(8).member_of?(Project.find(5))
               end
               def test_destroy_should_unassign_issues
                 group = Group.first
                 Issue.update_all(["assigned_to_id = ?", group.id], 'id = 1')
                 assert group.destroy
                 assert group.destroyed?
                 assert_equal nil, Issue.find(1).assigned_to_id
               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