project_spec.rb 132 KB
Newer Older
gitlabhq's avatar
gitlabhq committed
1 2
require 'spec_helper'

3
describe Project do
4
  include ProjectForksHelper
5
  include GitHelpers
6

7
  describe 'associations' do
8 9 10
    it { is_expected.to belong_to(:group) }
    it { is_expected.to belong_to(:namespace) }
    it { is_expected.to belong_to(:creator).class_name('User') }
11
    it { is_expected.to belong_to(:pool_repository) }
12
    it { is_expected.to have_many(:users) }
ubudzisz's avatar
ubudzisz committed
13
    it { is_expected.to have_many(:services) }
14 15 16 17 18
    it { is_expected.to have_many(:events) }
    it { is_expected.to have_many(:merge_requests) }
    it { is_expected.to have_many(:issues) }
    it { is_expected.to have_many(:milestones) }
    it { is_expected.to have_many(:project_members).dependent(:delete_all) }
19
    it { is_expected.to have_many(:users).through(:project_members) }
20 21 22 23
    it { is_expected.to have_many(:requesters).dependent(:delete_all) }
    it { is_expected.to have_many(:notes) }
    it { is_expected.to have_many(:snippets).class_name('ProjectSnippet') }
    it { is_expected.to have_many(:deploy_keys_projects) }
24
    it { is_expected.to have_many(:deploy_keys) }
25 26 27 28 29
    it { is_expected.to have_many(:hooks) }
    it { is_expected.to have_many(:protected_branches) }
    it { is_expected.to have_one(:slack_service) }
    it { is_expected.to have_one(:microsoft_teams_service) }
    it { is_expected.to have_one(:mattermost_service) }
30
    it { is_expected.to have_one(:hangouts_chat_service) }
31
    it { is_expected.to have_one(:packagist_service) }
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
    it { is_expected.to have_one(:pushover_service) }
    it { is_expected.to have_one(:asana_service) }
    it { is_expected.to have_many(:boards) }
    it { is_expected.to have_one(:campfire_service) }
    it { is_expected.to have_one(:drone_ci_service) }
    it { is_expected.to have_one(:emails_on_push_service) }
    it { is_expected.to have_one(:pipelines_email_service) }
    it { is_expected.to have_one(:irker_service) }
    it { is_expected.to have_one(:pivotaltracker_service) }
    it { is_expected.to have_one(:hipchat_service) }
    it { is_expected.to have_one(:flowdock_service) }
    it { is_expected.to have_one(:assembla_service) }
    it { is_expected.to have_one(:slack_slash_commands_service) }
    it { is_expected.to have_one(:mattermost_slash_commands_service) }
    it { is_expected.to have_one(:buildkite_service) }
    it { is_expected.to have_one(:bamboo_service) }
    it { is_expected.to have_one(:teamcity_service) }
    it { is_expected.to have_one(:jira_service) }
50
    it { is_expected.to have_one(:github_service) }
51 52 53 54 55 56 57 58
    it { is_expected.to have_one(:redmine_service) }
    it { is_expected.to have_one(:custom_issue_tracker_service) }
    it { is_expected.to have_one(:bugzilla_service) }
    it { is_expected.to have_one(:gitlab_issue_tracker_service) }
    it { is_expected.to have_one(:external_wiki_service) }
    it { is_expected.to have_one(:project_feature) }
    it { is_expected.to have_one(:statistics).class_name('ProjectStatistics') }
    it { is_expected.to have_one(:import_data).class_name('ProjectImportData') }
ubudzisz's avatar
ubudzisz committed
59
    it { is_expected.to have_one(:last_event).class_name('Event') }
60
    it { is_expected.to have_one(:forked_from_project).through(:fork_network_member) }
Zeger-Jan van de Weg's avatar
Zeger-Jan van de Weg committed
61
    it { is_expected.to have_one(:auto_devops).class_name('ProjectAutoDevops') }
Kamil Trzcinski's avatar
Kamil Trzcinski committed
62
    it { is_expected.to have_many(:commit_statuses) }
63
    it { is_expected.to have_many(:pipelines) }
64
    it { is_expected.to have_many(:builds) }
65
    it { is_expected.to have_many(:build_trace_section_names)}
66 67 68 69
    it { is_expected.to have_many(:runner_projects) }
    it { is_expected.to have_many(:runners) }
    it { is_expected.to have_many(:variables) }
    it { is_expected.to have_many(:triggers) }
Kamil Trzcinski's avatar
Kamil Trzcinski committed
70
    it { is_expected.to have_many(:pages_domains) }
71 72
    it { is_expected.to have_many(:labels).class_name('ProjectLabel') }
    it { is_expected.to have_many(:users_star_projects) }
73
    it { is_expected.to have_many(:repository_languages) }
74 75 76 77 78 79 80
    it { is_expected.to have_many(:environments) }
    it { is_expected.to have_many(:deployments) }
    it { is_expected.to have_many(:todos) }
    it { is_expected.to have_many(:releases) }
    it { is_expected.to have_many(:lfs_objects_projects) }
    it { is_expected.to have_many(:project_group_links) }
    it { is_expected.to have_many(:notification_settings).dependent(:delete_all) }
81 82
    it { is_expected.to have_many(:forked_to_members).class_name('ForkNetworkMember') }
    it { is_expected.to have_many(:forks).through(:forked_to_members) }
Jan Provaznik's avatar
Jan Provaznik committed
83
    it { is_expected.to have_many(:uploads) }
84
    it { is_expected.to have_many(:pipeline_schedules) }
85
    it { is_expected.to have_many(:members_and_requesters) }
86
    it { is_expected.to have_many(:clusters) }
87
    it { is_expected.to have_many(:custom_attributes).class_name('ProjectCustomAttribute') }
88
    it { is_expected.to have_many(:project_badges).class_name('ProjectBadge') }
89
    it { is_expected.to have_many(:lfs_file_locks) }
90 91
    it { is_expected.to have_many(:project_deploy_tokens) }
    it { is_expected.to have_many(:deploy_tokens).through(:project_deploy_tokens) }
92

93 94 95 96
    it 'has an inverse relationship with merge requests' do
      expect(described_class.reflect_on_association(:merge_requests).has_inverse?).to eq(:target_project)
    end

97 98
    context 'after initialized' do
      it "has a project_feature" do
99
        expect(described_class.new.project_feature).to be_present
100 101 102
      end
    end

103 104 105 106 107 108 109 110 111
    context 'when creating a new project' do
      it 'automatically creates a CI/CD settings row' do
        project = create(:project)

        expect(project.ci_cd_settings).to be_an_instance_of(ProjectCiCdSetting)
        expect(project.ci_cd_settings).to be_persisted
      end
    end

112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
    context 'Site Statistics' do
      context 'when creating a new project' do
        it 'tracks project in SiteStatistic' do
          expect { create(:project) }.to change { SiteStatistic.fetch.repositories_count }.by(1)
        end
      end

      context 'when deleting a project' do
        it 'untracks project in SiteStatistic' do
          project = create(:project)

          expect { project.destroy }.to change { SiteStatistic.fetch.repositories_count }.by(-1)
        end
      end
    end

128 129 130 131 132 133 134 135
    context 'updating cd_cd_settings' do
      it 'does not raise an error' do
        project = create(:project)

        expect { project.update(ci_cd_settings: nil) }.not_to raise_exception
      end
    end

136
    describe '#members & #requesters' do
137
      let(:project) { create(:project, :public, :access_requestable) }
138 139 140 141
      let(:requester) { create(:user) }
      let(:developer) { create(:user) }
      before do
        project.request_access(requester)
142
        project.add_developer(developer)
143 144
      end

145 146
      it_behaves_like 'members and requesters associations' do
        let(:namespace) { project }
147 148
      end
    end
gitlabhq's avatar
gitlabhq committed
149 150
  end

151 152 153 154 155 156 157 158
  describe 'modules' do
    subject { described_class }

    it { is_expected.to include_module(Gitlab::ConfigHelper) }
    it { is_expected.to include_module(Gitlab::ShellAdapter) }
    it { is_expected.to include_module(Gitlab::VisibilityLevel) }
    it { is_expected.to include_module(Referable) }
    it { is_expected.to include_module(Sortable) }
159 160
  end

161 162 163 164 165 166 167 168 169 170 171 172
  describe 'scopes' do
    context '#with_wiki_enabled' do
      it 'returns a project' do
        project = create(:project_empty_repo, wiki_access_level: ProjectFeature::ENABLED)
        project1 = create(:project, wiki_access_level: ProjectFeature::DISABLED)

        expect(described_class.with_wiki_enabled).to include(project)
        expect(described_class.with_wiki_enabled).not_to include(project1)
      end
    end
  end

173
  describe 'validation' do
174
    let!(:project) { create(:project) }
175

176 177
    it { is_expected.to validate_presence_of(:name) }
    it { is_expected.to validate_uniqueness_of(:name).scoped_to(:namespace_id) }
178
    it { is_expected.to validate_length_of(:name).is_at_most(255) }
179
    it { is_expected.to validate_presence_of(:path) }
180 181
    it { is_expected.to validate_length_of(:path).is_at_most(255) }
    it { is_expected.to validate_length_of(:description).is_at_most(2000) }
182 183 184
    it { is_expected.to validate_length_of(:ci_config_path).is_at_most(255) }
    it { is_expected.to allow_value('').for(:ci_config_path) }
    it { is_expected.not_to allow_value('test/../foo').for(:ci_config_path) }
185
    it { is_expected.not_to allow_value('/test/foo').for(:ci_config_path) }
186 187
    it { is_expected.to validate_presence_of(:creator) }
    it { is_expected.to validate_presence_of(:namespace) }
188
    it { is_expected.to validate_presence_of(:repository_storage) }
189

190 191 192 193 194 195 196 197
    it 'validates build timeout constraints' do
      is_expected.to validate_numericality_of(:build_timeout)
        .only_integer
        .is_greater_than_or_equal_to(10.minutes)
        .is_less_than(1.month)
        .with_message('needs to be beetween 10 minutes and 1 month')
    end

198
    it 'does not allow new projects beyond user limits' do
199
      project2 = build(:project)
200 201
      allow(project2).to receive(:creator).and_return(double(can_create_project?: false, projects_limit: 0).as_null_object)
      expect(project2).not_to be_valid
Phil Hughes's avatar
Phil Hughes committed
202
      expect(project2.errors[:limit_reached].first).to match(/Personal project creation is not allowed/)
203
    end
204 205 206

    describe 'wiki path conflict' do
      context "when the new path has been used by the wiki of other Project" do
207
        it 'has an error on the name attribute' do
208
          new_project = build_stubbed(:project, namespace_id: project.namespace_id, path: "#{project.path}.wiki")
209 210 211 212 213 214 215

          expect(new_project).not_to be_valid
          expect(new_project.errors[:name].first).to eq('has already been taken')
        end
      end

      context "when the new wiki path has been used by the path of other Project" do
216
        it 'has an error on the name attribute' do
217 218
          project_with_wiki_suffix = create(:project, path: 'foo.wiki')
          new_project = build_stubbed(:project, namespace_id: project_with_wiki_suffix.namespace_id, path: 'foo')
219 220 221 222 223 224

          expect(new_project).not_to be_valid
          expect(new_project.errors[:name].first).to eq('has already been taken')
        end
      end
    end
225

226
    context 'repository storages inclusion' do
227
      let(:project2) { build(:project, repository_storage: 'missing') }
228 229

      before do
230
        storages = { 'custom' => { 'path' => 'tmp/tests/custom_repositories' } }
231 232 233
        allow(Gitlab.config.repositories).to receive(:storages).and_return(storages)
      end

234
      it "does not allow repository storages that don't match a label in the configuration" do
235 236 237 238
        expect(project2).not_to be_valid
        expect(project2.errors[:repository_storage].first).to match(/is not included in the list/)
      end
    end
239

240 241 242 243
    context '#mark_stuck_remote_mirrors_as_failed!' do
      it 'fails stuck remote mirrors' do
        project = create(:project, :repository, :remote_mirror)

Lin Jen-Shin's avatar
Lin Jen-Shin committed
244
        project.remote_mirrors.first.update(
245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
          update_status: :started,
          last_update_at: 2.days.ago
        )

        expect do
          project.mark_stuck_remote_mirrors_as_failed!
        end.to change { project.remote_mirrors.stuck.count }.from(1).to(0)
      end
    end

    context 'mirror' do
      subject { build(:project, mirror: true) }

      it { is_expected.to validate_presence_of(:import_url) }
      it { is_expected.to validate_presence_of(:mirror_user) }
    end

262
    it 'does not allow an invalid URI as import_url' do
263
      project = build(:project, import_url: 'invalid://')
James Lopez's avatar
James Lopez committed
264

265 266 267 268 269 270 271 272 273 274 275 276 277 278
      expect(project).not_to be_valid
    end

    it 'does allow a SSH URI as import_url for persisted projects' do
      project = create(:project)
      project.import_url = 'ssh://test@gitlab.com/project.git'

      expect(project).to be_valid
    end

    it 'does not allow a SSH URI as import_url for new projects' do
      project = build(:project, import_url: 'ssh://test@gitlab.com/project.git')

      expect(project).not_to be_valid
James Lopez's avatar
James Lopez committed
279 280
    end

281
    it 'does allow a valid URI as import_url' do
282
      project = build(:project, import_url: 'http://gitlab.com/project.git')
James Lopez's avatar
James Lopez committed
283

284
      expect(project).to be_valid
285
    end
286

287
    it 'allows an empty URI' do
288
      project = build(:project, import_url: '')
289

290
      expect(project).to be_valid
291 292 293
    end

    it 'does not produce import data on an empty URI' do
294
      project = build(:project, import_url: '')
295

296
      expect(project.import_data).to be_nil
297 298 299
    end

    it 'does not produce import data on an invalid URI' do
300
      project = build(:project, import_url: 'test://')
301

302
      expect(project.import_data).to be_nil
303
    end
James Lopez's avatar
James Lopez committed
304

305
    it "does not allow import_url pointing to localhost" do
306 307 308 309 310 311 312 313
      project = build(:project, import_url: 'http://localhost:9000/t.git')

      expect(project).to be_invalid
      expect(project.errors[:import_url].first).to include('Requests to localhost are not allowed')
    end

    it "does not allow import_url with invalid ports for new projects" do
      project = build(:project, import_url: 'http://github.com:25/t.git')
314

315 316
      expect(project).to be_invalid
      expect(project.errors[:import_url].first).to include('Only allowed ports are 80, 443')
317 318
    end

319 320 321
    it "does not allow import_url with invalid ports for persisted projects" do
      project = create(:project)
      project.import_url = 'http://github.com:25/t.git'
322

323 324
      expect(project).to be_invalid
      expect(project.errors[:import_url].first).to include('Only allowed ports are 22, 80, 443')
325 326
    end

327
    it "does not allow import_url with invalid user" do
328
      project = build(:project, import_url: 'http://$user:password@github.com/t.git')
329

330 331
      expect(project).to be_invalid
      expect(project.errors[:import_url].first).to include('Username needs to start with an alphanumeric character')
332 333
    end

334 335
    it 'creates import state when mirror gets enabled' do
      project2 = create(:project)
336

337
      expect do
Lin Jen-Shin's avatar
Lin Jen-Shin committed
338
        project2.update(mirror: true, import_url: generate(:url), mirror_user: project.creator)
339
      end.to change { ProjectImportState.where(project: project2).count }.from(0).to(1)
340 341
    end

James Lopez's avatar
James Lopez committed
342 343
    describe 'project pending deletion' do
      let!(:project_pending_deletion) do
344
        create(:project,
James Lopez's avatar
James Lopez committed
345 346 347
               pending_delete: true)
      end
      let(:new_project) do
348
        build(:project,
James Lopez's avatar
James Lopez committed
349 350 351 352 353 354 355 356 357 358 359 360
              name: project_pending_deletion.name,
              namespace: project_pending_deletion.namespace)
      end

      before do
        new_project.validate
      end

      it 'contains errors related to the project being deleted' do
        expect(new_project.errors.full_messages.first).to eq('The project is still being deleted. Please try again later.')
      end
    end
361 362 363

    describe 'path validation' do
      it 'allows paths reserved on the root namespace' do
364
        project = build(:project, path: 'api')
365 366 367 368 369

        expect(project).to be_valid
      end

      it 'rejects paths reserved on another level' do
370
        project = build(:project, path: 'tree')
371 372 373 374 375 376

        expect(project).not_to be_valid
      end

      it 'rejects nested paths' do
        parent = create(:group, :nested, path: 'environments')
377
        project = build(:project, path: 'folders', namespace: parent)
378 379 380 381 382 383

        expect(project).not_to be_valid
      end

      it 'allows a reserved group name' do
        parent = create(:group)
384
        project = build(:project, path: 'avatar', namespace: parent)
385 386 387

        expect(project).to be_valid
      end
388 389 390 391 392 393

      it 'allows a path ending in a period' do
        project = build(:project, path: 'foo.')

        expect(project).to be_valid
      end
394
    end
gitlabhq's avatar
gitlabhq committed
395
  end
396

397
  describe 'project token' do
398
    it 'sets an random token if none provided' do
399
      project = FactoryBot.create(:project, runners_token: '')
Kamil Trzcinski's avatar
Kamil Trzcinski committed
400
      expect(project.runners_token).not_to eq('')
401 402
    end

ubudzisz's avatar
ubudzisz committed
403
    it 'does not set an random token if one provided' do
404
      project = FactoryBot.create(:project, runners_token: 'my-token')
Kamil Trzcinski's avatar
Kamil Trzcinski committed
405
      expect(project.runners_token).to eq('my-token')
406 407
    end
  end
gitlabhq's avatar
gitlabhq committed
408

409
  describe 'Respond to' do
410 411 412 413 414
    it { is_expected.to respond_to(:url_to_repo) }
    it { is_expected.to respond_to(:repo_exists?) }
    it { is_expected.to respond_to(:execute_hooks) }
    it { is_expected.to respond_to(:owner) }
    it { is_expected.to respond_to(:path_with_namespace) }
415
    it { is_expected.to respond_to(:full_path) }
gitlabhq's avatar
gitlabhq committed
416 417
  end

418
  describe 'delegation' do
419
    [:add_guest, :add_reporter, :add_developer, :add_maintainer, :add_user, :add_users].each do |method|
420 421 422 423 424
      it { is_expected.to delegate_method(method).to(:team) }
    end

    it { is_expected.to delegate_method(:members).to(:team).with_prefix(true) }
    it { is_expected.to delegate_method(:name).to(:owner).with_prefix(true).with_arguments(allow_nil: true) }
425 426
  end

427 428 429 430 431 432 433 434 435
  describe '#to_reference_with_postfix' do
    it 'returns the full path with reference_postfix' do
      namespace = create(:namespace, path: 'sample-namespace')
      project = create(:project, path: 'sample-project', namespace: namespace)

      expect(project.to_reference_with_postfix).to eq 'sample-namespace/sample-project>'
    end
  end

436
  describe '#to_reference' do
437
    let(:owner)     { create(:user, name: 'Gitlab') }
438
    let(:namespace) { create(:namespace, path: 'sample-namespace', owner: owner) }
439
    let(:project)   { create(:project, path: 'sample-project', namespace: namespace) }
440
    let(:group)     { create(:group, name: 'Group', path: 'sample-group') }
441

442 443 444 445 446 447
    context 'when nil argument' do
      it 'returns nil' do
        expect(project.to_reference).to be_nil
      end
    end

448
    context 'when full is true' do
449
      it 'returns complete path to the project' do
450 451 452
        expect(project.to_reference(full: true)).to          eq 'sample-namespace/sample-project'
        expect(project.to_reference(project, full: true)).to eq 'sample-namespace/sample-project'
        expect(project.to_reference(group, full: true)).to   eq 'sample-namespace/sample-project'
453 454 455 456 457 458 459 460 461 462
      end
    end

    context 'when same project argument' do
      it 'returns nil' do
        expect(project.to_reference(project)).to be_nil
      end
    end

    context 'when cross namespace project argument' do
463
      let(:another_namespace_project) { create(:project, name: 'another-project') }
464 465 466 467 468 469 470

      it 'returns complete path to the project' do
        expect(project.to_reference(another_namespace_project)).to eq 'sample-namespace/sample-project'
      end
    end

    context 'when same namespace / cross-project argument' do
471
      let(:another_project) { create(:project, namespace: namespace) }
472

473
      it 'returns path to the project' do
474 475 476
        expect(project.to_reference(another_project)).to eq 'sample-project'
      end
    end
477

478 479
    context 'when different namespace / cross-project argument' do
      let(:another_namespace) { create(:namespace, path: 'another-namespace', owner: owner) }
480
      let(:another_project)   { create(:project, path: 'another-project', namespace: another_namespace) }
481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497

      it 'returns full path to the project' do
        expect(project.to_reference(another_project)).to eq 'sample-namespace/sample-project'
      end
    end

    context 'when argument is a namespace' do
      context 'with same project path' do
        it 'returns path to the project' do
          expect(project.to_reference(namespace)).to eq 'sample-project'
        end
      end

      context 'with different project path' do
        it 'returns full path to the project' do
          expect(project.to_reference(group)).to eq 'sample-namespace/sample-project'
        end
498 499
      end
    end
500 501 502 503 504
  end

  describe '#to_human_reference' do
    let(:owner) { create(:user, name: 'Gitlab') }
    let(:namespace) { create(:namespace, name: 'Sample namespace', owner: owner) }
505
    let(:project) { create(:project, name: 'Sample project', namespace: namespace) }
506 507 508 509 510 511 512 513 514 515 516 517 518 519

    context 'when nil argument' do
      it 'returns nil' do
        expect(project.to_human_reference).to be_nil
      end
    end

    context 'when same project argument' do
      it 'returns nil' do
        expect(project.to_human_reference(project)).to be_nil
      end
    end

    context 'when cross namespace project argument' do
520
      let(:another_namespace_project) { create(:project, name: 'another-project') }
521 522 523 524 525

      it 'returns complete name with namespace of the project' do
        expect(project.to_human_reference(another_namespace_project)).to eq 'Gitlab / Sample project'
      end
    end
526

527
    context 'when same namespace / cross-project argument' do
528
      let(:another_project) { create(:project, namespace: namespace) }
529 530 531 532

      it 'returns name of the project' do
        expect(project.to_human_reference(another_project)).to eq 'Sample project'
      end
533 534 535
    end
  end

536
  describe '#merge_method' do
Jan Provaznik's avatar
Jan Provaznik committed
537 538 539 540 541 542 543
    using RSpec::Parameterized::TableSyntax

    where(:ff, :rebase, :method) do
      true  | true  | :ff
      true  | false | :ff
      false | true  | :rebase_merge
      false | false | :merge
544 545
    end

Jan Provaznik's avatar
Jan Provaznik committed
546 547 548 549 550 551
    with_them do
      let(:project) { build(:project, merge_requests_rebase_enabled: rebase, merge_requests_ff_only_enabled: ff) }

      subject { project.merge_method }

      it { is_expected.to eq(method) }
552
    end
553 554
  end

555
  it 'returns valid url to repo' do
556
    project = described_class.new(path: 'somewhere')
557
    expect(project.url_to_repo).to eq(Gitlab.config.gitlab_shell.ssh_path_prefix + 'somewhere.git')
gitlabhq's avatar
gitlabhq committed
558 559
  end

Douwe Maan's avatar
Douwe Maan committed
560
  describe "#web_url" do
561
    let(:project) { create(:project, path: "somewhere") }
Douwe Maan's avatar
Douwe Maan committed
562 563

    it 'returns the full web URL for this repo' do
564
      expect(project.web_url).to eq("#{Gitlab.config.gitlab.url}/#{project.namespace.full_path}/somewhere")
Douwe Maan's avatar
Douwe Maan committed
565
    end
566 567
  end

568 569 570 571 572
  describe "#kerberos_url_to_repo" do
    let(:project) { create(:project, path: "somewhere") }

    it 'returns valid kerberos url for this repo' do
      expect(project.kerberos_url_to_repo).to eq("#{Gitlab.config.build_gitlab_kerberos_url}/#{project.namespace.path}/somewhere.git")
573 574 575
    end
  end

576 577
  describe "#readme_url" do
    context 'with a non-existing repository' do
578
      let(:project) { create(:project) }
579

580
      it 'returns nil' do
581 582 583 584 585 586
        expect(project.readme_url).to be_nil
      end
    end

    context 'with an existing repository' do
      context 'when no README exists' do
587
        let(:project) { create(:project, :empty_repo) }
588

589
        it 'returns nil' do
590 591 592 593 594
          expect(project.readme_url).to be_nil
        end
      end

      context 'when a README exists' do
595 596
        let(:project) { create(:project, :repository) }

597
        it 'returns the README' do
598
          expect(project.readme_url).to eq("#{project.web_url}/blob/master/README.md")
599 600
        end
      end
601 602 603
    end
  end

604
  describe "#new_issuable_address" do
605
    let(:project) { create(:project, path: "somewhere") }
606 607
    let(:user) { create(:user) }

608 609 610 611 612 613
    context 'incoming email enabled' do
      before do
        stub_incoming_email_setting(enabled: true, address: "p+%{key}@gl.ab")
      end

      it 'returns the address to create a new issue' do
614
        address = "p+#{project.full_path}+#{user.incoming_email_token}@gl.ab"
615

616 617 618 619 620 621 622
        expect(project.new_issuable_address(user, 'issue')).to eq(address)
      end

      it 'returns the address to create a new merge request' do
        address = "p+#{project.full_path}+merge-request+#{user.incoming_email_token}@gl.ab"

        expect(project.new_issuable_address(user, 'merge_request')).to eq(address)
623 624 625 626 627 628 629
      end
    end

    context 'incoming email disabled' do
      before do
        stub_incoming_email_setting(enabled: false)
      end
630

631
      it 'returns nil' do
632 633 634 635 636
        expect(project.new_issuable_address(user, 'issue')).to be_nil
      end

      it 'returns nil' do
        expect(project.new_issuable_address(user, 'merge_request')).to be_nil
637
      end
638 639 640
    end
  end

641
  describe 'last_activity methods' do
642 643
    let(:timestamp) { 2.hours.ago }
    # last_activity_at gets set to created_at upon creation
644
    let(:project) { create(:project, created_at: timestamp, updated_at: timestamp) }
gitlabhq's avatar
gitlabhq committed
645

646
    describe 'last_activity' do
647
      it 'alias last_activity to last_event' do
648
        last_event = create(:event, :closed, project: project)
649

650
        expect(project.last_activity).to eq(last_event)
651
      end
gitlabhq's avatar
gitlabhq committed
652 653
    end

654 655
    describe 'last_activity_date' do
      it 'returns the creation date of the project\'s last event if present' do
656
        new_event = create(:event, :closed, project: project, created_at: Time.now)
657

658
        project.reload
659
        expect(project.last_activity_at.to_i).to eq(new_event.created_at.to_i)
660
      end
661

662
      it 'returns the project\'s last update date if it has no events' do
663
        expect(project.last_activity_date).to eq(project.updated_at)
664
      end
665 666

      it 'returns the most recent timestamp' do
667 668 669
        project.update(updated_at: nil,
                       last_activity_at: timestamp,
                       last_repository_updated_at: timestamp - 1.hour)
670

671
        expect(project.last_activity_date).to be_like_time(timestamp)
672

673 674 675
        project.update(updated_at: timestamp,
                       last_activity_at: timestamp - 1.hour,
                       last_repository_updated_at: nil)
676

677
        expect(project.last_activity_date).to be_like_time(timestamp)
678
      end
679 680
    end
  end
681

682
  describe '#get_issue' do
683
    let(:project) { create(:project) }
684
    let!(:issue)  { create(:issue, project: project) }
685 686 687
    let(:user)    { create(:user) }

    before do
688
      project.add_developer(user)
689
    end
690 691 692

    context 'with default issues tracker' do
      it 'returns an issue' do
693
        expect(project.get_issue(issue.iid, user)).to eq issue
694 695
      end

696 697 698 699
      it 'returns count of open issues' do
        expect(project.open_issues_count).to eq(1)
      end

700
      it 'returns nil when no issue found' do
701 702 703 704 705 706
        expect(project.get_issue(999, user)).to be_nil
      end

      it "returns nil when user doesn't have access" do
        user = create(:user)
        expect(project.get_issue(issue.iid, user)).to eq nil
707 708 709 710
      end
    end

    context 'with external issues tracker' do
711
      let!(:internal_issue) { create(:issue, project: project) }
712
      before do
713
        allow(project).to receive(:external_issue_tracker).and_return(true)
714 715
      end

716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752
      context 'when internal issues are enabled' do
        it 'returns interlan issue' do
          issue = project.get_issue(internal_issue.iid, user)

          expect(issue).to be_kind_of(Issue)
          expect(issue.iid).to eq(internal_issue.iid)
          expect(issue.project).to eq(project)
        end

        it 'returns an ExternalIssue when internal issue does not exists' do
          issue = project.get_issue('FOO-1234', user)

          expect(issue).to be_kind_of(ExternalIssue)
          expect(issue.iid).to eq('FOO-1234')
          expect(issue.project).to eq(project)
        end
      end

      context 'when internal issues are disabled' do
        before do
          project.issues_enabled = false
          project.save!
        end

        it 'returns always an External issues' do
          issue = project.get_issue(internal_issue.iid, user)
          expect(issue).to be_kind_of(ExternalIssue)
          expect(issue.iid).to eq(internal_issue.iid.to_s)
          expect(issue.project).to eq(project)
        end

        it 'returns an ExternalIssue when internal issue does not exists' do
          issue = project.get_issue('FOO-1234', user)
          expect(issue).to be_kind_of(ExternalIssue)
          expect(issue.iid).to eq('FOO-1234')
          expect(issue.project).to eq(project)
        end
753 754 755 756 757
      end
    end
  end

  describe '#issue_exists?' do
758
    let(:project) { create(:project) }
759 760 761 762 763 764 765 766 767 768 769 770

    it 'is truthy when issue exists' do
      expect(project).to receive(:get_issue).and_return(double)
      expect(project.issue_exists?(1)).to be_truthy
    end

    it 'is falsey when issue does not exist' do
      expect(project).to receive(:get_issue).and_return(nil)
      expect(project.issue_exists?(1)).to be_falsey
    end
  end

771
  describe '#to_param' do
772 773
    context 'with namespace' do
      before do
774
        @group = create(:group, name: 'gitlab')
775
        @project = create(:project, name: 'gitlabhq', namespace: @group)
776 777
      end

Vinnie Okada's avatar
Vinnie Okada committed
778
      it { expect(@project.to_param).to eq('gitlabhq') }
779
    end
780 781 782

    context 'with invalid path' do
      it 'returns previous path to keep project suitable for use in URLs when persisted' do
783
        project = create(:project, path: 'gitlab')
784 785 786 787 788 789 790
        project.path = 'foo&bar'

        expect(project).not_to be_valid
        expect(project.to_param).to eq 'gitlab'
      end

      it 'returns current path when new record' do
791
        project = build(:project, path: 'gitlab')
792 793 794 795 796 797
        project.path = 'foo&bar'

        expect(project).not_to be_valid
        expect(project.to_param).to eq 'foo&bar'
      end
    end
798
  end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
799

800
  describe '#repository' do
801
    let(:project) { create(:project, :repository) }
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
802

803
    it 'returns valid repo' do
804
      expect(project.repository).to be_kind_of(Repository)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
805 806
    end
  end
807

808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893
  describe 'repository size restrictions' do
    let(:project) { build(:project) }

    before do
      allow_any_instance_of(ApplicationSetting).to receive(:repository_size_limit).and_return(50)
    end

    describe '#changes_will_exceed_size_limit?' do
      before do
        allow(project).to receive(:repository_and_lfs_size).and_return(49)
      end
      it 'returns true when changes go over' do
        expect(project.changes_will_exceed_size_limit?(5)).to be_truthy
      end
    end

    describe '#actual_size_limit' do
      it 'returns the limit set in the application settings' do
        expect(project.actual_size_limit).to eq(50)
      end

      it 'returns the value set in the group' do
        group = create(:group, repository_size_limit: 100)
        project.update_attribute(:namespace_id, group.id)

        expect(project.actual_size_limit).to eq(100)
      end

      it 'returns the value set locally' do
        project.update_attribute(:repository_size_limit, 75)

        expect(project.actual_size_limit).to eq(75)
      end
    end

    describe '#size_limit_enabled?' do
      it 'returns false when disabled' do
        project.update_attribute(:repository_size_limit, 0)

        expect(project.size_limit_enabled?).to be_falsey
      end

      it 'returns true when a limit is set' do
        project.update_attribute(:repository_size_limit, 75)

        expect(project.size_limit_enabled?).to be_truthy
      end
    end

    describe '#above_size_limit?' do
      let(:project) do
        create(:project,
               statistics: build(:project_statistics))
      end

      it 'returns true when above the limit' do
        allow(project).to receive(:repository_and_lfs_size).and_return(100)

        expect(project.above_size_limit?).to be_truthy
      end

      it 'returns false when not over the limit' do
        expect(project.above_size_limit?).to be_falsey
      end
    end

    describe '#size_to_remove' do
      it 'returns the correct value' do
        allow(project).to receive(:repository_and_lfs_size).and_return(100)

        expect(project.size_to_remove).to eq(50)
      end
    end
  end

  describe '#repository_size_limit column' do
    it 'support values up to 8 exabytes' do
      project = create(:project)
      project.update_column(:repository_size_limit, 8.exabytes - 1)

      project.reload

      expect(project.repository_size_limit).to eql(8.exabytes - 1)
    end
  end

894
  describe '#default_issues_tracker?' do
895
    it "is true if used internal tracker" do
896
      project = build(:project)
897

898
      expect(project.default_issues_tracker?).to be_truthy
899 900
    end

901
    it "is false if used other tracker" do
902 903 904 905
      # NOTE: The current nature of this factory requires persistence
      project = create(:redmine_project)

      expect(project.default_issues_tracker?).to be_falsey
906 907 908
    end
  end

909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926
  describe '#empty_repo?' do
    context 'when the repo does not exist' do
      let(:project) { build_stubbed(:project) }

      it 'returns true' do
        expect(project.empty_repo?).to be(true)
      end
    end

    context 'when the repo exists' do
      let(:project) { create(:project, :repository) }
      let(:empty_project) { create(:project, :empty_repo) }

      it { expect(empty_project.empty_repo?).to be(true) }
      it { expect(project.empty_repo?).to be(false) }
    end
  end

927
  describe '#external_issue_tracker' do
928
    let(:project) { create(:project) }
929 930 931
    let(:ext_project) { create(:redmine_project) }

    context 'on existing projects with no value for has_external_issue_tracker' do
932
      before do
933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961
        project.update_column(:has_external_issue_tracker, nil)
        ext_project.update_column(:has_external_issue_tracker, nil)
      end

      it 'updates the has_external_issue_tracker boolean' do
        expect do
          project.external_issue_tracker
        end.to change { project.reload.has_external_issue_tracker }.to(false)

        expect do
          ext_project.external_issue_tracker
        end.to change { ext_project.reload.has_external_issue_tracker }.to(true)
      end
    end

    it 'returns nil and does not query services when there is no external issue tracker' do
      expect(project).not_to receive(:services)

      expect(project.external_issue_tracker).to eq(nil)
    end

    it 'retrieves external_issue_tracker querying services and cache it when there is external issue tracker' do
      ext_project.reload # Factory returns a project with changed attributes
      expect(ext_project).to receive(:services).once.and_call_original

      2.times { expect(ext_project.external_issue_tracker).to be_a_kind_of(RedmineService) }
    end
  end

962
  describe '#cache_has_external_issue_tracker' do
963
    let(:project) { create(:project, has_external_issue_tracker: nil) }
964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981

    it 'stores true if there is any external_issue_tracker' do
      services = double(:service, external_issue_trackers: [RedmineService.new])
      expect(project).to receive(:services).and_return(services)

      expect do
        project.cache_has_external_issue_tracker
      end.to change { project.has_external_issue_tracker}.to(true)
    end

    it 'stores false if there is no external_issue_tracker' do
      services = double(:service, external_issue_trackers: [])
      expect(project).to receive(:services).and_return(services)

      expect do
        project.cache_has_external_issue_tracker
      end.to change { project.has_external_issue_tracker}.to(false)
    end
982

983
    it 'does not cache data when in a read-only GitLab instance' do
984
      allow(Gitlab::Database).to receive(:read_only?) { true }
985 986 987 988 989 990

      expect do
        project.cache_has_external_issue_tracker
      end.not_to change { project.has_external_issue_tracker }
    end
  end
991 992

  describe '#cache_has_external_wiki' do
993
    let(:project) { create(:project, has_external_wiki: nil) }
994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012

    it 'stores true if there is any external_wikis' do
      services = double(:service, external_wikis: [ExternalWikiService.new])
      expect(project).to receive(:services).and_return(services)

      expect do
        project.cache_has_external_wiki
      end.to change { project.has_external_wiki}.to(true)
    end

    it 'stores false if there is no external_wikis' do
      services = double(:service, external_wikis: [])
      expect(project).to receive(:services).and_return(services)

      expect do
        project.cache_has_external_wiki
      end.to change { project.has_external_wiki}.to(false)
    end

1013
    it 'does not cache data when in a read-only GitLab instance' do
1014
      allow(Gitlab::Database).to receive(:read_only?) { true }
1015 1016 1017 1018 1019

      expect do
        project.cache_has_external_wiki
      end.not_to change { project.has_external_wiki }
    end
1020 1021
  end

1022
  describe '#has_wiki?' do
1023 1024 1025
    let(:no_wiki_project)       { create(:project, :wiki_disabled, has_external_wiki: false) }
    let(:wiki_enabled_project)  { create(:project) }
    let(:external_wiki_project) { create(:project, has_external_wiki: true) }
1026 1027 1028 1029 1030 1031 1032 1033

    it 'returns true if project is wiki enabled or has external wiki' do
      expect(wiki_enabled_project).to have_wiki
      expect(external_wiki_project).to have_wiki
      expect(no_wiki_project).not_to have_wiki
    end
  end

1034
  describe '#external_wiki' do
1035
    let(:project) { create(:project) }
1036

1037 1038 1039 1040 1041
    context 'with an active external wiki' do
      before do
        create(:service, project: project, type: 'ExternalWikiService', active: true)
        project.external_wiki
      end
1042

1043 1044 1045
      it 'sets :has_external_wiki as true' do
        expect(project.has_external_wiki).to be(true)
      end
1046

1047 1048
      it 'sets :has_external_wiki as false if an external wiki service is destroyed later' do
        expect(project.has_external_wiki).to be(true)
1049

1050 1051 1052 1053
        project.services.external_wikis.first.destroy

        expect(project.has_external_wiki).to be(false)
      end
1054 1055
    end

1056 1057 1058 1059
    context 'with an inactive external wiki' do
      before do
        create(:service, project: project, type: 'ExternalWikiService', active: false)
      end
1060

1061 1062 1063
      it 'sets :has_external_wiki as false' do
        expect(project.has_external_wiki).to be(false)
      end
1064 1065
    end

1066 1067 1068 1069
    context 'with no external wiki' do
      before do
        project.external_wiki
      end
1070

1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081
      it 'sets :has_external_wiki as false' do
        expect(project.has_external_wiki).to be(false)
      end

      it 'sets :has_external_wiki as true if an external wiki service is created later' do
        expect(project.has_external_wiki).to be(false)

        create(:service, project: project, type: 'ExternalWikiService', active: true)

        expect(project.has_external_wiki).to be(true)
      end
1082 1083 1084
    end
  end

1085 1086
  describe '#star_count' do
    it 'counts stars from multiple users' do
1087 1088
      user1 = create(:user)
      user2 = create(:user)
1089
      project = create(:project, :public)
Ciro Santilli's avatar
Ciro Santilli committed
1090 1091

      expect(project.star_count).to eq(0)
1092

Ciro Santilli's avatar
Ciro Santilli committed
1093
      user1.toggle_star(project)
1094 1095
      expect(project.reload.star_count).to eq(1)

Ciro Santilli's avatar
Ciro Santilli committed
1096
      user2.toggle_star(project)
1097 1098 1099
      project.reload
      expect(project.reload.star_count).to eq(2)

Ciro Santilli's avatar
Ciro Santilli committed
1100
      user1.toggle_star(project)
1101 1102 1103
      project.reload
      expect(project.reload.star_count).to eq(1)

Ciro Santilli's avatar
Ciro Santilli committed
1104
      user2.toggle_star(project)
1105 1106 1107 1108
      project.reload
      expect(project.reload.star_count).to eq(0)
    end

1109
    it 'counts stars on the right project' do
1110
      user = create(:user)
1111 1112
      project1 = create(:project, :public)
      project2 = create(:project, :public)
1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139

      expect(project1.star_count).to eq(0)
      expect(project2.star_count).to eq(0)

      user.toggle_star(project1)
      project1.reload
      project2.reload
      expect(project1.star_count).to eq(1)
      expect(project2.star_count).to eq(0)

      user.toggle_star(project1)
      project1.reload
      project2.reload
      expect(project1.star_count).to eq(0)
      expect(project2.star_count).to eq(0)

      user.toggle_star(project2)
      project1.reload
      project2.reload
      expect(project1.star_count).to eq(0)
      expect(project2.star_count).to eq(1)

      user.toggle_star(project2)
      project1.reload
      project2.reload
      expect(project1.star_count).to eq(0)
      expect(project2.star_count).to eq(0)
Ciro Santilli's avatar
Ciro Santilli committed
1140 1141
    end
  end
1142

1143
  describe '#avatar_type' do
1144
    let(:project) { create(:project) }
1145

1146
    it 'is true if avatar is image' do
1147
      project.update_attribute(:avatar, 'uploads/avatar.png')
1148
      expect(project.avatar_type).to be_truthy
1149 1150
    end

1151
    it 'is false if avatar is html page' do
1152
      project.update_attribute(:avatar, 'uploads/avatar.html')
1153
      expect(project.avatar_type).to eq(['file format is not supported. Please try one of the following supported formats: png, jpg, jpeg, gif, bmp, tiff, ico'])
1154 1155
    end
  end
sue445's avatar
sue445 committed
1156

1157
  describe '#avatar_url' do
sue445's avatar
sue445 committed
1158 1159
    subject { project.avatar_url }

1160
    let(:project) { create(:project) }
sue445's avatar
sue445 committed
1161

1162
    context 'when avatar file is uploaded' do
1163
      let(:project) { create(:project, :public, :with_avatar) }
sue445's avatar
sue445 committed
1164

Rémy Coutable's avatar
Rémy Coutable committed
1165
      it 'shows correct url' do
1166 1167
        expect(project.avatar_url).to eq(project.avatar.url)
        expect(project.avatar_url(only_path: false)).to eq([Gitlab.config.gitlab.url, project.avatar.url].join)
Rémy Coutable's avatar
Rémy Coutable committed
1168
      end
sue445's avatar
sue445 committed
1169 1170
    end

1171
    context 'when avatar file in git' do
sue445's avatar
sue445 committed
1172 1173 1174 1175
      before do
        allow(project).to receive(:avatar_in_git) { true }
      end

1176
      let(:avatar_path) { "/#{project.full_path}/avatar" }
sue445's avatar
sue445 committed
1177

1178
      it { is_expected.to eq "http://#{Gitlab.config.gitlab.host}#{avatar_path}" }
sue445's avatar
sue445 committed
1179
    end
1180 1181

    context 'when git repo is empty' do
1182
      let(:project) { create(:project) }
1183

1184
      it { is_expected.to eq nil }
1185 1186
    end
  end
1187

1188
  describe '#pipeline_for' do
1189
    let(:project) { create(:project, :repository) }
1190
    let!(:pipeline) { create_pipeline }
1191

1192 1193
    shared_examples 'giving the correct pipeline' do
      it { is_expected.to eq(pipeline) }
1194

1195 1196
      context 'return latest' do
        let!(:pipeline2) { create_pipeline }
1197

1198
        it { is_expected.to eq(pipeline2) }
1199
      end
1200 1201 1202 1203
    end

    context 'with explicit sha' do
      subject { project.pipeline_for('master', pipeline.sha) }
1204

1205 1206 1207 1208 1209 1210 1211 1212
      it_behaves_like 'giving the correct pipeline'
    end

    context 'with implicit sha' do
      subject { project.pipeline_for('master') }

      it_behaves_like 'giving the correct pipeline'
    end
1213

1214 1215 1216 1217 1218
    def create_pipeline
      create(:ci_pipeline,
             project: project,
             ref: 'master',
             sha: project.commit('master').sha)
1219
    end
1220
  end
1221

1222
  describe '#builds_enabled' do
1223
    let(:project) { create(:project) }
1224

1225 1226 1227
    subject { project.builds_enabled }

    it { expect(project.builds_enabled?).to be_truthy }
1228
  end
1229

1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241
  describe '.sort_by_attribute' do
    it 'reorders the input relation by start count desc' do
      project1 = create(:project, star_count: 2)
      project2 = create(:project, star_count: 1)
      project3 = create(:project)

      projects = described_class.sort_by_attribute(:stars_desc)

      expect(projects).to eq([project1, project2, project3])
    end
  end

1242
  describe '.with_shared_runners' do
1243
    subject { described_class.with_shared_runners }
1244 1245

    context 'when shared runners are enabled for project' do
1246
      let!(:project) { create(:project, shared_runners_enabled: true) }
1247 1248 1249 1250 1251 1252 1253

      it "returns a project" do
        is_expected.to eq([project])
      end
    end

    context 'when shared runners are disabled for project' do
1254
      let!(:project) { create(:project, shared_runners_enabled: false) }
1255

1256 1257
      it "returns an empty array" do
        is_expected.to be_empty
1258 1259 1260 1261
      end
    end
  end

1262
  describe '.cached_count', :use_clean_rails_memory_store_caching do
1263
    let(:group)     { create(:group, :public) }
1264 1265
    let!(:project1) { create(:project, :public, group: group) }
    let!(:project2) { create(:project, :public, group: group) }
1266 1267

    it 'returns total project count' do
1268
      expect(described_class).to receive(:count).once.and_call_original
1269 1270

      3.times do
1271
        expect(described_class.cached_count).to eq(2)
1272 1273 1274 1275
      end
    end
  end

1276
  describe '.trending' do
Felipe Artur's avatar
Felipe Artur committed
1277
    let(:group)    { create(:group, :public) }
1278 1279
    let(:project1) { create(:project, :public, group: group) }
    let(:project2) { create(:project, :public, group: group) }
1280 1281 1282 1283 1284 1285 1286 1287

    before do
      2.times do
        create(:note_on_commit, project: project1)
      end

      create(:note_on_commit, project: project2)

1288
      TrendingProject.refresh!
1289 1290
    end

1291
    subject { described_class.trending.to_a }
1292

1293 1294
    it 'sorts projects by the amount of notes in descending order' do
      expect(subject).to eq([project1, project2])
1295
    end
1296 1297 1298 1299 1300 1301 1302 1303

    it 'does not take system notes into account' do
      10.times do
        create(:note_on_commit, project: project2, system: true)
      end

      expect(described_class.trending.to_a).to eq([project1, project2])
    end
1304
  end
1305

1306 1307 1308 1309
  describe '.starred_by' do
    it 'returns only projects starred by the given user' do
      user1 = create(:user)
      user2 = create(:user)
1310 1311 1312
      project1 = create(:project)
      project2 = create(:project)
      create(:project)
1313 1314 1315
      user1.toggle_star(project1)
      user2.toggle_star(project2)

1316
      expect(described_class.starred_by(user1)).to contain_exactly(project1)
1317 1318 1319
    end
  end

1320
  describe '.visible_to_user' do
1321
    let!(:project) { create(:project, :private) }
1322 1323 1324 1325 1326 1327
    let!(:user)    { create(:user) }

    subject { described_class.visible_to_user(user) }

    describe 'when a user has access to a project' do
      before do
1328
        project.add_user(user, Gitlab::Access::MAINTAINER)
1329 1330 1331 1332 1333 1334 1335 1336 1337
      end

      it { is_expected.to eq([project]) }
    end

    describe 'when a user does not have access to any projects' do
      it { is_expected.to eq([]) }
    end
  end
1338

1339
  context 'repository storage by default' do
1340
    let(:project) { build(:project) }
1341 1342

    before do
1343
      storages = {
1344 1345
        'default' => Gitlab::GitalyClient::StorageSettings.new('path' => 'tmp/tests/repositories'),
        'picked'  => Gitlab::GitalyClient::StorageSettings.new('path' => 'tmp/tests/repositories')
1346
      }
1347 1348 1349
      allow(Gitlab.config.repositories).to receive(:storages).and_return(storages)
    end

1350 1351 1352 1353 1354
    it 'picks storage from ApplicationSetting' do
      expect_any_instance_of(ApplicationSetting).to receive(:pick_repository_storage).and_return('picked')

      expect(project.repository_storage).to eq('picked')
    end
1355 1356
  end

1357
  context 'shared runners by default' do
1358
    let(:project) { create(:project) }
1359 1360 1361 1362

    subject { project.shared_runners_enabled }

    context 'are enabled' do
1363 1364 1365
      before do
        stub_application_setting(shared_runners_enabled: true)
      end
1366 1367 1368 1369 1370

      it { is_expected.to be_truthy }
    end

    context 'are disabled' do
1371 1372 1373
      before do
        stub_application_setting(shared_runners_enabled: false)
      end
1374 1375 1376 1377 1378

      it { is_expected.to be_falsey }
    end
  end

1379
  describe '#any_runners?' do
1380
    context 'shared runners' do
1381
      let(:project) { create(:project, shared_runners_enabled: shared_runners_enabled) }
1382 1383
      let(:specific_runner) { create(:ci_runner, :project, projects: [project]) }
      let(:shared_runner) { create(:ci_runner, :instance) }
1384

1385 1386
      context 'for shared runners disabled' do
        let(:shared_runners_enabled) { false }
1387

1388 1389 1390
        it 'has no runners available' do
          expect(project.any_runners?).to be_falsey
        end
1391

1392
        it 'has a specific runner' do
1393
          specific_runner
1394

1395 1396 1397 1398 1399
          expect(project.any_runners?).to be_truthy
        end

        it 'has a shared runner, but they are prohibited to use' do
          shared_runner
1400

1401 1402
          expect(project.any_runners?).to be_falsey
        end
1403

1404
        it 'checks the presence of specific runner' do
1405
          specific_runner
1406

1407 1408
          expect(project.any_runners? { |runner| runner == specific_runner }).to be_truthy
        end
1409

1410
        it 'returns false if match cannot be found' do
1411
          specific_runner
1412

1413 1414
          expect(project.any_runners? { false }).to be_falsey
        end
1415
      end
1416

1417 1418 1419 1420 1421
      context 'for shared runners enabled' do
        let(:shared_runners_enabled) { true }

        it 'has a shared runner' do
          shared_runner
1422

1423 1424 1425 1426 1427
          expect(project.any_runners?).to be_truthy
        end

        it 'checks the presence of shared runner' do
          shared_runner
1428

1429 1430
          expect(project.any_runners? { |runner| runner == shared_runner }).to be_truthy
        end
1431 1432 1433

        it 'returns false if match cannot be found' do
          shared_runner
1434

1435 1436
          expect(project.any_runners? { false }).to be_falsey
        end
1437 1438
      end
    end
1439

1440
    context 'group runners' do
1441 1442
      let(:project) { create(:project, group_runners_enabled: group_runners_enabled) }
      let(:group) { create(:group, projects: [project]) }
1443
      let(:group_runner) { create(:ci_runner, :group, groups: [group]) }
1444 1445 1446

      context 'for group runners disabled' do
        let(:group_runners_enabled) { false }
1447

1448 1449 1450 1451 1452 1453
        it 'has no runners available' do
          expect(project.any_runners?).to be_falsey
        end

        it 'has a group runner, but they are prohibited to use' do
          group_runner
1454

1455 1456
          expect(project.any_runners?).to be_falsey
        end
1457 1458
      end

1459 1460 1461 1462 1463
      context 'for group runners enabled' do
        let(:group_runners_enabled) { true }

        it 'has a group runner' do
          group_runner
1464

1465 1466 1467 1468 1469
          expect(project.any_runners?).to be_truthy
        end

        it 'checks the presence of group runner' do
          group_runner
1470

1471 1472
          expect(project.any_runners? { |runner| runner == group_runner }).to be_truthy
        end
1473 1474 1475

        it 'returns false if match cannot be found' do
          group_runner
1476

1477 1478
          expect(project.any_runners? { false }).to be_falsey
        end
1479 1480 1481
      end
    end
  end
1482

1483
  describe '#shared_runners' do
1484
    let!(:runner) { create(:ci_runner, :instance) }
1485 1486 1487 1488

    subject { project.shared_runners }

    context 'when shared runners are enabled for project' do
1489
      let!(:project) { create(:project, shared_runners_enabled: true) }
1490 1491 1492 1493 1494 1495 1496

      it "returns a list of shared runners" do
        is_expected.to eq([runner])
      end
    end

    context 'when shared runners are disabled for project' do
1497
      let!(:project) { create(:project, shared_runners_enabled: false) }
1498 1499

      it "returns a empty list" do
1500
        is_expected.to be_empty
1501 1502 1503 1504
      end
    end
  end

1505
  describe '#visibility_level_allowed?' do
1506
    let(:project) { create(:project, :internal) }
1507 1508 1509 1510 1511 1512 1513 1514

    context 'when checking on non-forked project' do
      it { expect(project.visibility_level_allowed?(Gitlab::VisibilityLevel::PRIVATE)).to be_truthy }
      it { expect(project.visibility_level_allowed?(Gitlab::VisibilityLevel::INTERNAL)).to be_truthy }
      it { expect(project.visibility_level_allowed?(Gitlab::VisibilityLevel::PUBLIC)).to be_truthy }
    end

    context 'when checking on forked project' do
1515
      let(:project)        { create(:project, :internal) }
1516
      let(:forked_project) { fork_project(project) }
1517 1518 1519 1520 1521

      it { expect(forked_project.visibility_level_allowed?(Gitlab::VisibilityLevel::PRIVATE)).to be_truthy }
      it { expect(forked_project.visibility_level_allowed?(Gitlab::VisibilityLevel::INTERNAL)).to be_truthy }
      it { expect(forked_project.visibility_level_allowed?(Gitlab::VisibilityLevel::PUBLIC)).to be_falsey }
    end
1522 1523 1524
  end

  describe '#pages_deployed?' do
1525
    let(:project) { create(:project) }
1526 1527 1528 1529

    subject { project.pages_deployed? }

    context 'if public folder does exist' do
1530 1531 1532
      before do
        allow(Dir).to receive(:exist?).with(project.public_pages_path).and_return(true)
      end
1533 1534 1535

      it { is_expected.to be_truthy }
    end
1536

1537 1538 1539
    context "if public folder doesn't exist" do
      it { is_expected.to be_falsey }
    end
1540
  end
1541

1542
  describe '#pages_url' do
1543 1544
    let(:group) { create(:group, name: group_name) }
    let(:project) { create(:project, namespace: group, name: project_name) }
1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567
    let(:domain) { 'Example.com' }

    subject { project.pages_url }

    before do
      allow(Settings.pages).to receive(:host).and_return(domain)
      allow(Gitlab.config.pages).to receive(:url).and_return('http://example.com')
    end

    context 'group page' do
      let(:group_name) { 'Group' }
      let(:project_name) { 'group.example.com' }

      it { is_expected.to eq("http://group.example.com") }
    end

    context 'project page' do
      let(:group_name) { 'Group' }
      let(:project_name) { 'Project' }

      it { is_expected.to eq("http://group.example.com/project") }
    end
  end
1568

1569
  describe '#pages_group_url' do
1570 1571
    let(:group) { create(:group, name: group_name) }
    let(:project) { create(:project, namespace: group, name: project_name) }
1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593
    let(:domain) { 'Example.com' }
    let(:port) { 1234 }

    subject { project.pages_group_url }

    before do
      allow(Settings.pages).to receive(:host).and_return(domain)
      allow(Gitlab.config.pages).to receive(:url).and_return("http://example.com:#{port}")
    end

    context 'group page' do
      let(:group_name) { 'Group' }
      let(:project_name) { 'group.example.com' }

      it { is_expected.to eq("http://group.example.com:#{port}") }
    end

    context 'project page' do
      let(:group_name) { 'Group' }
      let(:project_name) { 'Project' }

      it { is_expected.to eq("http://group.example.com:#{port}") }
1594 1595 1596
    end
  end

1597
  describe '.search' do
1598
    let(:project) { create(:project, description: 'kitten mittens') }
1599 1600 1601 1602

    it 'returns projects with a matching name' do
      expect(described_class.search(project.name)).to eq([project])
    end
1603

1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635
    it 'returns projects with a partially matching name' do
      expect(described_class.search(project.name[0..2])).to eq([project])
    end

    it 'returns projects with a matching name regardless of the casing' do
      expect(described_class.search(project.name.upcase)).to eq([project])
    end

    it 'returns projects with a matching description' do
      expect(described_class.search(project.description)).to eq([project])
    end

    it 'returns projects with a partially matching description' do
      expect(described_class.search('kitten')).to eq([project])
    end

    it 'returns projects with a matching description regardless of the casing' do
      expect(described_class.search('KITTEN')).to eq([project])
    end

    it 'returns projects with a matching path' do
      expect(described_class.search(project.path)).to eq([project])
    end

    it 'returns projects with a partially matching path' do
      expect(described_class.search(project.path[0..2])).to eq([project])
    end

    it 'returns projects with a matching path regardless of the casing' do
      expect(described_class.search(project.path.upcase)).to eq([project])
    end

1636
    describe 'with pending_delete project' do
1637
      let(:pending_delete_project) { create(:project, pending_delete: true) }
1638 1639 1640 1641 1642 1643 1644

      it 'shows pending deletion project' do
        search_result = described_class.search(pending_delete_project.name)

        expect(search_result).to eq([pending_delete_project])
      end
    end
1645
  end
1646

1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693
  describe '.optionally_search' do
    let(:project) { create(:project) }

    it 'searches for projects matching the query if one is given' do
      relation = described_class.optionally_search(project.name)

      expect(relation).to eq([project])
    end

    it 'returns the current relation if no search query is given' do
      relation = described_class.where(id: project.id)

      expect(relation.optionally_search).to eq(relation)
    end
  end

  describe '.paginate_in_descending_order_using_id' do
    let!(:project1) { create(:project) }
    let!(:project2) { create(:project) }

    it 'orders the relation in descending order' do
      expect(described_class.paginate_in_descending_order_using_id)
        .to eq([project2, project1])
    end

    it 'applies a limit to the relation' do
      expect(described_class.paginate_in_descending_order_using_id(limit: 1))
        .to eq([project2])
    end

    it 'limits projects by and ID when given' do
      expect(described_class.paginate_in_descending_order_using_id(before: project2.id))
        .to eq([project1])
    end
  end

  describe '.including_namespace_and_owner' do
    it 'eager loads the namespace and namespace owner' do
      create(:project)

      row = described_class.eager_load_namespace_and_owner.to_a.first
      recorder = ActiveRecord::QueryRecorder.new { row.namespace.owner }

      expect(recorder.count).to be_zero
    end
  end

1694
  describe '#expire_caches_before_rename' do
1695
    let(:project) { create(:project, :repository) }
1696 1697 1698 1699
    let(:repo)    { double(:repo, exists?: true) }
    let(:wiki)    { double(:wiki, exists?: true) }

    it 'expires the caches of the repository and wiki' do
1700 1701 1702
      allow(Repository).to receive(:new)
        .with('foo', project)
        .and_return(repo)
1703

1704 1705 1706
      allow(Repository).to receive(:new)
        .with('foo.wiki', project)
        .and_return(wiki)
1707

1708 1709
      expect(repo).to receive(:before_delete)
      expect(wiki).to receive(:before_delete)
1710 1711 1712 1713

      project.expire_caches_before_rename('foo')
    end
  end
1714 1715

  describe '.search_by_title' do
1716
    let(:project) { create(:project, name: 'kittens') }
1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729

    it 'returns projects with a matching name' do
      expect(described_class.search_by_title(project.name)).to eq([project])
    end

    it 'returns projects with a partially matching name' do
      expect(described_class.search_by_title('kitten')).to eq([project])
    end

    it 'returns projects with a matching name regardless of the casing' do
      expect(described_class.search_by_title('KITTENS')).to eq([project])
    end
  end
1730 1731 1732 1733 1734

  context 'when checking projects from groups' do
    let(:private_group)    { create(:group, visibility_level: 0)  }
    let(:internal_group)   { create(:group, visibility_level: 10) }

1735 1736
    let(:private_project)  { create(:project, :private, group: private_group) }
    let(:internal_project) { create(:project, :internal, group: internal_group) }
1737 1738 1739 1740 1741 1742 1743 1744 1745

    context 'when group is private project can not be internal' do
      it { expect(private_project.visibility_level_allowed?(Gitlab::VisibilityLevel::INTERNAL)).to be_falsey }
    end

    context 'when group is internal project can not be public' do
      it { expect(internal_project.visibility_level_allowed?(Gitlab::VisibilityLevel::PUBLIC)).to be_falsey }
    end
  end
1746

1747
  describe '#create_repository' do
1748
    let(:project) { create(:project, :repository) }
1749 1750 1751 1752 1753 1754 1755 1756
    let(:shell) { Gitlab::Shell.new }

    before do
      allow(project).to receive(:gitlab_shell).and_return(shell)
    end

    context 'using a regular repository' do
      it 'creates the repository' do
1757
        expect(shell).to receive(:create_repository)
1758
          .with(project.repository_storage, project.disk_path)
1759
          .and_return(true)
1760 1761 1762 1763 1764 1765 1766

        expect(project.repository).to receive(:after_create)

        expect(project.create_repository).to eq(true)
      end

      it 'adds an error if the repository could not be created' do
1767
        expect(shell).to receive(:create_repository)
1768
          .with(project.repository_storage, project.disk_path)
1769
          .and_return(false)
1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780

        expect(project.repository).not_to receive(:after_create)

        expect(project.create_repository).to eq(false)
        expect(project.errors).not_to be_empty
      end
    end

    context 'using a forked repository' do
      it 'does nothing' do
        expect(project).to receive(:forked?).and_return(true)
1781
        expect(shell).not_to receive(:create_repository)
1782 1783 1784 1785 1786

        project.create_repository
      end
    end
  end
1787

1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799
  describe '#ensure_repository' do
    let(:project) { create(:project, :repository) }
    let(:shell) { Gitlab::Shell.new }

    before do
      allow(project).to receive(:gitlab_shell).and_return(shell)
    end

    it 'creates the repository if it not exist' do
      allow(project).to receive(:repository_exists?)
        .and_return(false)

1800
      allow(shell).to receive(:create_repository)
1801
        .with(project.repository_storage, project.disk_path)
1802 1803
        .and_return(true)

1804
      expect(project).to receive(:create_repository).with(force: true)
1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816

      project.ensure_repository
    end

    it 'does not create the repository if it exists' do
      allow(project).to receive(:repository_exists?)
        .and_return(true)

      expect(project).not_to receive(:create_repository)

      project.ensure_repository
    end
1817 1818 1819 1820 1821 1822 1823

    it 'creates the repository if it is a fork' do
      expect(project).to receive(:forked?).and_return(true)

      allow(project).to receive(:repository_exists?)
        .and_return(false)

1824
      expect(shell).to receive(:create_repository)
1825
        .with(project.repository_storage, project.disk_path)
1826 1827 1828 1829
        .and_return(true)

      project.ensure_repository
    end
1830 1831
  end

1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844
  describe 'handling import URL' do
    context 'when project is a mirror' do
      it 'returns the full URL' do
        project = create(:project, :mirror, import_url: 'http://user:pass@test.com')

        project.import_finish

        expect(project.reload.import_url).to eq('http://user:pass@test.com')
      end
    end

    context 'when project is not a mirror' do
      it 'returns the sanitized URL' do
1845
        project = create(:project, :import_started, import_url: 'http://user:pass@test.com')
1846 1847 1848 1849 1850 1851 1852 1853

        project.import_finish

        expect(project.reload.import_url).to eq('http://test.com')
      end
    end
  end

1854
  describe '#container_registry_url' do
1855
    let(:project) { create(:project) }
1856

1857
    subject { project.container_registry_url }
1858

1859 1860 1861
    before do
      stub_container_registry_config(**registry_settings)
    end
1862 1863 1864

    context 'for enabled registry' do
      let(:registry_settings) do
1865 1866
        { enabled: true,
          host_port: 'example.com' }
1867 1868
      end

1869
      it { is_expected.not_to be_nil }
1870 1871 1872 1873
    end

    context 'for disabled registry' do
      let(:registry_settings) do
1874
        { enabled: false }
1875 1876 1877 1878 1879 1880 1881
      end

      it { is_expected.to be_nil }
    end
  end

  describe '#has_container_registry_tags?' do
1882
    let(:project) { create(:project) }
1883

1884
    context 'when container registry is enabled' do
1885 1886 1887
      before do
        stub_container_registry_config(enabled: true)
      end
1888

1889 1890 1891 1892 1893 1894 1895
      context 'when tags are present for multi-level registries' do
        before do
          create(:container_repository, project: project, name: 'image')

          stub_container_registry_tags(repository: /image/,
                                       tags: %w[latest rc1])
        end
1896

1897 1898 1899
        it 'should have image tags' do
          expect(project).to have_container_registry_tags
        end
1900 1901
      end

1902 1903 1904 1905 1906
      context 'when tags are present for root repository' do
        before do
          stub_container_registry_tags(repository: project.full_path,
                                       tags: %w[latest rc1 pre1])
        end
1907

1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920
        it 'should have image tags' do
          expect(project).to have_container_registry_tags
        end
      end

      context 'when there are no tags at all' do
        before do
          stub_container_registry_tags(repository: :any, tags: [])
        end

        it 'should not have image tags' do
          expect(project).not_to have_container_registry_tags
        end
1921 1922 1923
      end
    end

1924
    context 'when container registry is disabled' do
1925 1926 1927
      before do
        stub_container_registry_config(enabled: false)
      end
1928

1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941
      it 'should not have image tags' do
        expect(project).not_to have_container_registry_tags
      end

      it 'should not check root repository tags' do
        expect(project).not_to receive(:full_path)
        expect(project).not_to have_container_registry_tags
      end

      it 'should iterate through container repositories' do
        expect(project).to receive(:container_repositories)
        expect(project).not_to have_container_registry_tags
      end
1942 1943
    end
  end
1944

1945
  describe '#ci_config_path=' do
1946
    let(:project) { create(:project) }
1947 1948

    it 'sets nil' do
1949
      project.update!(ci_config_path: nil)
1950

1951
      expect(project.ci_config_path).to be_nil
1952 1953 1954
    end

    it 'sets a string' do
1955
      project.update!(ci_config_path: 'foo/.gitlab_ci.yml')
1956

1957
      expect(project.ci_config_path).to eq('foo/.gitlab_ci.yml')
1958 1959
    end

1960 1961
    it 'sets a string but removes all null characters' do
      project.update!(ci_config_path: "f\0oo/\0/.gitlab_ci.yml")
1962

1963
      expect(project.ci_config_path).to eq('foo//.gitlab_ci.yml')
1964 1965 1966
    end
  end

1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991
  describe '#human_import_status_name' do
    context 'when import_state exists' do
      it 'returns the humanized status name' do
        project = create(:project)
        create(:import_state, :started, project: project)

        expect(project.human_import_status_name).to eq("started")
      end
    end

    context 'when import_state was not created yet' do
      let(:project) { create(:project, :import_started) }

      it 'ensures import_state is created and returns humanized status name' do
        expect do
          project.human_import_status_name
        end.to change { ProjectImportState.count }.from(0).to(1)
      end

      it 'returns humanized status name' do
        expect(project.human_import_status_name).to eq("started")
      end
    end
  end

1992
  describe 'Project import job' do
1993
    let(:project) { create(:project, import_url: generate(:url)) }
1994 1995

    before do
Douwe Maan's avatar
Douwe Maan committed
1996
      allow_any_instance_of(Gitlab::Shell).to receive(:import_repository)
1997
        .with(project.repository_storage, project.disk_path, project.import_url)
Douwe Maan's avatar
Douwe Maan committed
1998
        .and_return(true)
1999

2000
      # Works around https://github.com/rspec/rspec-mocks/issues/910
2001
      allow(described_class).to receive(:find).with(project.id).and_return(project)
2002 2003 2004
      expect(project.repository).to receive(:after_import)
        .and_call_original
      expect(project.wiki.repository).to receive(:after_import)
Douwe Maan's avatar
Douwe Maan committed
2005
        .and_call_original
2006 2007 2008
    end

    it 'imports a project' do
2009
      expect(RepositoryImportWorker).to receive(:perform_async).and_call_original
2010

2011
      expect { project.import_schedule }.to change { project.import_jid }
2012 2013 2014
      expect(project.reload.import_status).to eq('finished')
    end
  end
2015

2016 2017
  describe 'project import state transitions' do
    context 'state transition: [:started] => [:finished]' do
2018 2019
      let(:after_import_service) { spy(:after_import_service) }
      let(:housekeeping_service) { spy(:housekeeping_service) }
2020 2021

      before do
2022 2023 2024 2025 2026 2027 2028 2029
        allow(Projects::AfterImportService)
          .to receive(:new) { after_import_service }

        allow(after_import_service)
          .to receive(:execute) { housekeeping_service.execute }

        allow(Projects::HousekeepingService)
          .to receive(:new) { housekeeping_service }
2030 2031
      end

2032 2033
      it 'resets project import_error' do
        error_message = 'Some error'
2034
        mirror = create(:project_empty_repo, :import_started)
2035
        mirror.import_state.update(last_error: error_message)
2036 2037 2038 2039

        expect { mirror.import_finish }.to change { mirror.import_error }.from(error_message).to(nil)
      end

2040 2041 2042 2043 2044
      it 'performs housekeeping when an import of a fresh project is completed' do
        project = create(:project_empty_repo, :import_started, import_type: :github)

        project.import_finish

2045
        expect(after_import_service).to have_received(:execute)
2046 2047 2048 2049
        expect(housekeeping_service).to have_received(:execute)
      end

      it 'does not perform housekeeping when project repository does not exist' do
2050
        project = create(:project, :import_started, import_type: :github)
2051 2052 2053 2054 2055 2056 2057

        project.import_finish

        expect(housekeeping_service).not_to have_received(:execute)
      end

      it 'does not perform housekeeping when project does not have a valid import type' do
2058
        project = create(:project, :import_started, import_type: nil)
2059 2060 2061 2062 2063 2064 2065 2066

        project.import_finish

        expect(housekeeping_service).not_to have_received(:execute)
      end
    end
  end

2067
  describe '#latest_successful_builds_for' do
Lin Jen-Shin's avatar
Lin Jen-Shin committed
2068
    def create_pipeline(status = 'success')
2069
      create(:ci_pipeline, project: project,
Lin Jen-Shin's avatar
Lin Jen-Shin committed
2070
                           sha: project.commit.sha,
2071
                           ref: project.default_branch,
Lin Jen-Shin's avatar
Lin Jen-Shin committed
2072
                           status: status)
2073 2074
    end

Lin Jen-Shin's avatar
Lin Jen-Shin committed
2075 2076 2077
    def create_build(new_pipeline = pipeline, name = 'test')
      create(:ci_build, :success, :artifacts,
             pipeline: new_pipeline,
Lin Jen-Shin's avatar
Lin Jen-Shin committed
2078
             status: new_pipeline.status,
Lin Jen-Shin's avatar
Lin Jen-Shin committed
2079
             name: name)
2080 2081
    end

2082
    let(:project) { create(:project, :repository) }
Lin Jen-Shin's avatar
Lin Jen-Shin committed
2083
    let(:pipeline) { create_pipeline }
Lin Jen-Shin's avatar
Lin Jen-Shin committed
2084 2085

    context 'with many builds' do
2086
      it 'gives the latest builds from latest pipeline' do
2087 2088
        pipeline1 = create_pipeline
        pipeline2 = create_pipeline
2089
        build1_p2 = create_build(pipeline2, 'test')
2090 2091
        create_build(pipeline1, 'test')
        create_build(pipeline1, 'test2')
2092
        build2_p2 = create_build(pipeline2, 'test2')
Lin Jen-Shin's avatar
Lin Jen-Shin committed
2093 2094 2095

        latest_builds = project.latest_successful_builds_for

2096
        expect(latest_builds).to contain_exactly(build2_p2, build1_p2)
Lin Jen-Shin's avatar
Lin Jen-Shin committed
2097 2098
      end
    end
Lin Jen-Shin's avatar
Lin Jen-Shin committed
2099

Lin Jen-Shin's avatar
Lin Jen-Shin committed
2100
    context 'with succeeded pipeline' do
Lin Jen-Shin's avatar
Lin Jen-Shin committed
2101
      let!(:build) { create_build }
2102

Lin Jen-Shin's avatar
Lin Jen-Shin committed
2103
      context 'standalone pipeline' do
2104 2105 2106 2107 2108 2109 2110 2111
        it 'returns builds for ref for default_branch' do
          builds = project.latest_successful_builds_for

          expect(builds).to contain_exactly(build)
        end

        it 'returns empty relation if the build cannot be found' do
          builds = project.latest_successful_builds_for('TAIL')
2112

2113 2114 2115
          expect(builds).to be_kind_of(ActiveRecord::Relation)
          expect(builds).to be_empty
        end
2116 2117
      end

Lin Jen-Shin's avatar
Lin Jen-Shin committed
2118
      context 'with some pending pipeline' do
2119
        before do
Lin Jen-Shin's avatar
Lin Jen-Shin committed
2120
          create_build(create_pipeline('pending'))
2121 2122
        end

Lin Jen-Shin's avatar
Lin Jen-Shin committed
2123 2124
        it 'gives the latest build from latest pipeline' do
          latest_build = project.latest_successful_builds_for
2125

Lin Jen-Shin's avatar
Lin Jen-Shin committed
2126
          expect(latest_build).to contain_exactly(build)
2127
        end
2128 2129 2130 2131 2132 2133
      end
    end

    context 'with pending pipeline' do
      before do
        pipeline.update(status: 'pending')
Lin Jen-Shin's avatar
Lin Jen-Shin committed
2134
        create_build(pipeline)
2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145
      end

      it 'returns empty relation' do
        builds = project.latest_successful_builds_for

        expect(builds).to be_kind_of(ActiveRecord::Relation)
        expect(builds).to be_empty
      end
    end
  end

2146
  describe '#add_import_job' do
2147
    let(:import_jid) { '123' }
2148

2149
    context 'forked' do
2150 2151 2152 2153 2154 2155
      let(:forked_from_project) { create(:project, :repository) }
      let(:project) { create(:project) }

      before do
        fork_project(forked_from_project, nil, target_project: project)
      end
2156 2157

      it 'schedules a RepositoryForkWorker job' do
2158
        expect(RepositoryForkWorker).to receive(:perform_async).with(project.id).and_return(import_jid)
2159

2160
        expect(project.add_import_job).to eq(import_jid)
2161
      end
2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187

      context 'without mirror' do
        it 'returns nil' do
          project = create(:project)

          expect(project.add_import_job).to be nil
        end
      end

      context 'without repository' do
        it 'schedules RepositoryImportWorker' do
          project = create(:project, import_url: generate(:url))

          expect(RepositoryImportWorker).to receive(:perform_async).with(project.id).and_return(import_jid)
          expect(project.add_import_job).to eq(import_jid)
        end
      end

      context 'with mirror' do
        it 'schedules RepositoryUpdateMirrorWorker' do
          project = create(:project, :mirror, :repository)

          expect(RepositoryUpdateMirrorWorker).to receive(:perform_async).with(project.id).and_return(import_jid)
          expect(project.add_import_job).to eq(import_jid)
        end
      end
2188
    end
Nick Thomas's avatar
Nick Thomas committed
2189 2190 2191

    context 'not forked' do
      it 'schedules a RepositoryImportWorker job' do
2192
        project = create(:project, import_url: generate(:url))
Nick Thomas's avatar
Nick Thomas committed
2193

2194 2195
        expect(RepositoryImportWorker).to receive(:perform_async).with(project.id).and_return(import_jid)
        expect(project.add_import_job).to eq(import_jid)
Nick Thomas's avatar
Nick Thomas committed
2196 2197
      end
    end
2198 2199
  end

Rémy Coutable's avatar
Rémy Coutable committed
2200
  describe '#gitlab_project_import?' do
2201
    subject(:project) { build(:project, import_type: 'gitlab_project') }
Rémy Coutable's avatar
Rémy Coutable committed
2202 2203 2204 2205 2206

    it { expect(project.gitlab_project_import?).to be true }
  end

  describe '#gitea_import?' do
2207
    subject(:project) { build(:project, import_type: 'gitea') }
Rémy Coutable's avatar
Rémy Coutable committed
2208 2209 2210 2211

    it { expect(project.gitea_import?).to be true }
  end

2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224
  describe '#has_remote_mirror?' do
    let(:project) { create(:project, :remote_mirror, :import_started) }
    subject { project.has_remote_mirror? }

    before do
      allow_any_instance_of(RemoteMirror).to receive(:refresh_remote)
    end

    it 'returns true when a remote mirror is enabled' do
      is_expected.to be_truthy
    end

    it 'returns false when remote mirror is disabled' do
2225
      project.remote_mirrors.first.update(enabled: false)
2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254

      is_expected.to be_falsy
    end
  end

  describe '#update_remote_mirrors' do
    let(:project) { create(:project, :remote_mirror, :import_started) }
    delegate :update_remote_mirrors, to: :project

    before do
      allow_any_instance_of(RemoteMirror).to receive(:refresh_remote)
    end

    it 'syncs enabled remote mirror' do
      expect_any_instance_of(RemoteMirror).to receive(:sync)

      update_remote_mirrors
    end

    it 'does nothing when remote mirror is disabled globally and not overridden' do
      stub_application_setting(mirror_available: false)
      project.remote_mirror_available_overridden = false

      expect_any_instance_of(RemoteMirror).not_to receive(:sync)

      update_remote_mirrors
    end

    it 'does not sync disabled remote mirrors' do
2255
      project.remote_mirrors.first.update(enabled: false)
2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288

      expect_any_instance_of(RemoteMirror).not_to receive(:sync)

      update_remote_mirrors
    end
  end

  describe '#remote_mirror_available?' do
    let(:project) { create(:project) }

    context 'when remote mirror global setting is enabled' do
      it 'returns true' do
        expect(project.remote_mirror_available?).to be(true)
      end
    end

    context 'when remote mirror global setting is disabled' do
      before do
        stub_application_setting(mirror_available: false)
      end

      it 'returns true when overridden' do
        project.remote_mirror_available_overridden = true

        expect(project.remote_mirror_available?).to be(true)
      end

      it 'returns false when not overridden' do
        expect(project.remote_mirror_available?).to be(false)
      end
    end
  end

2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303
  describe '#ancestors_upto', :nested_groups do
    let(:parent) { create(:group) }
    let(:child) { create(:group, parent: parent) }
    let(:child2) { create(:group, parent: child) }
    let(:project) { create(:project, namespace: child2) }

    it 'returns all ancestors when no namespace is given' do
      expect(project.ancestors_upto).to contain_exactly(child2, child, parent)
    end

    it 'includes ancestors upto but excluding the given ancestor' do
      expect(project.ancestors_upto(parent)).to contain_exactly(child2, child)
    end
  end

2304
  describe '#lfs_enabled?' do
2305
    let(:project) { create(:project) }
2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365

    shared_examples 'project overrides group' do
      it 'returns true when enabled in project' do
        project.update_attribute(:lfs_enabled, true)

        expect(project.lfs_enabled?).to be_truthy
      end

      it 'returns false when disabled in project' do
        project.update_attribute(:lfs_enabled, false)

        expect(project.lfs_enabled?).to be_falsey
      end

      it 'returns the value from the namespace, when no value is set in project' do
        expect(project.lfs_enabled?).to eq(project.namespace.lfs_enabled?)
      end
    end

    context 'LFS disabled in group' do
      before do
        project.namespace.update_attribute(:lfs_enabled, false)
        enable_lfs
      end

      it_behaves_like 'project overrides group'
    end

    context 'LFS enabled in group' do
      before do
        project.namespace.update_attribute(:lfs_enabled, true)
        enable_lfs
      end

      it_behaves_like 'project overrides group'
    end

    describe 'LFS disabled globally' do
      shared_examples 'it always returns false' do
        it do
          expect(project.lfs_enabled?).to be_falsey
          expect(project.namespace.lfs_enabled?).to be_falsey
        end
      end

      context 'when no values are set' do
        it_behaves_like 'it always returns false'
      end

      context 'when all values are set to true' do
        before do
          project.namespace.update_attribute(:lfs_enabled, true)
          project.update_attribute(:lfs_enabled, true)
        end

        it_behaves_like 'it always returns false'
      end
    end
  end

2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441
  describe '.where_full_path_in' do
    context 'without any paths' do
      it 'returns an empty relation' do
        expect(described_class.where_full_path_in([])).to eq([])
      end
    end

    context 'without any valid paths' do
      it 'returns an empty relation' do
        expect(described_class.where_full_path_in(%w[foo])).to eq([])
      end
    end

    context 'with valid paths' do
      let!(:project1) { create(:project) }
      let!(:project2) { create(:project) }

      it 'returns the projects matching the paths' do
        projects = described_class.where_full_path_in([project1.full_path,
                                                       project2.full_path])

        expect(projects).to contain_exactly(project1, project2)
      end

      it 'returns projects regardless of the casing of paths' do
        projects = described_class.where_full_path_in([project1.full_path.upcase,
                                                       project2.full_path.upcase])

        expect(projects).to contain_exactly(project1, project2)
      end
    end
  end

  describe '#change_repository_storage' do
    let(:project) { create(:project, :repository) }
    let(:read_only_project) { create(:project, :repository, repository_read_only: true) }

    before do
      FileUtils.mkdir('tmp/tests/extra_storage')
      stub_storage_settings('extra' => { 'path' => 'tmp/tests/extra_storage' })
    end

    after do
      FileUtils.rm_rf('tmp/tests/extra_storage')
    end

    it 'schedule the transfer of the repository to the new storage and locks the project' do
      expect(ProjectUpdateRepositoryStorageWorker).to receive(:perform_async).with(project.id, 'extra')

      project.change_repository_storage('extra')
      project.save

      expect(project).to be_repository_read_only
    end

    it "doesn't schedule the transfer if the repository is already read-only" do
      expect(ProjectUpdateRepositoryStorageWorker).not_to receive(:perform_async)

      read_only_project.change_repository_storage('extra')
      read_only_project.save
    end

    it "doesn't lock or schedule the transfer if the storage hasn't changed" do
      expect(ProjectUpdateRepositoryStorageWorker).not_to receive(:perform_async)

      project.change_repository_storage(project.repository_storage)
      project.save

      expect(project).not_to be_repository_read_only
    end

    it 'throws an error if an invalid repository storage is provided' do
      expect { project.change_repository_storage('unknown') }.to raise_error(ArgumentError)
    end
  end

2442
  describe '#change_head' do
2443
    let(:project) { create(:project, :repository) }
2444

2445 2446 2447 2448 2449
    it 'returns error if branch does not exist' do
      expect(project.change_head('unexisted-branch')).to be false
      expect(project.errors.size).to eq(1)
    end

2450
    it 'calls the before_change_head and after_change_head methods' do
2451
      expect(project.repository).to receive(:before_change_head)
2452 2453
      expect(project.repository).to receive(:after_change_head)

2454 2455 2456
      project.change_head(project.default_branch)
    end

2457
    it 'creates the new reference with rugged' do
2458 2459
      expect(project.repository.raw_repository).to receive(:write_ref).with('HEAD', "refs/heads/#{project.default_branch}", shell: false)

2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472
      project.change_head(project.default_branch)
    end

    it 'copies the gitattributes' do
      expect(project.repository).to receive(:copy_gitattributes).with(project.default_branch)
      project.change_head(project.default_branch)
    end

    it 'reloads the default branch' do
      expect(project).to receive(:reload_default_branch)
      project.change_head(project.default_branch)
    end
  end
2473

2474
  context 'forks' do
2475 2476
    include ProjectForksHelper

2477 2478 2479 2480 2481
    let(:project) { create(:project, :public) }
    let!(:forked_project) { fork_project(project) }

    describe '#fork_network' do
      it 'includes a fork of the project' do
2482
        expect(project.fork_network.projects).to include(forked_project)
2483 2484 2485 2486 2487
      end

      it 'includes a fork of a fork' do
        other_fork = fork_project(forked_project)

2488
        expect(project.fork_network.projects).to include(other_fork)
2489 2490 2491 2492 2493
      end

      it 'includes sibling forks' do
        other_fork = fork_project(project)

2494
        expect(forked_project.fork_network.projects).to include(other_fork)
2495 2496 2497
      end

      it 'includes the base project' do
2498
        expect(forked_project.fork_network.projects).to include(project.reload)
2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524
      end
    end

    describe '#in_fork_network_of?' do
      it 'is true for a real fork' do
        expect(forked_project.in_fork_network_of?(project)).to be_truthy
      end

      it 'is true for a fork of a fork', :postgresql do
        other_fork = fork_project(forked_project)

        expect(other_fork.in_fork_network_of?(project)).to be_truthy
      end

      it 'is true for sibling forks' do
        sibling = fork_project(project)

        expect(sibling.in_fork_network_of?(forked_project)).to be_truthy
      end

      it 'is false when another project is given' do
        other_project = build_stubbed(:project)

        expect(forked_project.in_fork_network_of?(other_project)).to be_falsy
      end
    end
2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537

    describe '#fork_source' do
      let!(:second_fork) { fork_project(forked_project) }

      it 'returns the direct source if it exists' do
        expect(second_fork.fork_source).to eq(forked_project)
      end

      it 'returns the root of the fork network when the directs source was deleted' do
        forked_project.destroy

        expect(second_fork.fork_source).to eq(project)
      end
2538 2539 2540 2541

      it 'returns nil if it is the root of the fork network' do
        expect(project.fork_source).to be_nil
      end
2542
    end
2543

2544 2545 2546 2547 2548 2549
    describe '#forks' do
      it 'includes direct forks of the project' do
        expect(project.forks).to contain_exactly(forked_project)
      end
    end

2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566
    describe '#lfs_storage_project' do
      it 'returns self for non-forks' do
        expect(project.lfs_storage_project).to eq project
      end

      it 'returns the fork network root for forks' do
        second_fork = fork_project(forked_project)

        expect(second_fork.lfs_storage_project).to eq project
      end

      it 'returns self when fork_source is nil' do
        expect(forked_project).to receive(:fork_source).and_return(nil)

        expect(forked_project.lfs_storage_project).to eq forked_project
      end
    end
2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582

    describe '#all_lfs_objects' do
      let(:lfs_object) { create(:lfs_object) }

      before do
        project.lfs_objects << lfs_object
      end

      it 'returns the lfs object for a project' do
        expect(project.all_lfs_objects).to contain_exactly(lfs_object)
      end

      it 'returns the lfs object for a fork' do
        expect(forked_project.all_lfs_objects).to contain_exactly(lfs_object)
      end
    end
2583 2584
  end

2585
  describe '#pushes_since_gc' do
2586
    let(:project) { create(:project) }
2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607

    after do
      project.reset_pushes_since_gc
    end

    context 'without any pushes' do
      it 'returns 0' do
        expect(project.pushes_since_gc).to eq(0)
      end
    end

    context 'with a number of pushes' do
      it 'returns the number of pushes' do
        3.times { project.increment_pushes_since_gc }

        expect(project.pushes_since_gc).to eq(3)
      end
    end
  end

  describe '#increment_pushes_since_gc' do
2608
    let(:project) { create(:project) }
2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620

    after do
      project.reset_pushes_since_gc
    end

    it 'increments the number of pushes since the last GC' do
      3.times { project.increment_pushes_since_gc }

      expect(project.pushes_since_gc).to eq(3)
    end
  end

2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649
  describe '#repository_and_lfs_size' do
    let(:project) { create(:project, :repository) }
    let(:size) { 50 }

    before do
      allow(project.statistics).to receive(:total_repository_size).and_return(size)
    end

    it 'returns the total repository and lfs size' do
      expect(project.repository_and_lfs_size).to eq(size)
    end
  end

  describe '#approver_group_ids=' do
    let(:project) { create(:project) }

    it 'create approver_groups' do
      group = create :group
      group1 = create :group

      project = create :project

      project.approver_group_ids = "#{group.id}, #{group1.id}"
      project.save!

      expect(project.approver_groups.map(&:group)).to match_array([group, group1])
    end
  end

2650
  describe '#reset_pushes_since_gc' do
2651
    let(:project) { create(:project) }
2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664

    after do
      project.reset_pushes_since_gc
    end

    it 'resets the number of pushes since the last GC' do
      3.times { project.increment_pushes_since_gc }

      project.reset_pushes_since_gc

      expect(project.pushes_since_gc).to eq(0)
    end
  end
2665

2666 2667
  describe '#deployment_variables' do
    context 'when project has no deployment service' do
2668
      let(:project) { create(:project) }
2669 2670 2671 2672 2673 2674 2675

      it 'returns an empty array' do
        expect(project.deployment_variables).to eq []
      end
    end

    context 'when project has a deployment service' do
2676
      shared_examples 'same behavior between KubernetesService and Platform::Kubernetes' do
2677 2678
        it 'returns variables from this service' do
          expect(project.deployment_variables).to include(
2679
            { key: 'KUBE_TOKEN', value: project.deployment_platform.token, public: false }
2680 2681 2682
          )
        end
      end
2683

2684 2685 2686
      context 'when user configured kubernetes from Integration > Kubernetes' do
        let(:project) { create(:kubernetes_project) }

2687
        it_behaves_like 'same behavior between KubernetesService and Platform::Kubernetes'
2688 2689
      end

2690
      context 'when user configured kubernetes from CI/CD > Clusters and KubernetesNamespace migration has not been executed' do
2691 2692 2693
        let!(:cluster) { create(:cluster, :project, :provided_by_gcp) }
        let(:project) { cluster.project }

2694
        it_behaves_like 'same behavior between KubernetesService and Platform::Kubernetes'
2695
      end
2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707

      context 'when user configured kubernetes from CI/CD > Clusters and KubernetesNamespace migration has been executed' do
        let!(:kubernetes_namespace) { create(:cluster_kubernetes_namespace) }
        let!(:cluster) { kubernetes_namespace.cluster }
        let(:project) { kubernetes_namespace.project }

        it 'should return token from kubernetes namespace' do
          expect(project.deployment_variables).to include(
            { key: 'KUBE_TOKEN', value: kubernetes_namespace.service_account_token, public: false }
          )
        end
      end
2708 2709 2710
    end
  end

2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732
  describe '#default_environment' do
    let(:project) { create(:project) }

    it 'returns production environment when it exists' do
      production = create(:environment, name: "production", project: project)
      create(:environment, name: 'staging', project: project)

      expect(project.default_environment).to eq(production)
    end

    it 'returns first environment when no production environment exists' do
      create(:environment, name: 'staging', project: project)
      create(:environment, name: 'foo', project: project)

      expect(project.default_environment).to eq(project.environments.first)
    end

    it 'returns nil when no available environment exists' do
      expect(project.default_environment).to be_nil
    end
  end

2733
  describe '#ci_variables_for' do
2734
    let(:project) { create(:project) }
2735

2736
    let!(:ci_variable) do
2737 2738 2739 2740 2741 2742 2743
      create(:ci_variable, value: 'secret', project: project)
    end

    let!(:protected_variable) do
      create(:ci_variable, :protected, value: 'protected', project: project)
    end

2744
    subject { project.reload.ci_variables_for(ref: 'ref') }
2745 2746 2747 2748 2749

    before do
      stub_application_setting(
        default_branch_protection: Gitlab::Access::PROTECTION_NONE)
    end
2750 2751 2752

    shared_examples 'ref is protected' do
      it 'contains all the variables' do
2753
        is_expected.to contain_exactly(ci_variable, protected_variable)
2754 2755 2756 2757
      end
    end

    context 'when the ref is not protected' do
2758 2759
      it 'contains only the CI variables' do
        is_expected.to contain_exactly(ci_variable)
2760 2761 2762
      end
    end

2763 2764
    context 'when the ref is a protected branch' do
      before do
2765
        allow(project).to receive(:protected_for?).with('ref').and_return(true)
2766
      end
2767 2768 2769 2770 2771 2772

      it_behaves_like 'ref is protected'
    end

    context 'when the ref is a protected tag' do
      before do
2773
        allow(project).to receive(:protected_for?).with('ref').and_return(true)
2774 2775 2776
      end

      it_behaves_like 'ref is protected'
2777 2778 2779
    end
  end

2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795
  describe '#any_lfs_file_locks?', :request_store do
    set(:project) { create(:project) }

    it 'returns false when there are no LFS file locks' do
      expect(project.any_lfs_file_locks?).to be_falsey
    end

    it 'returns a cached true when there are LFS file locks' do
      create(:lfs_file_lock, project: project)

      expect(project.lfs_file_locks).to receive(:any?).once.and_call_original

      2.times { expect(project.any_lfs_file_locks?).to be_truthy }
    end
  end

2796
  describe '#protected_for?' do
2797
    let(:project) { create(:project) }
2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813

    subject { project.protected_for?('ref') }

    context 'when the ref is not protected' do
      before do
        stub_application_setting(
          default_branch_protection: Gitlab::Access::PROTECTION_NONE)
      end

      it 'returns false' do
        is_expected.to be_falsey
      end
    end

    context 'when the ref is a protected branch' do
      before do
2814 2815
        allow(project).to receive(:repository).and_call_original
        allow(project).to receive_message_chain(:repository, :branch_exists?).and_return(true)
2816 2817 2818 2819 2820 2821 2822 2823 2824 2825
        create(:protected_branch, name: 'ref', project: project)
      end

      it 'returns true' do
        is_expected.to be_truthy
      end
    end

    context 'when the ref is a protected tag' do
      before do
2826 2827
        allow(project).to receive_message_chain(:repository, :branch_exists?).and_return(false)
        allow(project).to receive_message_chain(:repository, :tag_exists?).and_return(true)
2828 2829 2830 2831 2832 2833 2834 2835 2836
        create(:protected_tag, name: 'ref', project: project)
      end

      it 'returns true' do
        is_expected.to be_truthy
      end
    end
  end

2837
  describe '#update_project_statistics' do
2838
    let(:project) { create(:project) }
2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856

    it "is called after creation" do
      expect(project.statistics).to be_a ProjectStatistics
      expect(project.statistics).to be_persisted
    end

    it "copies the namespace_id" do
      expect(project.statistics.namespace_id).to eq project.namespace_id
    end

    it "updates the namespace_id when changed" do
      namespace = create(:namespace)
      project.update(namespace: namespace)

      expect(project.statistics.namespace_id).to eq namespace.id
    end
  end

2857
  describe '#create_import_state' do
2858 2859 2860
    it 'it is called after save' do
      project = create(:project)

2861
      expect(project).to receive(:create_import_state)
2862 2863 2864 2865 2866

      project.update(mirror: true, mirror_user: project.owner, import_url: 'http://foo.com')
    end
  end

2867
  describe 'inside_path' do
2868 2869 2870
    let!(:project1) { create(:project, namespace: create(:namespace, path: 'name_pace')) }
    let!(:project2) { create(:project) }
    let!(:project3) { create(:project, namespace: create(:namespace, path: 'namespace')) }
2871
    let!(:path) { project1.namespace.full_path }
2872

2873
    it 'returns correct project' do
2874
      expect(described_class.inside_path(path)).to eq([project1])
2875
    end
2876 2877
  end

Douwe Maan's avatar
Douwe Maan committed
2878
  describe '#route_map_for' do
2879
    let(:project) { create(:project, :repository) }
Douwe Maan's avatar
Douwe Maan committed
2880 2881 2882 2883 2884 2885 2886 2887
    let(:route_map) do
      <<-MAP.strip_heredoc
      - source: /source/(.*)/
        public: '\\1'
      MAP
    end

    before do
2888
      project.repository.create_file(User.last, '.gitlab/route-map.yml', route_map, message: 'Add .gitlab/route-map.yml', branch_name: 'master')
Douwe Maan's avatar
Douwe Maan committed
2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915
    end

    context 'when there is a .gitlab/route-map.yml at the commit' do
      context 'when the route map is valid' do
        it 'returns a route map' do
          map = project.route_map_for(project.commit.sha)
          expect(map).to be_a_kind_of(Gitlab::RouteMap)
        end
      end

      context 'when the route map is invalid' do
        let(:route_map) { 'INVALID' }

        it 'returns nil' do
          expect(project.route_map_for(project.commit.sha)).to be_nil
        end
      end
    end

    context 'when there is no .gitlab/route-map.yml at the commit' do
      it 'returns nil' do
        expect(project.route_map_for(project.commit.parent.sha)).to be_nil
      end
    end
  end

  describe '#public_path_for_source_path' do
2916
    let(:project) { create(:project, :repository) }
Douwe Maan's avatar
Douwe Maan committed
2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953
    let(:route_map) do
      Gitlab::RouteMap.new(<<-MAP.strip_heredoc)
        - source: /source/(.*)/
          public: '\\1'
      MAP
    end
    let(:sha) { project.commit.id }

    context 'when there is a route map' do
      before do
        allow(project).to receive(:route_map_for).with(sha).and_return(route_map)
      end

      context 'when the source path is mapped' do
        it 'returns the public path' do
          expect(project.public_path_for_source_path('source/file.html', sha)).to eq('file.html')
        end
      end

      context 'when the source path is not mapped' do
        it 'returns nil' do
          expect(project.public_path_for_source_path('file.html', sha)).to be_nil
        end
      end
    end

    context 'when there is no route map' do
      before do
        allow(project).to receive(:route_map_for).with(sha).and_return(nil)
      end

      it 'returns nil' do
        expect(project.public_path_for_source_path('source/file.html', sha)).to be_nil
      end
    end
  end

2954
  describe '#parent' do
2955
    let(:project) { create(:project) }
2956 2957 2958 2959

    it { expect(project.parent).to eq(project.namespace) }
  end

2960 2961 2962 2963 2964 2965
  describe '#parent_id' do
    let(:project) { create(:project) }

    it { expect(project.parent_id).to eq(project.namespace_id) }
  end

2966
  describe '#parent_changed?' do
2967
    let(:project) { create(:project) }
2968

2969 2970 2971
    before do
      project.namespace_id = 7
    end
2972 2973 2974 2975

    it { expect(project.parent_changed?).to be_truthy }
  end

2976 2977 2978
  def enable_lfs
    allow(Gitlab.config.lfs).to receive(:enabled).and_return(true)
  end
2979

2980
  describe '#pages_url' do
2981 2982
    let(:group) { create(:group, name: 'Group') }
    let(:nested_group) { create(:group, parent: group) }
2983 2984 2985 2986 2987 2988 2989 2990 2991
    let(:domain) { 'Example.com' }

    subject { project.pages_url }

    before do
      allow(Settings.pages).to receive(:host).and_return(domain)
      allow(Gitlab.config.pages).to receive(:url).and_return('http://example.com')
    end

2992
    context 'top-level group' do
2993
      let(:project) { create(:project, namespace: group, name: project_name) }
2994

2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005
      context 'group page' do
        let(:project_name) { 'group.example.com' }

        it { is_expected.to eq("http://group.example.com") }
      end

      context 'project page' do
        let(:project_name) { 'Project' }

        it { is_expected.to eq("http://group.example.com/project") }
      end
3006 3007
    end

3008
    context 'nested group' do
3009
      let(:project) { create(:project, namespace: nested_group, name: project_name) }
3010
      let(:expected_url) { "http://group.example.com/#{nested_group.path}/#{project.path}" }
3011

3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022
      context 'group page' do
        let(:project_name) { 'group.example.com' }

        it { is_expected.to eq(expected_url) }
      end

      context 'project page' do
        let(:project_name) { 'Project' }

        it { is_expected.to eq(expected_url) }
      end
3023 3024
    end
  end
3025 3026

  describe '#http_url_to_repo' do
3027
    let(:project) { create(:project) }
3028

3029 3030 3031
    it 'returns the url to the repo without a username' do
      expect(project.http_url_to_repo).to eq("#{project.web_url}.git")
      expect(project.http_url_to_repo).not_to include('@')
3032 3033
    end
  end
3034 3035

  describe '#pipeline_status' do
3036
    let(:project) { create(:project, :repository) }
3037
    it 'builds a pipeline status' do
3038
      expect(project.pipeline_status).to be_a(Gitlab::Cache::Ci::ProjectPipelineStatus)
3039 3040 3041 3042 3043 3044
    end

    it 'hase a loaded pipeline status' do
      expect(project.pipeline_status).to be_loaded
    end
  end
3045 3046

  describe '#append_or_update_attribute' do
3047
    let(:project) { create(:project) }
3048 3049 3050 3051 3052

    it 'shows full error updating an invalid MR' do
      error_message = 'Failed to replace merge_requests because one or more of the new records could not be saved.'\
                      ' Validate fork Source project is not a fork of the target project'

3053 3054
      expect { project.append_or_update_attribute(:merge_requests, [create(:merge_request)]) }
        .to raise_error(ActiveRecord::RecordNotSaved, error_message)
3055 3056
    end

3057
    it 'updates the project successfully' do
3058 3059
      merge_request = create(:merge_request, target_project: project, source_project: project)

3060 3061
      expect { project.append_or_update_attribute(:merge_requests, [merge_request]) }
        .not_to raise_error
3062 3063
    end
  end
3064 3065 3066

  describe '#last_repository_updated_at' do
    it 'sets to created_at upon creation' do
3067
      project = create(:project, created_at: 2.hours.ago)
3068 3069 3070 3071

      expect(project.last_repository_updated_at.to_i).to eq(project.created_at.to_i)
    end
  end
3072 3073 3074 3075 3076

  describe '.public_or_visible_to_user' do
    let!(:user) { create(:user) }

    let!(:private_project) do
3077
      create(:project, :private, creator: user, namespace: user.namespace)
3078 3079
    end

3080
    let!(:public_project) { create(:project, :public) }
3081 3082 3083

    context 'with a user' do
      let(:projects) do
3084
        described_class.all.public_or_visible_to_user(user)
3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097
      end

      it 'includes projects the user has access to' do
        expect(projects).to include(private_project)
      end

      it 'includes projects the user can see' do
        expect(projects).to include(public_project)
      end
    end

    context 'without a user' do
      it 'only includes public projects' do
3098
        projects = described_class.all.public_or_visible_to_user
3099 3100 3101 3102 3103

        expect(projects).to eq([public_project])
      end
    end
  end
3104

3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126
  describe '#pages_available?' do
    let(:project) { create(:project, group: group) }

    subject { project.pages_available? }

    before do
      allow(Gitlab.config.pages).to receive(:enabled).and_return(true)
    end

    context 'when the project is in a top level namespace' do
      let(:group) { create(:group) }

      it { is_expected.to be(true) }
    end

    context 'when the project is in a subgroup' do
      let(:group) { create(:group, :nested) }

      it { is_expected.to be(false) }
    end
  end

3127
  describe '#remove_private_deploy_keys' do
3128
    let!(:project) { create(:project) }
3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143

    context 'for a private deploy key' do
      let!(:key) { create(:deploy_key, public: false) }
      let!(:deploy_keys_project) { create(:deploy_keys_project, deploy_key: key, project: project) }

      context 'when the key is not linked to another project' do
        it 'removes the key' do
          project.remove_private_deploy_keys

          expect(project.deploy_keys).not_to include(key)
        end
      end

      context 'when the key is linked to another project' do
        before do
3144
          another_project = create(:project)
3145 3146
          create(:deploy_keys_project, deploy_key: key, project: another_project)
        end
3147

3148 3149
        it 'does not remove the key' do
          project.remove_private_deploy_keys
3150

3151 3152 3153 3154 3155 3156 3157 3158
          expect(project.deploy_keys).to include(key)
        end
      end
    end

    context 'for a public deploy key' do
      let!(:key) { create(:deploy_key, public: true) }
      let!(:deploy_keys_project) { create(:deploy_keys_project, deploy_key: key, project: project) }
3159

3160 3161
      it 'does not remove the key' do
        project.remove_private_deploy_keys
3162

3163 3164
        expect(project.deploy_keys).to include(key)
      end
3165 3166
    end
  end
3167

3168 3169
  describe '#remove_pages' do
    let(:project) { create(:project) }
3170
    let(:namespace) { project.namespace }
3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181
    let(:pages_path) { project.pages_path }

    around do |example|
      FileUtils.mkdir_p(pages_path)
      begin
        example.run
      ensure
        FileUtils.rm_rf(pages_path)
      end
    end

3182 3183 3184 3185 3186 3187 3188 3189
    it 'removes the pages directory' do
      expect_any_instance_of(Projects::UpdatePagesConfigurationService).to receive(:execute)
      expect_any_instance_of(Gitlab::PagesTransfer).to receive(:rename_project).and_return(true)
      expect(PagesWorker).to receive(:perform_in).with(5.minutes, :remove, namespace.full_path, anything)

      project.remove_pages
    end

3190
    it 'is a no-op when there is no namespace' do
3191 3192
      project.namespace.delete
      project.reload
3193 3194 3195 3196 3197 3198

      expect_any_instance_of(Projects::UpdatePagesConfigurationService).not_to receive(:execute)
      expect_any_instance_of(Gitlab::PagesTransfer).not_to receive(:rename_project)

      project.remove_pages
    end
3199 3200 3201 3202 3203 3204

    it 'is run when the project is destroyed' do
      expect(project).to receive(:remove_pages).and_call_original

      project.destroy
    end
3205 3206
  end

3207
  describe '#remove_export' do
3208 3209
    let(:project) { create(:project, :with_export) }

3210
    it 'removes the export' do
3211 3212
      project.remove_exports

3213
      expect(project.export_file_exists?).to be_falsey
3214 3215 3216
    end
  end

3217 3218 3219 3220
  describe '#forks_count' do
    it 'returns the number of forks' do
      project = build(:project)

3221
      expect_any_instance_of(Projects::ForksCountService).to receive(:count).and_return(1)
3222 3223 3224 3225

      expect(project.forks_count).to eq(1)
    end
  end
3226 3227

  context 'legacy storage' do
3228
    let(:project) { create(:project, :repository, :legacy_storage) }
3229
    let(:gitlab_shell) { Gitlab::Shell.new }
3230
    let(:project_storage) { project.send(:storage) }
3231

3232 3233 3234 3235
    before do
      allow(project).to receive(:gitlab_shell).and_return(gitlab_shell)
    end

3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247
    describe '#base_dir' do
      it 'returns base_dir based on namespace only' do
        expect(project.base_dir).to eq(project.namespace.full_path)
      end
    end

    describe '#disk_path' do
      it 'returns disk_path based on namespace and project path' do
        expect(project.disk_path).to eq("#{project.namespace.full_path}/#{project.path}")
      end
    end

3248
    describe '#ensure_storage_path_exists' do
3249
      it 'delegates to gitlab_shell to ensure namespace is created' do
3250
        expect(gitlab_shell).to receive(:add_namespace).with(project.repository_storage, project.base_dir)
3251

3252
        project.ensure_storage_path_exists
3253 3254 3255
      end
    end

3256 3257
    describe '#legacy_storage?' do
      it 'returns true when storage_version is nil' do
3258 3259 3260 3261
        project = build(:project, storage_version: nil)

        expect(project.legacy_storage?).to be_truthy
      end
3262 3263 3264 3265 3266 3267 3268 3269 3270 3271

      it 'returns true when the storage_version is 0' do
        project = build(:project, storage_version: 0)

        expect(project.legacy_storage?).to be_truthy
      end
    end

    describe '#hashed_storage?' do
      it 'returns false' do
3272
        expect(project.hashed_storage?(:repository)).to be_falsey
3273
      end
3274 3275
    end

3276 3277 3278 3279 3280
    describe '#pages_path' do
      it 'returns a path where pages are stored' do
        expect(project.pages_path).to eq(File.join(Settings.pages.path, project.namespace.full_path, project.path))
      end
    end
3281 3282 3283 3284 3285 3286

    describe '#migrate_to_hashed_storage!' do
      it 'returns true' do
        expect(project.migrate_to_hashed_storage!).to be_truthy
      end

3287
      it 'flags as read-only' do
3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312
        expect { project.migrate_to_hashed_storage! }.to change { project.repository_read_only }.to(true)
      end

      it 'schedules ProjectMigrateHashedStorageWorker with delayed start when the project repo is in use' do
        Gitlab::ReferenceCounter.new(project.gl_repository(is_wiki: false)).increase

        expect(ProjectMigrateHashedStorageWorker).to receive(:perform_in)

        project.migrate_to_hashed_storage!
      end

      it 'schedules ProjectMigrateHashedStorageWorker with delayed start when the wiki repo is in use' do
        Gitlab::ReferenceCounter.new(project.gl_repository(is_wiki: true)).increase

        expect(ProjectMigrateHashedStorageWorker).to receive(:perform_in)

        project.migrate_to_hashed_storage!
      end

      it 'schedules ProjectMigrateHashedStorageWorker' do
        expect(ProjectMigrateHashedStorageWorker).to receive(:perform_async).with(project.id)

        project.migrate_to_hashed_storage!
      end
    end
3313 3314 3315
  end

  context 'hashed storage' do
3316
    let(:project) { create(:project, :repository, skip_disk_validation: true) }
3317
    let(:gitlab_shell) { Gitlab::Shell.new }
3318
    let(:hash) { Digest::SHA2.hexdigest(project.id.to_s) }
3319 3320
    let(:hashed_prefix) { File.join('@hashed', hash[0..1], hash[2..3]) }
    let(:hashed_path) { File.join(hashed_prefix, hash) }
3321 3322

    before do
3323
      stub_application_setting(hashed_storage_enabled: true)
3324 3325
    end

3326 3327 3328 3329 3330 3331 3332
    describe '#legacy_storage?' do
      it 'returns false' do
        expect(project.legacy_storage?).to be_falsey
      end
    end

    describe '#hashed_storage?' do
3333 3334
      it 'returns true if rolled out' do
        expect(project.hashed_storage?(:attachments)).to be_truthy
3335 3336
      end

3337 3338
      it 'returns false when not rolled out yet' do
        project.storage_version = 1
3339

3340
        expect(project.hashed_storage?(:attachments)).to be_falsey
3341 3342 3343
      end
    end

3344 3345
    describe '#base_dir' do
      it 'returns base_dir based on hash of project id' do
3346
        expect(project.base_dir).to eq(hashed_prefix)
3347 3348 3349 3350
      end
    end

    describe '#disk_path' do
3351
      it 'returns disk_path based on hash of project id' do
3352 3353 3354 3355
        expect(project.disk_path).to eq(hashed_path)
      end
    end

3356
    describe '#ensure_storage_path_exists' do
3357
      it 'delegates to gitlab_shell to ensure namespace is created' do
3358 3359
        allow(project).to receive(:gitlab_shell).and_return(gitlab_shell)

3360
        expect(gitlab_shell).to receive(:add_namespace).with(project.repository_storage, hashed_prefix)
3361

3362
        project.ensure_storage_path_exists
3363 3364 3365
      end
    end

3366 3367 3368 3369 3370
    describe '#pages_path' do
      it 'returns a path where pages are stored' do
        expect(project.pages_path).to eq(File.join(Settings.pages.path, project.namespace.full_path, project.path))
      end
    end
3371 3372 3373 3374 3375 3376

    describe '#migrate_to_hashed_storage!' do
      it 'returns nil' do
        expect(project.migrate_to_hashed_storage!).to be_nil
      end

3377
      it 'does not flag as read-only' do
3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390
        expect { project.migrate_to_hashed_storage! }.not_to change { project.repository_read_only }
      end
    end
  end

  describe '#gl_repository' do
    let(:project) { create(:project) }

    it 'delegates to Gitlab::GlRepository.gl_repository' do
      expect(Gitlab::GlRepository).to receive(:gl_repository).with(project, true)

      project.gl_repository(is_wiki: true)
    end
3391
  end
3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415

  describe '#has_ci?' do
    set(:project) { create(:project) }
    let(:repository) { double }

    before do
      expect(project).to receive(:repository) { repository }
    end

    context 'when has .gitlab-ci.yml' do
      before do
        expect(repository).to receive(:gitlab_ci_yml) { 'content' }
      end

      it "CI is available" do
        expect(project).to have_ci
      end
    end

    context 'when there is no .gitlab-ci.yml' do
      before do
        expect(repository).to receive(:gitlab_ci_yml) { nil }
      end

3416 3417
      it "CI is available" do
        expect(project).to have_ci
3418 3419
      end

3420
      context 'when auto devops is disabled' do
3421
        before do
3422
          stub_application_setting(auto_devops_enabled: false)
3423 3424
        end

3425 3426
        it "CI is not available" do
          expect(project).not_to have_ci
3427 3428 3429 3430 3431 3432
        end
      end
    end
  end

  describe '#auto_devops_enabled?' do
3433 3434 3435 3436 3437
    before do
      allow(Feature).to receive(:enabled?).and_call_original
      Feature.get(:force_autodevops_on_by_default).enable_percentage_of_actors(0)
    end

3438 3439 3440 3441 3442 3443 3444 3445 3446
    set(:project) { create(:project) }

    subject { project.auto_devops_enabled? }

    context 'when enabled in settings' do
      before do
        stub_application_setting(auto_devops_enabled: true)
      end

3447
      it { is_expected.to be_truthy }
3448 3449 3450 3451 3452 3453

      context 'when explicitly enabled' do
        before do
          create(:project_auto_devops, project: project)
        end

3454
        it { is_expected.to be_truthy }
3455 3456 3457 3458 3459 3460 3461
      end

      context 'when explicitly disabled' do
        before do
          create(:project_auto_devops, project: project, enabled: false)
        end

3462
        it { is_expected.to be_falsey }
3463 3464 3465 3466 3467 3468 3469 3470
      end
    end

    context 'when disabled in settings' do
      before do
        stub_application_setting(auto_devops_enabled: false)
      end

3471
      it { is_expected.to be_falsey }
3472 3473 3474 3475 3476 3477

      context 'when explicitly enabled' do
        before do
          create(:project_auto_devops, project: project)
        end

3478 3479 3480 3481 3482 3483
        it { is_expected.to be_truthy }
      end

      context 'when force_autodevops_on_by_default is enabled for the project' do
        before do
          Feature.get(:force_autodevops_on_by_default).enable_percentage_of_actors(100)
3484
        end
3485 3486

        it { is_expected.to be_truthy }
3487 3488 3489 3490
      end
    end
  end

3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534
  describe '#has_auto_devops_implicitly_enabled?' do
    set(:project) { create(:project) }

    context 'when disabled in settings' do
      before do
        stub_application_setting(auto_devops_enabled: false)
      end

      it 'does not have auto devops implicitly disabled' do
        expect(project).not_to have_auto_devops_implicitly_enabled
      end
    end

    context 'when enabled in settings' do
      before do
        stub_application_setting(auto_devops_enabled: true)
      end

      it 'auto devops is implicitly disabled' do
        expect(project).to have_auto_devops_implicitly_enabled
      end

      context 'when explicitly disabled' do
        before do
          create(:project_auto_devops, project: project, enabled: false)
        end

        it 'does not have auto devops implicitly disabled' do
          expect(project).not_to have_auto_devops_implicitly_enabled
        end
      end

      context 'when explicitly enabled' do
        before do
          create(:project_auto_devops, project: project, enabled: true)
        end

        it 'does not have auto devops implicitly disabled' do
          expect(project).not_to have_auto_devops_implicitly_enabled
        end
      end
    end
  end

3535
  describe '#has_auto_devops_implicitly_disabled?' do
3536 3537 3538 3539 3540
    before do
      allow(Feature).to receive(:enabled?).and_call_original
      Feature.get(:force_autodevops_on_by_default).enable_percentage_of_actors(0)
    end

3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561
    set(:project) { create(:project) }

    context 'when enabled in settings' do
      before do
        stub_application_setting(auto_devops_enabled: true)
      end

      it 'does not have auto devops implicitly disabled' do
        expect(project).not_to have_auto_devops_implicitly_disabled
      end
    end

    context 'when disabled in settings' do
      before do
        stub_application_setting(auto_devops_enabled: false)
      end

      it 'auto devops is implicitly disabled' do
        expect(project).to have_auto_devops_implicitly_disabled
      end

3562 3563 3564 3565 3566 3567 3568 3569 3570 3571
      context 'when force_autodevops_on_by_default is enabled for the project' do
        before do
          Feature.get(:force_autodevops_on_by_default).enable_percentage_of_actors(100)
        end

        it 'does not have auto devops implicitly disabled' do
          expect(project).not_to have_auto_devops_implicitly_disabled
        end
      end

3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583
      context 'when explicitly disabled' do
        before do
          create(:project_auto_devops, project: project, enabled: false)
        end

        it 'does not have auto devops implicitly disabled' do
          expect(project).not_to have_auto_devops_implicitly_disabled
        end
      end

      context 'when explicitly enabled' do
        before do
3584
          create(:project_auto_devops, project: project, enabled: true)
3585 3586 3587 3588 3589 3590 3591 3592 3593
        end

        it 'does not have auto devops implicitly disabled' do
          expect(project).not_to have_auto_devops_implicitly_disabled
        end
      end
    end
  end

3594 3595 3596 3597 3598
  context '#auto_devops_variables' do
    set(:project) { create(:project) }

    subject { project.auto_devops_variables }

3599
    context 'when enabled in instance settings' do
3600 3601 3602 3603
      before do
        stub_application_setting(auto_devops_enabled: true)
      end

3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624
      context 'when domain is empty' do
        before do
          stub_application_setting(auto_devops_domain: nil)
        end

        it 'variables does not include AUTO_DEVOPS_DOMAIN' do
          is_expected.not_to include(domain_variable)
        end
      end

      context 'when domain is configured' do
        before do
          stub_application_setting(auto_devops_domain: 'example.com')
        end

        it 'variables includes AUTO_DEVOPS_DOMAIN' do
          is_expected.to include(domain_variable)
        end
      end
    end

3625
    context 'when explicitly enabled' do
3626 3627 3628 3629 3630
      context 'when domain is empty' do
        before do
          create(:project_auto_devops, project: project, domain: nil)
        end

3631 3632
        it 'variables does not include AUTO_DEVOPS_DOMAIN' do
          is_expected.not_to include(domain_variable)
3633 3634 3635 3636 3637 3638 3639 3640
        end
      end

      context 'when domain is configured' do
        before do
          create(:project_auto_devops, project: project, domain: 'example.com')
        end

3641 3642
        it 'variables includes AUTO_DEVOPS_DOMAIN' do
          is_expected.to include(domain_variable)
3643 3644 3645
        end
      end
    end
3646 3647 3648 3649

    def domain_variable
      { key: 'AUTO_DEVOPS_DOMAIN', value: 'example.com', public: true }
    end
3650
  end
3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685

  describe '#latest_successful_builds_for' do
    let(:project) { build(:project) }

    before do
      allow(project).to receive(:default_branch).and_return('master')
    end

    context 'without a ref' do
      it 'returns a pipeline for the default branch' do
        expect(project)
          .to receive(:latest_successful_pipeline_for_default_branch)

        project.latest_successful_pipeline_for
      end
    end

    context 'with the ref set to the default branch' do
      it 'returns a pipeline for the default branch' do
        expect(project)
          .to receive(:latest_successful_pipeline_for_default_branch)

        project.latest_successful_pipeline_for(project.default_branch)
      end
    end

    context 'with a ref that is not the default branch' do
      it 'returns the latest successful pipeline for the given ref' do
        expect(project.pipelines).to receive(:latest_successful_for).with('foo')

        project.latest_successful_pipeline_for('foo')
      end
    end
  end

3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696
  describe '#check_repository_path_availability' do
    let(:project) { build(:project) }

    it 'skips gitlab-shell exists?' do
      project.skip_disk_validation = true

      expect(project.gitlab_shell).not_to receive(:exists?)
      expect(project.check_repository_path_availability).to be_truthy
    end
  end

3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717
  describe '#latest_successful_pipeline_for_default_branch' do
    let(:project) { build(:project) }

    before do
      allow(project).to receive(:default_branch).and_return('master')
    end

    it 'memoizes and returns the latest successful pipeline for the default branch' do
      pipeline = double(:pipeline)

      expect(project.pipelines).to receive(:latest_successful_for)
        .with(project.default_branch)
        .and_return(pipeline)
        .once

      2.times do
        expect(project.latest_successful_pipeline_for_default_branch)
          .to eq(pipeline)
      end
    end
  end
3718 3719

  describe '#after_import' do
3720
    let(:project) { create(:project) }
3721 3722 3723

    it 'runs the correct hooks' do
      expect(project.repository).to receive(:after_import)
3724
      expect(project.wiki.repository).to receive(:after_import)
3725 3726 3727
      expect(project).to receive(:import_finish)
      expect(project).to receive(:update_project_counter_caches)
      expect(project).to receive(:remove_import_jid)
3728
      expect(project).to receive(:after_create_default_branch)
3729
      expect(project).to receive(:refresh_markdown_cache!)
3730 3731 3732

      project.after_import
    end
3733 3734

    context 'branch protection' do
3735
      let(:project) { create(:project, :repository, :import_started) }
3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769

      it 'does not protect when branch protection is disabled' do
        stub_application_setting(default_branch_protection: Gitlab::Access::PROTECTION_NONE)

        project.after_import

        expect(project.protected_branches).to be_empty
      end

      it "gives developer access to push when branch protection is set to 'developers can push'" do
        stub_application_setting(default_branch_protection: Gitlab::Access::PROTECTION_DEV_CAN_PUSH)

        project.after_import

        expect(project.protected_branches).not_to be_empty
        expect(project.default_branch).to eq(project.protected_branches.first.name)
        expect(project.protected_branches.first.push_access_levels.map(&:access_level)).to eq([Gitlab::Access::DEVELOPER])
      end

      it "gives developer access to merge when branch protection is set to 'developers can merge'" do
        stub_application_setting(default_branch_protection: Gitlab::Access::PROTECTION_DEV_CAN_MERGE)

        project.after_import

        expect(project.protected_branches).not_to be_empty
        expect(project.default_branch).to eq(project.protected_branches.first.name)
        expect(project.protected_branches.first.merge_access_levels.map(&:access_level)).to eq([Gitlab::Access::DEVELOPER])
      end

      it 'protects default branch' do
        project.after_import

        expect(project.protected_branches).not_to be_empty
        expect(project.default_branch).to eq(project.protected_branches.first.name)
3770 3771
        expect(project.protected_branches.first.push_access_levels.map(&:access_level)).to eq([Gitlab::Access::MAINTAINER])
        expect(project.protected_branches.first.merge_access_levels.map(&:access_level)).to eq([Gitlab::Access::MAINTAINER])
3772 3773
      end
    end
3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807
  end

  describe '#update_project_counter_caches' do
    let(:project) { create(:project) }

    it 'updates all project counter caches' do
      expect_any_instance_of(Projects::OpenIssuesCountService)
        .to receive(:refresh_cache)
        .and_call_original

      expect_any_instance_of(Projects::OpenMergeRequestsCountService)
        .to receive(:refresh_cache)
        .and_call_original

      project.update_project_counter_caches
    end
  end

  describe '#remove_import_jid', :clean_gitlab_redis_cache do
    let(:project) {  }

    context 'without an import JID' do
      it 'does nothing' do
        project = create(:project)

        expect(Gitlab::SidekiqStatus)
          .not_to receive(:unset)

        project.remove_import_jid
      end
    end

    context 'with an import JID' do
      it 'unsets the import JID' do
3808 3809
        project = create(:project)
        create(:import_state, project: project, jid: '123')
3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835

        expect(Gitlab::SidekiqStatus)
          .to receive(:unset)
          .with('123')
          .and_call_original

        project.remove_import_jid

        expect(project.import_jid).to be_nil
      end
    end
  end

  describe '#wiki_repository_exists?' do
    it 'returns true when the wiki repository exists' do
      project = create(:project, :wiki_repo)

      expect(project.wiki_repository_exists?).to eq(true)
    end

    it 'returns false when the wiki repository does not exist' do
      project = create(:project)

      expect(project.wiki_repository_exists?).to eq(false)
    end
  end
ayufanpl's avatar
ayufanpl committed
3836

3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859
  describe '#root_namespace' do
    let(:project) { build(:project, namespace: parent) }

    subject { project.root_namespace }

    context 'when namespace has parent group' do
      let(:root_ancestor) { create(:group) }
      let(:parent) { build(:group, parent: root_ancestor) }

      it 'returns root ancestor' do
        is_expected.to eq(root_ancestor)
      end
    end

    context 'when namespace is root ancestor' do
      let(:parent) { build(:group) }

      it 'returns current namespace' do
        is_expected.to eq(parent)
      end
    end
  end

3860 3861 3862 3863 3864 3865
  describe '#write_repository_config' do
    set(:project) { create(:project, :repository) }

    it 'writes full path in .git/config when key is missing' do
      project.write_repository_config

3866
      expect(rugged_config['gitlab.fullpath']).to eq project.full_path
3867 3868 3869 3870 3871
    end

    it 'updates full path in .git/config when key is present' do
      project.write_repository_config(gl_full_path: 'old/path')

3872
      expect { project.write_repository_config }.to change { rugged_config['gitlab.fullpath'] }.from('old/path').to(project.full_path)
3873 3874 3875 3876 3877 3878 3879 3880
    end

    it 'does not raise an error with an empty repository' do
      project = create(:project_empty_repo)

      expect { project.write_repository_config }.not_to raise_error
    end
  end
3881 3882

  describe '#execute_hooks' do
3883
    let(:data) { { ref: 'refs/heads/master', data: 'data' } }
3884
    it 'executes active projects hooks with the specified scope' do
3885 3886 3887 3888
      hook = create(:project_hook, merge_requests_events: false, push_events: true)
      expect(ProjectHook).to receive(:select_active)
        .with(:push_hooks, data)
        .and_return([hook])
3889
      project = create(:project, hooks: [hook])
3890 3891 3892

      expect_any_instance_of(ProjectHook).to receive(:async_execute).once

3893
      project.execute_hooks(data, :push_hooks)
3894 3895 3896
    end

    it 'does not execute project hooks that dont match the specified scope' do
3897
      hook = create(:project_hook, merge_requests_events: true, push_events: false)
3898 3899 3900 3901
      project = create(:project, hooks: [hook])

      expect_any_instance_of(ProjectHook).not_to receive(:async_execute).once

3902
      project.execute_hooks(data, :push_hooks)
3903 3904
    end

3905
    it 'does not execute project hooks which are not active' do
3906 3907 3908 3909
      hook = create(:project_hook, push_events: true)
      expect(ProjectHook).to receive(:select_active)
        .with(:push_hooks, data)
        .and_return([])
3910 3911 3912 3913
      project = create(:project, hooks: [hook])

      expect_any_instance_of(ProjectHook).not_to receive(:async_execute).once

3914
      project.execute_hooks(data, :push_hooks)
3915 3916 3917
    end

    it 'executes the system hooks with the specified scope' do
3918
      expect_any_instance_of(SystemHooksService).to receive(:execute_hooks).with(data, :merge_request_hooks)
3919 3920

      project = build(:project)
3921
      project.execute_hooks(data, :merge_request_hooks)
3922
    end
3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935

    it 'executes the system hooks when inside a transaction' do
      allow_any_instance_of(WebHookService).to receive(:execute)

      create(:system_hook, merge_requests_events: true)

      project = build(:project)

      # Ideally, we'd test that `WebHookWorker.jobs.size` increased by 1,
      # but since the entire spec run takes place in a transaction, we never
      # actually get to the `after_commit` hook that queues these jobs.
      expect do
        project.transaction do
3936
          project.execute_hooks(data, :merge_request_hooks)
3937 3938 3939
        end
      end.not_to raise_error # Sidekiq::Worker::EnqueueFromTransactionError
    end
3940
  end
3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972

  describe '#badges' do
    let(:project_group) { create(:group) }
    let(:project) {  create(:project, path: 'avatar', namespace: project_group) }

    before do
      create_list(:project_badge, 2, project: project)
      create(:group_badge, group: project_group)
    end

    it 'returns the project and the project group badges' do
      create(:group_badge, group: create(:group))

      expect(Badge.count).to eq 4
      expect(project.badges.count).to eq 3
    end

    if Group.supports_nested_groups?
      context 'with nested_groups' do
        let(:parent_group) { create(:group) }

        before do
          create_list(:group_badge, 2, group: project_group)
          project_group.update(parent: parent_group)
        end

        it 'returns the project and the project nested groups badges' do
          expect(project.badges.count).to eq 5
        end
      end
    end
  end
3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984

  context 'with cross project merge requests' do
    let(:user) { create(:user) }
    let(:target_project) { create(:project, :repository) }
    let(:project) { fork_project(target_project, nil, repository: true) }
    let!(:merge_request) do
      create(
        :merge_request,
        target_project: target_project,
        target_branch: 'target-branch',
        source_project: project,
        source_branch: 'awesome-feature-1',
3985
        allow_collaboration: true
3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021
      )
    end

    before do
      target_project.add_developer(user)
    end

    describe '#merge_requests_allowing_push_to_user' do
      it 'returns open merge requests for which the user has developer access to the target project' do
        expect(project.merge_requests_allowing_push_to_user(user)).to include(merge_request)
      end

      it 'does not include closed merge requests' do
        merge_request.close

        expect(project.merge_requests_allowing_push_to_user(user)).to be_empty
      end

      it 'does not include merge requests for guest users' do
        guest = create(:user)
        target_project.add_guest(guest)

        expect(project.merge_requests_allowing_push_to_user(guest)).to be_empty
      end

      it 'does not include the merge request for other users' do
        other_user = create(:user)

        expect(project.merge_requests_allowing_push_to_user(other_user)).to be_empty
      end

      it 'is empty when no user is passed' do
        expect(project.merge_requests_allowing_push_to_user(nil)).to be_empty
      end
    end

4022
    describe '#branch_allows_collaboration_push?' do
4023
      it 'allows access if the user can merge the merge request' do
4024
        expect(project.branch_allows_collaboration?(user, 'awesome-feature-1'))
4025 4026 4027
          .to be_truthy
      end

4028 4029 4030 4031 4032
      it 'allows access when there are merge requests open but no branch name is given' do
        expect(project.branch_allows_collaboration?(user, nil))
          .to be_truthy
      end

4033 4034 4035 4036
      it 'does not allow guest users access' do
        guest = create(:user)
        target_project.add_guest(guest)

4037
        expect(project.branch_allows_collaboration?(guest, 'awesome-feature-1'))
4038 4039 4040 4041 4042 4043 4044 4045 4046
          .to be_falsy
      end

      it 'does not allow access to branches for which the merge request was closed' do
        create(:merge_request, :closed,
               target_project: target_project,
               target_branch: 'target-branch',
               source_project: project,
               source_branch: 'rejected-feature-1',
4047
               allow_collaboration: true)
4048

4049
        expect(project.branch_allows_collaboration?(user, 'rejected-feature-1'))
4050 4051 4052 4053
          .to be_falsy
      end

      it 'does not allow access if the user cannot merge the merge request' do
4054
        create(:protected_branch, :maintainers_can_push, project: target_project, name: 'target-branch')
4055

4056
        expect(project.branch_allows_collaboration?(user, 'awesome-feature-1'))
4057 4058 4059 4060
          .to be_falsy
      end

      it 'caches the result' do
4061
        control = ActiveRecord::QueryRecorder.new { project.branch_allows_collaboration?(user, 'awesome-feature-1') }
4062

4063
        expect { 3.times { project.branch_allows_collaboration?(user, 'awesome-feature-1') } }
4064 4065 4066 4067 4068
          .not_to exceed_query_limit(control)
      end

      context 'when the requeststore is active', :request_store do
        it 'only queries per project across instances' do
4069
          control = ActiveRecord::QueryRecorder.new { project.branch_allows_collaboration?(user, 'awesome-feature-1') }
4070

4071
          expect { 2.times { described_class.find(project.id).branch_allows_collaboration?(user, 'awesome-feature-1') } }
4072 4073 4074 4075 4076
            .not_to exceed_query_limit(control).with_threshold(2)
        end
      end
    end
  end
Rob Watson's avatar
Rob Watson committed
4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121

  describe "#pages_https_only?" do
    subject { build(:project) }

    context "when HTTPS pages are disabled" do
      it { is_expected.not_to be_pages_https_only }
    end

    context "when HTTPS pages are enabled", :https_pages_enabled do
      it { is_expected.to be_pages_https_only }
    end
  end

  describe "#pages_https_only? validation", :https_pages_enabled do
    subject(:project) do
      # set-up dirty object:
      create(:project, pages_https_only: false).tap do |p|
        p.pages_https_only = true
      end
    end

    context "when no domains are associated" do
      it { is_expected.to be_valid }
    end

    context "when domains including keys and certificates are associated" do
      before do
        allow(project)
          .to receive(:pages_domains)
          .and_return([instance_double(PagesDomain, https?: true)])
      end

      it { is_expected.to be_valid }
    end

    context "when domains including no keys or certificates are associated" do
      before do
        allow(project)
          .to receive(:pages_domains)
          .and_return([instance_double(PagesDomain, https?: false)])
      end

      it { is_expected.not_to be_valid }
    end
  end
4122

4123
  describe '#toggle_ci_cd_settings!' do
4124
    it 'toggles the value on #settings' do
4125
      project = create(:project, group_runners_enabled: false)
4126 4127 4128

      expect(project.group_runners_enabled).to be false

4129
      project.toggle_ci_cd_settings!(:group_runners_enabled)
4130 4131 4132 4133

      expect(project.group_runners_enabled).to be true
    end
  end
4134

4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154
  describe '#gitlab_deploy_token' do
    let(:project) { create(:project) }

    subject { project.gitlab_deploy_token }

    context 'when there is a gitlab deploy token associated' do
      let!(:deploy_token) { create(:deploy_token, :gitlab_deploy_token, projects: [project]) }

      it { is_expected.to eq(deploy_token) }
    end

    context 'when there is no a gitlab deploy token associated' do
      it { is_expected.to be_nil }
    end

    context 'when there is a gitlab deploy token associated but is has been revoked' do
      let!(:deploy_token) { create(:deploy_token, :gitlab_deploy_token, :revoked, projects: [project]) }
      it { is_expected.to be_nil }
    end

4155
    context 'when there is a gitlab deploy token associated but it is expired' do
4156 4157 4158 4159
      let!(:deploy_token) { create(:deploy_token, :gitlab_deploy_token, :expired, projects: [project]) }

      it { is_expected.to be_nil }
    end
4160

4161
    context 'when there is a deploy token associated with a different name' do
4162 4163 4164 4165
      let!(:deploy_token) { create(:deploy_token, projects: [project]) }

      it { is_expected.to be_nil }
    end
4166 4167 4168 4169 4170 4171 4172

    context 'when there is a deploy token associated to a different project' do
      let(:project_2) { create(:project) }
      let!(:deploy_token) { create(:deploy_token, projects: [project_2]) }

      it { is_expected.to be_nil }
    end
4173
  end
Jan Provaznik's avatar
Jan Provaznik committed
4174 4175 4176 4177 4178 4179 4180 4181

  context 'with uploads' do
    it_behaves_like 'model with mounted uploader', true do
      let(:model_object) { create(:project, :with_avatar) }
      let(:upload_attribute) { :avatar }
      let(:uploader_class) { AttachmentUploader }
    end
  end
4182

4183 4184 4185 4186 4187 4188 4189 4190 4191 4192
  context '#commits_by' do
    let(:project) { create(:project, :repository) }
    let(:commits) { project.repository.commits('HEAD', limit: 3).commits }
    let(:commit_shas) { commits.map(&:id) }

    it 'retrieves several commits from the repository by oid' do
      expect(project.commits_by(oids: commit_shas)).to eq commits
    end
  end

4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233
  context '#members_among' do
    let(:users) { create_list(:user, 3) }
    set(:group) { create(:group) }
    set(:project) { create(:project, namespace: group) }

    before do
      project.add_guest(users.first)
      project.group.add_maintainer(users.last)
    end

    context 'when users is an Array' do
      it 'returns project members among the users' do
        expect(project.members_among(users)).to eq([users.first, users.last])
      end

      it 'maintains input order' do
        expect(project.members_among(users.reverse)).to eq([users.last, users.first])
      end

      it 'returns empty array if users is empty' do
        result = project.members_among([])

        expect(result).to be_empty
      end
    end

    context 'when users is a relation' do
      it 'returns project members among the users' do
        result = project.members_among(User.where(id: users.map(&:id)))

        expect(result).to be_a(ActiveRecord::Relation)
        expect(result).to eq([users.first, users.last])
      end

      it 'returns empty relation if users is empty' do
        result = project.members_among(User.none)

        expect(result).to be_a(ActiveRecord::Relation)
        expect(result).to be_empty
      end
    end
4234
  end
4235

4236 4237
  describe "#find_or_initialize_services" do
    subject { build(:project) }
4238

4239 4240 4241
    it 'returns only enabled services' do
      allow(Service).to receive(:available_services_names).and_return(%w(prometheus pushover))
      allow(subject).to receive(:disabled_services).and_return(%w(prometheus))
4242

4243
      services = subject.find_or_initialize_services
4244

4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266
      expect(services.count).to eq 1
      expect(services).to include(PushoverService)
    end
  end

  describe "#find_or_initialize_service" do
    subject { build(:project) }

    it 'avoids N+1 database queries' do
      allow(Service).to receive(:available_services_names).and_return(%w(prometheus pushover))

      control_count = ActiveRecord::QueryRecorder.new { subject.find_or_initialize_service('prometheus') }.count

      allow(Service).to receive(:available_services_names).and_call_original

      expect { subject.find_or_initialize_service('prometheus') }.not_to exceed_query_limit(control_count)
    end

    it 'returns nil if service is disabled' do
      allow(subject).to receive(:disabled_services).and_return(%w(prometheus))

      expect(subject.find_or_initialize_service('prometheus')).to be_nil
4267
    end
4268 4269
  end

4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292
  describe '.find_without_deleted' do
    it 'returns nil if the project is about to be removed' do
      project = create(:project, pending_delete: true)

      expect(described_class.find_without_deleted(project.id)).to be_nil
    end

    it 'returns a project when it is not about to be removed' do
      project = create(:project)

      expect(described_class.find_without_deleted(project.id)).to eq(project)
    end
  end

  describe '.for_group' do
    it 'returns the projects for a given group' do
      group = create(:group)
      project = create(:project, namespace: group)

      expect(described_class.for_group(group)).to eq([project])
    end
  end

4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326
  describe '.deployments' do
    subject { project.deployments }

    let(:project) { create(:project) }

    before do
      allow_any_instance_of(Deployment).to receive(:create_ref)
    end

    context 'when there is a deployment record with created status' do
      let(:deployment) { create(:deployment, :created, project: project) }

      it 'does not return the record' do
        is_expected.to be_empty
      end
    end

    context 'when there is a deployment record with running status' do
      let(:deployment) { create(:deployment, :running, project: project) }

      it 'does not return the record' do
        is_expected.to be_empty
      end
    end

    context 'when there is a deployment record with success status' do
      let(:deployment) { create(:deployment, :success, project: project) }

      it 'returns the record' do
        is_expected.to eq([deployment])
      end
    end
  end

4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348
  describe '#snippets_visible?' do
    it 'returns true when a logged in user can read snippets' do
      project = create(:project, :public)
      user = create(:user)

      expect(project.snippets_visible?(user)).to eq(true)
    end

    it 'returns true when an anonymous user can read snippets' do
      project = create(:project, :public)

      expect(project.snippets_visible?).to eq(true)
    end

    it 'returns false when a user can not read snippets' do
      project = create(:project, :private)
      user = create(:user)

      expect(project.snippets_visible?(user)).to eq(false)
    end
  end

4349
  def rugged_config
4350
    rugged_repo(project.repository).config
4351
  end
gitlabhq's avatar
gitlabhq committed
4352
end