project_spec.rb 70.9 KB
Newer Older
gitlabhq's avatar
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's avatar
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's avatar
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's avatar
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's avatar
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) }
Kamil Trzcinski's avatar
Kamil Trzcinski committed
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's avatar
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(:empty_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's avatar
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(:empty_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(:empty_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
Phil Hughes's avatar
Phil Hughes committed
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(:empty_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(:empty_project, path: 'foo.wiki')
          new_project = build_stubbed(:empty_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(:empty_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(:empty_project, import_url: 'invalid://')
James Lopez's avatar
James Lopez committed
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(:empty_project, import_url: 'ssh://test@gitlab.com/project.git')
James Lopez's avatar
James Lopez committed
206

207 208
      expect(project2).to be_valid
    end
209

210
    it 'allows an empty URI' do
211
      project2 = build(:empty_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(:empty_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(:empty_project, import_url: 'test://')
224 225 226

      expect(project2.import_data).to be_nil
    end
227

228 229 230 231 232 233 234 235 236 237 238 239 240 241
    it "does not allow blocked import_url localhost" do
      project2 = build(:empty_project, import_url: 'http://localhost:9000/t.git')

      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
      project2 = build(:empty_project, import_url: 'http://github.com:25/t.git')

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

242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260
    describe 'project pending deletion' do
      let!(:project_pending_deletion) do
        create(:empty_project,
               pending_delete: true)
      end
      let(:new_project) do
        build(:empty_project,
              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 264 265 266 267 268 269 270 271 272 273

    describe 'path validation' do
      it 'allows paths reserved on the root namespace' do
        project = build(:project, path: 'api')

        expect(project).to be_valid
      end

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

        expect(project).not_to be_valid
      end
274 275 276 277 278 279 280

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

        expect(project).not_to be_valid
      end
281 282 283 284 285 286 287

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

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

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

ubudzisz's avatar
ubudzisz committed
297
    it 'does not set an random token if one provided' do
Kamil Trzcinski's avatar
Kamil Trzcinski committed
298 299
      project = FactoryGirl.create :empty_project, runners_token: 'my-token'
      expect(project.runners_token).to eq('my-token')
300 301
    end
  end
gitlabhq's avatar
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) }
gitlabhq's avatar
gitlabhq committed
309 310
  end

311
  describe 'delegation' do
312 313 314 315 316 317 318 319
    [: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) }
320 321
  end

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

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

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

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

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

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

      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
384 385
      end
    end
386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418
  end

  describe '#to_human_reference' do
    let(:owner) { create(:user, name: 'Gitlab') }
    let(:namespace) { create(:namespace, name: 'Sample namespace', owner: owner) }
    let(:project) { create(:empty_project, name: 'Sample project', namespace: namespace) }

    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
      let(:another_namespace_project) { create(:empty_project, name: 'another-project') }

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

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

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

    before do
      FileUtils.mkdir('tmp/tests/custom_repositories')
427
      storages = { 'custom' => { 'path' => 'tmp/tests/custom_repositories' } }
428 429 430 431 432 433 434 435 436 437 438 439
      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

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

Douwe Maan's avatar
Douwe Maan committed
445 446 447 448
  describe "#web_url" do
    let(:project) { create(:empty_project, path: "somewhere") }

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

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

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

        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
473

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

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

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

489
        expect(project.last_activity).to eq(last_event)
490
      end
gitlabhq's avatar
gitlabhq committed
491 492
    end

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

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

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

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

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

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

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

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

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

541 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
      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
578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595
      end
    end
  end

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

    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

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

Vinnie Okada's avatar
Vinnie Okada committed
603
      it { expect(@project.to_param).to eq('gitlabhq') }
604
    end
605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622

    context 'with invalid path' do
      it 'returns previous path to keep project suitable for use in URLs when persisted' do
        project = create(:empty_project, path: 'gitlab')
        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
        project = build(:empty_project, path: 'gitlab')
        project.path = 'foo&bar'

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

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

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

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

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

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

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

648
  describe '#external_issue_tracker' do
649
    let(:project) { create(:empty_project) }
650 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
    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

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

    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

705
  describe '#has_wiki?' do
706
    let(:no_wiki_project)       { create(:empty_project, :wiki_disabled, has_external_wiki: false) }
707 708
    let(:wiki_enabled_project)  { create(:empty_project) }
    let(:external_wiki_project) { create(:empty_project, has_external_wiki: true) }
709 710 711 712 713 714 715 716

    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

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

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

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

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

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

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

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

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

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

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

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

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

Ciro Santilli's avatar
Ciro Santilli committed
776
      user1.toggle_star(project)
777 778
      expect(project.reload.star_count).to eq(1)

Ciro Santilli's avatar
Ciro Santilli committed
779
      user2.toggle_star(project)
780 781 782
      project.reload
      expect(project.reload.star_count).to eq(2)

Ciro Santilli's avatar
Ciro Santilli committed
783
      user1.toggle_star(project)
784 785 786
      project.reload
      expect(project.reload.star_count).to eq(1)

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

792
    it 'counts stars on the right project' do
793
      user = create :user
794 795
      project1 = create(:empty_project, :public)
      project2 = create(:empty_project, :public)
796 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

      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
823 824
    end
  end
825

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

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

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

840
  describe '#avatar_url' do
sue445's avatar
sue445 committed
841 842
    subject { project.avatar_url }

843
    let(:project) { create(:empty_project) }
sue445's avatar
sue445 committed
844

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

850 851 852 853 854 855 856 857
      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
sue445's avatar
sue445 committed
858 859 860 861 862 863 864
    end

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

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

867
      it { is_expected.to eq "http://#{Gitlab.config.gitlab.host}#{avatar_path}" }
sue445's avatar
sue445 committed
868
    end
869 870 871 872

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

873
      it { is_expected.to eq nil }
874
    end
sue445's avatar
sue445 committed
875
  end
876

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

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

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

887
        it { is_expected.to eq(pipeline2) }
888
      end
889 890 891 892 893 894 895 896 897 898 899 900 901
    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
902

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

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

914 915 916
    subject { project.builds_enabled }

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

919
  describe '.with_shared_runners' do
920
    subject { described_class.with_shared_runners }
921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938

    context 'when shared runners are enabled for project' do
      let!(:project) { create(:empty_project, shared_runners_enabled: true) }

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

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

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

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

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

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

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

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

      create(:note_on_commit, project: project2)

965
      TrendingProject.refresh!
966 967
    end

968
    subject { described_class.trending.to_a }
969

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

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

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

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

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

    subject { described_class.visible_to_user(user) }

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

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

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

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

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

    subject { project.shared_runners_enabled }

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

      it { is_expected.to be_truthy }
    end

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

      it { is_expected.to be_falsey }
    end
  end

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

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

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

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

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

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

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

1087
      it 'has a shared runner' do
1088 1089 1090 1091 1092 1093 1094 1095 1096 1097
        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
1098

1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120
  describe '#shared_runners' do
    let!(:runner) { create(:ci_runner, :shared) }

    subject { project.shared_runners }

    context 'when shared runners are enabled for project' do
      let!(:project) { create(:empty_project, shared_runners_enabled: true) }

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

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

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

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

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

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

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

    subject { project.pages_deployed? }

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

      it { is_expected.to be_truthy }
    end

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

1158
  describe '.search' do
1159
    let(:project) { create(:empty_project, description: 'kitten mittens') }
1160

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

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

1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207
    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
1208 1209 1210 1211 1212

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

      expect(relation.search(project.namespace.name)).to eq([project])
1213
    end
1214 1215 1216 1217 1218 1219 1220 1221 1222 1223

    describe 'with pending_delete project' do
      let(:pending_delete_project) { create(:empty_project, pending_delete: true) }

      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
1224
  end
1225 1226

  describe '#rename_repo' do
1227
    let(:project) { create(:project, :repository) }
1228 1229 1230 1231 1232 1233 1234
    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'])
Kamil Trzcinski's avatar
Kamil Trzcinski committed
1235
    end
1236

Kamil Trzcinski's avatar
Kamil Trzcinski committed
1237
    it 'renames a repository' do
1238 1239
      stub_container_registry_config(enabled: false)

1240 1241 1242 1243
      expect(gitlab_shell).to receive(:mv_repository)
        .ordered
        .with(project.repository_storage_path, "#{project.namespace.full_path}/foo", "#{project.full_path}")
        .and_return(true)
1244

1245 1246 1247 1248
      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)
1249

1250 1251 1252
      expect_any_instance_of(SystemHooksService)
        .to receive(:execute_hooks_for)
        .with(project, :rename)
1253

1254 1255 1256
      expect_any_instance_of(Gitlab::UploadsTransfer)
        .to receive(:rename_project)
        .with('foo', project.path, project.namespace.full_path)
1257 1258 1259

      expect(project).to receive(:expire_caches_before_rename)

1260 1261
      expect(project).to receive(:expires_full_path_cache)

1262 1263
      project.rename_repo
    end
Kamil Trzcinski's avatar
Kamil Trzcinski committed
1264

1265
    context 'container registry with images' do
1266
      let(:container_repository) { create(:container_repository) }
1267

Kamil Trzcinski's avatar
Kamil Trzcinski committed
1268 1269
      before do
        stub_container_registry_config(enabled: true)
1270
        stub_container_registry_tags(repository: :any, tags: ['tag'])
1271
        project.container_repositories << container_repository
Kamil Trzcinski's avatar
Kamil Trzcinski committed
1272 1273 1274 1275
      end

      subject { project.rename_repo }

1276
      it { expect{subject}.to raise_error(StandardError) }
Kamil Trzcinski's avatar
Kamil Trzcinski committed
1277
    end
1278 1279 1280
  end

  describe '#expire_caches_before_rename' do
1281
    let(:project) { create(:project, :repository) }
1282 1283 1284 1285
    let(:repo)    { double(:repo, exists?: true) }
    let(:wiki)    { double(:wiki, exists?: true) }

    it 'expires the caches of the repository and wiki' do
1286 1287 1288
      allow(Repository).to receive(:new)
        .with('foo', project)
        .and_return(repo)
1289

1290 1291 1292
      allow(Repository).to receive(:new)
        .with('foo.wiki', project)
        .and_return(wiki)
1293

1294 1295
      expect(repo).to receive(:before_delete)
      expect(wiki).to receive(:before_delete)
1296 1297 1298 1299

      project.expire_caches_before_rename('foo')
    end
  end
1300 1301

  describe '.search_by_title' do
1302
    let(:project) { create(:empty_project, name: 'kittens') }
1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315

    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
1316 1317 1318 1319 1320

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

1321 1322
    let(:private_project)  { create :empty_project, :private, group: private_group }
    let(:internal_project) { create :empty_project, :internal, group: internal_group }
1323 1324 1325 1326 1327 1328 1329 1330 1331

    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
1332

1333
  describe '#create_repository' do
1334
    let(:project) { create(:project, :repository) }
1335 1336 1337 1338 1339 1340 1341 1342
    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
1343 1344 1345
        expect(shell).to receive(:add_repository)
          .with(project.repository_storage_path, project.path_with_namespace)
          .and_return(true)
1346 1347 1348 1349 1350 1351 1352

        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
1353 1354 1355
        expect(shell).to receive(:add_repository)
          .with(project.repository_storage_path, project.path_with_namespace)
          .and_return(false)
1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372

        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
1373

1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389
  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)
        .with(project.repository_storage_path, project.path_with_namespace)
        .and_return(true)

1390
      expect(project).to receive(:create_repository).with(force: true)
1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402

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

    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)
        .with(project.repository_storage_path, project.path_with_namespace)
        .and_return(true)

      project.ensure_repository
    end
1416 1417
  end

1418
  describe '#user_can_push_to_empty_repo?' do
1419
    let(:project) { create(:empty_project) }
1420
    let(:user)    { create(:user) }
1421

1422 1423 1424
    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)
1425

1426
      expect(project.user_can_push_to_empty_repo?(user)).to be_falsey
1427 1428
    end

1429 1430 1431
    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)
1432

1433
      expect(project.user_can_push_to_empty_repo?(user)).to be_falsey
1434 1435
    end

1436 1437 1438
    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)
1439

1440 1441
      expect(project.user_can_push_to_empty_repo?(user)).to be_truthy
    end
1442

1443 1444 1445
    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)
1446

1447
      expect(project.user_can_push_to_empty_repo?(user)).to be_truthy
1448
    end
1449

1450 1451
    it 'returns true when user is master' do
      project.team << [user, :master]
1452

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

1457
  describe '#container_registry_url' do
1458 1459
    let(:project) { create(:empty_project) }

1460
    subject { project.container_registry_url }
1461

1462 1463 1464
    before do
      stub_container_registry_config(**registry_settings)
    end
1465 1466 1467

    context 'for enabled registry' do
      let(:registry_settings) do
1468 1469
        { enabled: true,
          host_port: 'example.com' }
1470 1471
      end

1472
      it { is_expected.not_to be_nil }
1473 1474 1475 1476
    end

    context 'for disabled registry' do
      let(:registry_settings) do
1477
        { enabled: false }
1478 1479 1480 1481 1482 1483
      end

      it { is_expected.to be_nil }
    end
  end

1484 1485 1486 1487
  describe '#has_container_registry_tags?' do
    let(:project) { create(:empty_project) }

    context 'when container registry is enabled' do
1488 1489 1490
      before do
        stub_container_registry_config(enabled: true)
      end
1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527

      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
1528 1529 1530
      before do
        stub_container_registry_config(enabled: false)
      end
1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547

      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

1548
  describe '#ci_config_path=' do
1549 1550 1551
    let(:project) { create(:empty_project) }

    it 'sets nil' do
1552
      project.update!(ci_config_path: nil)
1553

1554
      expect(project.ci_config_path).to be_nil
1555 1556 1557
    end

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

1560
      expect(project.ci_config_path).to eq('foo/.gitlab_ci.yml')
1561 1562
    end

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

1566
      expect(project.ci_config_path).to eq('foo//.gitlab_ci.yml')
1567 1568 1569
    end
  end

1570
  describe 'Project import job' do
1571
    let(:project) { create(:empty_project, import_url: generate(:url)) }
1572 1573

    before do
1574 1575 1576 1577 1578 1579
      allow_any_instance_of(Gitlab::Shell).to receive(:import_repository)
        .with(project.repository_storage_path, project.path_with_namespace, project.import_url)
        .and_return(true)

      expect_any_instance_of(Repository).to receive(:after_import)
        .and_call_original
1580 1581 1582 1583 1584
    end

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

1585
      project.import_schedule
1586 1587 1588 1589 1590

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

1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624
  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
        project = create(:empty_project, :import_started, import_type: :github)

        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
        project = create(:empty_project, :import_started, import_type: nil)

        project.import_finish

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

1625
  describe '#latest_successful_builds_for' do
Lin Jen-Shin's avatar
Lin Jen-Shin committed
1626
    def create_pipeline(status = 'success')
1627
      create(:ci_pipeline, project: project,
Lin Jen-Shin's avatar
Lin Jen-Shin committed
1628
                           sha: project.commit.sha,
1629
                           ref: project.default_branch,
Lin Jen-Shin's avatar
Lin Jen-Shin committed
1630
                           status: status)
1631 1632
    end

Lin Jen-Shin's avatar
Lin Jen-Shin committed
1633 1634 1635
    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
1636
             status: new_pipeline.status,
Lin Jen-Shin's avatar
Lin Jen-Shin committed
1637
             name: name)
1638 1639
    end

1640
    let(:project) { create(:project, :repository) }
Lin Jen-Shin's avatar
Lin Jen-Shin committed
1641
    let(:pipeline) { create_pipeline }
Lin Jen-Shin's avatar
Lin Jen-Shin committed
1642 1643

    context 'with many builds' do
1644
      it 'gives the latest builds from latest pipeline' do
1645 1646
        pipeline1 = create_pipeline
        pipeline2 = create_pipeline
1647
        build1_p2 = create_build(pipeline2, 'test')
1648 1649
        create_build(pipeline1, 'test')
        create_build(pipeline1, 'test2')
1650
        build2_p2 = create_build(pipeline2, 'test2')
Lin Jen-Shin's avatar
Lin Jen-Shin committed
1651 1652 1653

        latest_builds = project.latest_successful_builds_for

1654
        expect(latest_builds).to contain_exactly(build2_p2, build1_p2)
Lin Jen-Shin's avatar
Lin Jen-Shin committed
1655 1656
      end
    end
Lin Jen-Shin's avatar
Lin Jen-Shin committed
1657

Lin Jen-Shin's avatar
Lin Jen-Shin committed
1658
    context 'with succeeded pipeline' do
Lin Jen-Shin's avatar
Lin Jen-Shin committed
1659
      let!(:build) { create_build }
1660

Lin Jen-Shin's avatar
Lin Jen-Shin committed
1661
      context 'standalone pipeline' do
1662 1663 1664 1665 1666 1667 1668 1669
        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')
1670

1671 1672 1673
          expect(builds).to be_kind_of(ActiveRecord::Relation)
          expect(builds).to be_empty
        end
1674 1675
      end

Lin Jen-Shin's avatar
Lin Jen-Shin committed
1676
      context 'with some pending pipeline' do
1677
        before do
Lin Jen-Shin's avatar
Lin Jen-Shin committed
1678
          create_build(create_pipeline('pending'))
1679 1680
        end

Lin Jen-Shin's avatar
Lin Jen-Shin committed
1681 1682
        it 'gives the latest build from latest pipeline' do
          latest_build = project.latest_successful_builds_for
1683

Lin Jen-Shin's avatar
Lin Jen-Shin committed
1684
          expect(latest_build).to contain_exactly(build)
1685
        end
1686 1687 1688 1689 1690 1691
      end
    end

    context 'with pending pipeline' do
      before do
        pipeline.update(status: 'pending')
Lin Jen-Shin's avatar
Lin Jen-Shin committed
1692
        create_build(pipeline)
1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703
      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

1704 1705
  describe '#add_import_job' do
    context 'forked' do
1706
      let(:forked_project_link) { create(:forked_project_link, :forked_to_empty_project) }
1707 1708 1709 1710
      let(:forked_from_project) { forked_project_link.forked_from_project }
      let(:project) { forked_project_link.forked_to_project }

      it 'schedules a RepositoryForkWorker job' do
1711 1712
        expect(RepositoryForkWorker).to receive(:perform_async)
          .with(project.id, forked_from_project.repository_storage_path,
1713
              forked_from_project.path_with_namespace, project.namespace.full_path)
1714 1715 1716 1717 1718 1719 1720

        project.add_import_job
      end
    end

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

1723 1724 1725 1726 1727 1728 1729
        expect(RepositoryImportWorker).to receive(:perform_async).with(project.id)

        project.add_import_job
      end
    end
  end

Rémy Coutable's avatar
Rémy Coutable committed
1730
  describe '#gitlab_project_import?' do
1731
    subject(:project) { build(:empty_project, import_type: 'gitlab_project') }
Rémy Coutable's avatar
Rémy Coutable committed
1732 1733 1734 1735 1736

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

  describe '#gitea_import?' do
1737
    subject(:project) { build(:empty_project, import_type: 'gitea') }
Rémy Coutable's avatar
Rémy Coutable committed
1738 1739 1740 1741

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

1742
  describe '#lfs_enabled?' do
1743
    let(:project) { create(:empty_project) }
1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 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

    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

1804
  describe '#change_head' do
1805
    let(:project) { create(:project, :repository) }
1806

1807
    it 'calls the before_change_head and after_change_head methods' do
1808
      expect(project.repository).to receive(:before_change_head)
1809 1810
      expect(project.repository).to receive(:after_change_head)

1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830
      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
1831 1832

  describe '#pushes_since_gc' do
1833
    let(:project) { create(:empty_project) }
1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854

    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
1855
    let(:project) { create(:empty_project) }
1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868

    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
1869
    let(:project) { create(:empty_project) }
1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882

    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
1883

1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903
  describe '#deployment_variables' do
    context 'when project has no deployment service' do
      let(:project) { create(:empty_project) }

      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

1904
  describe '#secret_variables_for' do
1905 1906 1907 1908 1909 1910 1911 1912 1913 1914
    let(:project) { create(:empty_project) }

    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's avatar
Lin Jen-Shin committed
1915 1916 1917 1918 1919 1920
    subject { project.secret_variables_for(ref: 'ref') }

    before do
      stub_application_setting(
        default_branch_protection: Gitlab::Access::PROTECTION_NONE)
    end
1921 1922 1923

    shared_examples 'ref is protected' do
      it 'contains all the variables' do
1924
        is_expected.to contain_exactly(secret_variable, protected_variable)
1925 1926 1927 1928
      end
    end

    context 'when the ref is not protected' do
1929
      it 'contains only the secret variables' do
1930
        is_expected.to contain_exactly(secret_variable)
1931 1932 1933
      end
    end

1934 1935 1936
    context 'when the ref is a protected branch' do
      before do
        create(:protected_branch, name: 'ref', project: project)
1937
      end
1938 1939 1940 1941 1942 1943 1944 1945 1946 1947

      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'
1948 1949 1950
    end
  end

1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987
  describe '#protected_for?' do
    let(:project) { create(:empty_project) }

    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

1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007
  describe '#update_project_statistics' do
    let(:project) { create(:empty_project) }

    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

2008
  describe 'inside_path' do
2009
    let!(:project1) { create(:empty_project, namespace: create(:namespace, path: 'name_pace')) }
2010
    let!(:project2) { create(:empty_project) }
2011
    let!(:project3) { create(:empty_project, namespace: create(:namespace, path: 'namespace')) }
2012
    let!(:path) { project1.namespace.full_path }
2013

2014
    it 'returns correct project' do
2015
      expect(described_class.inside_path(path)).to eq([project1])
2016
    end
2017 2018
  end

Douwe Maan's avatar
Douwe Maan committed
2019 2020 2021 2022 2023 2024 2025 2026 2027 2028
  describe '#route_map_for' do
    let(:project) { create(:project) }
    let(:route_map) do
      <<-MAP.strip_heredoc
      - source: /source/(.*)/
        public: '\\1'
      MAP
    end

    before do
2029
      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
2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 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 2090 2091 2092 2093 2094
    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
    let(:project) { create(:project) }
    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

2095 2096 2097 2098 2099 2100 2101 2102 2103
  describe '#parent' do
    let(:project) { create(:empty_project) }

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

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

2104 2105 2106
    before do
      project.namespace_id = 7
    end
2107 2108 2109 2110

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

2111 2112 2113
  def enable_lfs
    allow(Gitlab.config.lfs).to receive(:enabled).and_return(true)
  end
2114

2115
  describe '#pages_url' do
2116 2117
    let(:group) { create :group, name: 'Group' }
    let(:nested_group) { create :group, parent: group }
2118 2119 2120 2121 2122 2123 2124 2125 2126
    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

2127 2128
    context 'top-level group' do
      let(:project) { create :empty_project, namespace: group, name: project_name }
2129

2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140
      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
2141 2142
    end

2143 2144 2145
    context 'nested group' do
      let(:project) { create :empty_project, namespace: nested_group, name: project_name }
      let(:expected_url) { "http://group.example.com/#{nested_group.path}/#{project.path}" }
2146

2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157
      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
2158 2159
    end
  end
2160 2161 2162 2163

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

2164 2165 2166
    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('@')
2167 2168
    end
  end
2169 2170 2171 2172

  describe '#pipeline_status' do
    let(:project) { create(:project) }
    it 'builds a pipeline status' do
2173
      expect(project.pipeline_status).to be_a(Gitlab::Cache::Ci::ProjectPipelineStatus)
2174 2175 2176 2177 2178 2179
    end

    it 'hase a loaded pipeline status' do
      expect(project.pipeline_status).to be_loaded
    end
  end
2180 2181 2182 2183 2184 2185 2186 2187

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

    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'

2188 2189
      expect { project.append_or_update_attribute(:merge_requests, [create(:merge_request)]) }
        .to raise_error(ActiveRecord::RecordNotSaved, error_message)
2190 2191 2192 2193 2194
    end

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

2195 2196
      expect { project.append_or_update_attribute(:merge_requests, [merge_request]) }
        .not_to raise_error
2197 2198
    end
  end
2199 2200 2201 2202 2203 2204 2205 2206

  describe '#last_repository_updated_at' do
    it 'sets to created_at upon creation' do
      project = create(:empty_project, created_at: 2.hours.ago)

      expect(project.last_repository_updated_at.to_i).to eq(project.created_at.to_i)
    end
  end
2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218

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

    let!(:private_project) do
      create(:empty_project, :private, creator: user, namespace: user.namespace)
    end

    let!(:public_project) { create(:empty_project, :public) }

    context 'with a user' do
      let(:projects) do
2219
        described_class.all.public_or_visible_to_user(user)
2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232
      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
2233
        projects = described_class.all.public_or_visible_to_user
2234 2235 2236 2237 2238

        expect(projects).to eq([public_project])
      end
    end
  end
2239 2240

  describe '#remove_private_deploy_keys' do
2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259
    let!(:project) { create(:empty_project) }

    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
          another_project = create(:empty_project)
          create(:deploy_keys_project, deploy_key: key, project: another_project)
        end
2260

2261 2262
        it 'does not remove the key' do
          project.remove_private_deploy_keys
2263

2264 2265 2266 2267 2268 2269 2270 2271
          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) }
2272

2273 2274
      it 'does not remove the key' do
        project.remove_private_deploy_keys
2275

2276 2277
        expect(project.deploy_keys).to include(key)
      end
2278 2279
    end
  end
gitlabhq's avatar
gitlabhq committed
2280
end