jro_apps/redmine Commit - r13053:7e7ac5340a28

Adds buit-in groups to give specific permissions to anonymous and non members users per project (#17976)....

Jean-Philippe Lang -

r13053:7e7ac5340a28

parent child

Context file:

r13053:7e7ac5340a28

Expand all files

app/models/group_anonymous.rb created 644 +30 0

@@ -0,0 +1,30
	1	# Redmine - project management software
	2	# Copyright (C) 2006-2014 Jean-Philippe Lang
	3	#
	4	# This program is free software; you can redistribute it and/or
	5	# modify it under the terms of the GNU General Public License
	6	# as published by the Free Software Foundation; either version 2
	7	# of the License, or (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	17
	18	class GroupAnonymous < GroupBuiltin
	19	def name
	20	l(:label_group_anonymous)
	21	end
	22
	23	def builtin_type
	24	"anonymous"
	25	end
	26
	27	def self.instance_id
	28	@@instance_id \|\|= load_instance.id
	29	end
	30	end

app/models/group_builtin.rb created 644 +56 0

@@ -0,0 +1,56
	1	# Redmine - project management software
	2	# Copyright (C) 2006-2014 Jean-Philippe Lang
	3	#
	4	# This program is free software; you can redistribute it and/or
	5	# modify it under the terms of the GNU General Public License
	6	# as published by the Free Software Foundation; either version 2
	7	# of the License, or (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	17
	18	class GroupBuiltin < Group
	19	validate :validate_uniqueness, :on => :create
	20
	21	def validate_uniqueness
	22	errors.add :base, 'The builtin group already exists.' if self.class.exists?
	23	end
	24
	25	def builtin?
	26	true
	27	end
	28
	29	def destroy
	30	false
	31	end
	32
	33	def user_added(user)
	34	raise 'Cannot add users to a builtin group'
	35	end
	36
	37	class << self
	38	def load_instance
	39	return nil if self == GroupBuiltin
	40	instance = first(:order => 'id') \|\| create_instance
	41	end
	42
	43	def create_instance
	44	raise 'The builtin group already exists.' if exists?
	45	instance = new
	46	instance.lastname = name
	47	instance.save :validate => false
	48	raise 'Unable to create builtin group.' if instance.new_record?
	49	instance
	50	end
	51	private :create_instance
	52	end
	53	end
	54
	55	require_dependency "group_anonymous"
	56	require_dependency "group_non_member"

app/models/group_non_member.rb created 644 +30 0

@@ -0,0 +1,30
	1	# Redmine - project management software
	2	# Copyright (C) 2006-2014 Jean-Philippe Lang
	3	#
	4	# This program is free software; you can redistribute it and/or
	5	# modify it under the terms of the GNU General Public License
	6	# as published by the Free Software Foundation; either version 2
	7	# of the License, or (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	17
	18	class GroupNonMember < GroupBuiltin
	19	def name
	20	l(:label_group_non_member)
	21	end
	22
	23	def builtin_type
	24	"non_member"
	25	end
	26
	27	def self.instance_id
	28	@@instance_id \|\|= load_instance.id
	29	end
	30	end

db/migrate/20140920094058_insert_builtin_groups.rb created 644 +21 0

@@ -0,0 +1,21
	1	class InsertBuiltinGroups < ActiveRecord::Migration
	2	def up
	3	Group.reset_column_information
	4
	5	unless GroupAnonymous.any?
	6	g = GroupAnonymous.new(:lastname => 'Anonymous users')
	7	g.status = 1
	8	g.save :validate => false
	9	end
	10	unless GroupNonMember.any?
	11	g = GroupNonMember.new(:lastname => 'Non member users')
	12	g.status = 1
	13	g.save :validate => false
	14	end
	15	end
	16
	17	def down
	18	GroupAnonymous.delete_all
	19	GroupNonMember.delete_all
	20	end
	21	end

app/controllers/groups_controller.rb +6 -2

               helper :custom_fields
               def index
-                @groups = Group.sorted.all
                 respond_to do |format|
                   format.html {
+                    @groups = Group.sorted.all
                     @user_count_by_group_id = user_count_by_group_id
                   }
-                  format.api
+                  format.api {
+                    scope = Group.sorted
+                    scope = scope.givable unless params[:builtin] == '1'
+                    @groups = scope.all
+                  }
                 end
               end

app/helpers/groups_helper.rb +6 -5

             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             module GroupsHelper
-              def group_settings_tabs
+              def group_settings_tabs(group)
-                tabs = [{:name => 'general', :partial => 'groups/general', :label => :label_general},
+                tabs = []
-                        {:name => 'users', :partial => 'groups/users', :label => :label_user_plural},
+                tabs << {:name => 'general', :partial => 'groups/general', :label => :label_general}
-                        {:name => 'memberships', :partial => 'groups/memberships', :label => :label_project_plural}
+                tabs << {:name => 'users', :partial => 'groups/users', :label => :label_user_plural} if group.givable?
+                tabs << {:name => 'memberships', :partial => 'groups/memberships', :label => :label_project_plural}
+                tabs
               end
               def render_principals_for_new_group_users(group)

app/helpers/users_helper.rb +1 -1

                 tabs = [{:name => 'general', :partial => 'users/general', :label => :label_general},
                         {:name => 'memberships', :partial => 'users/memberships', :label => :label_project_plural}
                         ]
-                if Group.all.any?
+                if Group.givable.any?
                   tabs.insert 1, {:name => 'groups', :partial => 'users/groups', :label => :label_group_plural}
                 end
                 tabs

app/models/group.rb +32 -3

               before_destroy :remove_references_before_destroy
-              scope :sorted, lambda { order("#{table_name}.lastname ASC") }
+              scope :sorted, lambda { order("#{table_name}.type, #{table_name}.lastname ASC") }
               scope :named, lambda {|arg| where("LOWER(#{table_name}.lastname) = LOWER(?)", arg.to_s.strip)}
+              scope :givable, lambda {where(:type => 'Group')}
               safe_attributes 'name',
                 'user_ids',
                 'custom_field_values',
                 'custom_fields',
-                :if => lambda {|group, user| user.admin?}
+                :if => lambda {|group, user| user.admin? && !group.builtin?}
               def to_s
-                lastname.to_s
+                name.to_s
               end
               def name
                 self.lastname = arg
               end
+              def builtin_type
+                nil
+              end
+              # Return true if the group is a builtin group
+              def builtin?
+                false
+              end
+              # Returns true if the group can be given to a user
+              def givable?
+                !builtin?
+              end
               def user_added(user)
                 members.each do |member|
                   next if member.project.nil?
                 super(attr_name, *args)
               end
+              def self.builtin_id(arg)
+                (arg.anonymous? ? GroupAnonymous : GroupNonMember).instance_id
+              end
+              def self.anonymous
+                GroupAnonymous.load_instance
+              end
+              def self.non_member
+                GroupNonMember.load_instance
+              end
               private
               # Removes references that are not handled by associations
                 Issue.where(['assigned_to_id = ?', id]).update_all('assigned_to_id = NULL')
               end
             end
+            require_dependency "group_builtin"

app/models/issue_query.rb +4 -3

                 end
                 principals.uniq!
                 principals.sort!
+                principals.reject! {|p| p.is_a?(GroupBuiltin)}
                 users = principals.select {|p| p.is_a?(User)}
                 add_available_filter "status_id",
                   :type => :list_optional, :values => assigned_to_values
                 ) unless assigned_to_values.empty?
-                group_values = Group.all.collect {|g| [g.name, g.id.to_s] }
+                group_values = Group.givable.collect {|g| [g.name, g.id.to_s] }
                 add_available_filter("member_of_group",
                   :type => :list_optional, :values => group_values
                 ) unless group_values.empty?
               def sql_for_member_of_group_field(field, operator, value)
                 if operator == '*' # Any group
-                  groups = Group.all
+                  groups = Group.givable
                   operator = '=' # Override the operator since we want to find by assigned_to
                 elsif operator == "!*"
-                  groups = Group.all
+                  groups = Group.givable
                   operator = '!' # Override the operator since we want to find by assigned_to
                 else
                   groups = Group.where(:id => value).all

app/models/principal.rb +3 0

                 true
               end
             end
+            require_dependency "user"
+            require_dependency "group"

app/models/project.rb +18 -8

               has_many :memberships, :class_name => 'Member'
               has_many :member_principals, :class_name => 'Member',
                                            :include => :principal,
-                                           :conditions => "#{Principal.table_name}.type='Group' OR (#{Principal.table_name}.type='User' AND #{Principal.table_name}.status=#{Principal::STATUS_ACTIVE})"
+                                           :conditions => "#{Principal.table_name}.status=#{Principal::STATUS_ACTIVE}"
               has_many :enabled_modules, :dependent => :delete_all
               has_and_belongs_to_many :trackers, :order => "#{Tracker.table_name}.position"
                       statement_by_role[role] = "#{Project.table_name}.is_public = #{connection.quoted_true}"
                     end
                   end
-                  if user.logged?
+                  user.projects_by_role.each do |role, projects|
-                    user.projects_by_role.each do |role, projects|
+                    if role.allowed_to?(permission) && projects.any?
-                      if role.allowed_to?(permission) && projects.any?
+                      statement_by_role[role] = "#{Project.table_name}.id IN (#{projects.collect(&:id).join(',')})"
-                        statement_by_role[role] = "#{Project.table_name}.id IN (#{projects.collect(&:id).join(',')})"
-                      end
                     end
                   end
                   if statement_by_role.empty?
                 end
               end
+              def override_roles(role)
+                @override_members ||= memberships.where(:user_id => [GroupAnonymous.instance_id, GroupNonMember.instance_id]).all
+                member = @override_members.detect {|m| role.anonymous? ^ (m.user_id == GroupNonMember.instance_id)}
+                member ? member.roles : [role]
+              end
               def principals
                 @principals ||= Principal.active.joins(:members).where("#{Member.table_name}.project_id = ?", id).uniq
               end
                 @actions_allowed = nil
                 @start_date = nil
                 @due_date = nil
+                @override_members = nil
                 base_reload(*args)
               end
               # Users/groups issues can be assigned to
               def assignable_users
-                assignable = Setting.issue_group_assignment? ? member_principals : members
+                types = ['User']
-                assignable.select {|m| m.roles.detect {|role| role.assignable?}}.collect {|m| m.principal}.sort
+                types << 'Group' if Setting.issue_group_assignment?
+                member_principals.
+                  select {|m| types.include?(m.principal.type) && m.roles.detect(&:assignable?)}.
+                  map(&:principal).
+                  sort
               end
               # Returns the mail addresses of users that should be always notified on project events

app/models/user.rb +21 -13

               # Return user's roles for project
               def roles_for_project(project)
-                roles = []
                 # No role on archived projects
-                return roles if project.nil? || project.archived?
+                return [] if project.nil? || project.archived?
                 if membership = membership(project)
-                  roles = membership.roles
+                  membership.roles.dup
+                elsif project.is_public?
+                  project.override_roles(builtin_role)
                 else
-                  roles << builtin_role
+                  []
                 end
-                roles
               end
               # Return true if the user is a member of project
               def projects_by_role
                 return @projects_by_role if @projects_by_role
-                @projects_by_role = Hash.new([])
+                hash = Hash.new([])
-                memberships.each do |membership|
-                  if membership.project
+                members = Member.joins(:project).
-                    membership.roles.each do |role|
+                  where("#{Project.table_name}.status <> 9").
-                      @projects_by_role[role] = [] unless @projects_by_role.key?(role)
+                  where("#{Member.table_name}.user_id = ? OR (#{Project.table_name}.is_public = ? AND #{Member.table_name}.user_id = ?)", self.id, true, Group.builtin_id(self)).
-                      @projects_by_role[role] << membership.project
+                  preload(:project, :roles)
+                members.reject! {|member| member.user_id != id && project_ids.include?(member.project_id)}
+                members.each do |member|
+                  if member.project
+                    member.roles.each do |role|
+                      hash[role] = [] unless hash.key?(role)
+                      hash[role] << member.project
                     end
                   end
                 end
-                @projects_by_role.each do |role, projects|
+                hash.each do |role, projects|
                   projects.uniq!
                 end
-                @projects_by_role
+                @projects_by_role = hash
               end
               # Returns true if user is arg or belongs to arg

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

             <%= error_messages_for @group %>
             <div class="box tabular">
-              <p><%= f.text_field :name, :required => true, :size => 60 %></p>
+              <p><%= f.text_field :name, :required => true, :size => 60,
+                       :disabled => !@group.safe_attribute?('name')  %></p>
               <% @group.custom_field_values.each do |value| %>
                 <p><%= custom_field_tag_with_label :group, value %></p>
               <% end %>

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

-            <%= labelled_form_for @group do |f| %>
+            <%= labelled_form_for @group, :url => group_path(@group) do |f| %>
             <%= render :partial => 'form', :locals => { :f => f } %>
             <%= submit_tag l(:button_save) %>
             <% end %>

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

@@ -1,3 +1,3
1	<%= title [l(:label_group_plural), groups_path], @group.name %>	1	<%= title [l(:label_group_plural), groups_path], @group.name %>
2		2
3	<%= render_tabs group_settings_tabs %>	3	<%= render_tabs group_settings_tabs(@group) %>

app/views/groups/index.api.rsb +1 0

                 api.group do
                   api.id         group.id
                   api.name       group.lastname
+                  api.builtin    group.builtin_type if group.builtin_type
                   render_api_custom_values group.visible_custom_field_values, api
                 end

app/views/groups/index.html.erb +3 -3

               </tr></thead>
               <tbody>
             <% @groups.each do |group| %>
-              <tr id="group-<%= group.id %>" class="<%= cycle 'odd', 'even' %>">
+              <tr id="group-<%= group.id %>" class="<%= cycle 'odd', 'even' %> <%= "builtin" if group.builtin? %>">
                 <td class="name"><%= link_to h(group), edit_group_path(group) %></td>
-                <td class="user_count"><%= @user_count_by_group_id[group.id] || 0 %></td>
+                <td class="user_count"><%= (@user_count_by_group_id[group.id] || 0) unless group.builtin? %></td>
-                <td class="buttons"><%= delete_link group %></td>
+                <td class="buttons"><%= delete_link group unless group.builtin? %></td>
               </tr>
             <% end %>
               </tbody>

app/views/groups/show.api.rsb +2 -1

             api.group do
               api.id         @group.id
               api.name       @group.lastname
+              api.builtin    @group.builtin_type if @group.builtin_type
               render_api_custom_values @group.visible_custom_field_values, api
                 @group.users.each do |user|
                   api.user :id => user.id, :name => user.name
                 end
-              end if include_in_api_response?('users')
+              end if include_in_api_response?('users') && !@group.builtin?
               api.array :memberships do
                 @group.memberships.each do |membership|

app/views/users/_groups.html.erb +1 -1

             <%= form_for(:user, :url => { :action => 'update' }, :html => {:method => :put}) do %>
             <div class="box">
-            <% Group.all.sort.each do |group| %>
+            <% Group.givable.sort.each do |group| %>
             <label><%= check_box_tag 'user[group_ids][]', group.id, @user.groups.include?(group), :id => nil %> <%=h group %></label><br />
             <% end %>
             <%= hidden_field_tag 'user[group_ids][]', '' %>

config/locales/en.yml +2 0

               label_group: Group
               label_group_plural: Groups
               label_group_new: New group
+              label_group_anonymous: Anonymous users
+              label_group_non_member: Non member users
               label_time_entry_plural: Spent time
               label_version_sharing_none: Not shared
               label_version_sharing_descendants: With subprojects

config/locales/fr.yml +2 0

               label_group: Groupe
               label_group_plural: Groupes
               label_group_new: Nouveau groupe
+              label_group_anonymous: Utilisateurs anonymes
+              label_group_non_member: Utilisateurs non membres
               label_time_entry_plural: Temps passé
               label_version_sharing_none: Non partagé
               label_version_sharing_descendants: Avec les sous-projets

extra/svn/Redmine.pm +15 -5

                             AND (
                               roles.id IN (SELECT member_roles.role_id FROM members, member_roles WHERE members.user_id = users.id AND members.project_id = projects.id AND members.id = member_roles.member_id)
                               OR
-                              (roles.builtin=1 AND cast(projects.is_public as CHAR) IN ('t', '1'))
+                              (cast(projects.is_public as CHAR) IN ('t', '1')
+                                AND (roles.builtin=1
+                                     OR roles.id IN (SELECT member_roles.role_id FROM members, member_roles, users g
+                                             WHERE members.user_id = g.id AND members.project_id = projects.id AND members.id = member_roles.member_id
+                                             AND g.type = 'GroupNonMember'))
+                              )
                             )
                             AND roles.permissions IS NOT NULL";
               $self->{RedmineQuery} = trim($query);
               my $project_id = get_project_identifier($r);
               $r->set_handlers(PerlAuthenHandler => [\&OK])
-                  if is_public_project($project_id, $r) && anonymous_role_allows_browse_repository($r);
+                  if is_public_project($project_id, $r) && anonymous_allowed_to_browse_repository($project_id, $r);
               return OK
             }
                 $ret;
             }
-            sub anonymous_role_allows_browse_repository {
+            sub anonymous_allowed_to_browse_repository {
+              my $project_id = shift;
               my $r = shift;
               my $dbh = connect_database($r);
               my $sth = $dbh->prepare(
-                  "SELECT permissions FROM roles WHERE builtin = 2;"
+                  "SELECT permissions FROM roles WHERE permissions like '%browse_repository%'
+                    AND (roles.builtin = 2
+                         OR roles.id IN (SELECT member_roles.role_id FROM projects, members, member_roles, users
+                                         WHERE members.user_id = users.id AND members.project_id = projects.id AND members.id = member_roles.member_id
+                                         AND projects.identifier = ? AND users.type = 'GroupAnonymous'));"
               );
-              $sth->execute();
+              $sth->execute($project_id);
               my $ret = 0;
               if (my @row = $sth->fetchrow_array) {
                 if ($row[0] =~ /:browse_repository/) {

public/stylesheets/application.css +4 -1

             .odd {background-color:#f6f7f8;}
             .even {background-color: #fff;}
+            tr.builtin td.name {font-style:italic;}
             a.sort { padding-right: 16px; background-position: 100% 50%; background-repeat: no-repeat; }
             a.sort.asc  { background-image: url(../images/sort_asc.png); }
             a.sort.desc { background-image: url(../images/sort_desc.png); }
             #users_for_watcher {height: 200px; overflow:auto;}
             #users_for_watcher label {display: block;}
-            table.members td.group { padding-left: 20px; background: url(../images/group.png) no-repeat 0% 50%; }
+            table.members td.name {padding-left: 20px;}
+            table.members td.group, table.members td.groupnonmember, table.members td.groupanonymous {background: url(../images/group.png) no-repeat 0% 1px;}
             input#principal_search, input#user_search {width:90%}

test/extra/redmine_pm/repository_subversion_test.rb +15 0

                 assert_success "ls", svn_url
               end
+              def test_anonymous_read_on_public_repo_with_anonymous_group_permission_should_succeed
+                Role.anonymous.remove_permission! :browse_repository
+                Member.create!(:project_id => 1, :principal => Group.anonymous, :role_ids => [2])
+                assert_success "ls", svn_url
+              end
               def test_anonymous_read_on_public_repo_without_permission_should_fail
                 Role.anonymous.remove_permission! :browse_repository
                 assert_failure "ls", svn_url
                 end
               end
+              def test_non_member_read_on_public_repo_with_non_member_group_permission_should_succeed
+                Role.anonymous.remove_permission! :browse_repository
+                Role.non_member.remove_permission! :browse_repository
+                Member.create!(:project_id => 1, :principal => Group.non_member, :role_ids => [2])
+                with_credentials "miscuser8", "foo" do
+                  assert_success "ls", svn_url
+                end
+              end
               def test_non_member_read_on_public_repo_without_permission_should_fail
                 Role.anonymous.remove_permission! :browse_repository
                 Role.non_member.remove_permission! :browse_repository

test/extra/redmine_pm/test_case.rb +1 0

                   @command = args.join(' ')
                   @status = nil
                   IO.popen("#{command} 2>&1") do |io|
+                    io.set_encoding("ASCII-8BIT") if io.respond_to?(:set_encoding)
                     @response = io.read
                   end
                   @status = $?.exitstatus

test/fixtures/users.yml +12 -1

@@ -161,9 +161,20 groups_010:
161	id: 10	161	id: 10
162	lastname: A Team	162	lastname: A Team
163	type: Group	163	type: Group
		164	status: 1
164	groups_011:	165	groups_011:
165	id: 11	166	id: 11
166	lastname: B Team	167	lastname: B Team
167	type: Group	168	type: Group
		169	status: 1
		170	groups_non_member:
		171	id: 12
		172	lastname: Non member users
		173	type: GroupNonMember
		174	status: 1
		175	groups_anonymous:
		176	id: 13
		177	lastname: Anonymous users
		178	type: GroupAnonymous
		179	status: 1
168		180
169

test/integration/api_test/groups_test.rb +32 -2

                 assert_response 401
               end
-              test "GET /groups.xml should return groups" do
+              test "GET /groups.xml should return givable groups" do
                 get '/groups.xml', {}, credentials('admin')
                 assert_response :success
                 assert_equal 'application/xml', response.content_type
                 assert_select 'groups' do
+                  assert_select 'group', Group.givable.count
                   assert_select 'group' do
                     assert_select 'name', :text => 'A Team'
                     assert_select 'id', :text => '10'
                 end
               end
+              test "GET /groups.xml?builtin=1 should return all groups" do
+                get '/groups.xml?builtin=1', {}, credentials('admin')
+                assert_response :success
+                assert_equal 'application/xml', response.content_type
+                assert_select 'groups' do
+                  assert_select 'group', Group.givable.count + 2
+                  assert_select 'group' do
+                    assert_select 'builtin', :text => 'non_member'
+                    assert_select 'id', :text => '12'
+                  end
+                  assert_select 'group' do
+                    assert_select 'builtin', :text => 'anonymous'
+                    assert_select 'id', :text => '13'
+                  end
+                end
+              end
               test "GET /groups.json should require authentication" do
                 get '/groups.json'
                 assert_response 401
                 assert_equal({'id' => 10, 'name' => 'A Team'}, group)
               end
-              test "GET /groups/:id.xml should return the group with its users" do
+              test "GET /groups/:id.xml should return the group" do
                 get '/groups/10.xml', {}, credentials('admin')
                 assert_response :success
                 assert_equal 'application/xml', response.content_type
                 end
               end
+              test "GET /groups/:id.xml should return the builtin group" do
+                get '/groups/12.xml', {}, credentials('admin')
+                assert_response :success
+                assert_equal 'application/xml', response.content_type
+                assert_select 'group' do
+                  assert_select 'builtin', :text => 'non_member'
+                  assert_select 'id', :text => '12'
+                end
+              end
               test "GET /groups/:id.xml should include users if requested" do
                 get '/groups/10.xml?include=users', {}, credentials('admin')
                 assert_response :success

test/integration/issues_test.rb +21 0

@@ -65,6 +65,27 class IssuesTest < ActionController::IntegrationTest
65	assert_equal 1, issue.status.id	65	assert_equal 1, issue.status.id
66	end	66	end
67		67
		68	def test_create_issue_by_anonymous_without_permission_should_fail
		69	Role.anonymous.remove_permission! :add_issues
		70
		71	assert_no_difference 'Issue.count' do
		72	post 'projects/1/issues', :tracker_id => "1", :issue => {:subject => "new test issue"}
		73	end
		74	assert_response 302
		75	end
		76
		77	def test_create_issue_by_anonymous_with_custom_permission_should_succeed
		78	Role.anonymous.remove_permission! :add_issues
		79	Member.create!(:project_id => 1, :principal => Group.anonymous, :role_ids => [3])
		80
		81	assert_difference 'Issue.count' do
		82	post 'projects/1/issues', :tracker_id => "1", :issue => {:subject => "new test issue"}
		83	end
		84	assert_response 302
		85	issue = Issue.order("id DESC").first
		86	assert_equal User.anonymous, issue.author
		87	end
		88
68	# add then remove 2 attachments to an issue	89	# add then remove 2 attachments to an issue
69	def test_issue_attachments	90	def test_issue_attachments
70	log_user('jsmith', 'jsmith')	91	log_user('jsmith', 'jsmith')

test/unit/group_test.rb +16 0

@@ -133,4 +133,20 class GroupTest < ActiveSupport::TestCase
133		133
134	assert_equal nil, Issue.find(1).assigned_to_id	134	assert_equal nil, Issue.find(1).assigned_to_id
135	end	135	end
		136
		137	def test_builtin_id_with_anonymous_user_should_return_anonymous_group
		138	assert_equal 13, Group.builtin_id(User.anonymous)
		139	end
		140
		141	def test_builtin_id_with_anonymous_role_should_return_anonymous_group
		142	assert_equal 13, Group.builtin_id(Role.anonymous)
		143	end
		144
		145	def test_builtin_id_with_user_should_return_non_member_group
		146	assert_equal 12, Group.builtin_id(User.find(1))
		147	end
		148
		149	def test_builtin_id_with_non_member_role_should_return_non_member_group
		150	assert_equal 12, Group.builtin_id(Role.non_member)
		151	end
136	end	152	end

test/unit/issue_test.rb +31 0

@@ -219,6 +219,16 class IssueTest < ActiveSupport::TestCase
219	assert_visibility_match User.anonymous, issues	219	assert_visibility_match User.anonymous, issues
220	end	220	end
221		221
		222	def test_visible_scope_for_anonymous_without_view_issues_permissions_and_membership
		223	Role.anonymous.remove_permission!(:view_issues)
		224	Member.create!(:project_id => 1, :principal => Group.anonymous, :role_ids => [2])
		225
		226	issues = Issue.visible(User.anonymous).all
		227	assert issues.any?
		228	assert_equal [1], issues.map(&:project_id).uniq.sort
		229	assert_visibility_match User.anonymous, issues
		230	end
		231
222	def test_anonymous_should_not_see_private_issues_with_issues_visibility_set_to_default	232	def test_anonymous_should_not_see_private_issues_with_issues_visibility_set_to_default
223	assert Role.anonymous.update_attribute(:issues_visibility, 'default')	233	assert Role.anonymous.update_attribute(:issues_visibility, 'default')
224	issue = Issue.generate!(:author => User.anonymous, :assigned_to => User.anonymous, :is_private => true)	234	issue = Issue.generate!(:author => User.anonymous, :assigned_to => User.anonymous, :is_private => true)
@@ -265,6 +275,17 class IssueTest < ActiveSupport::TestCase
265	assert_visibility_match user, issues	275	assert_visibility_match user, issues
266	end	276	end
267		277
		278	def test_visible_scope_for_non_member_without_view_issues_permissions_and_membership
		279	Role.non_member.remove_permission!(:view_issues)
		280	Member.create!(:project_id => 1, :principal => Group.non_member, :role_ids => [2])
		281	user = User.find(9)
		282
		283	issues = Issue.visible(user).all
		284	assert issues.any?
		285	assert_equal [1], issues.map(&:project_id).uniq.sort
		286	assert_visibility_match user, issues
		287	end
		288
268	def test_visible_scope_for_member	289	def test_visible_scope_for_member
269	user = User.find(9)	290	user = User.find(9)
270	# User should see issues of projects for which user has view_issues permissions only	291	# User should see issues of projects for which user has view_issues permissions only
@@ -1724,6 +1745,16 class IssueTest < ActiveSupport::TestCase
1724	end	1745	end
1725	end	1746	end
1726		1747
		1748	def test_assignable_users_should_not_include_builtin_groups
		1749	Member.create!(:project_id => 1, :principal => Group.non_member, :role_ids => [1])
		1750	Member.create!(:project_id => 1, :principal => Group.anonymous, :role_ids => [1])
		1751	issue = Issue.new(:project => Project.find(1))
		1752
		1753	with_settings :issue_group_assignment => '1' do
		1754	assert_nil issue.assignable_users.detect {\|u\| u.is_a?(GroupBuiltin)}
		1755	end
		1756	end
		1757
1727	def test_create_should_send_email_notification	1758	def test_create_should_send_email_notification
1728	ActionMailer::Base.deliveries.clear	1759	ActionMailer::Base.deliveries.clear
1729	issue = Issue.new(:project_id => 1, :tracker_id => 1,	1760	issue = Issue.new(:project_id => 1, :tracker_id => 1,

test/unit/principal_test.rb +5 -11

@@ -55,17 +55,11 class PrincipalTest < ActiveSupport::TestCase
55	end	55	end
56		56
57	def test_sorted_scope_should_sort_users_before_groups	57	def test_sorted_scope_should_sort_users_before_groups
58	scope = Principal.where(~~"type <> ?"~~, '~~AnonymousUser'~~)	58	scope = Principal.where(:type => ['User', 'Group'])
59	expected_order = scope.all.sort do \|a, b\|	59	users = scope.select {\|p\| p.is_a?(User)}.sort
60	if a.is_a?(User) && b.is_a?(Group)	60	groups = scope.select {\|p\| p.is_a?(Group)}.sort
61	-1	61
62	elsif a.is_a?(Group) && b.is_a?(User)	62	assert_equal (users + groups).map(&:name).map(&:downcase),
63	1
64	else
65	a.name.downcase <=> b.name.downcase
66	end
67	end
68	assert_equal expected_order.map(&:name).map(&:downcase),
69	scope.sorted.map(&:name).map(&:downcase)	63	scope.sorted.map(&:name).map(&:downcase)
70	end	64	end
71		65

test/unit/query_test.rb +1 -1

                 assert query.available_filters.keys.include?("member_of_group")
                 assert_equal :list_optional, query.available_filters["member_of_group"][:type]
                 assert query.available_filters["member_of_group"][:values].present?
-                assert_equal Group.all.sort.map {|g| [g.name, g.id.to_s]},
+                assert_equal Group.givable.sort.map {|g| [g.name, g.id.to_s]},
                   query.available_filters["member_of_group"][:values].sort
               end

test/unit/user_test.rb +33 -5

@@ -838,14 +838,42 class UserTest < ActiveSupport::TestCase
838	assert_nil membership	838	assert_nil membership
839	end	839	end
840		840
841	def test_roles_for_project	841	def test_roles_for_project_with_member_on_public_project_should_return_roles_and_non_member
842	# user with a role
843	roles = @jsmith.roles_for_project(Project.find(1))	842	roles = @jsmith.roles_for_project(Project.find(1))
844	assert_kind_of Role, roles.first	843	assert_kind_of Role, roles.first
845	assert_equal "Manager", roles.~~first~~.~~name~~	844	assert_equal ["Manager"], roles.map(&:name)
		845	end
		846
		847	def test_roles_for_project_with_member_on_private_project_should_return_roles
		848	Project.find(1).update_attribute :is_public, false
		849
		850	roles = @jsmith.roles_for_project(Project.find(1))
		851	assert_kind_of Role, roles.first
		852	assert_equal ["Manager"], roles.map(&:name)
		853	end
		854
		855	def test_roles_for_project_with_non_member_with_public_project_should_return_non_member
		856	roles = User.find(8).roles_for_project(Project.find(1))
		857	assert_equal ["Non member"], roles.map(&:name)
		858	end
		859
		860	def test_roles_for_project_with_non_member_with_public_project_should_return_no_roles
		861	Project.find(1).update_attribute :is_public, false
		862
		863	roles = User.find(8).roles_for_project(Project.find(1))
		864	assert_equal [], roles.map(&:name)
		865	end
		866
		867	def test_roles_for_project_with_anonymous_with_public_project_should_return_anonymous
		868	roles = User.anonymous.roles_for_project(Project.find(1))
		869	assert_equal ["Anonymous"], roles.map(&:name)
		870	end
846		871
847	# user with no role	872	def test_roles_for_project_with_anonymous_with_public_project_should_return_no_roles
848	assert_nil @dlopper.roles_for_project(Project.find(2)).detect {\|role\| role.member?}	873	Project.find(1).update_attribute :is_public, false
		874
		875	roles = User.anonymous.roles_for_project(Project.find(1))
		876	assert_equal [], roles.map(&:name)
849	end	877	end
850		878
851	def test_projects_by_role_for_user_with_role	879	def test_projects_by_role_for_user_with_role

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