jro_apps/redmine Commit - r11764:888c3581eb0f

Role based custom queries (#1019)....

Jean-Philippe Lang -

r11764:888c3581eb0f

parent child

Context file:

r11764:888c3581eb0f

Collapse all files

db/migrate/20130602092539_create_queries_roles.rb created 644 +13 0

@@ -0,0 +1,13
	1	class CreateQueriesRoles < ActiveRecord::Migration
	2	def self.up
	3	create_table :queries_roles, :id => false do \|t\|
	4	t.column :query_id, :integer, :null => false
	5	t.column :role_id, :integer, :null => false
	6	end
	7	add_index :queries_roles, [:query_id, :role_id], :unique => true, :name => :queries_roles_ids
	8	end
	9
	10	def self.down
	11	drop_table :queries_roles
	12	end
	13	end

db/migrate/20130710182539_add_queries_visibility.rb created 644 +13 0

@@ -0,0 +1,13
	1	class AddQueriesVisibility < ActiveRecord::Migration
	2	def up
	3	add_column :queries, :visibility, :integer, :default => 0
	4	Query.where(:is_public => true).update_all(:visibility => 2)
	5	remove_column :queries, :is_public
	6	end
	7
	8	def down
	9	add_column :queries, :is_public, :boolean, :default => true, :null => false
	10	Query.where('visibility <> ?', 2).update_all(:is_public => false)
	11	remove_column :queries, :visibility
	12	end
	13	end

app/controllers/queries_controller.rb +3 -3

                 @query = IssueQuery.new
                 @query.user = User.current
                 @query.project = @project
-                @query.is_public = false unless User.current.allowed_to?(:manage_public_queries, @project) || User.current.admin?
+                @query.visibility = IssueQuery::VISIBILITY_PRIVATE unless User.current.allowed_to?(:manage_public_queries, @project) || User.current.admin?
                 @query.build_from_params(params)
               end
                 @query = IssueQuery.new(params[:query])
                 @query.user = User.current
                 @query.project = params[:query_is_for_all] ? nil : @project
-                @query.is_public = false unless User.current.allowed_to?(:manage_public_queries, @project) || User.current.admin?
+                @query.visibility = IssueQuery::VISIBILITY_PRIVATE unless User.current.allowed_to?(:manage_public_queries, @project) || User.current.admin?
                 @query.build_from_params(params)
                 @query.column_names = nil if params[:default_columns]
               def update
                 @query.attributes = params[:query]
                 @query.project = nil if params[:query_is_for_all]
-                @query.is_public = false unless User.current.allowed_to?(:manage_public_queries, @project) || User.current.admin?
+                @query.visibility = IssueQuery::VISIBILITY_PRIVATE unless User.current.allowed_to?(:manage_public_queries, @project) || User.current.admin?
                 @query.build_from_params(params)
                 @query.column_names = nil if params[:default_columns]

app/helpers/issues_helper.rb +2 -2

               def render_sidebar_queries
                 out = ''.html_safe
-                out << query_links(l(:label_my_queries), sidebar_queries.reject(&:is_public?))
+                out << query_links(l(:label_my_queries), sidebar_queries.select(&:is_private?))
-                out << query_links(l(:label_query_plural), sidebar_queries.select(&:is_public?))
+                out << query_links(l(:label_query_plural), sidebar_queries.reject(&:is_private?))
                 out
               end

app/models/issue_query.rb +41 -4

@@ -45,9 +45,25 class IssueQuery < Query
45	scope :visible, lambda {\|*args\|	45	scope :visible, lambda {\|*args\|
46	user = args.shift \|\| User.current	46	user = args.shift \|\| User.current
47	base = Project.allowed_to_condition(user, :view_issues, *args)	47	base = Project.allowed_to_condition(user, :view_issues, *args)
48	user_id = user.logged? ? user.id : 0	48	scope = includes(:project).where("#{table_name}.project_id IS NULL OR (#{base})")
49		49
50	includes(:project).where("(#{table_name}.project_id IS NULL OR (#{base})) AND (#{table_name}.is_public = ? OR #{table_name}.user_id = ?)", true, user_id)	50	if user.admin?
		51	scope.where("#{table_name}.visibility <> ? OR #{table_name}.user_id = ?", VISIBILITY_PRIVATE, user.id)
		52	elsif user.memberships.any?
		53	scope.where("#{table_name}.visibility = ?" +
		54	" OR (#{table_name}.visibility = ? AND #{table_name}.id IN (" +
		55	"SELECT DISTINCT q.id FROM #{table_name} q" +
		56	" INNER JOIN #{table_name_prefix}queries_roles#{table_name_suffix} qr on qr.query_id = q.id" +
		57	" INNER JOIN #{MemberRole.table_name} mr ON mr.role_id = qr.role_id" +
		58	" INNER JOIN #{Member.table_name} m ON m.id = mr.member_id AND m.user_id = ?" +
		59	" WHERE q.project_id IS NULL OR q.project_id = m.project_id))" +
		60	" OR #{table_name}.user_id = ?",
		61	VISIBILITY_PUBLIC, VISIBILITY_ROLES, user.id, user.id)
		62	elsif user.logged?
		63	scope.where("#{table_name}.visibility = ? OR #{table_name}.user_id = ?", VISIBILITY_PUBLIC, user.id)
		64	else
		65	scope.where("#{table_name}.visibility = ?", VISIBILITY_PUBLIC)
		66	end
51	}	67	}
52		68
53	def initialize(attributes=nil, *args)	69	def initialize(attributes=nil, *args)
@@ -57,7 +73,28 class IssueQuery < Query
57		73
58	# Returns true if the query is visible to +user+ or the current user.	74	# Returns true if the query is visible to +user+ or the current user.
59	def visible?(user=User.current)	75	def visible?(user=User.current)
60	(project.nil? \|\| user.allowed_to?(:view_issues, project)) && (self.is_public? \|\| self.user_id == user.id)	76	return true if user.admin?
		77	return false unless project.nil? \|\| user.allowed_to?(:view_issues, project)
		78	case visibility
		79	when VISIBILITY_PUBLIC
		80	true
		81	when VISIBILITY_ROLES
		82	if project
		83	(user.roles_for_project(project) & roles).any?
		84	else
		85	Member.where(:user_id => user.id).joins(:roles).where(:member_roles => {:role_id => roles.map(&:id)}).any?
		86	end
		87	else
		88	user == self.user
		89	end
		90	end
		91
		92	def is_private?
		93	visibility == VISIBILITY_PRIVATE
		94	end
		95
		96	def is_public?
		97	!is_private?
61	end	98	end
62		99
63	def initialize_available_filters	100	def initialize_available_filters

app/models/query.rb +17 -2

               class StatementInvalid < ::ActiveRecord::StatementInvalid
               end
+              VISIBILITY_PRIVATE = 0
+              VISIBILITY_ROLES   = 1
+              VISIBILITY_PUBLIC  = 2
               belongs_to :project
               belongs_to :user
+              has_and_belongs_to_many :roles, :join_table => "#{table_name_prefix}queries_roles#{table_name_suffix}", :foreign_key => "query_id"
               serialize :filters
               serialize :column_names
               serialize :sort_criteria, Array
               validates_presence_of :name
               validates_length_of :name, :maximum => 255
+              validates :visibility, :inclusion => { :in => [VISIBILITY_PUBLIC, VISIBILITY_ROLES, VISIBILITY_PRIVATE] }
               validate :validate_query_filters
+              validate do |query|
+                errors.add(:base, l(:label_role_plural) + ' ' + l('activerecord.errors.messages.blank')) if query.visibility == VISIBILITY_ROLES && roles.blank?
+              end
+              after_save do |query|
+                if query.visibility_changed? && query.visibility != VISIBILITY_ROLES
+            	    query.roles.clear
+            	  end
+              end
               class_attribute :operators
               self.operators = {
               def editable_by?(user)
                 return false unless user
                 # Admin can edit them all and regular users can edit their private queries
-                return true if user.admin? || (!is_public && self.user_id == user.id)
+                return true if user.admin? || (is_private? && self.user_id == user.id)
                 # Members can not edit public queries that are for all project (only admin is allowed to)
-                is_public && !@is_for_all && user.allowed_to?(:manage_public_queries, project)
+                is_public? && !@is_for_all && user.allowed_to?(:manage_public_queries, project)
               end
               def trackers

app/models/user.rb +1 -1

                 Message.update_all ['author_id = ?', substitute.id], ['author_id = ?', id]
                 News.update_all ['author_id = ?', substitute.id], ['author_id = ?', id]
                 # Remove private queries and keep public ones
-                ::Query.delete_all ['user_id = ? AND is_public = ?', id, false]
+                ::Query.delete_all ['user_id = ? AND visibility = ?', id, ::Query::VISIBILITY_PRIVATE]
                 ::Query.update_all ['user_id = ?', substitute.id], ['user_id = ?', id]
                 TimeEntry.update_all ['user_id = ?', substitute.id], ['user_id = ?', id]
                 Token.delete_all ['user_id = ?', id]

app/views/queries/_form.html.erb +20 -3

             <%= text_field 'query', 'name', :size => 80 %></p>
             <% if User.current.admin? || User.current.allowed_to?(:manage_public_queries, @project) %>
-            <p><label for="query_is_public"><%=l(:field_is_public)%></label>
+            <p><label><%=l(:field_visible)%></label>
-            <%= check_box 'query', 'is_public',
+              <label class="block"><%= radio_button 'query', 'visibility', Query::VISIBILITY_PRIVATE %> <%= l(:label_visibility_private) %></label>
-                  :onchange => (User.current.admin? ? nil : 'if (this.checked) {$("#query_is_for_all").removeAttr("checked"); $("#query_is_for_all").attr("disabled", true);} else {$("#query_is_for_all").removeAttr("disabled");}') %></p>
+              <label class="block"><%= radio_button 'query', 'visibility', Query::VISIBILITY_ROLES %> <%= l(:label_visibility_roles) %>:</label>
+              <% Role.givable.sorted.each do |role| %>
+                <label class="block role-visibility"><%= check_box_tag 'query[role_ids][]', role.id, @query.roles.include?(role), :id => nil %> <%= role.name %></label>
+              <% end %>
+              <label class="block"><%= radio_button 'query', 'visibility', Query::VISIBILITY_PUBLIC %> <%= l(:label_visibility_public) %></label>
+              <%= hidden_field_tag 'query[role_ids][]', '' %>
+            </p>
             <% end %>
             <p><label for="query_is_for_all"><%=l(:field_is_for_all)%></label>
             <%= check_box_tag 'query_is_for_all', 1, @query.project.nil?,
                   :disabled => (!@query.new_record? && (@query.project.nil? || (@query.is_public? && !User.current.admin?))) %></p>
+            <fieldset><legend><%= l(:label_options) %></legend>
             <p><label for="query_default_columns"><%=l(:label_default_columns)%></label>
             <%= check_box_tag 'default_columns', 1, @query.has_default_columns?, :id => 'query_default_columns',
                   :onclick => 'if (this.checked) {$("#columns").hide();} else {$("#columns").show();}' %></p>
             <p><label><%= l(:button_show) %></label>
             <%= available_block_columns_tags(@query) %></p>
+            </fieldset>
             </div>
             <fieldset id="filters"><legend><%= l(:label_filter_plural) %></legend>
             <% end %>
             </div>
+            <%= javascript_tag do %>
+            $(document).ready(function(){
+              $("input[name='query[visibility]']").change(function(){
+                var checked = $('#query_visibility_1').is(':checked');
+                $("input[name='query[role_ids][]'][type=checkbox]").attr('disabled', !checked);
+              }).trigger('change');
+            });
+            <% end %>

app/views/queries/index.api.rsb +1 -1

                 api.query do
                   api.id          query.id
                   api.name        query.name
-                  api.is_public   query.is_public
+                  api.is_public   query.is_public?
                   api.project_id  query.project_id
                 end
               end

config/locales/en.yml +3 0

               label_cross_project_hierarchy: With project hierarchy
               label_cross_project_system: With all projects
               label_gantt_progress_line: Progress line
+              label_visibility_private: to me only
+              label_visibility_roles: to these roles only
+              label_visibility_public: to any users
               button_login: Login
               button_submit: Submit

config/locales/fr.yml +3 0

               label_cross_project_hierarchy: Avec toute la hiérarchie
               label_cross_project_system: Avec tous les projets
               label_gantt_progress_line: Ligne de progression
+              label_visibility_private: par moi uniquement
+              label_visibility_roles: par ces roles uniquement
+              label_visibility_public: par tout le monde
               button_login: Connexion
               button_submit: Soumettre

public/stylesheets/application.css +2 0

               background-image: url(../images/loading.gif);
             }
+            .role-visibility {padding-left:2em;}
             /***** Flash & error messages ****/
             #errorExplanation, div.flash, .nodata, .warning, .conflict {
               padding: 4px 4px 4px 30px;

test/fixtures/queries.yml +9 -9

               id: 1
               type: IssueQuery
               project_id: 1
-              is_public: true
+              visibility: 2
               name: Multiple custom fields query
               filters: |
                 ---
               id: 2
               type: IssueQuery
               project_id: 1
-              is_public: false
+              visibility: 0
               name: Private query for cookbook
               filters: |
                 ---
               id: 3
               type: IssueQuery
               project_id:
-              is_public: false
+              visibility: 0
               name: Private query for all projects
               filters: |
                 ---
               id: 4
               type: IssueQuery
               project_id:
-              is_public: true
+              visibility: 2
               name: Public query for all projects
               filters: |
                 ---
               id: 5
               type: IssueQuery
               project_id:
-              is_public: true
+              visibility: 2
               name: Open issues by priority and tracker
               filters: |
                 ---
               id: 6
               type: IssueQuery
               project_id:
-              is_public: true
+              visibility: 2
               name: Open issues grouped by tracker
               filters: |
                 ---
               id: 7
               type: IssueQuery
               project_id: 2
-              is_public: true
+              visibility: 2
               name: Public query for project 2
               filters: |
                 ---
               id: 8
               type: IssueQuery
               project_id: 2
-              is_public: false
+              visibility: 0
               name: Private query for project 2
               filters: |
                 ---
               id: 9
               type: IssueQuery
               project_id:
-              is_public: true
+              visibility: 2
               name: Open issues grouped by list custom field
               filters: |
                 ---

test/functional/calendars_controller_test.rb +1 -1

               end
               def test_show_should_run_custom_queries
-                @query = IssueQuery.create!(:name => 'Calendar', :is_public => true)
+                @query = IssueQuery.create!(:name => 'Calendar', :visibility => IssueQuery::VISIBILITY_PUBLIC)
                 get :show, :query_id => @query.id
                 assert_response :success

test/functional/issues_controller_test.rb +6 -6

               end
               def test_index_with_cross_project_query_in_session_should_show_project_issues
-                q = IssueQuery.create!(:name => "test", :user_id => 2, :is_public => false, :project => nil)
+                q = IssueQuery.create!(:name => "test", :user_id => 2, :visibility => IssueQuery::VISIBILITY_PRIVATE, :project => nil)
                 @request.session[:query] = {:id => q.id, :project_id => 1}
                 with_settings :display_subprojects_issues => '0' do
               end
               def test_private_query_should_not_be_available_to_other_users
-                q = IssueQuery.create!(:name => "private", :user => User.find(2), :is_public => false, :project => nil)
+                q = IssueQuery.create!(:name => "private", :user => User.find(2), :visibility => IssueQuery::VISIBILITY_PRIVATE, :project => nil)
                 @request.session[:user_id] = 3
                 get :index, :query_id => q.id
               end
               def test_private_query_should_be_available_to_its_user
-                q = IssueQuery.create!(:name => "private", :user => User.find(2), :is_public => false, :project => nil)
+                q = IssueQuery.create!(:name => "private", :user => User.find(2), :visibility => IssueQuery::VISIBILITY_PRIVATE, :project => nil)
                 @request.session[:user_id] = 2
                 get :index, :query_id => q.id
               end
               def test_public_query_should_be_available_to_other_users
-                q = IssueQuery.create!(:name => "private", :user => User.find(2), :is_public => true, :project => nil)
+                q = IssueQuery.create!(:name => "private", :user => User.find(2), :visibility => IssueQuery::VISIBILITY_PUBLIC, :project => nil)
                 @request.session[:user_id] = 3
                 get :index, :query_id => q.id
               end
               def test_show_should_display_prev_next_links_with_saved_query_in_session
-                query = IssueQuery.create!(:name => 'test', :is_public => true,  :user_id => 1,
+                query = IssueQuery.create!(:name => 'test', :visibility => IssueQuery::VISIBILITY_PUBLIC,  :user_id => 1,
                   :filters => {'status_id' => {:values => ['5'], :operator => '='}},
                   :sort_criteria => [['id', 'asc']])
                 @request.session[:query] = {:id => query.id, :project_id => nil}
                 CustomValue.create!(:custom_field => cf, :customized => Issue.find(3), :value => '3')
                 CustomValue.create!(:custom_field => cf, :customized => Issue.find(5), :value => '')
-                query = IssueQuery.create!(:name => 'test', :is_public => true,  :user_id => 1, :filters => {},
+                query = IssueQuery.create!(:name => 'test', :visibility => IssueQuery::VISIBILITY_PUBLIC,  :user_id => 1, :filters => {},
                   :sort_criteria => [["cf_#{cf.id}", 'asc'], ['id', 'asc']])
                 @request.session[:query] = {:id => query.id, :project_id => nil}

test/functional/queries_controller_test.rb +12 -22

                 get :new, :project_id => 1
                 assert_response :success
                 assert_template 'new'
-                assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
+                assert_select 'input[name=?][value=0][checked=checked]', 'query[visibility]'
-                                                             :name => 'query[is_public]',
-                                                             :checked => nil }
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query_is_for_all',
                                                              :checked => nil,
                 get :new
                 assert_response :success
                 assert_template 'new'
-                assert_no_tag :tag => 'input', :attributes => { :type => 'checkbox',
+                assert_select 'input[name=?]', 'query[visibility]', 0
-                                                                :name => 'query[is_public]' }
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query_is_for_all',
                                                              :checked => 'checked',
                      :f => ["status_id", "assigned_to_id"],
                      :op => {"assigned_to_id" => "=", "status_id" => "o"},
                      :v => { "assigned_to_id" => ["1"], "status_id" => ["1"]},
-                     :query => {"name" => "test_new_project_public_query", "is_public" => "1"}
+                     :query => {"name" => "test_new_project_public_query", "visibility" => "2"}
                 q = Query.find_by_name('test_new_project_public_query')
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => 'ecookbook', :query_id => q
                      :fields => ["status_id", "assigned_to_id"],
                      :operators => {"assigned_to_id" => "=", "status_id" => "o"},
                      :values => { "assigned_to_id" => ["1"], "status_id" => ["1"]},
-                     :query => {"name" => "test_new_project_private_query", "is_public" => "1"}
+                     :query => {"name" => "test_new_project_private_query", "visibility" => "2"}
                 q = Query.find_by_name('test_new_project_private_query')
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => 'ecookbook', :query_id => q
                      :fields => ["status_id", "assigned_to_id"],
                      :operators => {"assigned_to_id" => "=", "status_id" => "o"},
                      :values => { "assigned_to_id" => ["me"], "status_id" => ["1"]},
-                     :query => {"name" => "test_new_global_private_query", "is_public" => "1"},
+                     :query => {"name" => "test_new_global_private_query", "visibility" => "2"},
                      :c => ["", "tracker", "subject", "priority", "category"]
                 q = Query.find_by_name('test_new_global_private_query')
                      :operators => {"status_id" => "o"},
                      :values => {"status_id" => ["1"]},
                      :query => {:name => "test_new_with_sort",
-                                :is_public => "1",
+                                :visibility => "2",
                                 :sort_criteria => {"0" => ["due_date", "desc"], "1" => ["tracker", ""]}}
                 query = Query.find_by_name("test_new_with_sort")
                 get :edit, :id => 4
                 assert_response :success
                 assert_template 'edit'
-                assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
+                assert_select 'input[name=?][value=2][checked=checked]', 'query[visibility]'
-                                                             :name => 'query[is_public]',
-                                                             :checked => 'checked' }
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query_is_for_all',
                                                              :checked => 'checked',
                 get :edit, :id => 3
                 assert_response :success
                 assert_template 'edit'
-                assert_no_tag :tag => 'input', :attributes => { :type => 'checkbox',
+                assert_select 'input[name=?]', 'query[visibility]', 0
-                                                                :name => 'query[is_public]' }
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query_is_for_all',
                                                              :checked => 'checked',
                 get :edit, :id => 2
                 assert_response :success
                 assert_template 'edit'
-                assert_no_tag :tag => 'input', :attributes => { :type => 'checkbox',
+                assert_select 'input[name=?]', 'query[visibility]', 0
-                                                                :name => 'query[is_public]' }
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query_is_for_all',
                                                              :checked => nil,
                 get :edit, :id => 1
                 assert_response :success
                 assert_template 'edit'
-                assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
+                assert_select 'input[name=?][value=2][checked=checked]', 'query[visibility]'
-                                                             :name => 'query[is_public]',
-                                                             :checked => 'checked'
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query_is_for_all',
                                                              :checked => nil,
                      :fields => ["status_id", "assigned_to_id"],
                      :operators => {"assigned_to_id" => "=", "status_id" => "o"},
                      :values => { "assigned_to_id" => ["me"], "status_id" => ["1"]},
-                     :query => {"name" => "test_edit_global_private_query", "is_public" => "1"}
+                     :query => {"name" => "test_edit_global_private_query", "visibility" => "2"}
                 assert_redirected_to :controller => 'issues', :action => 'index', :query_id => 3
                 q = Query.find_by_name('test_edit_global_private_query')
                      :fields => ["status_id", "assigned_to_id"],
                      :operators => {"assigned_to_id" => "=", "status_id" => "o"},
                      :values => { "assigned_to_id" => ["1"], "status_id" => ["1"]},
-                     :query => {"name" => "test_edit_global_public_query", "is_public" => "1"}
+                     :query => {"name" => "test_edit_global_public_query", "visibility" => "2"}
                 assert_redirected_to :controller => 'issues', :action => 'index', :query_id => 4
                 q = Query.find_by_name('test_edit_global_public_query')

test/unit/query_test.rb +66 0

@@ -28,6 +28,24 class QueryTest < ActiveSupport::TestCase
28	:projects_trackers,	28	:projects_trackers,
29	:custom_fields_trackers	29	:custom_fields_trackers
30		30
		31	def test_query_with_roles_visibility_should_validate_roles
		32	set_language_if_valid 'en'
		33	query = IssueQuery.new(:name => 'Query', :visibility => IssueQuery::VISIBILITY_ROLES)
		34	assert !query.save
		35	assert_include "Roles can't be blank", query.errors.full_messages
		36	query.role_ids = [1, 2]
		37	assert query.save
		38	end
		39
		40	def test_changing_roles_visibility_should_clear_roles
		41	query = IssueQuery.create!(:name => 'Query', :visibility => IssueQuery::VISIBILITY_ROLES, :role_ids => [1, 2])
		42	assert_equal 2, query.roles.count
		43
		44	query.visibility = IssueQuery::VISIBILITY_PUBLIC
		45	query.save!
		46	assert_equal 0, query.roles.count
		47	end
		48
31	def test_available_filters_should_be_ordered	49	def test_available_filters_should_be_ordered
32	set_language_if_valid 'en'	50	set_language_if_valid 'en'
33	query = IssueQuery.new	51	query = IssueQuery.new
@@ -1089,6 +1107,54 class QueryTest < ActiveSupport::TestCase
1089	assert !query_ids.include?(7), 'public query on private project was visible'	1107	assert !query_ids.include?(7), 'public query on private project was visible'
1090	end	1108	end
1091		1109
		1110	def test_query_with_public_visibility_should_be_visible_to_anyone
		1111	q = IssueQuery.create!(:name => 'Query', :visibility => IssueQuery::VISIBILITY_PUBLIC)
		1112
		1113	assert q.visible?(User.anonymous)
		1114	assert IssueQuery.visible(User.anonymous).find_by_id(q.id)
		1115
		1116	assert q.visible?(User.find(7))
		1117	assert IssueQuery.visible(User.find(7)).find_by_id(q.id)
		1118
		1119	assert q.visible?(User.find(2))
		1120	assert IssueQuery.visible(User.find(2)).find_by_id(q.id)
		1121
		1122	assert q.visible?(User.find(1))
		1123	assert IssueQuery.visible(User.find(1)).find_by_id(q.id)
		1124	end
		1125
		1126	def test_query_with_roles_visibility_should_be_visible_to_user_with_role
		1127	q = IssueQuery.create!(:name => 'Query', :visibility => IssueQuery::VISIBILITY_ROLES, :role_ids => [1,2])
		1128
		1129	assert !q.visible?(User.anonymous)
		1130	assert_nil IssueQuery.visible(User.anonymous).find_by_id(q.id)
		1131
		1132	assert !q.visible?(User.find(7))
		1133	assert_nil IssueQuery.visible(User.find(7)).find_by_id(q.id)
		1134
		1135	assert q.visible?(User.find(2))
		1136	assert IssueQuery.visible(User.find(2)).find_by_id(q.id)
		1137
		1138	assert q.visible?(User.find(1))
		1139	assert IssueQuery.visible(User.find(1)).find_by_id(q.id)
		1140	end
		1141
		1142	def test_query_with_private_visibility_should_be_visible_to_owner
		1143	q = IssueQuery.create!(:name => 'Query', :visibility => IssueQuery::VISIBILITY_PRIVATE, :user => User.find(7))
		1144
		1145	assert !q.visible?(User.anonymous)
		1146	assert_nil IssueQuery.visible(User.anonymous).find_by_id(q.id)
		1147
		1148	assert q.visible?(User.find(7))
		1149	assert IssueQuery.visible(User.find(7)).find_by_id(q.id)
		1150
		1151	assert !q.visible?(User.find(2))
		1152	assert_nil IssueQuery.visible(User.find(2)).find_by_id(q.id)
		1153
		1154	assert q.visible?(User.find(1))
		1155	assert_nil IssueQuery.visible(User.find(1)).find_by_id(q.id)
		1156	end
		1157
1092	test "#available_filters should include users of visible projects in cross-project view" do	1158	test "#available_filters should include users of visible projects in cross-project view" do
1093	users = IssueQuery.new.available_filters["assigned_to_id"]	1159	users = IssueQuery.new.available_filters["assigned_to_id"]
1094	assert_not_nil users	1160	assert_not_nil users

test/unit/user_test.rb +2 -2

               end
               def test_destroy_should_delete_private_queries
-                query = Query.new(:name => 'foo', :is_public => false)
+                query = Query.new(:name => 'foo', :visibility => Query::VISIBILITY_PRIVATE)
                 query.project_id = 1
                 query.user_id = 2
                 query.save!
               end
               def test_destroy_should_update_public_queries
-                query = Query.new(:name => 'foo', :is_public => true)
+                query = Query.new(:name => 'foo', :visibility => Query::VISIBILITY_PUBLIC)
                 query.project_id = 1
                 query.user_id = 2
                 query.save!

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