project_spec.rb 26.1 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 15
#  issues_enabled         :boolean          default(TRUE), not null
#  wall_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
16
#  namespace_id           :integer
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
17
#  issues_tracker         :string(255)      default("gitlab"), not null
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
18
#  issues_tracker_id      :string(255)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
19
#  snippets_enabled       :boolean          default(TRUE), not null
20
#  last_activity_at       :datetime
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
21
#  import_url             :string(255)
22
#  visibility_level       :integer          default(0), not null
23
#  archived               :boolean          default(FALSE), not null
Atsushi Ishida's avatar
Atsushi Ishida committed
24
#  avatar                 :string(255)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
25
#  import_status          :string(255)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
26 27
#  repository_size        :float            default(0.0)
#  star_count             :integer          default(0), not null
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
28 29
#  import_type            :string(255)
#  import_source          :string(255)
Atsushi Ishida's avatar
Atsushi Ishida committed
30
#  commit_count           :integer          default(0)
Stan Hu's avatar
Stan Hu committed
31
#  import_error           :text
Stan Hu's avatar
Stan Hu committed
32 33 34 35 36 37 38
#  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
39 40
#

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

Douwe Maan's avatar
Douwe Maan committed
43
describe Project, models: true do
44
  describe 'associations' do
45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
    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
64
    it { is_expected.to have_many(:commit_statuses) }
65 66 67 68 69 70
    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) }
71
    it { is_expected.to have_many(:todos).dependent(:destroy) }
gitlabhq's avatar
gitlabhq committed
72 73
  end

74 75 76 77 78 79 80 81
  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) }
82 83
  end

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

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

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

99
    it 'should not allow new projects beyond user limits' do
100
      project2 = build(:project)
101 102 103
      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/)
104
    end
gitlabhq's avatar
gitlabhq committed
105
  end
106

107 108 109 110 111 112 113 114 115
  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

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

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

128
  describe 'Respond to' do
129 130 131 132 133 134 135
    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
136 137
  end

138 139 140 141 142 143 144 145
  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

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

Douwe Maan's avatar
Douwe Maan committed
151 152 153 154 155 156
  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
157 158
  end

Douwe Maan's avatar
Douwe Maan committed
159 160 161 162 163 164
  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
165 166
  end

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

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

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

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

190 191
  describe '#get_issue' do
    let(:project) { create(:empty_project) }
192
    let!(:issue)  { create(:issue, project: project) }
193 194 195 196 197 198

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

199 200 201 202
      it 'returns count of open issues' do
        expect(project.open_issues_count).to eq(1)
      end

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

236
  describe :update_merge_requests do
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
237
    let(:project) { create(:project) }
238 239 240 241
    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 }
242

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

357
    it 'counts stars on the right project' do
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 387
      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
388 389
    end
  end
390 391 392 393 394 395

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

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

    it 'should be false if avatar is html page' do
      project.update_attribute(:avatar, 'uploads/avatar.html')
401
      expect(project.avatar_type).to eq(['only images allowed'])
402 403
    end
  end
sue445's avatar
sue445 committed
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 433

  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
434 435 436 437 438 439

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

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

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

446 447 448 449 450 451 452 453 454 455 456 457 458 459
    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
460
  end
461

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

465
    before { project.builds_enabled = true }
466

467 468 469
    subject { project.builds_enabled }

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

  describe '.trending' do
Felipe Artur's avatar
Felipe Artur committed
473
    let(:group)    { create(:group, :public) }
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 499
    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
500 501 502
          # 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)
503 504 505 506 507 508 509 510
        end
      end

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

  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
530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550

  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) }
551 552
    let(:specific_runner) { create(:ci_runner) }
    let(:shared_runner) { create(:ci_runner, :shared) }
553 554 555

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

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

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

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

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

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

580 581 582 583 584 585 586 587 588 589 590
      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
591 592

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

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

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

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

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

618 619 620
    it 'returns projects with a partially matching name' do
      expect(described_class.search(project.name[0..2])).to eq([project])
    end
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 660
    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
661 662 663 664 665

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

      expect(relation.search(project.namespace.name)).to eq([project])
666
    end
667
  end
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 721 722 723 724 725 726 727 728 729 730

  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)

      expect(repo).to receive(:expire_cache)
      expect(repo).to receive(:expire_emptiness_caches)

      expect(wiki).to receive(:expire_cache)
      expect(wiki).to receive(:expire_emptiness_caches)

      project.expire_caches_before_rename('foo')
    end
  end
731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746

  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
747 748 749 750 751

  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
752 753
    let(:private_project)  { create :project, :private, group: private_group }
    let(:internal_project) { create :project, :internal, group: internal_group }
754 755 756 757 758 759 760 761 762

    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
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 800 801 802 803
  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
gitlabhq's avatar
gitlabhq committed
804
end