helpers_spec.rb 14.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
Stan Hu's avatar
Stan Hu committed
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 Trzcinski's avatar
Kamil Trzcinski committed
26
  let(:header) { }
Francisco Lopez's avatar
Francisco Lopez 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 Trzcinski's avatar
Kamil Trzcinski 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

      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
174
          expect { current_user }.to raise_error /must accept the Terms of Service/
175 176 177 178 179 180 181 182
        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
      end

      it 'does not allow expired tokens' do
Lin Jen-Shin's avatar
Lin Jen-Shin committed
204
        personal_access_token.update!(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 211 212 213 214 215 216 217 218 219 220 221

      context 'when impersonation is disabled' do
        let(:personal_access_token) { create(:personal_access_token, :impersonation, user: user) }

        before do
          stub_config_setting(impersonation_enabled: false)
          env[Gitlab::Auth::UserAuthFinders::PRIVATE_TOKEN_HEADER] = personal_access_token.token
        end

        it 'does not allow impersonation tokens' do
          expect { current_user }.to raise_error Gitlab::Auth::ImpersonationDisabled
        end
      end
222 223
    end
  end
224

Stan Hu's avatar
Stan Hu committed
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244
  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)
245
      expect(Raven).to receive(:capture_exception).with(exception, extra: {})
Stan Hu's avatar
Stan Hu committed
246 247 248

      handle_api_exception(exception)
    end
249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269

    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
270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293

    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
Stan Hu's avatar
Stan Hu committed
294
  end
295 296 297 298 299

  describe '.authenticate_non_get!' do
    %w[HEAD GET].each do |method_name|
      context "method is #{method_name}" do
        before do
300
          expect_any_instance_of(self.class).to receive(:route).and_return(double(request_method: method_name))
301 302 303 304 305 306 307 308 309 310 311 312 313
        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
314
          expect_any_instance_of(self.class).to receive(:route).and_return(double(request_method: method_name))
315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
        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
333
        expect { authenticate! }.to raise_error /401/
334 335 336 337
      end
    end

    context 'current_user is present' do
338 339
      let(:user) { build(:user) }

340
      before do
341
        expect_any_instance_of(self.class).to receive(:current_user).and_return(user)
342 343 344 345 346 347 348
      end

      it 'does not raise an error' do
        expect { authenticate! }.not_to raise_error
      end
    end
  end
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 383

  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

384 385 386 387 388 389 390 391
              context 'when providing username (case insensitive)' do
                before do
                  env[API::Helpers::SUDO_HEADER] = user.username.upcase
                end

                it_behaves_like 'successful sudo'
              end

392 393 394 395 396 397 398 399 400 401 402 403
              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
404
                  set_param(API::Helpers::SUDO_PARAM, user.username)
405 406 407 408 409
                end

                it_behaves_like 'successful sudo'
              end

410 411 412 413 414 415 416 417
              context 'when providing username (case insensitive)' do
                before do
                  set_param(API::Helpers::SUDO_PARAM, user.username.upcase)
                end

                it_behaves_like 'successful sudo'
              end

418 419
              context 'when providing user ID' do
                before do
420
                  set_param(API::Helpers::SUDO_PARAM, user.id.to_s)
421 422 423 424 425 426 427 428 429
                end

                it_behaves_like 'successful sudo'
              end
            end
          end

          context 'when user does not exist' do
            before do
430
              set_param(API::Helpers::SUDO_PARAM, 'nonexistent')
431 432 433 434 435 436 437 438 439 440 441 442 443
            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!

444
            set_param(API::Helpers::SUDO_PARAM, user.id.to_s)
445 446 447
          end

          it 'raises an error' do
448
            expect { current_user }.to raise_error Gitlab::Auth::InsufficientScopeError
449 450 451 452 453 454 455 456 457
          end
        end
      end

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

458
          set_param(API::Helpers::SUDO_PARAM, user.id.to_s)
459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481
        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
482
          set_param(Gitlab::Auth::UserAuthFinders::PRIVATE_TOKEN_PARAM, token.token)
483 484 485 486 487 488 489
        end

        it_behaves_like 'sudo'
      end

      context 'passed as header' do
        before do
490
          env[Gitlab::Auth::UserAuthFinders::PRIVATE_TOKEN_HEADER] = token.token
491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507
        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
Jeroen van Baarsen's avatar
Jeroen van Baarsen committed
508
end