BigW Consortium Gitlab

git_access_spec.rb 14.1 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 186
    before { merge_into_protected_branch }
    let(:unprotected_branch) { FFaker::Internet.user_name }
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 202
    def stub_git_hooks
      # Running the `pre-receive` hook is expensive, and not necessary for this test.
      allow_any_instance_of(GitHooksService).to receive(:execute).and_yield
203
    end
204

205 206 207 208 209
    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')
210 211 212 213 214 215 216
        source_branch = project.repository.commit_file(
          user,
          FFaker::InternetSE.login_user_name,
          FFaker::HipsterIpsum.paragraph,
          message: FFaker::HipsterIpsum.sentence,
          branch_name: unprotected_branch,
          update: false)
217 218
        rugged = project.repository.rugged
        author = { email: "email@example.com", time: Time.now, name: "Example Git User" }
219

220 221
        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))
222 223
      end
    end
224

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

236 237
            permissions_matrix[role].each do |action, allowed|
              context action do
238
                subject { access.send(:check_push_access!, changes[action]) }
239 240
                it { expect(subject.allowed?).to allowed ? be_truthy : be_falsey }
              end
241 242 243 244 245
            end
          end
        end
      end
    end
246 247

    permissions_matrix = {
248 249 250 251 252 253 254 255 256 257 258
      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
      },

259 260 261 262 263 264 265 266 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
      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
      }
    }

    [['feature', 'exact'], ['feat*', 'wildcard']].each do |protected_branch_name, protected_branch_type|
      context do
        before { create(:protected_branch, name: protected_branch_name, project: project) }

        run_permission_checks(permissions_matrix)
      end

311 312
      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) }
313 314 315 316

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

317 318
      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) }
319 320 321 322

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

327 328
            run_permission_checks(permissions_matrix.deep_merge(developer: { merge_into_protected_branch: true }))
          end
329

330 331 332
          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)
333
            end
334 335

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

338
          context "when a merge request does not exist for the given source/target branch" do
339 340 341 342 343
            run_permission_checks(permissions_matrix.deep_merge(developer: { merge_into_protected_branch: false }))
          end
        end
      end

344 345
      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) }
346 347 348

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

350 351
      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) }
352

353 354 355 356
        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
357 358
    end
  end
359

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

Kamil Trzcinski committed
363
    context 'when project is authorized' do
Kamil Trzcinski committed
364
      before { authorize }
365

366
      it { expect(subject).public_send(can, be_allowed) }
Kamil Trzcinski committed
367 368 369 370
    end

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

373 374
        it { expect(subject).not_to be_allowed }
      end
375

Kamil Trzcinski committed
376
      context 'to internal project' do
377
        let(:project) { create(:project, :internal, :repository) }
378

Kamil Trzcinski committed
379 380
        it { expect(subject).not_to be_allowed }
      end
381

Kamil Trzcinski committed
382
      context 'to private project' do
383
        let(:project) { create(:project, :private, :repository) }
384

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

390 391
  describe 'build authentication abilities' do
    let(:authentication_abilities) { build_authentication_abilities }
Kamil Trzcinski committed
392

393
    it_behaves_like 'pushing code', :not_to do
Kamil Trzcinski committed
394 395 396 397
      def authorize
        project.team << [user, :reporter]
      end
    end
Kamil Trzcinski committed
398 399 400
  end

  describe 'deploy key permissions' do
401
    let(:key) { create(:deploy_key, user: user, can_push: can_push) }
Kamil Trzcinski committed
402 403
    let(:actor) { key }

404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420
    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
421 422
      end
    end
Kamil Trzcinski committed
423 424 425 426
  end

  private

427
  def build_authentication_abilities
Kamil Trzcinski committed
428 429 430 431 432
    [
      :read_project,
      :build_download_code
    ]
  end
433

434
  def full_authentication_abilities
435 436 437 438 439 440
    [
      :read_project,
      :download_code,
      :push_code
    ]
  end
441
end