BigW Consortium Gitlab

events_spec.rb 6.81 KB
Newer Older
1 2
require 'spec_helper'

3
describe API::Events do
4 5 6 7
  include ApiHelpers
  let(:user) { create(:user) }
  let(:non_member) { create(:user) }
  let(:other_user) { create(:user, username: 'otheruser') }
8
  let(:private_project) { create(:project, :private, creator_id: user.id, namespace: user.namespace) }
9 10 11 12 13 14 15 16
  let(:closed_issue) { create(:closed_issue, project: private_project, author: user) }
  let!(:closed_issue_event) { create(:event, project: private_project, author: user, target: closed_issue, action: Event::CLOSED, created_at: Date.new(2016, 12, 30)) }

  describe 'GET /events' do
    context 'when unauthenticated' do
      it 'returns authentication error' do
        get api('/events')

17
        expect(response).to have_gitlab_http_status(401)
18 19 20 21 22 23 24
      end
    end

    context 'when authenticated' do
      it 'returns users events' do
        get api('/events?action=closed&target_type=issue&after=2016-12-1&before=2016-12-31', user)

25
        expect(response).to have_gitlab_http_status(200)
26 27 28 29 30 31 32 33 34 35 36 37
        expect(response).to include_pagination_headers
        expect(json_response).to be_an Array
        expect(json_response.size).to eq(1)
      end
    end
  end

  describe 'GET /users/:id/events' do
    context "as a user that cannot see the event's project" do
      it 'returns no events' do
        get api("/users/#{user.id}/events", other_user)

38
        expect(response).to have_gitlab_http_status(200)
39 40 41 42 43
        expect(json_response).to be_empty
      end
    end

    context "as a user that can see the event's project" do
44 45 46
      it 'accepts a username' do
        get api("/users/#{user.username}/events", user)

47
        expect(response).to have_gitlab_http_status(200)
48 49 50 51 52
        expect(response).to include_pagination_headers
        expect(json_response).to be_an Array
        expect(json_response.size).to eq(1)
      end

53 54 55
      it 'returns the events' do
        get api("/users/#{user.id}/events", user)

56
        expect(response).to have_gitlab_http_status(200)
57 58 59 60 61
        expect(response).to include_pagination_headers
        expect(json_response).to be_an Array
        expect(json_response.size).to eq(1)
      end

62 63 64 65 66 67 68 69 70 71 72 73 74
      context 'when the list of events includes push events' do
        let(:event) do
          create(:push_event, author: user, project: private_project)
        end

        let!(:payload) { create(:push_event_payload, event: event) }
        let(:payload_hash) { json_response[0]['push_data'] }

        before do
          get api("/users/#{user.id}/events?action=pushed", user)
        end

        it 'responds with HTTP 200 OK' do
75
          expect(response).to have_gitlab_http_status(200)
76 77 78 79 80 81 82 83 84 85 86 87 88 89
        end

        it 'includes the push payload as a Hash' do
          expect(payload_hash).to be_an_instance_of(Hash)
        end

        it 'includes the push payload details' do
          expect(payload_hash['commit_count']).to eq(payload.commit_count)
          expect(payload_hash['action']).to eq(payload.action)
          expect(payload_hash['ref_type']).to eq(payload.ref_type)
          expect(payload_hash['commit_to']).to eq(payload.commit_to)
        end
      end

90
      context 'when there are multiple events from different projects' do
91
        let(:second_note) { create(:note_on_issue, project: create(:project)) }
92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122

        before do
          second_note.project.add_user(user, :developer)

          [second_note].each do |note|
            EventCreateService.new.leave_note(note, user)
          end
        end

        it 'returns events in the correct order (from newest to oldest)' do
          get api("/users/#{user.id}/events", user)

          comment_events = json_response.select { |e| e['action_name'] == 'commented on' }
          close_events = json_response.select { |e| e['action_name'] == 'closed' }

          expect(comment_events[0]['target_id']).to eq(second_note.id)
          expect(close_events[0]['target_id']).to eq(closed_issue.id)
        end

        it 'accepts filter parameters' do
          get api("/users/#{user.id}/events?action=closed&target_type=issue&after=2016-12-1&before=2016-12-31", user)

          expect(json_response.size).to eq(1)
          expect(json_response[0]['target_id']).to eq(closed_issue.id)
        end
      end
    end

    it 'returns a 404 error if not found' do
      get api('/users/42/events', user)

123
      expect(response).to have_gitlab_http_status(404)
124 125 126 127 128 129 130 131 132
      expect(json_response['message']).to eq('404 User Not Found')
    end
  end

  describe 'GET /projects/:id/events' do
    context 'when unauthenticated ' do
      it 'returns 404 for private project' do
        get api("/projects/#{private_project.id}/events")

133
        expect(response).to have_gitlab_http_status(404)
134 135 136
      end

      it 'returns 200 status for a public project' do
137
        public_project = create(:project, :public)
138 139 140

        get api("/projects/#{public_project.id}/events")

141
        expect(response).to have_gitlab_http_status(200)
142 143 144 145 146 147 148
      end
    end

    context 'when not permitted to read' do
      it 'returns 404' do
        get api("/projects/#{private_project.id}/events", non_member)

149
        expect(response).to have_gitlab_http_status(404)
150 151 152 153 154 155 156
      end
    end

    context 'when authenticated' do
      it 'returns project events' do
        get api("/projects/#{private_project.id}/events?action=closed&target_type=issue&after=2016-12-1&before=2016-12-31", user)

157
        expect(response).to have_gitlab_http_status(200)
158 159 160 161 162 163 164 165
        expect(response).to include_pagination_headers
        expect(json_response).to be_an Array
        expect(json_response.size).to eq(1)
      end

      it 'returns 404 if project does not exist' do
        get api("/projects/1234/events", user)

166
        expect(response).to have_gitlab_http_status(404)
167 168
      end
    end
sue445 committed
169 170

    context 'when exists some events' do
171 172 173
      let(:merge_request1) { create(:merge_request, :closed, author: user, assignee: user, source_project: private_project, title: 'Test') }
      let(:merge_request2) { create(:merge_request, :closed, author: user, assignee: user, source_project: private_project, title: 'Test') }

sue445 committed
174 175 176 177 178 179
      before do
        create_event(merge_request1)
      end

      it 'avoids N+1 queries' do
        control_count = ActiveRecord::QueryRecorder.new do
180
          get api("/projects/#{private_project.id}/events", user), target_type: :merge_request
sue445 committed
181 182 183 184 185
        end.count

        create_event(merge_request2)

        expect do
186
          get api("/projects/#{private_project.id}/events", user), target_type: :merge_request
sue445 committed
187 188
        end.not_to exceed_query_limit(control_count)

189
        expect(response).to have_gitlab_http_status(200)
sue445 committed
190
        expect(response).to include_pagination_headers
191 192
        expect(json_response.size).to eq(2)
        expect(json_response.map { |r| r['target_id'] }).to match_array([merge_request1.id, merge_request2.id])
sue445 committed
193 194 195 196 197 198
      end

      def create_event(target)
        create(:event, project: private_project, author: user, target: target)
      end
    end
199 200
  end
end