BigW Consortium Gitlab

git_access_spec.rb 14.3 KB
Newer Older
1 2
require 'spec_helper'

Douwe Maan committed
3
describe Gitlab::GitAccess, lib: true do
4
  let(:access) { Gitlab::GitAccess.new(actor, project, 'web', authentication_abilities: authentication_abilities) }
5
  let(:project) { create(:project, :repository) }
6
  let(:user) { create(:user) }
7
  let(:actor) { user }
8
  let(:authentication_abilities) do
Kamil Trzcinski committed
9 10 11 12 13 14
    [
      :read_project,
      :download_code,
      :push_code
    ]
  end
15

16 17 18
  describe '#check with single protocols allowed' do
    def disable_protocol(protocol)
      settings = ::ApplicationSetting.create_from_defaults
19
      settings.update_attribute(:enabled_git_access_protocol, protocol)
20 21 22 23 24
    end

    context 'ssh disabled' do
      before do
        disable_protocol('ssh')
25
        @acc = Gitlab::GitAccess.new(actor, project, 'ssh', authentication_abilities: authentication_abilities)
26 27 28
      end

      it 'blocks ssh git push' do
29
        expect(@acc.check('git-receive-pack', '_any').allowed?).to be_falsey
30 31 32
      end

      it 'blocks ssh git pull' do
33
        expect(@acc.check('git-upload-pack', '_any').allowed?).to be_falsey
34 35 36 37 38 39
      end
    end

    context 'http disabled' do
      before do
        disable_protocol('http')
40
        @acc = Gitlab::GitAccess.new(actor, project, 'http', authentication_abilities: authentication_abilities)
41 42 43
      end

      it 'blocks http push' do
44
        expect(@acc.check('git-receive-pack', '_any').allowed?).to be_falsey
45 46 47
      end

      it 'blocks http git pull' do
48
        expect(@acc.check('git-upload-pack', '_any').allowed?).to be_falsey
49 50 51 52
      end
    end
  end

53
  describe '#check_download_access!' do
54
    subject { access.check('git-upload-pack', '_any') }
55

56 57 58 59
    describe 'master permissions' do
      before { project.team << [user, :master] }

      context 'pull code' do
60
        it { expect(subject.allowed?).to be_truthy }
61 62 63 64 65 66 67
      end
    end

    describe 'guest permissions' do
      before { project.team << [user, :guest] }

      context 'pull code' do
68
        it { expect(subject.allowed?).to be_falsey }
69
        it { expect(subject.message).to match(/You are not allowed to download code/) }
70 71 72 73 74 75 76 77 78 79
      end
    end

    describe 'blocked user' do
      before do
        project.team << [user, :master]
        user.block
      end

      context 'pull code' do
80
        it { expect(subject.allowed?).to be_falsey }
81
        it { expect(subject.message).to match(/Your account has been blocked/) }
82 83 84
      end
    end

85
    describe 'without access to project' do
86
      context 'pull code' do
87
        it { expect(subject.allowed?).to be_falsey }
88
      end
89 90

      context 'when project is public' do
91
        let(:public_project) { create(:project, :public, :repository) }
92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109
        let(:guest_access) { Gitlab::GitAccess.new(nil, public_project, 'web', authentication_abilities: []) }
        subject { guest_access.check('git-upload-pack', '_any') }

        context 'when repository is enabled' do
          it 'give access to download code' do
            expect(subject.allowed?).to be_truthy
          end
        end

        context 'when repository is disabled' do
          it 'does not give access to download code' do
            public_project.project_feature.update_attribute(:repository_access_level, ProjectFeature::DISABLED)

            expect(subject.allowed?).to be_falsey
            expect(subject.message).to match(/You are not allowed to download code/)
          end
        end
      end
110
    end
111 112

    describe 'deploy key permissions' do
113
      let(:key) { create(:deploy_key, user: user) }
114
      let(:actor) { key }
115 116

      context 'pull code' do
117 118
        context 'when project is authorized' do
          before { key.projects << project }
119

120 121 122 123 124
          it { expect(subject).to be_allowed }
        end

        context 'when unauthorized' do
          context 'from public project' do
125
            let(:project) { create(:project, :public, :repository) }
126 127 128 129 130

            it { expect(subject).to be_allowed }
          end

          context 'from internal project' do
131
            let(:project) { create(:project, :internal, :repository) }
132 133 134 135 136

            it { expect(subject).not_to be_allowed }
          end

          context 'from private project' do
137
            let(:project) { create(:project, :private, :repository) }
138 139 140 141

            it { expect(subject).not_to be_allowed }
          end
        end
142 143
      end
    end
Kamil Trzcinski committed
144

145 146
    describe 'build authentication_abilities permissions' do
      let(:authentication_abilities) { build_authentication_abilities }
Kamil Trzcinski committed
147

148
      describe 'owner' do
149
        let(:project) { create(:project, :repository, namespace: user.namespace) }
150 151 152 153 154 155

        context 'pull code' do
          it { expect(subject).to be_allowed }
        end
      end

Kamil Trzcinski committed
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 181
      describe 'reporter user' do
        before { project.team << [user, :reporter] }

        context 'pull code' do
          it { expect(subject).to be_allowed }
        end
      end

      describe 'admin user' do
        let(:user) { create(:admin) }

        context 'when member of the project' do
          before { project.team << [user, :reporter] }

          context 'pull code' do
            it { expect(subject).to be_allowed }
          end
        end

        context 'when is not member of the project' do
          context 'pull code' do
            it { expect(subject).not_to be_allowed }
          end
        end
      end
    end
182 183
  end

184
  describe '#check_push_access!' do
185
    before { merge_into_protected_branch }
186
    let(:unprotected_branch) { 'unprotected_branch' }
187

188 189
    let(:changes) do
      { push_new_branch: "#{Gitlab::Git::BLANK_SHA} 570e7b2ab refs/heads/wow",
190 191
        push_master: '6f6d7e7ed 570e7b2ab refs/heads/master',
        push_protected_branch: '6f6d7e7ed 570e7b2ab refs/heads/feature',
192 193
        push_remove_protected_branch: "570e7b2ab #{Gitlab::Git::BLANK_SHA} "\
                                      'refs/heads/feature',
194
        push_tag: '6f6d7e7ed 570e7b2ab refs/tags/v1.0.0',
195
        push_new_tag: "#{Gitlab::Git::BLANK_SHA} 570e7b2ab refs/tags/v7.8.9",
196 197
        push_all: ['6f6d7e7ed 570e7b2ab refs/heads/master', '6f6d7e7ed 570e7b2ab refs/heads/feature'],
        merge_into_protected_branch: "0b4bc9a #{merge_into_protected_branch} refs/heads/feature" }
198
    end
199

200 201
    def stub_git_hooks
      # Running the `pre-receive` hook is expensive, and not necessary for this test.
Sean McGivern committed
202 203 204
      allow_any_instance_of(GitHooksService).to receive(:execute) do |service, &block|
        block.call(service)
      end
205
    end
206

207 208 209 210 211
    def merge_into_protected_branch
      @protected_branch_merge_commit ||= begin
        stub_git_hooks
        project.repository.add_branch(user, unprotected_branch, 'feature')
        target_branch = project.repository.lookup('feature')
212
        source_branch = project.repository.create_file(
213
          user,
214 215 216
          'John Doe',
          'This is the file content',
          message: 'This is a good commit message',
217
          branch_name: unprotected_branch)
218 219
        rugged = project.repository.rugged
        author = { email: "email@example.com", time: Time.now, name: "Example Git User" }
220

221 222
        merge_index = rugged.merge_commits(target_branch, source_branch)
        Rugged::Commit.create(rugged, author: author, committer: author, message: "commit message", parents: [target_branch, source_branch], tree: merge_index.write_tree(rugged))
223 224
      end
    end
225

226
    # Run permission checks for a user
227 228
    def self.run_permission_checks(permissions_matrix)
      permissions_matrix.keys.each do |role|
229
        describe "#{role} access" do
230 231 232 233 234 235
          before do
            if role == :admin
              user.update_attribute(:admin, true)
            else
              project.team << [user, role]
            end
Sean McGivern committed
236 237 238 239 240
          end

          permissions_matrix[role].each do |action, allowed|
            context action do
              subject { access.send(:check_push_access!, changes[action]) }
241

Sean McGivern committed
242 243 244 245 246 247
              it do
                if allowed
                  expect { subject }.not_to raise_error
                else
                  expect { subject }.to raise_error(Gitlab::GitAccess::UnauthorizedError)
                end
248
              end
249 250 251 252 253
            end
          end
        end
      end
    end
254 255

    permissions_matrix = {
256 257 258 259 260 261 262 263 264 265 266
      admin: {
        push_new_branch: true,
        push_master: true,
        push_protected_branch: true,
        push_remove_protected_branch: false,
        push_tag: true,
        push_new_tag: true,
        push_all: true,
        merge_into_protected_branch: true
      },

267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
      master: {
        push_new_branch: true,
        push_master: true,
        push_protected_branch: true,
        push_remove_protected_branch: false,
        push_tag: true,
        push_new_tag: true,
        push_all: true,
        merge_into_protected_branch: true
      },

      developer: {
        push_new_branch: true,
        push_master: true,
        push_protected_branch: false,
        push_remove_protected_branch: false,
        push_tag: false,
        push_new_tag: true,
        push_all: false,
        merge_into_protected_branch: false
      },

      reporter: {
        push_new_branch: false,
        push_master: false,
        push_protected_branch: false,
        push_remove_protected_branch: false,
        push_tag: false,
        push_new_tag: false,
        push_all: false,
        merge_into_protected_branch: false
      },

      guest: {
        push_new_branch: false,
        push_master: false,
        push_protected_branch: false,
        push_remove_protected_branch: false,
        push_tag: false,
        push_new_tag: false,
        push_all: false,
        merge_into_protected_branch: false
      }
    }

Douwe Maan committed
312
    [%w(feature exact), ['feat*', 'wildcard']].each do |protected_branch_name, protected_branch_type|
313 314 315 316 317 318
      context do
        before { create(:protected_branch, name: protected_branch_name, project: project) }

        run_permission_checks(permissions_matrix)
      end

319 320
      context "when developers are allowed to push into the #{protected_branch_type} protected branch" do
        before { create(:protected_branch, :developers_can_push, name: protected_branch_name, project: project) }
321 322 323 324

        run_permission_checks(permissions_matrix.deep_merge(developer: { push_protected_branch: true, push_all: true, merge_into_protected_branch: true }))
      end

325 326
      context "developers are allowed to merge into the #{protected_branch_type} protected branch" do
        before { create(:protected_branch, :developers_can_merge, name: protected_branch_name, project: project) }
327 328 329 330

        context "when a merge request exists for the given source/target branch" do
          context "when the merge request is in progress" do
            before do
331
              create(:merge_request, source_project: project, source_branch: unprotected_branch, target_branch: 'feature',
332
                                     state: 'locked', in_progress_merge_commit_sha: merge_into_protected_branch)
333 334
            end

335 336
            run_permission_checks(permissions_matrix.deep_merge(developer: { merge_into_protected_branch: true }))
          end
337

338 339 340
          context "when the merge request is not in progress" do
            before do
              create(:merge_request, source_project: project, source_branch: unprotected_branch, target_branch: 'feature', in_progress_merge_commit_sha: nil)
341
            end
342 343

            run_permission_checks(permissions_matrix.deep_merge(developer: { merge_into_protected_branch: false }))
344
          end
345

346
          context "when a merge request does not exist for the given source/target branch" do
347 348 349 350 351
            run_permission_checks(permissions_matrix.deep_merge(developer: { merge_into_protected_branch: false }))
          end
        end
      end

352 353
      context "when developers are allowed to push and merge into the #{protected_branch_type} protected branch" do
        before { create(:protected_branch, :developers_can_merge, :developers_can_push, name: protected_branch_name, project: project) }
354 355 356

        run_permission_checks(permissions_matrix.deep_merge(developer: { push_protected_branch: true, push_all: true, merge_into_protected_branch: true }))
      end
357

358 359
      context "when no one is allowed to push to the #{protected_branch_name} protected branch" do
        before { create(:protected_branch, :no_one_can_push, name: protected_branch_name, project: project) }
360

361 362 363 364
        run_permission_checks(permissions_matrix.deep_merge(developer: { push_protected_branch: false, push_all: false, merge_into_protected_branch: false },
                                                            master: { push_protected_branch: false, push_all: false, merge_into_protected_branch: false },
                                                            admin: { push_protected_branch: false, push_all: false, merge_into_protected_branch: false }))
      end
365 366
    end
  end
367

368
  shared_examples 'pushing code' do |can|
Kamil Trzcinski committed
369
    subject { access.check('git-receive-pack', '_any') }
370

Kamil Trzcinski committed
371
    context 'when project is authorized' do
Kamil Trzcinski committed
372
      before { authorize }
373

374
      it { expect(subject).public_send(can, be_allowed) }
Kamil Trzcinski committed
375 376 377 378
    end

    context 'when unauthorized' do
      context 'to public project' do
379
        let(:project) { create(:project, :public, :repository) }
380

381 382
        it { expect(subject).not_to be_allowed }
      end
383

Kamil Trzcinski committed
384
      context 'to internal project' do
385
        let(:project) { create(:project, :internal, :repository) }
386

Kamil Trzcinski committed
387 388
        it { expect(subject).not_to be_allowed }
      end
389

Kamil Trzcinski committed
390
      context 'to private project' do
391
        let(:project) { create(:project, :private, :repository) }
392

Kamil Trzcinski committed
393
        it { expect(subject).not_to be_allowed }
394 395
      end
    end
396
  end
Kamil Trzcinski committed
397

398 399
  describe 'build authentication abilities' do
    let(:authentication_abilities) { build_authentication_abilities }
Kamil Trzcinski committed
400

401
    it_behaves_like 'pushing code', :not_to do
Kamil Trzcinski committed
402 403 404 405
      def authorize
        project.team << [user, :reporter]
      end
    end
Kamil Trzcinski committed
406 407 408
  end

  describe 'deploy key permissions' do
409
    let(:key) { create(:deploy_key, user: user, can_push: can_push) }
Kamil Trzcinski committed
410 411
    let(:actor) { key }

412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428
    context 'when deploy_key can push' do
      let(:can_push) { true }

      it_behaves_like 'pushing code', :to do
        def authorize
          key.projects << project
        end
      end
    end

    context 'when deploy_key cannot push' do
      let(:can_push) { false }

      it_behaves_like 'pushing code', :not_to do
        def authorize
          key.projects << project
        end
Kamil Trzcinski committed
429 430
      end
    end
Kamil Trzcinski committed
431 432 433 434
  end

  private

435
  def build_authentication_abilities
Kamil Trzcinski committed
436 437 438 439 440
    [
      :read_project,
      :build_download_code
    ]
  end
441

442
  def full_authentication_abilities
443 444 445 446 447 448
    [
      :read_project,
      :download_code,
      :push_code
    ]
  end
449
end