BigW Consortium Gitlab

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

3
describe IssuesFinder do
4 5 6 7
  let(:user) { create(:user) }
  let(:user2) { create(:user) }
  let(:project1) { create(:empty_project) }
  let(:project2) { create(:empty_project) }
8
  let(:milestone) { create(:milestone, project: project1) }
9
  let(:label) { create(:label, project: project2) }
barthc committed
10 11
  let(:issue1) { create(:issue, author: user, assignee: user, project: project1, milestone: milestone, title: 'gitlab') }
  let(:issue2) { create(:issue, author: user, assignee: user, project: project2, description: 'gitlab') }
12
  let(:issue3) { create(:issue, author: user2, assignee: user2, project: project2) }
13

14
  describe '#execute' do
15 16
    let(:closed_issue) { create(:issue, author: user2, assignee: user2, project: project2, state: 'closed') }
    let!(:label_link) { create(:label_link, label: label, target: issue2) }
17 18
    let(:search_user) { user }
    let(:params) { {} }
19
    let(:issues) { IssuesFinder.new(search_user, params.reverse_merge(scope: scope, state: 'opened')).execute }
20

21 22 23 24 25 26 27 28 29 30
    before do
      project1.team << [user, :master]
      project2.team << [user, :developer]
      project2.team << [user2, :developer]

      issue1
      issue2
      issue3
    end

31
    context 'scope: all' do
32
      let(:scope) { 'all' }
33

34 35
      it 'returns all issues' do
        expect(issues).to contain_exactly(issue1, issue2, issue3)
36
      end
37

38 39 40 41 42 43
      context 'filtering by assignee ID' do
        let(:params) { { assignee_id: user.id } }

        it 'returns issues assigned to that user' do
          expect(issues).to contain_exactly(issue1, issue2)
        end
44
      end
45

46 47 48 49 50 51
      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
52 53
      end

54 55 56 57 58 59
      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
60 61
      end

62 63 64 65 66 67
      context 'filtering by no milestone' do
        let(:params) { { milestone_title: Milestone::None.title } }

        it 'returns issues with no milestone' do
          expect(issues).to contain_exactly(issue2, issue3)
        end
68 69
      end

70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
      context 'filtering by upcoming milestone' do
        let(:params) { { milestone_title: Milestone::Upcoming.name } }

        let(:project_no_upcoming_milestones) { create(:empty_project, :public) }
        let(:project_next_1_1) { create(:empty_project, :public) }
        let(:project_next_8_8) { create(:empty_project, :public) }

        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),
            create(:milestone, project: project_next_1_1, title: '8.8', due_date: ten_days_from_now),
            create(:milestone, project: project_next_8_8, title: '1.1', due_date: yesterday),
            create(:milestone, project: project_next_8_8, title: '8.8', due_date: tomorrow)
          ]
        end

        before do
          milestones.each do |milestone|
            create(:issue, project: milestone.project, milestone: milestone, author: user, assignee: user)
          end
        end

        it 'returns issues in the upcoming milestone for each project' do
          expect(issues.map { |issue| issue.milestone.title }).to contain_exactly('1.1', '8.8')
          expect(issues.map { |issue| issue.milestone.due_date }).to contain_exactly(tomorrow, two_days_from_now)
        end
      end

104 105
      context 'filtering by label' do
        let(:params) { { label_name: label.title } }
106

107 108 109 110
        it 'returns issues with that label' do
          expect(issues).to contain_exactly(issue2)
        end
      end
111

112 113 114
      context 'filtering by multiple labels' do
        let(:params) { { label_name: [label.title, label2.title].join(',') } }
        let(:label2) { create(:label, project: project2) }
115

116
        before { create(:label_link, label: label2, target: issue2) }
117

118 119 120
        it 'returns the unique issues with any of those labels' do
          expect(issues).to contain_exactly(issue2)
        end
121 122
      end

123 124 125 126 127 128
      context 'filtering by no label' do
        let(:params) { { label_name: Label::None.title } }

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

barthc committed
131 132 133 134 135 136 137 138
      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

139 140
      context 'filtering by issues iids' do
        let(:params) { { iids: issue3.iid } }
barthc committed
141

142
        it 'returns issues with iids match' do
barthc committed
143 144 145 146
          expect(issues).to contain_exactly(issue3)
        end
      end

147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
      context 'filtering by state' do
        context 'with opened' do
          let(:params) { { state: 'opened' } }

          it 'returns only opened issues' do
            expect(issues).to contain_exactly(issue1, issue2, issue3)
          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
            expect(issues).to contain_exactly(issue1, issue2, issue3, closed_issue)
          end
        end

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

          it 'returns all issues' do
            expect(issues).to contain_exactly(issue1, issue2, issue3, closed_issue)
          end
        end
      end

181 182 183 184 185 186
      context 'when the user is unauthorized' do
        let(:search_user) { nil }

        it 'returns no results' do
          expect(issues).to be_empty
        end
187 188
      end

189 190 191 192 193 194
      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
195
      end
196 197 198 199 200 201 202 203 204

      it 'finds issues user can access due to group' do
        group = create(:group)
        project = create(:empty_project, group: group)
        issue = create(:issue, project: project)
        group.add_user(user, :owner)

        expect(issues).to include(issue)
      end
205 206
    end

207
    context 'personal scope' do
208 209 210 211
      let(:scope) { 'assigned-to-me' }

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

214 215 216 217 218 219
      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
220
      end
221
    end
222 223 224 225 226

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

      it "doesn't return team-only issues to non team members" do
227
        project = create(:empty_project, :public, :issues_private)
228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259
        issue = create(:issue, project: project)

        expect(issues).not_to include(issue)
      end

      it "doesn't return issues if feature disabled" do
        [project1, project2].each do |project|
          project.project_feature.update!(issues_access_level: ProjectFeature::DISABLED)
        end

        expect(issues.count).to eq 0
      end
    end
  end

  describe '.not_restricted_by_confidentiality' do
    let(:authorized_user) { create(:user) }
    let(:project) { create(:empty_project, namespace: authorized_user.namespace) }
    let!(:public_issue) { create(:issue, project: project) }
    let!(:confidential_issue) { create(:issue, project: project, confidential: true) }

    it 'returns non confidential issues for nil user' do
      expect(IssuesFinder.send(:not_restricted_by_confidentiality, nil)).to include(public_issue)
    end

    it 'returns non confidential issues for user not authorized for the issues projects' do
      expect(IssuesFinder.send(:not_restricted_by_confidentiality, user)).to include(public_issue)
    end

    it 'returns all issues for user authorized for the issues projects' do
      expect(IssuesFinder.send(:not_restricted_by_confidentiality, authorized_user)).to include(public_issue, confidential_issue)
    end
260 261
  end
end