jro_apps/redmine Commit - r10303:1b6da80e16dd

Makes related issues available for display and filtering on the issue list (#3239, #3265)....

Jean-Philippe Lang -

r10303:1b6da80e16dd

parent child

Context file:

r10303:1b6da80e16dd

Collapse all files

app/helpers/application_helper.rb +3 -1

               #   link_to_issue(issue, :truncate => 6)        # => Defect #6: This i...
               #   link_to_issue(issue, :subject => false)     # => Defect #6
               #   link_to_issue(issue, :project => true)      # => Foo - Defect #6
+              #   link_to_issue(issue, :subject => false, :tracker => false)     # => #6
               #
               def link_to_issue(issue, options={})
                 title = nil
                 subject = nil
+                text = options[:tracker] == false ? "##{issue.id}" : "#{issue.tracker} ##{issue.id}"
                 if options[:subject] == false
                   title = truncate(issue.subject, :length => 60)
                 else
                     subject = truncate(subject, :length => options[:truncate])
                   end
                 end
-                s = link_to "#{h(issue.tracker)} ##{issue.id}", {:controller => "issues", :action => "show", :id => issue},
+                s = link_to text, {:controller => "issues", :action => "show", :id => issue},
                                                              :class => issue.css_classes,
                                                              :title => title
                 s << h(": #{subject}") if subject

app/helpers/queries_helper.rb +6 -1

               def column_content(column, issue)
                 value = column.value(issue)
                 if value.is_a?(Array)
-                  value.collect {|v| column_value(column, issue, v)}.compact.sort.join(', ').html_safe
+                  value.collect {|v| column_value(column, issue, v)}.compact.join(', ').html_safe
                 else
                   column_value(column, issue, value)
                 end
                   l(:general_text_No)
                 when 'Issue'
                   link_to_issue(value, :subject => false)
+                when 'IssueRelation'
+                  other = value.other_issue(issue)
+                  content_tag('span',
+                    (l(value.label_for(issue)) + " " + link_to_issue(other, :subject => false, :tracker => false)).html_safe,
+                    :class => value.css_classes_for(issue))
                 else
                   h(value)
                 end

app/models/issue.rb +20 -1

@@ -752,7 +752,7 class Issue < ActiveRecord::Base
752	end	752	end
753		753
754	def relations	754	def relations
755	@relations \|\|= (relations_from + relations_to).sort	755	@relations \|\|= IssueRelations.new(self, (relations_from + relations_to).sort)
756	end	756	end
757		757
758	# Preloads relations for a collection of issues	758	# Preloads relations for a collection of issues
@@ -775,6 +775,25 class Issue < ActiveRecord::Base
775	end	775	end
776	end	776	end
777		777
		778	# Preloads visible relations for a collection of issues
		779	def self.load_visible_relations(issues, user=User.current)
		780	if issues.any?
		781	issue_ids = issues.map(&:id)
		782	# Relations with issue_from in given issues and visible issue_to
		783	relations_from = IssueRelation.includes(:issue_to => [:status, :project]).where(visible_condition(user)).where(:issue_from_id => issue_ids).all
		784	# Relations with issue_to in given issues and visible issue_from
		785	relations_to = IssueRelation.includes(:issue_from => [:status, :project]).where(visible_condition(user)).where(:issue_to_id => issue_ids).all
		786
		787	issues.each do \|issue\|
		788	relations =
		789	relations_from.select {\|relation\| relation.issue_from_id == issue.id} +
		790	relations_to.select {\|relation\| relation.issue_to_id == issue.id}
		791
		792	issue.instance_variable_set "@relations", IssueRelations.new(issue, relations.sort)
		793	end
		794	end
		795	end
		796
778	# Finds an issue relation given its id.	797	# Finds an issue relation given its id.
779	def find_relation(relation_id)	798	def find_relation(relation_id)
780	IssueRelation.find(relation_id, :conditions => ["issue_to_id = ? OR issue_from_id = ?", id, id])	799	IssueRelation.find(relation_id, :conditions => ["issue_to_id = ? OR issue_from_id = ?", id, id])

app/models/issue_relation.rb +20 -1

             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+            # Class used to represent the relations of an issue
+            class IssueRelations < Array
+              include Redmine::I18n
+              def initialize(issue, *args)
+                @issue = issue
+                super(*args)
+              end
+              def to_s(*args)
+                map {|relation| "#{l(relation.label_for(@issue))} ##{relation.other_issue(@issue).id}"}.join(', ')
+              end
+            end
             class IssueRelation < ActiveRecord::Base
               belongs_to :issue_from, :class_name => 'Issue', :foreign_key => 'issue_from_id'
               belongs_to :issue_to, :class_name => 'Issue', :foreign_key => 'issue_to_id'
                 TYPES[relation_type] ? TYPES[relation_type][(self.issue_from_id == issue.id) ? :name : :sym_name] : :unknow
               end
+              def css_classes_for(issue)
+                "rel-#{relation_type_for(issue)}"
+              end
               def handle_issue_order
                 reverse_if_needed
               end
               def <=>(relation)
-                TYPES[self.relation_type][:order] <=> TYPES[relation.relation_type][:order]
+                r = TYPES[self.relation_type][:order] <=> TYPES[relation.relation_type][:order]
+                r == 0 ? id <=> relation.id : r
               end
               private

app/models/query.rb +65 -8

                               "<t-" => :label_more_than_ago,
                               "t-"  => :label_ago,
                               "~"   => :label_contains,
-                              "!~"  => :label_not_contains }
+                              "!~"  => :label_not_contains,
+                              "=p"  => :label_any_issues_in_project,
+                              "=!p" => :label_any_issues_not_in_project}
               cattr_reader :operators
                                              :string => [ "=", "~", "!", "!~", "!*", "*" ],
                                              :text => [  "~", "!~", "!*", "*" ],
                                              :integer => [ "=", ">=", "<=", "><", "!*", "*" ],
-                                             :float => [ "=", ">=", "<=", "><", "!*", "*" ] }
+                                             :float => [ "=", ">=", "<=", "><", "!*", "*" ],
+                                             :relation => ["=", "=p", "=!p", "!*", "*"]}
               cattr_reader :operators_by_filter_type
                 QueryColumn.new(:estimated_hours, :sortable => "#{Issue.table_name}.estimated_hours"),
                 QueryColumn.new(:done_ratio, :sortable => "#{Issue.table_name}.done_ratio", :groupable => true),
                 QueryColumn.new(:created_on, :sortable => "#{Issue.table_name}.created_on", :default_order => 'desc'),
+                QueryColumn.new(:relations, :caption => :label_related_issues)
               ]
               cattr_reader :available_columns
                                        "estimated_hours" => { :type => :float, :order => 13 },
                                        "done_ratio" =>  { :type => :integer, :order => 14 }}
+                IssueRelation::TYPES.each do |relation_type, options|
+                  @available_filters[relation_type] = {:type => :relation, :order => @available_filters.size + 100, :label => options[:name]}
+                end
                 principals = []
                 if project
                   principals += project.principals.sort
                     end
                   end
                 else
-                  all_projects = Project.visible.all
                   if all_projects.any?
                     # members of visible projects
                     principals += Principal.member_of(all_projects)
                     if User.current.logged? && User.current.memberships.any?
                       project_values << ["<< #{l(:label_my_projects).downcase} >>", "mine"]
                     end
-                    Project.project_tree(all_projects) do |p, level|
+                    project_values += all_projects_values
-                      prefix = (level > 0 ? ('--' * level + ' ') : '')
-                      project_values << ["#{prefix}#{p.name}", p.id.to_s]
-                    end
                     @available_filters["project_id"] = { :type => :list, :order => 1, :values => project_values} unless project_values.empty?
                   end
                 end
                 }
                 @available_filters.each do |field, options|
-                  options[:name] ||= l("field_#{field}".gsub(/_id$/, ''))
+                  options[:name] ||= l(options[:label] || "field_#{field}".gsub(/_id$/, ''))
                 end
                 @available_filters
                 json
               end
+              def all_projects
+                @all_projects ||= Project.visible.all
+              end
+              def all_projects_values
+                return @all_projects_values if @all_projects_values
+                values = []
+                Project.project_tree(all_projects) do |p, level|
+                  prefix = (level > 0 ? ('--' * level + ' ') : '')
+                  values << ["#{prefix}#{p.name}", p.id.to_s]
+                end
+                @all_projects_values = values
+              end
               def add_filter(field, operator, values)
                 # values must be an array
                 return unless values.nil? || values.is_a?(Array)
                 if has_column?(:spent_hours)
                   Issue.load_visible_spent_hours(issues)
                 end
+                if has_column?(:relations)
+                  Issue.load_visible_relations(issues)
+                end
                 issues
               rescue ::ActiveRecord::StatementInvalid => e
                 raise StatementInvalid.new(e.message)
                 "#{Issue.table_name}.is_private #{op} (#{va})"
               end
+              def sql_for_relations(field, operator, value, options={})
+                relation_options = IssueRelation::TYPES[field]
+                return relation_options unless relation_options
+                relation_type = field
+                join_column, target_join_column = "issue_from_id", "issue_to_id"
+                if relation_options[:reverse] || options[:reverse]
+                  relation_type = relation_options[:reverse] || relation_type
+                  join_column, target_join_column = target_join_column, join_column
+                end
+                sql = case operator
+                  when "*", "!*"
+                    op = (operator == "*" ? 'IN' : 'NOT IN')
+                    "#{Issue.table_name}.id #{op} (SELECT DISTINCT #{IssueRelation.table_name}.#{join_column} FROM #{IssueRelation.table_name} WHERE #{IssueRelation.table_name}.relation_type = '#{connection.quote_string(relation_type)}')"
+                  when "=", "!"
+                    op = (operator == "=" ? 'IN' : 'NOT IN')
+                    "#{Issue.table_name}.id #{op} (SELECT DISTINCT #{IssueRelation.table_name}.#{join_column} FROM #{IssueRelation.table_name} WHERE #{IssueRelation.table_name}.relation_type = '#{connection.quote_string(relation_type)}' AND #{IssueRelation.table_name}.#{target_join_column} = #{value.first.to_i})"
+                  when "=p", "=!p"
+                    op = (operator == "=p" ? '=' : '<>')
+                    "#{Issue.table_name}.id IN (SELECT DISTINCT #{IssueRelation.table_name}.#{join_column} FROM #{IssueRelation.table_name}, #{Issue.table_name} relissues WHERE #{IssueRelation.table_name}.relation_type = '#{connection.quote_string(relation_type)}' AND #{IssueRelation.table_name}.#{target_join_column} = relissues.id AND relissues.project_id #{op} #{value.first.to_i})"
+                  end
+                if relation_options[:sym] == field && !options[:reverse]
+                  sqls = [sql, sql_for_relations(field, operator, value, :reverse => true)]
+                  sqls.join(["!", "!*"].include?(operator) ? " AND " : " OR ")
+                else
+                  sql
+                end
+              end
+              IssueRelation::TYPES.keys.each do |relation_type|
+                alias_method "sql_for_#{relation_type}_field".to_sym, :sql_for_relations
+              end
               private
               def sql_for_custom_field(field, operator, value, custom_field_id)

app/views/queries/_filters.html.erb +1 0

             var operatorByType = <%= raw_json Query.operators_by_filter_type %>;
             var availableFilters = <%= raw_json query.available_filters_as_json %>;
             var labelDayPlural = <%= raw_json l(:label_day_plural) %>;
+            var allProjects = <%= raw query.all_projects_values.to_json %>;
             $(document).ready(function(){
               initFilters();
               <% query.filters.each do |field, options| %>

config/locales/en.yml +11 -9

               label_ago: days ago
               label_contains: contains
               label_not_contains: doesn't contain
+              label_any_issues_in_project: any issues in project
+              label_any_issues_not_in_project: any issues not in project
               label_day_plural: days
               label_repository: Repository
               label_repository_new: New repository
               label_loading: Loading...
               label_relation_new: New relation
               label_relation_delete: Delete relation
-              label_relates_to: related to
+              label_relates_to: Related to
-              label_duplicates: duplicates
+              label_duplicates: Duplicates
-              label_duplicated_by: duplicated by
+              label_duplicated_by: Duplicated by
-              label_blocks: blocks
+              label_blocks: Blocks
-              label_blocked_by: blocked by
+              label_blocked_by: Blocked by
-              label_precedes: precedes
+              label_precedes: Precedes
-              label_follows: follows
+              label_follows: Follows
-              label_copied_to: copied to
+              label_copied_to: Copied to
-              label_copied_from: copied from
+              label_copied_from: Copied from
               label_end_to_start: end to start
               label_end_to_end: end to end
               label_start_to_start: start to start

config/locales/fr.yml +11 -9

               label_ago: il y a
               label_contains: contient
               label_not_contains: ne contient pas
+              label_any_issues_in_project: une demande du projet
+              label_any_issues_not_in_project: une demande hors du projet
               label_day_plural: jours
               label_repository: Dépôt
               label_repository_new: Nouveau dépôt
               label_loading: Chargement...
               label_relation_new: Nouvelle relation
               label_relation_delete: Supprimer la relation
-              label_relates_to: lié à
+              label_relates_to: Lié à
-              label_duplicates: duplique
+              label_duplicates: Duplique
-              label_duplicated_by: dupliqué par
+              label_duplicated_by: Dupliqué par
-              label_blocks: bloque
+              label_blocks: Bloque
-              label_blocked_by: bloqué par
+              label_blocked_by: Bloqué par
-              label_precedes: précède
+              label_precedes: Précède
-              label_follows: suit
+              label_follows: Suit
-              label_copied_to: copié vers
+              label_copied_to: Copié vers
-              label_copied_from: copié depuis
+              label_copied_from: Copié depuis
               label_end_to_start: fin à début
               label_end_to_end: fin à fin
               label_start_to_start: début à début

public/javascripts/application.js +18 0

@@ -178,6 +178,20 function buildFilterRow(field, operator, values) {
178	);	178	);
179	$('#values_'+fieldId).val(values[0]);	179	$('#values_'+fieldId).val(values[0]);
180	break;	180	break;
		181	case "relation":
		182	tr.find('td.values').append(
		183	'<span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'" size="6" class="value" /></span>' +
		184	'<span style="display:none;"><select class="value" name="v['+field+'][]" id="values_'+fieldId+'_1"></select></span>'
		185	);
		186	$('#values_'+fieldId).val(values[0]);
		187	select = tr.find('td.values select');
		188	for (i=0;i<allProjects.length;i++){
		189	var filterValue = allProjects[i];
		190	var option = $('<option>');
		191	option.val(filterValue[1]).text(filterValue[0]);
		192	if (values[0] == filterValue[1]) {option.attr('selected', true)};
		193	select.append(option);
		194	}
181	case "integer":	195	case "integer":
182	case "float":	196	case "float":
183	tr.find('td.values').append(	197	tr.find('td.values').append(
@@ -244,6 +258,10 function toggleOperator(field) {
244	case "t-":	258	case "t-":
245	enableValues(field, [2]);	259	enableValues(field, [2]);
246	break;	260	break;
		261	case "=p":
		262	case "=!p":
		263	enableValues(field, [1]);
		264	break;
247	default:	265	default:
248	enableValues(field, [0]);	266	enableValues(field, [0]);
249	break;	267	break;

public/stylesheets/application.css +8 -5

             /***** Tables *****/
             table.list { border: 1px solid #e4e4e4;  border-collapse: collapse; width: 100%; margin-bottom: 4px; }
             table.list th {  background-color:#EEEEEE; padding: 4px; white-space:nowrap; }
-            table.list td { vertical-align: top; }
+            table.list td { vertical-align: top; padding-right:10px; }
             table.list td.id { width: 2%; text-align: center;}
             table.list td.checkbox { width: 15px; padding: 2px 0 0 0; }
             table.list td.checkbox input {padding:0px;}
             tr.project.idnt-9 td.name {padding-left: 12.5em;}
             tr.issue { text-align: center; white-space: nowrap; }
-            tr.issue td.subject, tr.issue td.category, td.assigned_to, tr.issue td.string, tr.issue td.text { white-space: normal; }
+            tr.issue td.subject, tr.issue td.category, td.assigned_to, tr.issue td.string, tr.issue td.text, tr.issue td.relations { white-space: normal; }
-            tr.issue td.subject { text-align: left; }
+            tr.issue td.subject, tr.issue td.relations { text-align: left; }
             tr.issue td.done_ratio table.progress { margin-left:auto; margin-right: auto;}
+            tr.issue td.relations span {white-space: nowrap;}
             tr.issue.idnt td.subject a {background: url(../images/bullet_arrow_right.png) no-repeat 0 50%; padding-left: 16px;}
             tr.issue.idnt-1 td.subject {padding-left: 0.5em;}
             fieldset#filters table { border-collapse: collapse; }
             fieldset#filters table td { padding: 0; vertical-align: middle; }
             fieldset#filters tr.filter { height: 2.1em; }
-            fieldset#filters td.field { width:250px; }
+            fieldset#filters td.field { width:230px; }
-            fieldset#filters td.operator { width:170px; }
+            fieldset#filters td.operator { width:180px; }
+            fieldset#filters td.operator select {max-width:170px;}
             fieldset#filters td.values { white-space:nowrap; }
             fieldset#filters td.values select {min-width:130px;}
             fieldset#filters td.values input {height:1em;}
             fieldset#filters td.add-filter { text-align: right; vertical-align: top; }
             .toggle-multiselect {background: url(../images/bullet_toggle_plus.png) no-repeat 0% 40%; padding-left:8px; margin-left:0; cursor:pointer;}
             .buttons { font-size: 0.9em; margin-bottom: 1.4em; margin-top: 1em; }

test/functional/issues_controller_test.rb +38 -2

@@ -766,7 +766,7 class IssuesControllerTest < ActionController::TestCase
766	end	766	end
767	end	767	end
768		768
769	def test_index_with_done_ratio	769	def test_index_with_done_ratio_column
770	Issue.find(1).update_attribute :done_ratio, 40	770	Issue.find(1).update_attribute :done_ratio, 40
771		771
772	get :index, :set_filter => 1, :c => %w(done_ratio)	772	get :index, :set_filter => 1, :c => %w(done_ratio)
@@ -792,12 +792,48 class IssuesControllerTest < ActionController::TestCase
792	assert_no_tag 'td', :attributes => {:class => /spent_hours/}	792	assert_no_tag 'td', :attributes => {:class => /spent_hours/}
793	end	793	end
794		794
795	def test_index_with_fixed_version	795	def test_index_with_fixed_version_column
796	get :index, :set_filter => 1, :c => %w(fixed_version)	796	get :index, :set_filter => 1, :c => %w(fixed_version)
797	assert_tag 'td', :attributes => {:class => /fixed_version/},	797	assert_tag 'td', :attributes => {:class => /fixed_version/},
798	:child => {:tag => 'a', :content => '1.0', :attributes => {:href => '/versions/2'}}	798	:child => {:tag => 'a', :content => '1.0', :attributes => {:href => '/versions/2'}}
799	end	799	end
800		800
		801	def test_index_with_relations_column
		802	IssueRelation.delete_all
		803	IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Issue.find(7))
		804	IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(8), :issue_to => Issue.find(1))
		805	IssueRelation.create!(:relation_type => "blocks", :issue_from => Issue.find(1), :issue_to => Issue.find(11))
		806	IssueRelation.create!(:relation_type => "blocks", :issue_from => Issue.find(12), :issue_to => Issue.find(2))
		807
		808	get :index, :set_filter => 1, :c => %w(subject relations)
		809	assert_response :success
		810	assert_select "tr#issue-1 td.relations" do
		811	assert_select "span", 3
		812	assert_select "span", :text => "Related to #7"
		813	assert_select "span", :text => "Related to #8"
		814	assert_select "span", :text => "Blocks #11"
		815	end
		816	assert_select "tr#issue-2 td.relations" do
		817	assert_select "span", 1
		818	assert_select "span", :text => "Blocked by #12"
		819	end
		820	assert_select "tr#issue-3 td.relations" do
		821	assert_select "span", 0
		822	end
		823
		824	get :index, :set_filter => 1, :c => %w(relations), :format => 'csv'
		825	assert_response :success
		826	assert_equal 'text/csv; header=present', response.content_type
		827	lines = response.body.chomp.split("\n")
		828	assert_include '1,"Related to #7, Related to #8, Blocks #11"', lines
		829	assert_include '2,Blocked by #12', lines
		830	assert_include '3,""', lines
		831
		832	get :index, :set_filter => 1, :c => %w(subject relations), :format => 'pdf'
		833	assert_response :success
		834	assert_equal 'application/pdf', response.content_type
		835	end
		836
801	def test_index_send_html_if_query_is_invalid	837	def test_index_send_html_if_query_is_invalid
802	get :index, :f => ['start_date'], :op => {:start_date => '='}	838	get :index, :f => ['start_date'], :op => {:start_date => '='}
803	assert_equal 'text/html', @response.content_type	839	assert_equal 'text/html', @response.content_type

test/unit/query_test.rb +70 0

@@ -624,6 +624,76 class QueryTest < ActiveSupport::TestCase
624	assert_equal [2], find_issues_with_query(query).map(&:fixed_version_id).uniq.sort	624	assert_equal [2], find_issues_with_query(query).map(&:fixed_version_id).uniq.sort
625	end	625	end
626		626
		627	def test_filter_on_relations_with_a_specific_issue
		628	IssueRelation.delete_all
		629	IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Issue.find(2))
		630	IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(3), :issue_to => Issue.find(1))
		631
		632	query = Query.new(:name => '_')
		633	query.filters = {"relates" => {:operator => '=', :values => ['1']}}
		634	assert_equal [2, 3], find_issues_with_query(query).map(&:id).sort
		635
		636	query = Query.new(:name => '_')
		637	query.filters = {"relates" => {:operator => '=', :values => ['2']}}
		638	assert_equal [1], find_issues_with_query(query).map(&:id).sort
		639	end
		640
		641	def test_filter_on_relations_with_any_issues_in_a_project
		642	IssueRelation.delete_all
		643	with_settings :cross_project_issue_relations => '1' do
		644	IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(2).issues.first)
		645	IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(2), :issue_to => Project.find(2).issues.first)
		646	IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(3).issues.first)
		647	end
		648
		649	query = Query.new(:name => '_')
		650	query.filters = {"relates" => {:operator => '=p', :values => ['2']}}
		651	assert_equal [1, 2], find_issues_with_query(query).map(&:id).sort
		652
		653	query = Query.new(:name => '_')
		654	query.filters = {"relates" => {:operator => '=p', :values => ['3']}}
		655	assert_equal [1], find_issues_with_query(query).map(&:id).sort
		656
		657	query = Query.new(:name => '_')
		658	query.filters = {"relates" => {:operator => '=p', :values => ['4']}}
		659	assert_equal [], find_issues_with_query(query).map(&:id).sort
		660	end
		661
		662	def test_filter_on_relations_with_any_issues_not_in_a_project
		663	IssueRelation.delete_all
		664	with_settings :cross_project_issue_relations => '1' do
		665	IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(2).issues.first)
		666	#IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(2), :issue_to => Project.find(1).issues.first)
		667	IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(3).issues.first)
		668	end
		669
		670	query = Query.new(:name => '_')
		671	query.filters = {"relates" => {:operator => '=!p', :values => ['1']}}
		672	assert_equal [1], find_issues_with_query(query).map(&:id).sort
		673	end
		674
		675	def test_filter_on_relations_with_no_issues
		676	IssueRelation.delete_all
		677	IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Issue.find(2))
		678	IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(3), :issue_to => Issue.find(1))
		679
		680	query = Query.new(:name => '_')
		681	query.filters = {"relates" => {:operator => '!*', :values => ['']}}
		682	ids = find_issues_with_query(query).map(&:id)
		683	assert_equal [], ids & [1, 2, 3]
		684	assert_include 4, ids
		685	end
		686
		687	def test_filter_on_relations_with_any_issue
		688	IssueRelation.delete_all
		689	IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Issue.find(2))
		690	IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(3), :issue_to => Issue.find(1))
		691
		692	query = Query.new(:name => '_')
		693	query.filters = {"relates" => {:operator => '*', :values => ['']}}
		694	assert_equal [1, 2, 3], find_issues_with_query(query).map(&:id)
		695	end
		696
627	def test_statement_should_be_nil_with_no_filters	697	def test_statement_should_be_nil_with_no_filters
628	q = Query.new(:name => '_')	698	q = Query.new(:name => '_')
629	q.filters = {}	699	q.filters = {}

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