Read about our upcoming Code of Conduct on this issue

This instance will be upgraded to Heptapod 0.28.1 on 2022-01-26 at 16:00 UTC+1 (a few minutes of down time)

issues_finder_spec.rb 25.4 KB
Newer Older
1
2
require 'spec_helper'

3
describe IssuesFinder do
4
  include_context 'IssuesFinder context'
5

Sean McGivern's avatar
Sean McGivern committed
6
  describe '#execute' do
7
    include_context 'IssuesFinder#execute context'
8

9
    context 'scope: all' do
Sean McGivern's avatar
Sean McGivern committed
10
      let(:scope) { 'all' }
11

Sean McGivern's avatar
Sean McGivern committed
12
      it 'returns all issues' do
13
        expect(issues).to contain_exactly(issue1, issue2, issue3, issue4)
14
      end
15

16
17
      context 'assignee filtering' do
        let(:issuables) { issues }
Sean McGivern's avatar
Sean McGivern committed
18

19
20
21
        it_behaves_like 'assignee ID filter' do
          let(:params) { { assignee_id: user.id } }
          let(:expected_issuables) { [issue1, issue2] }
Sean McGivern's avatar
Sean McGivern committed
22
        end
23

24
25
26
27
28
        it_behaves_like 'assignee username filter' do
          before do
            project2.add_developer(user3)
            issue3.assignees = [user2, user3]
          end
29

30
31
32
          set(:user3) { create(:user) }
          let(:params) { { assignee_username: [user2.username, user3.username] } }
          let(:expected_issuables) { [issue3] }
33
34
        end

35
36
37
        it_behaves_like 'no assignee filter' do
          set(:user3) { create(:user) }
          let(:expected_issuables) { [issue4] }
Heinrich Lee Yu's avatar
Heinrich Lee Yu committed
38
        end
39

40
41
        it_behaves_like 'any assignee filter' do
          let(:expected_issuables) { [issue1, issue2, issue3] }
Heinrich Lee Yu's avatar
Heinrich Lee Yu committed
42
        end
43
44
      end

45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
      context 'filtering by group_id' do
        let(:params) { { group_id: group.id } }

        context 'when include_subgroup param not set' do
          it 'returns all group issues' do
            expect(issues).to contain_exactly(issue1)
          end
        end

        context 'when include_subgroup param is true', :nested_groups do
          before do
            params[:include_subgroups] = true
          end

          it 'returns all group and subgroup issues' do
            expect(issues).to contain_exactly(issue1, issue4)
          end
        end
      end

Sean McGivern's avatar
Sean McGivern committed
65
66
67
68
69
70
      context 'filtering by author ID' do
        let(:params) { { author_id: user2.id } }

        it 'returns issues created by that user' do
          expect(issues).to contain_exactly(issue3)
        end
71
72
      end

Sean McGivern's avatar
Sean McGivern committed
73
74
75
76
77
78
      context 'filtering by milestone' do
        let(:params) { { milestone_title: milestone.title } }

        it 'returns issues assigned to that milestone' do
          expect(issues).to contain_exactly(issue1)
        end
79
80
      end

Felipe Artur's avatar
Felipe Artur committed
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
      context 'filtering by group milestone' do
        let!(:group) { create(:group, :public) }
        let(:group_milestone) { create(:milestone, group: group) }
        let!(:group_member) { create(:group_member, group: group, user: user) }
        let(:params) { { milestone_title: group_milestone.title } }

        before do
          project2.update(namespace: group)
          issue2.update(milestone: group_milestone)
          issue3.update(milestone: group_milestone)
        end

        it 'returns issues assigned to that group milestone' do
          expect(issues).to contain_exactly(issue2, issue3)
        end
      end

Sean McGivern's avatar
Sean McGivern committed
98
      context 'filtering by no milestone' do
99
        let(:params) { { milestone_title: 'None' } }
Sean McGivern's avatar
Sean McGivern committed
100
101

        it 'returns issues with no milestone' do
102
          expect(issues).to contain_exactly(issue2, issue3, issue4)
Sean McGivern's avatar
Sean McGivern committed
103
        end
104
105
106
107
108
109

        it 'returns issues with no milestone (deprecated)' do
          params[:milestone_title] = Milestone::None.title

          expect(issues).to contain_exactly(issue2, issue3, issue4)
        end
110
111
      end

112
      context 'filtering by any milestone' do
113
        let(:params) { { milestone_title: 'Any' } }
114
115
116
117

        it 'returns issues with any assigned milestone' do
          expect(issues).to contain_exactly(issue1)
        end
118
119
120
121
122
123

        it 'returns issues with any assigned milestone (deprecated)' do
          params[:milestone_title] = Milestone::Any.title

          expect(issues).to contain_exactly(issue1)
        end
124
125
      end

126
127
128
      context 'filtering by upcoming milestone' do
        let(:params) { { milestone_title: Milestone::Upcoming.name } }

129
130
131
        let!(:group) { create(:group, :public) }
        let!(:group_member) { create(:group_member, group: group, user: user) }

132
133
134
        let(:project_no_upcoming_milestones) { create(:project, :public) }
        let(:project_next_1_1) { create(:project, :public) }
        let(:project_next_8_8) { create(:project, :public) }
135
        let(:project_in_group) { create(:project, :public, namespace: group) }
136
137
138
139
140
141
142
143
144
145

        let(:yesterday) { Date.today - 1.day }
        let(:tomorrow) { Date.today + 1.day }
        let(:two_days_from_now) { Date.today + 2.days }
        let(:ten_days_from_now) { Date.today + 10.days }

        let(:milestones) do
          [
            create(:milestone, :closed, project: project_no_upcoming_milestones),
            create(:milestone, project: project_next_1_1, title: '1.1', due_date: two_days_from_now),
146
147
148
149
            create(:milestone, project: project_next_1_1, title: '8.9', due_date: ten_days_from_now),
            create(:milestone, project: project_next_8_8, title: '1.2', due_date: yesterday),
            create(:milestone, project: project_next_8_8, title: '8.8', due_date: tomorrow),
            create(:milestone, group: group, title: '9.9', due_date: tomorrow)
150
151
152
153
154
          ]
        end

        before do
          milestones.each do |milestone|
155
            create(:issue, project: milestone.project || project_in_group, milestone: milestone, author: user, assignees: [user])
156
157
158
          end
        end

159
160
161
        it 'returns issues in the upcoming milestone for each project or group' do
          expect(issues.map { |issue| issue.milestone.title }).to contain_exactly('1.1', '8.8', '9.9')
          expect(issues.map { |issue| issue.milestone.due_date }).to contain_exactly(tomorrow, two_days_from_now, tomorrow)
162
163
164
        end
      end

165
166
167
      context 'filtering by started milestone' do
        let(:params) { { milestone_title: Milestone::Started.name } }

168
169
170
        let(:project_no_started_milestones) { create(:project, :public) }
        let(:project_started_1_and_2) { create(:project, :public) }
        let(:project_started_8) { create(:project, :public) }
171
172
173
174

        let(:yesterday) { Date.today - 1.day }
        let(:tomorrow) { Date.today + 1.day }
        let(:two_days_ago) { Date.today - 2.days }
175
        let(:three_days_ago) { Date.today - 3.days }
176
177
178
179
180
181
182

        let(:milestones) do
          [
            create(:milestone, project: project_no_started_milestones, start_date: tomorrow),
            create(:milestone, project: project_started_1_and_2, title: '1.0', start_date: two_days_ago),
            create(:milestone, project: project_started_1_and_2, title: '2.0', start_date: yesterday),
            create(:milestone, project: project_started_1_and_2, title: '3.0', start_date: tomorrow),
183
184
            create(:milestone, :closed, project: project_started_1_and_2, title: '4.0', start_date: three_days_ago),
            create(:milestone, :closed, project: project_started_8, title: '6.0', start_date: three_days_ago),
185
186
187
188
189
190
191
192
            create(:milestone, project: project_started_8, title: '7.0'),
            create(:milestone, project: project_started_8, title: '8.0', start_date: yesterday),
            create(:milestone, project: project_started_8, title: '9.0', start_date: tomorrow)
          ]
        end

        before do
          milestones.each do |milestone|
193
            create(:issue, project: milestone.project, milestone: milestone, author: user, assignees: [user])
194
195
196
197
198
199
200
201
202
          end
        end

        it 'returns issues in the started milestones for each project' do
          expect(issues.map { |issue| issue.milestone.title }).to contain_exactly('1.0', '2.0', '8.0')
          expect(issues.map { |issue| issue.milestone.start_date }).to contain_exactly(two_days_ago, yesterday, yesterday)
        end
      end

Sean McGivern's avatar
Sean McGivern committed
203
204
      context 'filtering by label' do
        let(:params) { { label_name: label.title } }
205

Sean McGivern's avatar
Sean McGivern committed
206
207
208
209
        it 'returns issues with that label' do
          expect(issues).to contain_exactly(issue2)
        end
      end
210

Sean McGivern's avatar
Sean McGivern committed
211
212
213
      context 'filtering by multiple labels' do
        let(:params) { { label_name: [label.title, label2.title].join(',') } }
        let(:label2) { create(:label, project: project2) }
214

215
216
217
        before do
          create(:label_link, label: label2, target: issue2)
        end
218

219
220
221
222
223
224
225
226
227
228
229
230
231
        it 'returns the unique issues with all those labels' do
          expect(issues).to contain_exactly(issue2)
        end
      end

      context 'filtering by a label that includes any or none in the title' do
        let(:params) { { label_name: [label.title, label2.title].join(',') } }
        let(:label) { create(:label, title: 'any foo', project: project2) }
        let(:label2) { create(:label, title: 'bar none', project: project2) }

        it 'returns the unique issues with all those labels' do
          create(:label_link, label: label2, target: issue2)

Sean McGivern's avatar
Sean McGivern committed
232
233
          expect(issues).to contain_exactly(issue2)
        end
234
235
      end

Sean McGivern's avatar
Sean McGivern committed
236
      context 'filtering by no label' do
237
        let(:params) { { label_name: described_class::FILTER_NONE } }
Sean McGivern's avatar
Sean McGivern committed
238
239

        it 'returns issues with no labels' do
240
          expect(issues).to contain_exactly(issue1, issue3, issue4)
Sean McGivern's avatar
Sean McGivern committed
241
        end
242
243
      end

244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
      context 'filtering by legacy No+Label' do
        let(:params) { { label_name: Label::NONE } }

        it 'returns issues with no labels' do
          expect(issues).to contain_exactly(issue1, issue3, issue4)
        end
      end

      context 'filtering by any label' do
        let(:params) { { label_name: described_class::FILTER_ANY } }

        it 'returns issues that have one or more label' do
          2.times do
            create(:label_link, label: create(:label, project: project2), target: issue3)
          end

          expect(issues).to contain_exactly(issue2, issue3)
        end
      end

barthc's avatar
barthc committed
264
265
266
267
268
269
270
271
      context 'filtering by issue term' do
        let(:params) { { search: 'git' } }

        it 'returns issues with title and description match for search term' do
          expect(issues).to contain_exactly(issue1, issue2)
        end
      end

272
273
274
275
276
277
278
279
      context 'filtering by issue term in title' do
        let(:params) { { search: 'git', in: 'title' } }

        it 'returns issues with title match for search term' do
          expect(issues).to contain_exactly(issue1)
        end
      end

mhasbini's avatar
mhasbini committed
280
281
      context 'filtering by issues iids' do
        let(:params) { { iids: issue3.iid } }
barthc's avatar
barthc committed
282

mhasbini's avatar
mhasbini committed
283
        it 'returns issues with iids match' do
barthc's avatar
barthc committed
284
285
286
287
          expect(issues).to contain_exactly(issue3)
        end
      end

288
289
290
291
292
      context 'filtering by state' do
        context 'with opened' do
          let(:params) { { state: 'opened' } }

          it 'returns only opened issues' do
293
            expect(issues).to contain_exactly(issue1, issue2, issue3, issue4)
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
          end
        end

        context 'with closed' do
          let(:params) { { state: 'closed' } }

          it 'returns only closed issues' do
            expect(issues).to contain_exactly(closed_issue)
          end
        end

        context 'with all' do
          let(:params) { { state: 'all' } }

          it 'returns all issues' do
309
            expect(issues).to contain_exactly(issue1, issue2, issue3, closed_issue, issue4)
310
311
312
313
314
315
316
          end
        end

        context 'with invalid state' do
          let(:params) { { state: 'invalid_state' } }

          it 'returns all issues' do
317
            expect(issues).to contain_exactly(issue1, issue2, issue3, closed_issue, issue4)
318
319
320
321
          end
        end
      end

322
323
324
325
326
327
328
329
330
331
      context 'filtering by created_at' do
        context 'through created_after' do
          let(:params) { { created_after: issue3.created_at } }

          it 'returns issues created on or after the given date' do
            expect(issues).to contain_exactly(issue3)
          end
        end

        context 'through created_before' do
332
          let(:params) { { created_before: issue1.created_at } }
333
334
335
336
337

          it 'returns issues created on or before the given date' do
            expect(issues).to contain_exactly(issue1)
          end
        end
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371

        context 'through created_after and created_before' do
          let(:params) { { created_after: issue2.created_at, created_before: issue3.created_at } }

          it 'returns issues created between the given dates' do
            expect(issues).to contain_exactly(issue2, issue3)
          end
        end
      end

      context 'filtering by updated_at' do
        context 'through updated_after' do
          let(:params) { { updated_after: issue3.updated_at } }

          it 'returns issues updated on or after the given date' do
            expect(issues).to contain_exactly(issue3)
          end
        end

        context 'through updated_before' do
          let(:params) { { updated_before: issue1.updated_at } }

          it 'returns issues updated on or before the given date' do
            expect(issues).to contain_exactly(issue1)
          end
        end

        context 'through updated_after and updated_before' do
          let(:params) { { updated_after: issue2.updated_at, updated_before: issue3.updated_at } }

          it 'returns issues updated between the given dates' do
            expect(issues).to contain_exactly(issue2, issue3)
          end
        end
372
373
      end

374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
      context 'filtering by closed_at' do
        let!(:closed_issue1) { create(:issue, project: project1, state: :closed, closed_at: 1.week.ago) }
        let!(:closed_issue2) { create(:issue, project: project2, state: :closed, closed_at: 1.week.from_now) }
        let!(:closed_issue3) { create(:issue, project: project2, state: :closed, closed_at: 2.weeks.from_now) }

        context 'through closed_after' do
          let(:params) { { state: :closed, closed_after: closed_issue3.closed_at } }

          it 'returns issues closed on or after the given date' do
            expect(issues).to contain_exactly(closed_issue3)
          end
        end

        context 'through closed_before' do
          let(:params) { { state: :closed, closed_before: closed_issue1.closed_at } }

          it 'returns issues closed on or before the given date' do
            expect(issues).to contain_exactly(closed_issue1)
          end
        end

        context 'through closed_after and closed_before' do
          let(:params) { { state: :closed, closed_after: closed_issue2.closed_at, closed_before: closed_issue3.closed_at } }

          it 'returns issues closed between the given dates' do
            expect(issues).to contain_exactly(closed_issue2, closed_issue3)
          end
        end
      end

Hiroyuki Sato's avatar
Hiroyuki Sato committed
404
      context 'filtering by reaction name' do
Heinrich Lee Yu's avatar
Heinrich Lee Yu committed
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
        context 'user searches by no reaction' do
          let(:params) { { my_reaction_emoji: 'None' } }

          it 'returns issues that the user did not react to' do
            expect(issues).to contain_exactly(issue2, issue4)
          end
        end

        context 'user searches by any reaction' do
          let(:params) { { my_reaction_emoji: 'Any' } }

          it 'returns issues that the user reacted to' do
            expect(issues).to contain_exactly(issue1, issue3)
          end
        end

Hiroyuki Sato's avatar
Hiroyuki Sato committed
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
        context 'user searches by "thumbsup" reaction' do
          let(:params) { { my_reaction_emoji: 'thumbsup' } }

          it 'returns issues that the user thumbsup to' do
            expect(issues).to contain_exactly(issue1)
          end
        end

        context 'user2 searches by "thumbsup" reaction' do
          let(:search_user) { user2 }

          let(:params) { { my_reaction_emoji: 'thumbsup' } }

          it 'returns issues that the user2 thumbsup to' do
            expect(issues).to contain_exactly(issue2)
          end
        end

        context 'user searches by "thumbsdown" reaction' do
          let(:params) { { my_reaction_emoji: 'thumbsdown' } }

          it 'returns issues that the user thumbsdown to' do
            expect(issues).to contain_exactly(issue3)
          end
        end
      end

448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
      context 'filtering by confidential' do
        set(:confidential_issue) { create(:issue, project: project1, confidential: true) }

        context 'no filtering' do
          it 'returns all issues' do
            expect(issues).to contain_exactly(issue1, issue2, issue3, issue4, confidential_issue)
          end
        end

        context 'user filters confidential issues' do
          let(:params) { { confidential: true } }

          it 'returns only confdential issues' do
            expect(issues).to contain_exactly(confidential_issue)
          end
        end

        context 'user filters only public issues' do
          let(:params) { { confidential: false } }

          it 'returns only confdential issues' do
            expect(issues).to contain_exactly(issue1, issue2, issue3, issue4)
          end
        end
      end

Sean McGivern's avatar
Sean McGivern committed
474
475
476
477
478
479
      context 'when the user is unauthorized' do
        let(:search_user) { nil }

        it 'returns no results' do
          expect(issues).to be_empty
        end
480
481
      end

Sean McGivern's avatar
Sean McGivern committed
482
483
484
485
486
487
      context 'when the user can see some, but not all, issues' do
        let(:search_user) { user2 }

        it 'returns only issues they can see' do
          expect(issues).to contain_exactly(issue2, issue3)
        end
488
      end
489
490
491

      it 'finds issues user can access due to group' do
        group = create(:group)
492
        project = create(:project, group: group)
493
494
495
496
497
        issue = create(:issue, project: project)
        group.add_user(user, :owner)

        expect(issues).to include(issue)
      end
498
499
    end

500
    context 'personal scope' do
501
      let(:scope) { 'assigned_to_me' }
Sean McGivern's avatar
Sean McGivern committed
502
503
504

      it 'returns issue assigned to the user' do
        expect(issues).to contain_exactly(issue1, issue2)
505
506
      end

Sean McGivern's avatar
Sean McGivern committed
507
508
509
510
511
512
      context 'filtering by project' do
        let(:params) { { project_id: project1.id } }

        it 'returns issues assigned to the user in that project' do
          expect(issues).to contain_exactly(issue1)
        end
513
      end
514
    end
515
516
517
518
519

    context 'when project restricts issues' do
      let(:scope) { nil }

      it "doesn't return team-only issues to non team members" do
520
        project = create(:project, :public, :issues_private)
521
522
523
524
525
526
        issue = create(:issue, project: project)

        expect(issues).not_to include(issue)
      end

      it "doesn't return issues if feature disabled" do
527
        [project1, project2, project3].each do |project|
528
529
530
531
532
533
          project.project_feature.update!(issues_access_level: ProjectFeature::DISABLED)
        end

        expect(issues.count).to eq 0
      end
    end
534
535
536
537
538
539
540

    context 'external authorization' do
      it_behaves_like 'a finder with external authorization service' do
        let!(:subject) { create(:issue, project: project) }
        let(:project_params) { { project_id: project.id } }
      end
    end
541
542
  end

543
544
545
546
  describe '#row_count', :request_store do
    it 'returns the number of rows for the default state' do
      finder = described_class.new(user)

547
      expect(finder.row_count).to eq(5)
548
549
550
551
552
553
554
555
556
    end

    it 'returns the number of rows for a given state' do
      finder = described_class.new(user, state: 'closed')

      expect(finder.row_count).to be_zero
    end
  end

557
  describe '#with_confidentiality_access_check' do
558
559
    let(:guest) { create(:user) }
    set(:authorized_user) { create(:user) }
560
    set(:project) { create(:project, namespace: authorized_user.namespace) }
561
562
563
564
565
566
567
    set(:public_issue) { create(:issue, project: project) }
    set(:confidential_issue) { create(:issue, project: project, confidential: true) }

    context 'when no project filter is given' do
      let(:params) { {} }

      context 'for an anonymous user' do
568
        subject { described_class.new(nil, params).with_confidentiality_access_check }
569
570
571
572
573
574
575
576

        it 'returns only public issues' do
          expect(subject).to include(public_issue)
          expect(subject).not_to include(confidential_issue)
        end
      end

      context 'for a user without project membership' do
577
        subject { described_class.new(user, params).with_confidentiality_access_check }
578
579
580
581
582
583
584
585

        it 'returns only public issues' do
          expect(subject).to include(public_issue)
          expect(subject).not_to include(confidential_issue)
        end
      end

      context 'for a guest user' do
586
        subject { described_class.new(guest, params).with_confidentiality_access_check }
587
588
589
590
591
592
593
594
595
596
597
598

        before do
          project.add_guest(guest)
        end

        it 'returns only public issues' do
          expect(subject).to include(public_issue)
          expect(subject).not_to include(confidential_issue)
        end
      end

      context 'for a project member with access to view confidential issues' do
599
        subject { described_class.new(authorized_user, params).with_confidentiality_access_check }
600

601
602
603
604
        it 'returns all issues' do
          expect(subject).to include(public_issue, confidential_issue)
        end
      end
605
606
607
608
609
610
611
612
613
614

      context 'for an admin' do
        let(:admin_user) { create(:user, :admin) }

        subject { described_class.new(admin_user, params).with_confidentiality_access_check }

        it 'returns all issues' do
          expect(subject).to include(public_issue, confidential_issue)
        end
      end
615
616
    end

617
618
619
620
    context 'when searching within a specific project' do
      let(:params) { { project_id: project.id } }

      context 'for an anonymous user' do
621
        subject { described_class.new(nil, params).with_confidentiality_access_check }
622
623
624
625
626
627
628
629
630
631
632
633
634
635

        it 'returns only public issues' do
          expect(subject).to include(public_issue)
          expect(subject).not_to include(confidential_issue)
        end

        it 'does not filter by confidentiality' do
          expect(Issue).not_to receive(:where).with(a_string_matching('confidential'), anything)

          subject
        end
      end

      context 'for a user without project membership' do
636
        subject { described_class.new(user, params).with_confidentiality_access_check }
637
638
639
640
641
642
643

        it 'returns only public issues' do
          expect(subject).to include(public_issue)
          expect(subject).not_to include(confidential_issue)
        end

        it 'filters by confidentiality' do
644
          expect(subject.to_sql).to match("issues.confidential")
645
646
647
648
        end
      end

      context 'for a guest user' do
649
        subject { described_class.new(guest, params).with_confidentiality_access_check }
650
651
652
653
654
655
656
657
658
659
660

        before do
          project.add_guest(guest)
        end

        it 'returns only public issues' do
          expect(subject).to include(public_issue)
          expect(subject).not_to include(confidential_issue)
        end

        it 'filters by confidentiality' do
661
          expect(subject.to_sql).to match("issues.confidential")
662
663
664
665
        end
      end

      context 'for a project member with access to view confidential issues' do
666
        subject { described_class.new(authorized_user, params).with_confidentiality_access_check }
667
668
669
670
671
672
673
674
675
676
677

        it 'returns all issues' do
          expect(subject).to include(public_issue, confidential_issue)
        end

        it 'does not filter by confidentiality' do
          expect(Issue).not_to receive(:where).with(a_string_matching('confidential'), anything)

          subject
        end
      end
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693

      context 'for an admin' do
        let(:admin_user) { create(:user, :admin) }

        subject { described_class.new(admin_user, params).with_confidentiality_access_check }

        it 'returns all issues' do
          expect(subject).to include(public_issue, confidential_issue)
        end

        it 'does not filter by confidentiality' do
          expect(Issue).not_to receive(:where).with(a_string_matching('confidential'), anything)

          subject
        end
      end
694
    end
695
  end
696

697
  describe '#use_cte_for_search?' do
698
699
700
701
    let(:finder) { described_class.new(nil, params) }

    before do
      allow(Gitlab::Database).to receive(:postgresql?).and_return(true)
702
      stub_feature_flags(attempt_group_search_optimizations: true)
703
704
705
706
707
708
    end

    context 'when there is no search param' do
      let(:params) { { attempt_group_search_optimizations: true } }

      it 'returns false' do
709
        expect(finder.use_cte_for_search?).to be_falsey
710
711
712
713
714
715
716
717
718
719
720
      end
    end

    context 'when the database is not Postgres' do
      let(:params) { { search: 'foo', attempt_group_search_optimizations: true } }

      before do
        allow(Gitlab::Database).to receive(:postgresql?).and_return(false)
      end

      it 'returns false' do
721
        expect(finder.use_cte_for_search?).to be_falsey
722
723
724
      end
    end

725
    context 'when the force_cte param is falsey' do
726
727
728
      let(:params) { { search: 'foo' } }

      it 'returns false' do
729
        expect(finder.use_cte_for_search?).to be_falsey
730
731
732
      end
    end

733
    context 'when the attempt_group_search_optimizations flag is disabled' do
734
735
736
      let(:params) { { search: 'foo', attempt_group_search_optimizations: true } }

      before do
737
        stub_feature_flags(attempt_group_search_optimizations: false)
738
739
740
      end

      it 'returns false' do
741
        expect(finder.use_cte_for_search?).to be_falsey
742
743
744
      end
    end

745
746
    context 'when attempt_group_search_optimizations is unset and attempt_project_search_optimizations is set' do
      let(:params) { { search: 'foo', attempt_project_search_optimizations: true } }
747

748
749
750
751
      context 'and the corresponding feature flag is disabled' do
        before do
          stub_feature_flags(attempt_project_search_optimizations: false)
        end
752

753
754
755
        it 'returns false' do
          expect(finder.use_cte_for_search?).to be_falsey
        end
756
757
      end

758
759
760
761
      context 'and the corresponding feature flag is enabled' do
        before do
          stub_feature_flags(attempt_project_search_optimizations: true)
        end
762

763
764
765
        it 'returns true' do
          expect(finder.use_cte_for_search?).to be_truthy
        end
766
767
768
769
      end
    end

    context 'when all conditions are met' do
770
      let(:params) { { search: 'foo', attempt_group_search_optimizations: true } }
771
772

      it 'returns true' do
773
        expect(finder.use_cte_for_search?).to be_truthy
774
775
776
      end
    end
  end
777
end