project_spec.rb 26.4 KB
Newer Older
1 2 3 4
# == Schema Information
#
# Table name: projects
#
5
#  id                     :integer          not null, primary key
6 7 8
#  name                   :string(255)
#  path                   :string(255)
#  description            :text
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
9 10
#  created_at             :datetime
#  updated_at             :datetime
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
11
#  creator_id             :integer
12 13 14
#  issues_enabled         :boolean          default(TRUE), not null
#  merge_requests_enabled :boolean          default(TRUE), not null
#  wiki_enabled           :boolean          default(TRUE), not null
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
15
#  namespace_id           :integer
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
16
#  issues_tracker         :string(255)      default("gitlab"), not null
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
17
#  issues_tracker_id      :string(255)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
18
#  snippets_enabled       :boolean          default(TRUE), not null
19
#  last_activity_at       :datetime
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
20
#  import_url             :string(255)
21
#  visibility_level       :integer          default(0), not null
22
#  archived               :boolean          default(FALSE), not null
Atsushi Ishida's avatar
Atsushi Ishida committed
23
#  avatar                 :string(255)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
24
#  import_status          :string(255)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
25 26
#  repository_size        :float            default(0.0)
#  star_count             :integer          default(0), not null
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
27 28
#  import_type            :string(255)
#  import_source          :string(255)
Atsushi Ishida's avatar
Atsushi Ishida committed
29
#  commit_count           :integer          default(0)
Stan Hu's avatar
Stan Hu committed
30
#  import_error           :text
Stan Hu's avatar
Stan Hu committed
31 32 33 34 35 36 37
#  ci_id                  :integer
#  builds_enabled         :boolean          default(TRUE), not null
#  shared_runners_enabled :boolean          default(TRUE), not null
#  runners_token          :string
#  build_coverage_regex   :string
#  build_allow_git_fetch  :boolean          default(TRUE), not null
#  build_timeout          :integer          default(3600), not null
38 39
#

gitlabhq's avatar
gitlabhq committed
40 41
require 'spec_helper'

Douwe Maan's avatar
Douwe Maan committed
42
describe Project, models: true do
43
  describe 'associations' do
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
    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) }
    it { is_expected.to have_many(:events).dependent(:destroy) }
    it { is_expected.to have_many(:merge_requests).dependent(:destroy) }
    it { is_expected.to have_many(:issues).dependent(:destroy) }
    it { is_expected.to have_many(:milestones).dependent(:destroy) }
    it { is_expected.to have_many(:project_members).dependent(:destroy) }
    it { is_expected.to have_many(:notes).dependent(:destroy) }
    it { is_expected.to have_many(:snippets).class_name('ProjectSnippet').dependent(:destroy) }
    it { is_expected.to have_many(:deploy_keys_projects).dependent(:destroy) }
    it { is_expected.to have_many(:deploy_keys) }
    it { is_expected.to have_many(:hooks).dependent(:destroy) }
    it { is_expected.to have_many(:protected_branches).dependent(:destroy) }
    it { is_expected.to have_one(:forked_project_link).dependent(:destroy) }
    it { is_expected.to have_one(:slack_service).dependent(:destroy) }
    it { is_expected.to have_one(:pushover_service).dependent(:destroy) }
    it { is_expected.to have_one(:asana_service).dependent(:destroy) }
Kamil Trzcinski's avatar
Kamil Trzcinski committed
63
    it { is_expected.to have_many(:commit_statuses) }
64 65 66 67 68 69
    it { is_expected.to have_many(:ci_commits) }
    it { is_expected.to have_many(:builds) }
    it { is_expected.to have_many(:runner_projects) }
    it { is_expected.to have_many(:runners) }
    it { is_expected.to have_many(:variables) }
    it { is_expected.to have_many(:triggers) }
70
    it { is_expected.to have_many(:todos).dependent(:destroy) }
gitlabhq's avatar
gitlabhq committed
71 72
  end

73 74 75 76 77 78 79 80
  describe 'modules' do
    subject { described_class }

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

83
  describe 'validation' do
84 85
    let!(:project) { create(:project) }

86 87
    it { is_expected.to validate_presence_of(:name) }
    it { is_expected.to validate_uniqueness_of(:name).scoped_to(:namespace_id) }
88
    it { is_expected.to validate_length_of(:name).is_within(0..255) }
89

90 91
    it { is_expected.to validate_presence_of(:path) }
    it { is_expected.to validate_uniqueness_of(:path).scoped_to(:namespace_id) }
92 93
    it { is_expected.to validate_length_of(:path).is_within(0..255) }
    it { is_expected.to validate_length_of(:description).is_within(0..2000) }
94
    it { is_expected.to validate_presence_of(:creator) }
95
    it { is_expected.to validate_length_of(:issues_tracker_id).is_within(0..255) }
96
    it { is_expected.to validate_presence_of(:namespace) }
97

98
    it 'should not allow new projects beyond user limits' do
99
      project2 = build(:project)
100 101 102
      allow(project2).to receive(:creator).and_return(double(can_create_project?: false, projects_limit: 0).as_null_object)
      expect(project2).not_to be_valid
      expect(project2.errors[:limit_reached].first).to match(/Your project limit is 0/)
103
    end
gitlabhq's avatar
gitlabhq committed
104
  end
105

106 107 108 109 110 111 112 113 114
  describe 'default_scope' do
    it 'excludes projects pending deletion from the results' do
      project = create(:empty_project)
      create(:empty_project, pending_delete: true)

      expect(Project.all).to eq [project]
    end
  end

115 116
  describe 'project token' do
    it 'should set an random token if none provided' do
Kamil Trzcinski's avatar
Kamil Trzcinski committed
117 118
      project = FactoryGirl.create :empty_project, runners_token: ''
      expect(project.runners_token).not_to eq('')
119 120 121
    end

    it 'should not set an random toke if one provided' do
Kamil Trzcinski's avatar
Kamil Trzcinski committed
122 123
      project = FactoryGirl.create :empty_project, runners_token: 'my-token'
      expect(project.runners_token).to eq('my-token')
124 125
    end
  end
gitlabhq's avatar
gitlabhq committed
126

127
  describe 'Respond to' do
128 129 130 131 132 133 134
    it { is_expected.to respond_to(:url_to_repo) }
    it { is_expected.to respond_to(:repo_exists?) }
    it { is_expected.to respond_to(:update_merge_requests) }
    it { is_expected.to respond_to(:execute_hooks) }
    it { is_expected.to respond_to(:name_with_namespace) }
    it { is_expected.to respond_to(:owner) }
    it { is_expected.to respond_to(:path_with_namespace) }
gitlabhq's avatar
gitlabhq committed
135 136
  end

137 138 139 140 141 142 143 144
  describe '#to_reference' do
    let(:project) { create(:empty_project) }

    it 'returns a String reference to the object' do
      expect(project.to_reference).to eq project.path_with_namespace
    end
  end

145 146
  it 'should return valid url to repo' do
    project = Project.new(path: 'somewhere')
147
    expect(project.url_to_repo).to eq(Gitlab.config.gitlab_shell.ssh_path_prefix + 'somewhere.git')
gitlabhq's avatar
gitlabhq committed
148 149
  end

Douwe Maan's avatar
Douwe Maan committed
150 151 152 153 154 155
  describe "#web_url" do
    let(:project) { create(:empty_project, path: "somewhere") }

    it 'returns the full web URL for this repo' do
      expect(project.web_url).to eq("#{Gitlab.config.gitlab.url}/#{project.namespace.path}/somewhere")
    end
156 157
  end

Douwe Maan's avatar
Douwe Maan committed
158 159 160 161 162 163
  describe "#web_url_without_protocol" do
    let(:project) { create(:empty_project, path: "somewhere") }

    it 'returns the web URL without the protocol for this repo' do
      expect(project.web_url_without_protocol).to eq("#{Gitlab.config.gitlab.url.split('://')[1]}/#{project.namespace.path}/somewhere")
    end
164 165
  end

166
  describe 'last_activity methods' do
167
    let(:project) { create(:project) }
168
    let(:last_event) { double(created_at: Time.now) }
gitlabhq's avatar
gitlabhq committed
169

170 171
    describe 'last_activity' do
      it 'should alias last_activity to last_event' do
172
        allow(project).to receive(:last_event).and_return(last_event)
173
        expect(project.last_activity).to eq(last_event)
174
      end
gitlabhq's avatar
gitlabhq committed
175 176
    end

177 178
    describe 'last_activity_date' do
      it 'returns the creation date of the project\'s last event if present' do
179
        create(:event, project: project)
180
        expect(project.last_activity_at.to_i).to eq(last_event.created_at.to_i)
181
      end
182

183
      it 'returns the project\'s last update date if it has no events' do
184
        expect(project.last_activity_date).to eq(project.updated_at)
185
      end
186 187
    end
  end
188

189 190
  describe '#get_issue' do
    let(:project) { create(:empty_project) }
Stan Hu's avatar
Stan Hu committed
191
    let!(:issue)  { create(:issue, project: project) }
192 193 194 195 196 197

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

Stan Hu's avatar
Stan Hu committed
198 199 200 201
      it 'returns count of open issues' do
        expect(project.open_issues_count).to eq(1)
      end

202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
      it 'returns nil when no issue found' do
        expect(project.get_issue(999)).to be_nil
      end
    end

    context 'with external issues tracker' do
      before do
        allow(project).to receive(:default_issues_tracker?).and_return(false)
      end

      it 'returns an ExternalIssue' do
        issue = project.get_issue('FOO-1234')
        expect(issue).to be_kind_of(ExternalIssue)
        expect(issue.iid).to eq 'FOO-1234'
        expect(issue.project).to eq project
      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

235
  describe :update_merge_requests do
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
236
    let(:project) { create(:project) }
237 238 239 240
    let(:merge_request) { create(:merge_request, source_project: project, target_project: project) }
    let(:key) { create(:key, user_id: project.owner.id) }
    let(:prev_commit_id) { merge_request.commits.last.id }
    let(:commit_id) { merge_request.commits.first.id }
241

242
    it 'should close merge request if last commit from source branch was pushed to target branch' do
243 244
      project.update_merge_requests(prev_commit_id, commit_id, "refs/heads/#{merge_request.target_branch}", key.user)
      merge_request.reload
245
      expect(merge_request.merged?).to be_truthy
246 247
    end

248
    it 'should update merge request commits with new one if pushed to source branch' do
249 250
      project.update_merge_requests(prev_commit_id, commit_id, "refs/heads/#{merge_request.source_branch}", key.user)
      merge_request.reload
251
      expect(merge_request.last_commit.id).to eq(commit_id)
252 253
    end
  end
254 255 256 257 258

  describe :find_with_namespace do
    context 'with namespace' do
      before do
        @group = create :group, name: 'gitlab'
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
259
        @project = create(:project, name: 'gitlabhq', namespace: @group)
260 261
      end

262
      it { expect(Project.find_with_namespace('gitlab/gitlabhq')).to eq(@project) }
263
      it { expect(Project.find_with_namespace('GitLab/GitlabHQ')).to eq(@project) }
264
      it { expect(Project.find_with_namespace('gitlab-ci')).to be_nil }
265 266 267 268 269 270 271
    end
  end

  describe :to_param do
    context 'with namespace' do
      before do
        @group = create :group, name: 'gitlab'
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
272
        @project = create(:project, name: 'gitlabhq', namespace: @group)
273 274
      end

Vinnie Okada's avatar
Vinnie Okada committed
275
      it { expect(@project.to_param).to eq('gitlabhq') }
276 277
    end
  end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
278

279
  describe :repository do
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
280 281
    let(:project) { create(:project) }

282
    it 'should return valid repo' do
283
      expect(project.repository).to be_kind_of(Repository)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
284 285
    end
  end
286

287
  describe :default_issues_tracker? do
288 289 290 291
    let(:project) { create(:project) }
    let(:ext_project) { create(:redmine_project) }

    it "should be true if used internal tracker" do
292
      expect(project.default_issues_tracker?).to be_truthy
293 294 295
    end

    it "should be false if used other tracker" do
296
      expect(ext_project.default_issues_tracker?).to be_falsey
297 298 299
    end
  end

Andrew8xx8's avatar
Andrew8xx8 committed
300 301 302 303
  describe :can_have_issues_tracker_id? do
    let(:project) { create(:project) }
    let(:ext_project) { create(:redmine_project) }

304
    it 'should be true for projects with external issues tracker if issues enabled' do
305
      expect(ext_project.can_have_issues_tracker_id?).to be_truthy
306
    end
Andrew8xx8's avatar
Andrew8xx8 committed
307

308
    it 'should be false for projects with internal issue tracker if issues enabled' do
309
      expect(project.can_have_issues_tracker_id?).to be_falsey
Andrew8xx8's avatar
Andrew8xx8 committed
310 311
    end

312
    it 'should be always false if issues disabled' do
Andrew8xx8's avatar
Andrew8xx8 committed
313 314 315
      project.issues_enabled = false
      ext_project.issues_enabled = false

316 317
      expect(project.can_have_issues_tracker_id?).to be_falsey
      expect(ext_project.can_have_issues_tracker_id?).to be_falsey
Andrew8xx8's avatar
Andrew8xx8 committed
318 319
    end
  end
320 321

  describe :open_branches do
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
322
    let(:project) { create(:project) }
323 324 325 326 327

    before do
      project.protected_branches.create(name: 'master')
    end

328 329
    it { expect(project.open_branches.map(&:name)).to include('feature') }
    it { expect(project.open_branches.map(&:name)).not_to include('master') }
330
  end
Ciro Santilli's avatar
Ciro Santilli committed
331

332 333
  describe '#star_count' do
    it 'counts stars from multiple users' do
Ciro Santilli's avatar
Ciro Santilli committed
334 335 336 337 338
      user1 = create :user
      user2 = create :user
      project = create :project, :public

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

Ciro Santilli's avatar
Ciro Santilli committed
340
      user1.toggle_star(project)
341 342
      expect(project.reload.star_count).to eq(1)

Ciro Santilli's avatar
Ciro Santilli committed
343
      user2.toggle_star(project)
344 345 346
      project.reload
      expect(project.reload.star_count).to eq(2)

Ciro Santilli's avatar
Ciro Santilli committed
347
      user1.toggle_star(project)
348 349 350
      project.reload
      expect(project.reload.star_count).to eq(1)

Ciro Santilli's avatar
Ciro Santilli committed
351
      user2.toggle_star(project)
352 353 354 355
      project.reload
      expect(project.reload.star_count).to eq(0)
    end

356
    it 'counts stars on the right project' do
357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386
      user = create :user
      project1 = create :project, :public
      project2 = create :project, :public

      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
387 388
    end
  end
389 390 391 392 393 394

  describe :avatar_type do
    let(:project) { create(:project) }

    it 'should be true if avatar is image' do
      project.update_attribute(:avatar, 'uploads/avatar.png')
395
      expect(project.avatar_type).to be_truthy
396 397 398 399
    end

    it 'should be false if avatar is html page' do
      project.update_attribute(:avatar, 'uploads/avatar.html')
400
      expect(project.avatar_type).to eq(['only images allowed'])
401 402
    end
  end
sue445's avatar
sue445 committed
403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432

  describe :avatar_url do
    subject { project.avatar_url }

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

    context 'When avatar file is uploaded' do
      before do
        project.update_columns(avatar: 'uploads/avatar.png')
        allow(project.avatar).to receive(:present?) { true }
      end

      let(:avatar_path) do
        "/uploads/project/avatar/#{project.id}/uploads/avatar.png"
      end

      it { should eq "http://localhost#{avatar_path}" }
    end

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

      let(:avatar_path) do
        "/#{project.namespace.name}/#{project.path}/avatar"
      end

      it { should eq "http://localhost#{avatar_path}" }
    end
433 434 435 436 437 438

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

      it { should eq nil }
    end
sue445's avatar
sue445 committed
439
  end
440 441 442

  describe :ci_commit do
    let(:project) { create :project }
Kamil Trzcinski's avatar
Kamil Trzcinski committed
443
    let(:commit) { create :ci_commit, project: project, ref: 'master' }
444

Kamil Trzcinski's avatar
Kamil Trzcinski committed
445 446 447 448 449 450 451 452 453 454 455 456 457 458
    subject { project.ci_commit(commit.sha, 'master') }

    it { is_expected.to eq(commit) }

    context 'return latest' do
      let(:commit2) { create :ci_commit, project: project, ref: 'master' }

      before do
        commit
        commit2
      end

      it { is_expected.to eq(commit2) }
    end
459
  end
460

461
  describe :builds_enabled do
462 463
    let(:project) { create :project }

464
    before { project.builds_enabled = true }
465

466 467 468
    subject { project.builds_enabled }

    it { expect(project.builds_enabled?).to be_truthy }
469
  end
470 471

  describe '.trending' do
Felipe Artur's avatar
Felipe Artur committed
472
    let(:group)    { create(:group, :public) }
473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498
    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)
    end

    describe 'without an explicit start date' do
      subject { described_class.trending.to_a }

      it 'sorts Projects by the amount of notes in descending order' do
        expect(subject).to eq([project1, project2])
      end
    end

    describe 'with an explicit start date' do
      let(:date) { 2.months.ago }

      subject { described_class.trending(date).to_a }

      before do
        2.times do
499 500 501
          # Little fix for special issue related to Fractional Seconds support for MySQL.
          # See: https://github.com/rails/rails/pull/14359/files
          create(:note_on_commit, project: project2, created_at: date + 1)
502 503 504 505 506 507 508 509
        end
      end

      it 'sorts Projects by the amount of notes in descending order' do
        expect(subject).to eq([project2, project1])
      end
    end
  end
Yorick Peterse's avatar
Yorick Peterse committed
510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528

  describe '.visible_to_user' do
    let!(:project) { create(:project, :private) }
    let!(:user)    { create(:user) }

    subject { described_class.visible_to_user(user) }

    describe 'when a user has access to a project' do
      before do
        project.team.add_user(user, Gitlab::Access::MASTER)
      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
529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549

  context 'shared runners by default' do
    let(:project) { create(:empty_project) }

    subject { project.shared_runners_enabled }

    context 'are enabled' do
      before { stub_application_setting(shared_runners_enabled: true) }

      it { is_expected.to be_truthy }
    end

    context 'are disabled' do
      before { stub_application_setting(shared_runners_enabled: false) }

      it { is_expected.to be_falsey }
    end
  end

  describe :any_runners do
    let(:project) { create(:empty_project, shared_runners_enabled: shared_runners_enabled) }
550 551
    let(:specific_runner) { create(:ci_runner) }
    let(:shared_runner) { create(:ci_runner, :shared) }
552 553 554

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

556 557 558
      it 'there are no runners available' do
        expect(project.any_runners?).to be_falsey
      end
559

560
      it 'there is a specific runner' do
561
        project.runners << specific_runner
562 563
        expect(project.any_runners?).to be_truthy
      end
564

565 566 567 568
      it 'there is a shared runner, but they are prohibited to use' do
        shared_runner
        expect(project.any_runners?).to be_falsey
      end
569

570
      it 'checks the presence of specific runner' do
571
        project.runners << specific_runner
572 573 574
        expect(project.any_runners? { |runner| runner == specific_runner }).to be_truthy
      end
    end
575

576 577
    context 'for shared runners enabled' do
      let(:shared_runners_enabled) { true }
578

579 580 581 582 583 584 585 586 587 588 589
      it 'there is a shared runner' do
        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
590 591

  describe '#visibility_level_allowed?' do
592
    let(:project) { create(:project, :internal) }
593 594 595 596 597 598 599 600

    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
601 602
      let(:project)        { create(:project, :internal) }
      let(:forked_project) { create(:project, forked_from_project: project) }
603 604 605 606 607

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

610 611
  describe '.search' do
    let(:project) { create(:project, description: 'kitten mittens') }
612

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

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

621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659
    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
660 661 662 663 664

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

      expect(relation.search(project.namespace.name)).to eq([project])
665
    end
666
  end
667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720

  describe '#rename_repo' do
    let(:project) { create(:project) }
    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)
    end

    it 'renames a repository' do
      allow(project).to receive(:previous_changes).and_return('path' => ['foo'])

      ns = project.namespace_dir

      expect(gitlab_shell).to receive(:mv_repository).
        ordered.
        with("#{ns}/foo", "#{ns}/#{project.path}").
        and_return(true)

      expect(gitlab_shell).to receive(:mv_repository).
        ordered.
        with("#{ns}/foo.wiki", "#{ns}/#{project.path}.wiki").
        and_return(true)

      expect_any_instance_of(SystemHooksService).
        to receive(:execute_hooks_for).
        with(project, :rename)

      expect_any_instance_of(Gitlab::UploadsTransfer).
        to receive(:rename_project).
        with('foo', project.path, ns)

      expect(project).to receive(:expire_caches_before_rename)

      project.rename_repo
    end
  end

  describe '#expire_caches_before_rename' do
    let(:project) { create(:project) }
    let(:repo)    { double(:repo, exists?: true) }
    let(:wiki)    { double(:wiki, exists?: true) }

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

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

721 722
      expect(repo).to receive(:before_delete)
      expect(wiki).to receive(:before_delete)
723 724 725 726

      project.expire_caches_before_rename('foo')
    end
  end
727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742

  describe '.search_by_title' do
    let(:project) { create(:project, name: 'kittens') }

    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
743 744 745 746 747

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

Douwe Maan's avatar
Douwe Maan committed
748 749
    let(:private_project)  { create :project, :private, group: private_group }
    let(:internal_project) { create :project, :internal, group: internal_group }
750 751 752 753 754 755 756 757 758

    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
759

760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799
  describe '#create_repository' do
    let(:project) { create(:project) }
    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
        expect(shell).to receive(:add_repository).
          with(project.path_with_namespace).
          and_return(true)

        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
        expect(shell).to receive(:add_repository).
          with(project.path_with_namespace).
          and_return(false)

        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
800 801 802 803 804 805 806 807 808 809 810 811 812 813

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

    it 'returns true when a branch is a protected branch' do
      project.protected_branches.create!(name: 'foo')

      expect(project.protected_branch?('foo')).to eq(true)
    end

    it 'returns false when a branch is not a protected branch' do
      expect(project.protected_branch?('foo')).to eq(false)
    end
  end
gitlabhq's avatar
gitlabhq committed
814
end