BigW Consortium Gitlab

project_spec.rb 71.2 KB
Newer Older
gitlabhq committed
1 2
require 'spec_helper'

3
describe Project do
4
  describe 'associations' do
5 6 7 8
    it { is_expected.to belong_to(:group) }
    it { is_expected.to belong_to(:namespace) }
    it { is_expected.to belong_to(:creator).class_name('User') }
    it { is_expected.to have_many(:users) }
ubudzisz committed
9
    it { is_expected.to have_many(:services) }
10 11 12 13 14
    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) }
15
    it { is_expected.to have_many(:users).through(:project_members) }
16 17 18 19
    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) }
20
    it { is_expected.to have_many(:deploy_keys) }
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53
    it { is_expected.to have_many(:hooks) }
    it { is_expected.to have_many(:protected_branches) }
    it { is_expected.to have_one(:forked_project_link) }
    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) }
    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(:gemnasium_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) }
    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 committed
54 55
    it { is_expected.to have_one(:last_event).class_name('Event') }
    it { is_expected.to have_one(:forked_from_project).through(:forked_project_link) }
Kamil Trzcinski committed
56
    it { is_expected.to have_many(:commit_statuses) }
57
    it { is_expected.to have_many(:pipelines) }
58 59 60
    it { is_expected.to have_many(:builds) }
    it { is_expected.to have_many(:runner_projects) }
    it { is_expected.to have_many(:runners) }
Kamil Trzcinski committed
61
    it { is_expected.to have_many(:active_runners) }
62 63
    it { is_expected.to have_many(:variables) }
    it { is_expected.to have_many(:triggers) }
64
    it { is_expected.to have_many(:pages_domains) }
65 66 67 68 69 70 71 72 73
    it { is_expected.to have_many(:labels).class_name('ProjectLabel') }
    it { is_expected.to have_many(:users_star_projects) }
    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) }
ubudzisz committed
74
    it { is_expected.to have_many(:forks).through(:forked_project_links) }
75
    it { is_expected.to have_many(:uploads).dependent(:destroy) }
76
    it { is_expected.to have_many(:pipeline_schedules) }
77

78 79
    context 'after initialized' do
      it "has a project_feature" do
80
        expect(described_class.new.project_feature).to be_present
81 82 83
      end
    end

84
    describe '#members & #requesters' do
85
      let(:project) { create(:project, :public, :access_requestable) }
86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
      let(:requester) { create(:user) }
      let(:developer) { create(:user) }
      before do
        project.request_access(requester)
        project.team << [developer, :developer]
      end

      describe '#members' do
        it 'includes members and exclude requesters' do
          member_user_ids = project.members.pluck(:user_id)

          expect(member_user_ids).to include(developer.id)
          expect(member_user_ids).not_to include(requester.id)
        end
      end

      describe '#requesters' do
        it 'does not include requesters' do
          requester_user_ids = project.requesters.pluck(:user_id)

          expect(requester_user_ids).to include(requester.id)
          expect(requester_user_ids).not_to include(developer.id)
        end
      end
    end
111 112 113 114 115

    describe '#boards' do
      it 'raises an error when attempting to add more than one board to the project' do
        subject.boards.build

116
        expect { subject.boards.build }.to raise_error(Project::BoardLimitExceeded, 'Number of permitted boards exceeded')
117 118 119
        expect(subject.boards.size).to eq 1
      end
    end
gitlabhq committed
120 121
  end

122 123 124 125 126 127
  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) }
128
    it { is_expected.to include_module(Gitlab::CurrentSettings) }
129 130
    it { is_expected.to include_module(Referable) }
    it { is_expected.to include_module(Sortable) }
131 132
  end

133
  describe 'validation' do
134
    let!(:project) { create(:project) }
135

136 137
    it { is_expected.to validate_presence_of(:name) }
    it { is_expected.to validate_uniqueness_of(:name).scoped_to(:namespace_id) }
138
    it { is_expected.to validate_length_of(:name).is_at_most(255) }
139

140 141
    it { is_expected.to validate_presence_of(:path) }
    it { is_expected.to validate_uniqueness_of(:path).scoped_to(:namespace_id) }
142 143 144 145
    it { is_expected.to validate_length_of(:path).is_at_most(255) }

    it { is_expected.to validate_length_of(:description).is_at_most(2000) }

146 147 148
    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) }
149

150
    it { is_expected.to validate_presence_of(:creator) }
151

152
    it { is_expected.to validate_presence_of(:namespace) }
153

154
    it { is_expected.to validate_presence_of(:repository_storage) }
155

156
    it 'does not allow new projects beyond user limits' do
157
      project2 = build(:project)
158 159
      allow(project2).to receive(:creator).and_return(double(can_create_project?: false, projects_limit: 0).as_null_object)
      expect(project2).not_to be_valid
160
      expect(project2.errors[:limit_reached].first).to match(/Personal project creation is not allowed/)
161
    end
162 163 164

    describe 'wiki path conflict' do
      context "when the new path has been used by the wiki of other Project" do
165
        it 'has an error on the name attribute' do
166
          new_project = build_stubbed(:project, namespace_id: project.namespace_id, path: "#{project.path}.wiki")
167 168 169 170 171 172 173

          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
174
        it 'has an error on the name attribute' do
175 176
          project_with_wiki_suffix = create(:project, path: 'foo.wiki')
          new_project = build_stubbed(:project, namespace_id: project_with_wiki_suffix.namespace_id, path: 'foo')
177 178 179 180 181 182

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

    context 'repository storages inclussion' do
185
      let(:project2) { build(:project, repository_storage: 'missing') }
186 187

      before do
188
        storages = { 'custom' => { 'path' => 'tmp/tests/custom_repositories' } }
189 190 191
        allow(Gitlab.config.repositories).to receive(:storages).and_return(storages)
      end

192
      it "does not allow repository storages that don't match a label in the configuration" do
193 194 195 196
        expect(project2).not_to be_valid
        expect(project2.errors[:repository_storage].first).to match(/is not included in the list/)
      end
    end
197

198
    it 'does not allow an invalid URI as import_url' do
199
      project2 = build(:project, import_url: 'invalid://')
200 201 202 203

      expect(project2).not_to be_valid
    end

204
    it 'does allow a valid URI as import_url' do
205
      project2 = build(:project, import_url: 'ssh://test@gitlab.com/project.git')
206

207 208
      expect(project2).to be_valid
    end
209

210
    it 'allows an empty URI' do
211
      project2 = build(:project, import_url: '')
212

213
      expect(project2).to be_valid
214 215 216
    end

    it 'does not produce import data on an empty URI' do
217
      project2 = build(:project, import_url: '')
218 219 220 221 222

      expect(project2.import_data).to be_nil
    end

    it 'does not produce import data on an invalid URI' do
223
      project2 = build(:project, import_url: 'test://')
224 225 226

      expect(project2.import_data).to be_nil
    end
227

228
    it "does not allow blocked import_url localhost" do
229
      project2 = build(:project, import_url: 'http://localhost:9000/t.git')
230 231 232 233 234 235

      expect(project2).to be_invalid
      expect(project2.errors[:import_url]).to include('imports are not allowed from that URL')
    end

    it "does not allow blocked import_url port" do
236
      project2 = build(:project, import_url: 'http://github.com:25/t.git')
237 238 239 240 241

      expect(project2).to be_invalid
      expect(project2.errors[:import_url]).to include('imports are not allowed from that URL')
    end

242 243
    describe 'project pending deletion' do
      let!(:project_pending_deletion) do
244
        create(:project,
245 246 247
               pending_delete: true)
      end
      let(:new_project) do
248
        build(:project,
249 250 251 252 253 254 255 256 257 258 259 260
              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
261 262 263

    describe 'path validation' do
      it 'allows paths reserved on the root namespace' do
264
        project = build(:project, path: 'api')
265 266 267 268 269

        expect(project).to be_valid
      end

      it 'rejects paths reserved on another level' do
270
        project = build(:project, path: 'tree')
271 272 273

        expect(project).not_to be_valid
      end
274 275 276

      it 'rejects nested paths' do
        parent = create(:group, :nested, path: 'environments')
277
        project = build(:project, path: 'folders', namespace: parent)
278 279 280

        expect(project).not_to be_valid
      end
281 282 283

      it 'allows a reserved group name' do
        parent = create(:group)
284
        project = build(:project, path: 'avatar', namespace: parent)
285 286 287

        expect(project).to be_valid
      end
288
    end
gitlabhq committed
289
  end
290

291
  describe 'project token' do
292
    it 'sets an random token if none provided' do
293
      project = FactoryGirl.create :project, runners_token: ''
294
      expect(project.runners_token).not_to eq('')
295 296
    end

ubudzisz committed
297
    it 'does not set an random token if one provided' do
298
      project = FactoryGirl.create :project, runners_token: 'my-token'
299
      expect(project.runners_token).to eq('my-token')
300 301
    end
  end
gitlabhq committed
302

303
  describe 'Respond to' do
304 305 306 307 308
    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) }
309
    it { is_expected.to respond_to(:full_path) }
gitlabhq committed
310 311
  end

312
  describe 'delegation' do
313 314 315 316 317 318 319 320
    [:add_guest, :add_reporter, :add_developer, :add_master, :add_user, :add_users].each do |method|
      it { is_expected.to delegate_method(method).to(:team) }
    end

    it { is_expected.to delegate_method(:empty_repo?).to(:repository) }
    it { is_expected.to delegate_method(:members).to(:team).with_prefix(true) }
    it { is_expected.to delegate_method(:count).to(:forks).with_prefix(true) }
    it { is_expected.to delegate_method(:name).to(:owner).with_prefix(true).with_arguments(allow_nil: true) }
321 322
  end

323
  describe '#to_reference' do
324
    let(:owner)     { create(:user, name: 'Gitlab') }
325
    let(:namespace) { create(:namespace, path: 'sample-namespace', owner: owner) }
326
    let(:project)   { create(:project, path: 'sample-project', namespace: namespace) }
327
    let(:group)     { create(:group, name: 'Group', path: 'sample-group', owner: owner) }
328

329
    context 'when nil argument' do
330 331 332 333 334
      it 'returns nil' do
        expect(project.to_reference).to be_nil
      end
    end

335
    context 'when full is true' do
336
      it 'returns complete path to the project' do
337 338 339
        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'
340 341 342 343 344 345 346 347 348 349
      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
350
      let(:another_namespace_project) { create(:project, name: 'another-project') }
351 352 353 354 355 356 357

      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
358
      let(:another_project) { create(:project, namespace: namespace) }
359

360
      it 'returns path to the project' do
361 362 363
        expect(project.to_reference(another_project)).to eq 'sample-project'
      end
    end
364

365 366
    context 'when different namespace / cross-project argument' do
      let(:another_namespace) { create(:namespace, path: 'another-namespace', owner: owner) }
367
      let(:another_project)   { create(:project, path: 'another-project', namespace: another_namespace) }
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384

      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
385 386
      end
    end
387 388 389 390 391
  end

  describe '#to_human_reference' do
    let(:owner) { create(:user, name: 'Gitlab') }
    let(:namespace) { create(:namespace, name: 'Sample namespace', owner: owner) }
392
    let(:project) { create(:project, name: 'Sample project', namespace: namespace) }
393 394 395 396 397 398 399 400 401 402 403 404 405 406

    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
407
      let(:another_namespace_project) { create(:project, name: 'another-project') }
408 409 410 411 412 413 414

      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

    context 'when same namespace / cross-project argument' do
415
      let(:another_project) { create(:project, namespace: namespace) }
416 417 418 419

      it 'returns name of the project' do
        expect(project.to_human_reference(another_project)).to eq 'Sample project'
      end
420 421 422
    end
  end

423
  describe '#repository_storage_path' do
424
    let(:project) { create(:project, repository_storage: 'custom') }
425 426 427

    before do
      FileUtils.mkdir('tmp/tests/custom_repositories')
428
      storages = { 'custom' => { 'path' => 'tmp/tests/custom_repositories' } }
429 430 431 432 433 434 435 436 437 438 439 440
      allow(Gitlab.config.repositories).to receive(:storages).and_return(storages)
    end

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

    it 'returns the repository storage path' do
      expect(project.repository_storage_path).to eq('tmp/tests/custom_repositories')
    end
  end

441
  it 'returns valid url to repo' do
442
    project = described_class.new(path: 'somewhere')
443
    expect(project.url_to_repo).to eq(Gitlab.config.gitlab_shell.ssh_path_prefix + 'somewhere.git')
gitlabhq committed
444 445
  end

Douwe Maan committed
446
  describe "#web_url" do
447
    let(:project) { create(:project, path: "somewhere") }
Douwe Maan committed
448 449

    it 'returns the full web URL for this repo' do
450
      expect(project.web_url).to eq("#{Gitlab.config.gitlab.url}/#{project.namespace.full_path}/somewhere")
Douwe Maan committed
451
    end
452 453
  end

454
  describe "#new_issue_address" do
455
    let(:project) { create(:project, path: "somewhere") }
456 457
    let(:user) { create(:user) }

458 459 460 461 462 463
    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
464
        address = "p+#{project.full_path}+#{user.incoming_email_token}@gl.ab"
465 466 467 468 469 470 471 472 473

        expect(project.new_issue_address(user)).to eq(address)
      end
    end

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

475 476 477
      it 'returns nil' do
        expect(project.new_issue_address(user)).to be_nil
      end
478 479 480
    end
  end

481
  describe 'last_activity methods' do
482 483
    let(:timestamp) { 2.hours.ago }
    # last_activity_at gets set to created_at upon creation
484
    let(:project) { create(:project, created_at: timestamp, updated_at: timestamp) }
gitlabhq committed
485

486
    describe 'last_activity' do
487
      it 'alias last_activity to last_event' do
488 489
        last_event = create(:event, project: project)

490
        expect(project.last_activity).to eq(last_event)
491
      end
gitlabhq committed
492 493
    end

494 495
    describe 'last_activity_date' do
      it 'returns the creation date of the project\'s last event if present' do
496 497
        new_event = create(:event, project: project, created_at: Time.now)

498
        project.reload
499
        expect(project.last_activity_at.to_i).to eq(new_event.created_at.to_i)
500
      end
501

502
      it 'returns the project\'s last update date if it has no events' do
503
        expect(project.last_activity_date).to eq(project.updated_at)
504
      end
505 506
    end
  end
507

508
  describe '#get_issue' do
509
    let(:project) { create(:project) }
510
    let!(:issue)  { create(:issue, project: project) }
511 512 513 514 515
    let(:user)    { create(:user) }

    before do
      project.team << [user, :developer]
    end
516 517 518

    context 'with default issues tracker' do
      it 'returns an issue' do
519
        expect(project.get_issue(issue.iid, user)).to eq issue
520 521
      end

522 523 524 525
      it 'returns count of open issues' do
        expect(project.open_issues_count).to eq(1)
      end

526
      it 'returns nil when no issue found' do
527 528 529 530 531 532
        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
533 534 535 536
      end
    end

    context 'with external issues tracker' do
537
      let!(:internal_issue) { create(:issue, project: project) }
538
      before do
539
        allow(project).to receive(:external_issue_tracker).and_return(true)
540 541
      end

542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
      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
579 580 581 582 583
      end
    end
  end

  describe '#issue_exists?' do
584
    let(:project) { create(:project) }
585 586 587 588 589 590 591 592 593 594 595 596

    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

597
  describe '#to_param' do
598 599 600
    context 'with namespace' do
      before do
        @group = create :group, name: 'gitlab'
601
        @project = create(:project, name: 'gitlabhq', namespace: @group)
602 603
      end

Vinnie Okada committed
604
      it { expect(@project.to_param).to eq('gitlabhq') }
605
    end
606 607 608

    context 'with invalid path' do
      it 'returns previous path to keep project suitable for use in URLs when persisted' do
609
        project = create(:project, path: 'gitlab')
610 611 612 613 614 615 616
        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
617
        project = build(:project, path: 'gitlab')
618 619 620 621 622 623
        project.path = 'foo&bar'

        expect(project).not_to be_valid
        expect(project.to_param).to eq 'foo&bar'
      end
    end
624
  end
Dmitriy Zaporozhets committed
625

626
  describe '#repository' do
627
    let(:project) { create(:project, :repository) }
Dmitriy Zaporozhets committed
628

629
    it 'returns valid repo' do
630
      expect(project.repository).to be_kind_of(Repository)
Dmitriy Zaporozhets committed
631 632
    end
  end
633

634
  describe '#default_issues_tracker?' do
635
    it "is true if used internal tracker" do
636
      project = build(:project)
637

638
      expect(project.default_issues_tracker?).to be_truthy
639 640
    end

641
    it "is false if used other tracker" do
642 643 644 645
      # NOTE: The current nature of this factory requires persistence
      project = create(:redmine_project)

      expect(project.default_issues_tracker?).to be_falsey
646 647 648
    end
  end

649
  describe '#external_issue_tracker' do
650
    let(:project) { create(:project) }
651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683
    let(:ext_project) { create(:redmine_project) }

    context 'on existing projects with no value for has_external_issue_tracker' do
      before(:each) do
        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

684
  describe '#cache_has_external_issue_tracker' do
685
    let(:project) { create(:project, has_external_issue_tracker: nil) }
686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705

    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
  end

706
  describe '#has_wiki?' do
707 708 709
    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) }
710 711 712 713 714 715 716 717

    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

718
  describe '#external_wiki' do
719
    let(:project) { create(:project) }
720

721 722 723 724 725
    context 'with an active external wiki' do
      before do
        create(:service, project: project, type: 'ExternalWikiService', active: true)
        project.external_wiki
      end
726

727 728 729
      it 'sets :has_external_wiki as true' do
        expect(project.has_external_wiki).to be(true)
      end
730

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

734 735 736 737
        project.services.external_wikis.first.destroy

        expect(project.has_external_wiki).to be(false)
      end
738 739
    end

740 741 742 743
    context 'with an inactive external wiki' do
      before do
        create(:service, project: project, type: 'ExternalWikiService', active: false)
      end
744

745 746 747
      it 'sets :has_external_wiki as false' do
        expect(project.has_external_wiki).to be(false)
      end
748 749
    end

750 751 752 753
    context 'with no external wiki' do
      before do
        project.external_wiki
      end
754

755 756 757 758 759 760 761 762 763 764 765
      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
766 767 768
    end
  end

769 770
  describe '#star_count' do
    it 'counts stars from multiple users' do
Ciro Santilli committed
771 772
      user1 = create :user
      user2 = create :user
773
      project = create(:project, :public)
Ciro Santilli committed
774 775

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

Ciro Santilli committed
777
      user1.toggle_star(project)
778 779
      expect(project.reload.star_count).to eq(1)

Ciro Santilli committed
780
      user2.toggle_star(project)
781 782 783
      project.reload
      expect(project.reload.star_count).to eq(2)

Ciro Santilli committed
784
      user1.toggle_star(project)
785 786 787
      project.reload
      expect(project.reload.star_count).to eq(1)

Ciro Santilli committed
788
      user2.toggle_star(project)
789 790 791 792
      project.reload
      expect(project.reload.star_count).to eq(0)
    end

793
    it 'counts stars on the right project' do
794
      user = create :user
795 796
      project1 = create(:project, :public)
      project2 = create(:project, :public)
797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823

      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 committed
824 825
    end
  end
826

827
  describe '#avatar_type' do
828
    let(:project) { create(:project) }
829

830
    it 'is true if avatar is image' do
831
      project.update_attribute(:avatar, 'uploads/avatar.png')
832
      expect(project.avatar_type).to be_truthy
833 834
    end

835
    it 'is false if avatar is html page' do
836
      project.update_attribute(:avatar, 'uploads/avatar.html')
837
      expect(project.avatar_type).to eq(['only images allowed'])
838 839
    end
  end
840

841
  describe '#avatar_url' do
842 843
    subject { project.avatar_url }

844
    let(:project) { create(:project) }
845

846
    context 'when avatar file is uploaded' do
847
      let(:project) { create(:project, :with_avatar) }
848
      let(:avatar_path) { "/uploads/-/system/project/avatar/#{project.id}/dk.png" }
849
      let(:gitlab_host) { "http://#{Gitlab.config.gitlab.host}" }
850

851 852 853 854 855 856 857 858
      it 'shows correct url' do
        expect(project.avatar_url).to eq(avatar_path)
        expect(project.avatar_url(only_path: false)).to eq([gitlab_host, avatar_path].join)

        allow(ActionController::Base).to receive(:asset_host).and_return(gitlab_host)

        expect(project.avatar_url).to eq([gitlab_host, avatar_path].join)
      end
859 860 861 862 863 864 865
    end

    context 'When avatar file in git' do
      before do
        allow(project).to receive(:avatar_in_git) { true }
      end

866
      let(:avatar_path) { "/#{project.full_path}/avatar" }
867

868
      it { is_expected.to eq "http://#{Gitlab.config.gitlab.host}#{avatar_path}" }
869
    end
870 871

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

874
      it { is_expected.to eq nil }
875
    end
876
  end
877

878
  describe '#pipeline_for' do
879
    let(:project) { create(:project, :repository) }
880
    let!(:pipeline) { create_pipeline }
881

882 883
    shared_examples 'giving the correct pipeline' do
      it { is_expected.to eq(pipeline) }
884

885 886
      context 'return latest' do
        let!(:pipeline2) { create_pipeline }
887

888
        it { is_expected.to eq(pipeline2) }
889
      end
890 891 892 893 894 895 896 897 898 899 900 901 902
    end

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

      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
903

904 905 906 907 908
    def create_pipeline
      create(:ci_pipeline,
             project: project,
             ref: 'master',
             sha: project.commit('master').sha)
909
    end
910
  end
911

912
  describe '#builds_enabled' do
913
    let(:project) { create(:project) }
914

915 916 917
    subject { project.builds_enabled }

    it { expect(project.builds_enabled?).to be_truthy }
918
  end
919

920
  describe '.with_shared_runners' do
921
    subject { described_class.with_shared_runners }
922 923

    context 'when shared runners are enabled for project' do
924
      let!(:project) { create(:project, shared_runners_enabled: true) }
925 926 927 928 929 930 931

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

    context 'when shared runners are disabled for project' do
932
      let!(:project) { create(:project, shared_runners_enabled: false) }
933 934 935 936 937 938 939

      it "returns an empty array" do
        is_expected.to be_empty
      end
    end
  end

940
  describe '.cached_count', :use_clean_rails_memory_store_caching do
941
    let(:group)     { create(:group, :public) }
942 943
    let!(:project1) { create(:project, :public, group: group) }
    let!(:project2) { create(:project, :public, group: group) }
944 945

    it 'returns total project count' do
946
      expect(described_class).to receive(:count).once.and_call_original
947 948

      3.times do
949
        expect(described_class.cached_count).to eq(2)
950 951 952 953
      end
    end
  end

954
  describe '.trending' do
Felipe Artur committed
955
    let(:group)    { create(:group, :public) }
956 957
    let(:project1) { create(:project, :public, group: group) }
    let(:project2) { create(:project, :public, group: group) }
958 959 960 961 962 963 964 965

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

      create(:note_on_commit, project: project2)

966
      TrendingProject.refresh!
967 968
    end

969
    subject { described_class.trending.to_a }
970

971 972
    it 'sorts projects by the amount of notes in descending order' do
      expect(subject).to eq([project1, project2])
973
    end
974 975 976 977 978 979 980 981

    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
982
  end
983

984 985 986 987
  describe '.starred_by' do
    it 'returns only projects starred by the given user' do
      user1 = create(:user)
      user2 = create(:user)
988 989 990
      project1 = create(:project)
      project2 = create(:project)
      create(:project)
991 992 993
      user1.toggle_star(project1)
      user2.toggle_star(project2)

994
      expect(described_class.starred_by(user1)).to contain_exactly(project1)
995 996 997
    end
  end

998
  describe '.visible_to_user' do
999
    let!(:project) { create(:project, :private) }
1000 1001 1002 1003 1004 1005
    let!(:user)    { create(:user) }

    subject { described_class.visible_to_user(user) }

    describe 'when a user has access to a project' do
      before do
1006
        project.add_user(user, Gitlab::Access::MASTER)
1007 1008 1009 1010 1011 1012 1013 1014 1015
      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
1016

1017
  context 'repository storage by default' do
1018
    let(:project) { create(:project) }
1019 1020

    before do
1021
      storages = {
1022
        'default' => { 'path' => 'tmp/tests/repositories' },
1023
        'picked'  => { 'path' => 'tmp/tests/repositories' }
1024
      }
1025 1026 1027
      allow(Gitlab.config.repositories).to receive(:storages).and_return(storages)
    end

1028 1029 1030 1031 1032
    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
1033 1034
  end

1035
  context 'shared runners by default' do
1036
    let(:project) { create(:project) }
1037 1038 1039 1040

    subject { project.shared_runners_enabled }

    context 'are enabled' do
1041 1042 1043
      before do
        stub_application_setting(shared_runners_enabled: true)
      end
1044 1045 1046 1047 1048

      it { is_expected.to be_truthy }
    end

    context 'are disabled' do
1049 1050 1051
      before do
        stub_application_setting(shared_runners_enabled: false)
      end
1052 1053 1054 1055 1056

      it { is_expected.to be_falsey }
    end
  end

1057
  describe '#any_runners' do
1058
    let(:project) { create(:project, shared_runners_enabled: shared_runners_enabled) }
1059 1060
    let(:specific_runner) { create(:ci_runner) }
    let(:shared_runner) { create(:ci_runner, :shared) }
1061 1062 1063

    context 'for shared runners disabled' do
      let(:shared_runners_enabled) { false }
1064

1065
      it 'has no runners available' do
1066 1067
        expect(project.any_runners?).to be_falsey
      end
1068

1069
      it 'has a specific runner' do
1070
        project.runners << specific_runner
1071 1072
        expect(project.any_runners?).to be_truthy
      end
1073

1074
      it 'has a shared runner, but they are prohibited to use' do
1075 1076 1077
        shared_runner
        expect(project.any_runners?).to be_falsey
      end
1078

1079
      it 'checks the presence of specific runner' do
1080
        project.runners << specific_runner
1081 1082 1083
        expect(project.any_runners? { |runner| runner == specific_runner }).to be_truthy
      end
    end
1084

1085 1086
    context 'for shared runners enabled' do
      let(:shared_runners_enabled) { true }
1087

1088
      it 'has a shared runner' do
1089 1090 1091 1092 1093 1094 1095 1096 1097 1098
        shared_runner
        expect(project.any_runners?).to be_truthy
      end

      it 'checks the presence of shared runner' do
        shared_runner
        expect(project.any_runners? { |runner| runner == shared_runner }).to be_truthy
      end
    end
  end
1099

1100 1101 1102 1103 1104 1105
  describe '#shared_runners' do
    let!(:runner) { create(:ci_runner, :shared) }

    subject { project.shared_runners }

    context 'when shared runners are enabled for project' do
1106
      let!(:project) { create(:project, shared_runners_enabled: true) }
1107 1108 1109 1110 1111 1112 1113

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

    context 'when shared runners are disabled for project' do
1114
      let!(:project) { create(:project, shared_runners_enabled: false) }
1115 1116 1117 1118 1119 1120 1121

      it "returns a empty list" do
        is_expected.to be_empty
      end
    end
  end

1122
  describe '#visibility_level_allowed?' do
1123
    let(:project) { create(:project, :internal) }
1124 1125 1126 1127 1128 1129 1130 1131

    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
1132 1133
      let(:project)        { create(:project, :internal) }
      let(:forked_project) { create(:project, forked_from_project: project) }
1134 1135 1136 1137 1138

      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
1139
  end
1140

1141
  describe '#pages_deployed?' do
1142
    let(:project) { create :project }
1143 1144 1145 1146

    subject { project.pages_deployed? }

    context 'if public folder does exist' do
1147 1148 1149
      before do
        allow(Dir).to receive(:exist?).with(project.public_pages_path).and_return(true)
      end
1150 1151 1152 1153 1154 1155 1156 1157 1158

      it { is_expected.to be_truthy }
    end

    context "if public folder doesn't exist" do
      it { is_expected.to be_falsey }
    end
  end

1159 1160
  describe '#pages_url' do
    let(:group) { create :group, name: group_name }
1161
    let(:project) { create :project, namespace: group, name: project_name }
1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185
    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

1186
  describe '.search' do
1187
    let(:project) { create(:project, description: 'kitten mittens') }
1188

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

1193 1194 1195
    it 'returns projects with a partially matching name' do
      expect(described_class.search(project.name[0..2])).to eq([project])
    end
1196

1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235
    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

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

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

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

    it 'returns projects when eager loading namespaces' do
      relation = described_class.all.includes(:namespace)

      expect(relation.search(project.namespace.name)).to eq([project])
1241
    end
1242 1243

    describe 'with pending_delete project' do
1244
      let(:pending_delete_project) { create(:project, pending_delete: true) }
1245 1246 1247 1248 1249 1250 1251

      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
1252
  end
1253 1254

  describe '#rename_repo' do
1255
    let(:project) { create(:project, :repository) }
1256 1257 1258 1259 1260 1261 1262
    let(:gitlab_shell) { Gitlab::Shell.new }

    before do
      # Project#gitlab_shell returns a new instance of Gitlab::Shell on every
      # call. This makes testing a bit easier.
      allow(project).to receive(:gitlab_shell).and_return(gitlab_shell)
      allow(project).to receive(:previous_changes).and_return('path' => ['foo'])
1263
    end
1264

1265
    it 'renames a repository' do
1266 1267
      stub_container_registry_config(enabled: false)

1268 1269 1270 1271
      expect(gitlab_shell).to receive(:mv_repository)
        .ordered
        .with(project.repository_storage_path, "#{project.namespace.full_path}/foo", "#{project.full_path}")
        .and_return(true)
1272

1273 1274 1275 1276
      expect(gitlab_shell).to receive(:mv_repository)
        .ordered
        .with(project.repository_storage_path, "#{project.namespace.full_path}/foo.wiki", "#{project.full_path}.wiki")
        .and_return(true)
1277

1278 1279 1280
      expect_any_instance_of(SystemHooksService)
        .to receive(:execute_hooks_for)
        .with(project, :rename)
1281

1282 1283 1284
      expect_any_instance_of(Gitlab::UploadsTransfer)
        .to receive(:rename_project)
        .with('foo', project.path, project.namespace.full_path)
1285 1286 1287

      expect(project).to receive(:expire_caches_before_rename)

1288 1289
      expect(project).to receive(:expires_full_path_cache)

1290 1291
      project.rename_repo
    end
1292

1293
    context 'container registry with images' do
1294
      let(:container_repository) { create(:container_repository) }
1295

1296 1297
      before do
        stub_container_registry_config(enabled: true)
1298
        stub_container_registry_tags(repository: :any, tags: ['tag'])
1299
        project.container_repositories << container_repository
1300 1301 1302 1303
      end

      subject { project.rename_repo }

1304
      it { expect {subject}.to raise_error(StandardError) }
1305
    end
1306 1307 1308
  end

  describe '#expire_caches_before_rename' do
1309
    let(:project) { create(:project, :repository) }
1310 1311 1312 1313
    let(:repo)    { double(:repo, exists?: true) }
    let(:wiki)    { double(:wiki, exists?: true) }

    it 'expires the caches of the repository and wiki' do
1314 1315 1316
      allow(Repository).to receive(:new)
        .with('foo', project)
        .and_return(repo)
1317

1318 1319 1320
      allow(Repository).to receive(:new)
        .with('foo.wiki', project)
        .and_return(wiki)
1321

1322 1323
      expect(repo).to receive(:before_delete)
      expect(wiki).to receive(:before_delete)
1324 1325 1326 1327

      project.expire_caches_before_rename('foo')
    end
  end
1328 1329

  describe '.search_by_title' do
1330
    let(:project) { create(:project, name: 'kittens') }
1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343

    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
1344 1345 1346 1347 1348

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

1349 1350
    let(:private_project)  { create :project, :private, group: private_group }
    let(:internal_project) { create :project, :internal, group: internal_group }
1351 1352 1353 1354 1355 1356 1357 1358 1359

    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
1360

1361
  describe '#create_repository' do
1362
    let(:project) { create(:project, :repository) }
1363 1364 1365 1366 1367 1368 1369 1370
    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
1371
        expect(shell).to receive(:add_repository)
1372
          .with(project.repository_storage_path, project.disk_path)
1373
          .and_return(true)
1374 1375 1376 1377 1378 1379 1380

        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
1381
        expect(shell).to receive(:add_repository)
1382
          .with(project.repository_storage_path, project.disk_path)
1383
          .and_return(false)
1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400

        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)
        expect(shell).not_to receive(:add_repository)

        project.create_repository
      end
    end
  end
1401

1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414
  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)

      allow(shell).to receive(:add_repository)
1415
        .with(project.repository_storage_path, project.disk_path)
1416 1417
        .and_return(true)

1418
      expect(project).to receive(:create_repository).with(force: true)
1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430

      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
1431 1432 1433 1434 1435 1436 1437 1438

    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)

      expect(shell).to receive(:add_repository)
1439
        .with(project.repository_storage_path, project.disk_path)
1440 1441 1442 1443
        .and_return(true)

      project.ensure_repository
    end
1444 1445
  end

1446
  describe '#user_can_push_to_empty_repo?' do
1447
    let(:project) { create(:project) }
1448
    let(:user)    { create(:user) }
1449

1450 1451 1452
    it 'returns false when default_branch_protection is in full protection and user is developer' do
      project.team << [user, :developer]
      stub_application_setting(default_branch_protection: Gitlab::Access::PROTECTION_FULL)
1453

1454
      expect(project.user_can_push_to_empty_repo?(user)).to be_falsey
1455 1456
    end

1457 1458 1459
    it 'returns false when default_branch_protection only lets devs merge and user is dev' do
      project.team << [user, :developer]
      stub_application_setting(default_branch_protection: Gitlab::Access::PROTECTION_DEV_CAN_MERGE)
1460

1461
      expect(project.user_can_push_to_empty_repo?(user)).to be_falsey
1462 1463
    end

1464 1465 1466
    it 'returns true when default_branch_protection lets devs push and user is developer' do
      project.team << [user, :developer]
      stub_application_setting(default_branch_protection: Gitlab::Access::PROTECTION_DEV_CAN_PUSH)
1467

1468 1469
      expect(project.user_can_push_to_empty_repo?(user)).to be_truthy
    end
1470

1471 1472 1473
    it 'returns true when default_branch_protection is unprotected and user is developer' do
      project.team << [user, :developer]
      stub_application_setting(default_branch_protection: Gitlab::Access::PROTECTION_NONE)
1474

1475
      expect(project.user_can_push_to_empty_repo?(user)).to be_truthy
1476
    end
1477

1478 1479
    it 'returns true when user is master' do
      project.team << [user, :master]
1480

1481
      expect(project.user_can_push_to_empty_repo?(user)).to be_truthy
1482 1483 1484
    end
  end

1485
  describe '#container_registry_url' do
1486
    let(:project) { create(:project) }
1487

1488
    subject { project.container_registry_url }
1489

1490 1491 1492
    before do
      stub_container_registry_config(**registry_settings)
    end
1493 1494 1495

    context 'for enabled registry' do
      let(:registry_settings) do
1496 1497
        { enabled: true,
          host_port: 'example.com' }
1498 1499
      end

1500
      it { is_expected.not_to be_nil }
1501 1502 1503 1504
    end

    context 'for disabled registry' do
      let(:registry_settings) do
1505
        { enabled: false }
1506 1507 1508 1509 1510 1511
      end

      it { is_expected.to be_nil }
    end
  end

1512
  describe '#has_container_registry_tags?' do
1513
    let(:project) { create(:project) }
1514 1515

    context 'when container registry is enabled' do
1516 1517 1518
      before do
        stub_container_registry_config(enabled: true)
      end
1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555

      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

        it 'should have image tags' do
          expect(project).to have_container_registry_tags
        end
      end

      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

        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
      end
    end

    context 'when container registry is disabled' do
1556 1557 1558
      before do
        stub_container_registry_config(enabled: false)
      end
1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575

      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
    end
  end

1576
  describe '#ci_config_path=' do
1577
    let(:project) { create(:project) }
1578 1579

    it 'sets nil' do
1580
      project.update!(ci_config_path: nil)
1581

1582
      expect(project.ci_config_path).to be_nil
1583 1584 1585
    end

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

1588
      expect(project.ci_config_path).to eq('foo/.gitlab_ci.yml')
1589 1590
    end

1591
    it 'sets a string but removes all leading slashes and null characters' do
1592
      project.update!(ci_config_path: "///f\0oo/\0/.gitlab_ci.yml")
1593

1594
      expect(project.ci_config_path).to eq('foo//.gitlab_ci.yml')
1595 1596 1597
    end
  end

1598
  describe 'Project import job' do
1599
    let(:project) { create(:project, import_url: generate(:url)) }
1600 1601

    before do
1602
      allow_any_instance_of(Gitlab::Shell).to receive(:import_repository)
1603
        .with(project.repository_storage_path, project.disk_path, project.import_url)
1604 1605 1606 1607
        .and_return(true)

      expect_any_instance_of(Repository).to receive(:after_import)
        .and_call_original
1608 1609 1610 1611 1612
    end

    it 'imports a project' do
      expect_any_instance_of(RepositoryImportWorker).to receive(:perform).and_call_original

1613
      project.import_schedule
1614 1615 1616 1617 1618

      expect(project.reload.import_status).to eq('finished')
    end
  end

1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635
  describe 'project import state transitions' do
    context 'state transition: [:started] => [:finished]' do
      let(:housekeeping_service) { spy }

      before do
        allow(Projects::HousekeepingService).to receive(:new) { housekeeping_service }
      end

      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

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

      it 'does not perform housekeeping when project repository does not exist' do
1636
        project = create(:project, :import_started, import_type: :github)
1637 1638 1639 1640 1641 1642 1643

        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
1644
        project = create(:project, :import_started, import_type: nil)
1645 1646 1647 1648 1649 1650 1651 1652

        project.import_finish

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

1653
  describe '#latest_successful_builds_for' do
Lin Jen-Shin committed
1654
    def create_pipeline(status = 'success')
1655
      create(:ci_pipeline, project: project,
Lin Jen-Shin committed
1656
                           sha: project.commit.sha,
1657
                           ref: project.default_branch,
Lin Jen-Shin committed
1658
                           status: status)
1659 1660
    end

Lin Jen-Shin committed
1661 1662 1663
    def create_build(new_pipeline = pipeline, name = 'test')
      create(:ci_build, :success, :artifacts,
             pipeline: new_pipeline,
Lin Jen-Shin committed
1664
             status: new_pipeline.status,
Lin Jen-Shin committed
1665
             name: name)
1666 1667
    end

1668
    let(:project) { create(:project, :repository) }
Lin Jen-Shin committed
1669
    let(:pipeline) { create_pipeline }
Lin Jen-Shin committed
1670 1671

    context 'with many builds' do
1672
      it 'gives the latest builds from latest pipeline' do
1673 1674
        pipeline1 = create_pipeline
        pipeline2 = create_pipeline
1675
        build1_p2 = create_build(pipeline2, 'test')
1676 1677
        create_build(pipeline1, 'test')
        create_build(pipeline1, 'test2')
1678
        build2_p2 = create_build(pipeline2, 'test2')
Lin Jen-Shin committed
1679 1680 1681

        latest_builds = project.latest_successful_builds_for

1682
        expect(latest_builds).to contain_exactly(build2_p2, build1_p2)
Lin Jen-Shin committed
1683 1684
      end
    end
Lin Jen-Shin committed
1685

Lin Jen-Shin committed
1686
    context 'with succeeded pipeline' do
Lin Jen-Shin committed
1687
      let!(:build) { create_build }
1688

Lin Jen-Shin committed
1689
      context 'standalone pipeline' do
1690 1691 1692 1693 1694 1695 1696 1697
        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')
1698

1699 1700 1701
          expect(builds).to be_kind_of(ActiveRecord::Relation)
          expect(builds).to be_empty
        end
1702 1703
      end

Lin Jen-Shin committed
1704
      context 'with some pending pipeline' do
1705
        before do
Lin Jen-Shin committed
1706
          create_build(create_pipeline('pending'))
1707 1708
        end

Lin Jen-Shin committed
1709 1710
        it 'gives the latest build from latest pipeline' do
          latest_build = project.latest_successful_builds_for
1711

Lin Jen-Shin committed
1712
          expect(latest_build).to contain_exactly(build)
1713
        end
1714 1715 1716 1717 1718 1719
      end
    end

    context 'with pending pipeline' do
      before do
        pipeline.update(status: 'pending')
1720
        create_build(pipeline)
1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731
      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

1732 1733
  describe '#add_import_job' do
    context 'forked' do
1734
      let(:forked_project_link) { create(:forked_project_link, :forked_to_empty_project) }
1735 1736 1737 1738
      let(:forked_from_project) { forked_project_link.forked_from_project }
      let(:project) { forked_project_link.forked_to_project }

      it 'schedules a RepositoryForkWorker job' do
1739 1740
        expect(RepositoryForkWorker).to receive(:perform_async)
          .with(project.id, forked_from_project.repository_storage_path,
1741
              forked_from_project.disk_path, project.namespace.full_path)
1742 1743 1744 1745 1746 1747 1748

        project.add_import_job
      end
    end

    context 'not forked' do
      it 'schedules a RepositoryImportWorker job' do
1749
        project = create(:project, import_url: generate(:url))
1750

1751 1752 1753 1754 1755 1756 1757
        expect(RepositoryImportWorker).to receive(:perform_async).with(project.id)

        project.add_import_job
      end
    end
  end

1758
  describe '#gitlab_project_import?' do
1759
    subject(:project) { build(:project, import_type: 'gitlab_project') }
1760 1761 1762 1763 1764

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

  describe '#gitea_import?' do
1765
    subject(:project) { build(:project, import_type: 'gitea') }
1766 1767 1768 1769

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

1770
  describe '#lfs_enabled?' do
1771
    let(:project) { create(:project) }
1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831

    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

1832
  describe '#change_head' do
1833
    let(:project) { create(:project, :repository) }
1834

1835 1836 1837 1838 1839
    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

1840
    it 'calls the before_change_head and after_change_head methods' do
1841
      expect(project.repository).to receive(:before_change_head)
1842 1843
      expect(project.repository).to receive(:after_change_head)

1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863
      project.change_head(project.default_branch)
    end

    it 'creates the new reference with rugged' do
      expect(project.repository.rugged.references).to receive(:create).with('HEAD',
                                                                            "refs/heads/#{project.default_branch}",
                                                                            force: true)
      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
1864 1865

  describe '#pushes_since_gc' do
1866
    let(:project) { create(:project) }
1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887

    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
1888
    let(:project) { create(:project) }
1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901

    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

  describe '#reset_pushes_since_gc' do
1902
    let(:project) { create(:project) }
1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915

    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
1916

1917 1918
  describe '#deployment_variables' do
    context 'when project has no deployment service' do
1919
      let(:project) { create(:project) }
1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936

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

    context 'when project has a deployment service' do
      let(:project) { create(:kubernetes_project) }

      it 'returns variables from this service' do
        expect(project.deployment_variables).to include(
          { key: 'KUBE_TOKEN', value: project.kubernetes_service.token, public: false }
        )
      end
    end
  end

1937
  describe '#secret_variables_for' do
1938
    let(:project) { create(:project) }
1939 1940 1941 1942 1943 1944 1945 1946 1947

    let!(:secret_variable) do
      create(:ci_variable, value: 'secret', project: project)
    end

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

Lin Jen-Shin committed
1948 1949 1950 1951 1952 1953
    subject { project.secret_variables_for(ref: 'ref') }

    before do
      stub_application_setting(
        default_branch_protection: Gitlab::Access::PROTECTION_NONE)
    end
1954 1955 1956

    shared_examples 'ref is protected' do
      it 'contains all the variables' do
1957
        is_expected.to contain_exactly(secret_variable, protected_variable)
1958 1959 1960 1961
      end
    end

    context 'when the ref is not protected' do
1962
      it 'contains only the secret variables' do
1963
        is_expected.to contain_exactly(secret_variable)
1964 1965 1966
      end
    end

1967 1968 1969
    context 'when the ref is a protected branch' do
      before do
        create(:protected_branch, name: 'ref', project: project)
1970
      end
1971 1972 1973 1974 1975 1976 1977 1978 1979 1980

      it_behaves_like 'ref is protected'
    end

    context 'when the ref is a protected tag' do
      before do
        create(:protected_tag, name: 'ref', project: project)
      end

      it_behaves_like 'ref is protected'
1981 1982 1983
    end
  end

1984
  describe '#protected_for?' do
1985
    let(:project) { create(:project) }
1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020

    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
        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
        create(:protected_tag, name: 'ref', project: project)
      end

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

2021
  describe '#update_project_statistics' do
2022
    let(:project) { create(:project) }
2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040

    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

2041
  describe 'inside_path' do
2042 2043 2044
    let!(:project1) { create(:project, namespace: create(:namespace, path: 'name_pace')) }
    let!(:project2) { create(:project) }
    let!(:project3) { create(:project, namespace: create(:namespace, path: 'namespace')) }
2045
    let!(:path) { project1.namespace.full_path }
2046

2047
    it 'returns correct project' do
2048
      expect(described_class.inside_path(path)).to eq([project1])
2049
    end
2050 2051
  end

Douwe Maan committed
2052
  describe '#route_map_for' do
2053
    let(:project) { create(:project, :repository) }
Douwe Maan committed
2054 2055 2056 2057 2058 2059 2060 2061
    let(:route_map) do
      <<-MAP.strip_heredoc
      - source: /source/(.*)/
        public: '\\1'
      MAP
    end

    before do
2062
      project.repository.create_file(User.last, '.gitlab/route-map.yml', route_map, message: 'Add .gitlab/route-map.yml', branch_name: 'master')
Douwe Maan committed
2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089
    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
2090
    let(:project) { create(:project, :repository) }
Douwe Maan committed
2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127
    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

2128
  describe '#parent' do
2129
    let(:project) { create(:project) }
2130 2131 2132 2133 2134

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

  describe '#parent_changed?' do
2135
    let(:project) { create(:project) }
2136

2137 2138 2139
    before do
      project.namespace_id = 7
    end
2140 2141 2142 2143

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

2144 2145 2146
  def enable_lfs
    allow(Gitlab.config.lfs).to receive(:enabled).and_return(true)
  end
2147

2148
  describe '#pages_url' do
2149 2150
    let(:group) { create :group, name: 'Group' }
    let(:nested_group) { create :group, parent: group }
2151 2152 2153 2154 2155 2156 2157 2158 2159
    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

2160
    context 'top-level group' do
2161
      let(:project) { create :project, namespace: group, name: project_name }
2162

2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173
      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
2174 2175
    end

2176
    context 'nested group' do
2177
      let(:project) { create :project, namespace: nested_group, name: project_name }
2178
      let(:expected_url) { "http://group.example.com/#{nested_group.path}/#{project.path}" }
2179

2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190
      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
2191 2192
    end
  end
2193 2194

  describe '#http_url_to_repo' do
2195
    let(:project) { create :project }
2196

2197 2198 2199
    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('@')
2200 2201
    end
  end
2202 2203

  describe '#pipeline_status' do
2204
    let(:project) { create(:project, :repository) }
2205
    it 'builds a pipeline status' do
2206
      expect(project.pipeline_status).to be_a(Gitlab::Cache::Ci::ProjectPipelineStatus)
2207 2208 2209 2210 2211 2212
    end

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

  describe '#append_or_update_attribute' do
2215
    let(:project) { create(:project) }
2216 2217 2218 2219 2220

    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'

2221 2222
      expect { project.append_or_update_attribute(:merge_requests, [create(:merge_request)]) }
        .to raise_error(ActiveRecord::RecordNotSaved, error_message)
2223 2224 2225 2226 2227
    end

    it 'updates the project succesfully' do
      merge_request = create(:merge_request, target_project: project, source_project: project)

2228 2229
      expect { project.append_or_update_attribute(:merge_requests, [merge_request]) }
        .not_to raise_error
2230 2231
    end
  end
2232 2233 2234

  describe '#last_repository_updated_at' do
    it 'sets to created_at upon creation' do
2235
      project = create(:project, created_at: 2.hours.ago)
2236 2237 2238 2239

      expect(project.last_repository_updated_at.to_i).to eq(project.created_at.to_i)
    end
  end
2240 2241 2242 2243 2244

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

    let!(:private_project) do
2245
      create(:project, :private, creator: user, namespace: user.namespace)
2246 2247
    end

2248
    let!(:public_project) { create(:project, :public) }
2249 2250 2251

    context 'with a user' do
      let(:projects) do
2252
        described_class.all.public_or_visible_to_user(user)
2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265
      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
2266
        projects = described_class.all.public_or_visible_to_user
2267 2268 2269 2270 2271

        expect(projects).to eq([public_project])
      end
    end
  end
2272 2273

  describe '#remove_private_deploy_keys' do
2274
    let!(:project) { create(:project) }
2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289

    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
2290
          another_project = create(:project)
2291 2292
          create(:deploy_keys_project, deploy_key: key, project: another_project)
        end
2293

2294 2295
        it 'does not remove the key' do
          project.remove_private_deploy_keys
2296

2297 2298 2299 2300 2301 2302 2303 2304
          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) }
2305

2306 2307
      it 'does not remove the key' do
        project.remove_private_deploy_keys
2308

2309 2310
        expect(project.deploy_keys).to include(key)
      end
2311 2312
    end
  end
gitlabhq committed
2313
end