helpers_spec.rb 13.7 KB
Newer Older
1
require 'spec_helper'
2 3
require 'raven/transports/dummy'
require_relative '../../../config/initializers/sentry'
4

5
describe API::Helpers do
6
  include API::APIGuard::HelperMethods
7
  include described_class
8
  include SentryHelper
9
  include TermsHelper
10

11 12 13 14
  let(:user) { create(:user) }
  let(:admin) { create(:admin) }
  let(:key) { create(:key, user: user) }

Douwe Maan's avatar
Douwe Maan committed
15 16 17 18 19 20 21
  let(:csrf_token) { SecureRandom.base64(ActionController::RequestForgeryProtection::AUTHENTICITY_TOKEN_LENGTH) }
  let(:env) do
    {
      'rack.input' => '',
      'rack.session' => {
        _csrf_token: csrf_token
      },
22 23
      'REQUEST_METHOD' => 'GET',
      'CONTENT_TYPE' => 'text/plain;charset=utf-8'
Douwe Maan's avatar
Douwe Maan committed
24 25
    }
  end
Kamil Trzciński's avatar
Kamil Trzciński committed
26
  let(:header) { }
Francisco Javier López's avatar
Francisco Javier López committed
27
  let(:request) { Grape::Request.new(env)}
28
  let(:params) { request.params }
29

30 31 32
  before do
    allow_any_instance_of(self.class).to receive(:options).and_return({})
  end
33

34 35 36 37 38
  def warden_authenticate_returns(value)
    warden = double("warden", authenticate: value)
    env['warden'] = warden
  end

Kamil Trzciński's avatar
Kamil Trzciński committed
39
  def error!(message, status, header)
40
    raise Exception.new("#{status} - #{message}")
41 42
  end

43 44 45 46
  def set_param(key, value)
    request.update_param(key, value)
  end

47
  describe ".current_user" do
48 49
    subject { current_user }

Douwe Maan's avatar
Douwe Maan committed
50
    describe "Warden authentication", :allow_forgery_protection do
51 52
      context "with invalid credentials" do
        context "GET request" do
53 54 55 56
          before do
            env['REQUEST_METHOD'] = 'GET'
          end

57 58
          it { is_expected.to be_nil }
        end
59 60
      end

61
      context "with valid credentials" do
62 63 64
        before do
          warden_authenticate_returns user
        end
65

66
        context "GET request" do
67 68 69 70
          before do
            env['REQUEST_METHOD'] = 'GET'
          end

71
          it { is_expected.to eq(user) }
72 73 74 75 76 77

          it 'sets the environment with data of the current user' do
            subject

            expect(env[API::Helpers::API_USER_ENV]).to eq({ user_id: subject.id, username: subject.username })
          end
78 79 80
        end

        context "HEAD request" do
81 82 83 84
          before do
            env['REQUEST_METHOD'] = 'HEAD'
          end

85 86 87 88
          it { is_expected.to eq(user) }
        end

        context "PUT request" do
89 90 91 92
          before do
            env['REQUEST_METHOD'] = 'PUT'
          end

Douwe Maan's avatar
Douwe Maan committed
93 94 95 96 97 98 99 100 101 102 103
          context 'without CSRF token' do
            it { is_expected.to be_nil }
          end

          context 'with CSRF token' do
            before do
              env['HTTP_X_CSRF_TOKEN'] = csrf_token
            end

            it { is_expected.to eq(user) }
          end
104 105 106
        end

        context "POST request" do
107 108 109 110
          before do
            env['REQUEST_METHOD'] = 'POST'
          end

Douwe Maan's avatar
Douwe Maan committed
111 112 113 114 115 116 117 118 119 120 121
          context 'without CSRF token' do
            it { is_expected.to be_nil }
          end

          context 'with CSRF token' do
            before do
              env['HTTP_X_CSRF_TOKEN'] = csrf_token
            end

            it { is_expected.to eq(user) }
          end
122 123 124
        end

        context "DELETE request" do
125 126 127 128
          before do
            env['REQUEST_METHOD'] = 'DELETE'
          end

Douwe Maan's avatar
Douwe Maan committed
129 130 131 132 133 134 135 136 137 138 139
          context 'without CSRF token' do
            it { is_expected.to be_nil }
          end

          context 'with CSRF token' do
            before do
              env['HTTP_X_CSRF_TOKEN'] = csrf_token
            end

            it { is_expected.to eq(user) }
          end
140
        end
141 142 143
      end
    end

144 145 146
    describe "when authenticating using a user's personal access tokens" do
      let(:personal_access_token) { create(:personal_access_token, user: user) }

147
      it "returns a 401 response for an invalid token" do
148
        env[Gitlab::Auth::UserAuthFinders::PRIVATE_TOKEN_HEADER] = 'invalid token'
149

150
        expect { current_user }.to raise_error /401/
151 152
      end

Douwe Maan's avatar
Douwe Maan committed
153
      it "returns a 403 response for a user without access" do
154
        env[Gitlab::Auth::UserAuthFinders::PRIVATE_TOKEN_HEADER] = personal_access_token.token
155
        allow_any_instance_of(Gitlab::UserAccess).to receive(:allowed?).and_return(false)
156

Douwe Maan's avatar
Douwe Maan committed
157
        expect { current_user }.to raise_error /403/
158 159
      end

Douwe Maan's avatar
Douwe Maan committed
160
      it 'returns a 403 response for a user who is blocked' do
161
        user.block!
162
        env[Gitlab::Auth::UserAuthFinders::PRIVATE_TOKEN_HEADER] = personal_access_token.token
163

Douwe Maan's avatar
Douwe Maan committed
164
        expect { current_user }.to raise_error /403/
165
      end
166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182

      context 'when terms are enforced' do
        before do
          enforce_terms
          env[Gitlab::Auth::UserAuthFinders::PRIVATE_TOKEN_HEADER] = personal_access_token.token
        end

        it 'returns a 403 when a user has not accepted the terms' do
          expect { current_user }.to raise_error /You must accept the Terms of Service/
        end

        it 'sets the current user when the user accepted the terms' do
          accept_terms(user)

          expect(current_user).to eq(user)
        end
      end
183

184
      it "sets current_user" do
185
        env[Gitlab::Auth::UserAuthFinders::PRIVATE_TOKEN_HEADER] = personal_access_token.token
186 187 188
        expect(current_user).to eq(user)
      end

189 190
      it "does not allow tokens without the appropriate scope" do
        personal_access_token = create(:personal_access_token, user: user, scopes: ['read_user'])
191
        env[Gitlab::Auth::UserAuthFinders::PRIVATE_TOKEN_HEADER] = personal_access_token.token
192

193
        expect { current_user }.to raise_error Gitlab::Auth::InsufficientScopeError
194 195
      end

196 197
      it 'does not allow revoked tokens' do
        personal_access_token.revoke!
198
        env[Gitlab::Auth::UserAuthFinders::PRIVATE_TOKEN_HEADER] = personal_access_token.token
199

200
        expect { current_user }.to raise_error Gitlab::Auth::RevokedError
201 202 203 204
      end

      it 'does not allow expired tokens' do
        personal_access_token.update_attributes!(expires_at: 1.day.ago)
205
        env[Gitlab::Auth::UserAuthFinders::PRIVATE_TOKEN_HEADER] = personal_access_token.token
206

207
        expect { current_user }.to raise_error Gitlab::Auth::ExpiredError
208
      end
209 210
    end
  end
211

212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
  describe '.handle_api_exception' do
    before do
      allow_any_instance_of(self.class).to receive(:sentry_enabled?).and_return(true)
      allow_any_instance_of(self.class).to receive(:rack_response)
    end

    it 'does not report a MethodNotAllowed exception to Sentry' do
      exception = Grape::Exceptions::MethodNotAllowed.new({ 'X-GitLab-Test' => '1' })
      allow(exception).to receive(:backtrace).and_return(caller)

      expect(Raven).not_to receive(:capture_exception).with(exception)

      handle_api_exception(exception)
    end

    it 'does report RuntimeError to Sentry' do
      exception = RuntimeError.new('test error')
      allow(exception).to receive(:backtrace).and_return(caller)

      expect_any_instance_of(self.class).to receive(:sentry_context)
232
      expect(Raven).to receive(:capture_exception).with(exception, extra: {})
233 234 235

      handle_api_exception(exception)
    end
236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256

    context 'with a personal access token given' do
      let(:token) { create(:personal_access_token, scopes: ['api'], user: user) }

      # Regression test for https://gitlab.com/gitlab-org/gitlab-ce/issues/38571
      it 'does not raise an additional exception because of missing `request`' do
        # We need to stub at a lower level than #sentry_enabled? otherwise
        # Sentry is not enabled when the request below is made, and the test
        # would pass even without the fix
        expect(Gitlab::Sentry).to receive(:enabled?).twice.and_return(true)
        expect(ProjectsFinder).to receive(:new).and_raise('Runtime Error!')

        get api('/projects', personal_access_token: token)

        # The 500 status is expected as we're testing a case where an exception
        # is raised, but Grape shouldn't raise an additional exception
        expect(response).to have_gitlab_http_status(500)
        expect(json_response['message']).not_to include("undefined local variable or method `request'")
        expect(json_response['message']).to start_with("\nRuntimeError (Runtime Error!):")
      end
    end
257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280

    context 'extra information' do
      # Sentry events are an array of the form [auth_header, data, options]
      let(:event_data) { Raven.client.transport.events.first[1] }

      before do
        stub_application_setting(
          sentry_enabled: true,
          sentry_dsn: "dummy://12345:67890@sentry.localdomain/sentry/42"
        )
        configure_sentry
        Raven.client.configuration.encoding = 'json'
      end

      it 'sends the params, excluding confidential values' do
        expect(Gitlab::Sentry).to receive(:enabled?).twice.and_return(true)
        expect(ProjectsFinder).to receive(:new).and_raise('Runtime Error!')

        get api('/projects', user), password: 'dont_send_this', other_param: 'send_this'

        expect(event_data).to include('other_param=send_this')
        expect(event_data).to include('password=********')
      end
    end
281
  end
282 283 284 285 286

  describe '.authenticate_non_get!' do
    %w[HEAD GET].each do |method_name|
      context "method is #{method_name}" do
        before do
287
          expect_any_instance_of(self.class).to receive(:route).and_return(double(request_method: method_name))
288 289 290 291 292 293 294 295 296 297 298 299 300
        end

        it 'does not raise an error' do
          expect_any_instance_of(self.class).not_to receive(:authenticate!)

          expect { authenticate_non_get! }.not_to raise_error
        end
      end
    end

    %w[POST PUT PATCH DELETE].each do |method_name|
      context "method is #{method_name}" do
        before do
301
          expect_any_instance_of(self.class).to receive(:route).and_return(double(request_method: method_name))
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319
        end

        it 'calls authenticate!' do
          expect_any_instance_of(self.class).to receive(:authenticate!)

          authenticate_non_get!
        end
      end
    end
  end

  describe '.authenticate!' do
    context 'current_user is nil' do
      before do
        expect_any_instance_of(self.class).to receive(:current_user).and_return(nil)
      end

      it 'returns a 401 response' do
320
        expect { authenticate! }.to raise_error /401/
321 322 323 324
      end
    end

    context 'current_user is present' do
325 326
      let(:user) { build(:user) }

327
      before do
328
        expect_any_instance_of(self.class).to receive(:current_user).and_return(user)
329 330 331 332 333 334 335
      end

      it 'does not raise an error' do
        expect { authenticate! }.not_to raise_error
      end
    end
  end
336 337 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 372 373 374 375 376 377 378 379 380 381 382

  context 'sudo' do
    shared_examples 'successful sudo' do
      it 'sets current_user' do
        expect(current_user).to eq(user)
      end

      it 'sets sudo?' do
        expect(sudo?).to be_truthy
      end
    end

    shared_examples 'sudo' do
      context 'when admin' do
        before do
          token.user = admin
          token.save!
        end

        context 'when token has sudo scope' do
          before do
            token.scopes = %w[sudo]
            token.save!
          end

          context 'when user exists' do
            context 'when using header' do
              context 'when providing username' do
                before do
                  env[API::Helpers::SUDO_HEADER] = user.username
                end

                it_behaves_like 'successful sudo'
              end

              context 'when providing user ID' do
                before do
                  env[API::Helpers::SUDO_HEADER] = user.id.to_s
                end

                it_behaves_like 'successful sudo'
              end
            end

            context 'when using param' do
              context 'when providing username' do
                before do
383
                  set_param(API::Helpers::SUDO_PARAM, user.username)
384 385 386 387 388 389 390
                end

                it_behaves_like 'successful sudo'
              end

              context 'when providing user ID' do
                before do
391
                  set_param(API::Helpers::SUDO_PARAM, user.id.to_s)
392 393 394 395 396 397 398 399 400
                end

                it_behaves_like 'successful sudo'
              end
            end
          end

          context 'when user does not exist' do
            before do
401
              set_param(API::Helpers::SUDO_PARAM, 'nonexistent')
402 403 404 405 406 407 408 409 410 411 412 413 414
            end

            it 'raises an error' do
              expect { current_user }.to raise_error /User with ID or username 'nonexistent' Not Found/
            end
          end
        end

        context 'when token does not have sudo scope' do
          before do
            token.scopes = %w[api]
            token.save!

415
            set_param(API::Helpers::SUDO_PARAM, user.id.to_s)
416 417 418
          end

          it 'raises an error' do
419
            expect { current_user }.to raise_error Gitlab::Auth::InsufficientScopeError
420 421 422 423 424 425 426 427 428
          end
        end
      end

      context 'when not admin' do
        before do
          token.user = user
          token.save!

429
          set_param(API::Helpers::SUDO_PARAM, user.id.to_s)
430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452
        end

        it 'raises an error' do
          expect { current_user }.to raise_error /Must be admin to use sudo/
        end
      end
    end

    context 'using an OAuth token' do
      let(:token) { create(:oauth_access_token) }

      before do
        env['HTTP_AUTHORIZATION'] = "Bearer #{token.token}"
      end

      it_behaves_like 'sudo'
    end

    context 'using a personal access token' do
      let(:token) { create(:personal_access_token) }

      context 'passed as param' do
        before do
453
          set_param(Gitlab::Auth::UserAuthFinders::PRIVATE_TOKEN_PARAM, token.token)
454 455 456 457 458 459 460
        end

        it_behaves_like 'sudo'
      end

      context 'passed as header' do
        before do
461
          env[Gitlab::Auth::UserAuthFinders::PRIVATE_TOKEN_HEADER] = token.token
462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478
        end

        it_behaves_like 'sudo'
      end
    end

    context 'using warden authentication' do
      before do
        warden_authenticate_returns admin
        env[API::Helpers::SUDO_HEADER] = user.username
      end

      it 'raises an error' do
        expect { current_user }.to raise_error /Must be authenticated using an OAuth or Personal Access Token to use sudo/
      end
    end
  end
479
end