project_spec.rb 23.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
  describe 'project token' do
    it 'should set an random token if none provided' do
Kamil Trzcinski's avatar
Kamil Trzcinski committed
109 110
      project = FactoryGirl.create :empty_project, runners_token: ''
      expect(project.runners_token).not_to eq('')
111 112 113
    end

    it 'should not set an random toke if one provided' do
Kamil Trzcinski's avatar
Kamil Trzcinski committed
114 115
      project = FactoryGirl.create :empty_project, runners_token: 'my-token'
      expect(project.runners_token).to eq('my-token')
116 117
    end
  end
gitlabhq's avatar
gitlabhq committed
118

119
  describe 'Respond to' do
120 121 122 123 124 125 126
    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
127 128
  end

129 130 131 132 133 134 135 136
  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

137 138
  it 'should return valid url to repo' do
    project = Project.new(path: 'somewhere')
139
    expect(project.url_to_repo).to eq(Gitlab.config.gitlab_shell.ssh_path_prefix + 'somewhere.git')
gitlabhq's avatar
gitlabhq committed
140 141
  end

Douwe Maan's avatar
Douwe Maan committed
142 143 144 145 146 147
  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
148 149
  end

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

158
  describe 'last_activity methods' do
159
    let(:project) { create(:project) }
160
    let(:last_event) { double(created_at: Time.now) }
gitlabhq's avatar
gitlabhq committed
161

162 163
    describe 'last_activity' do
      it 'should alias last_activity to last_event' do
164
        allow(project).to receive(:last_event).and_return(last_event)
165
        expect(project.last_activity).to eq(last_event)
166
      end
gitlabhq's avatar
gitlabhq committed
167 168
    end

169 170
    describe 'last_activity_date' do
      it 'returns the creation date of the project\'s last event if present' do
171
        create(:event, project: project)
172
        expect(project.last_activity_at.to_i).to eq(last_event.created_at.to_i)
173
      end
174

175
      it 'returns the project\'s last update date if it has no events' do
176
        expect(project.last_activity_date).to eq(project.updated_at)
177
      end
178 179
    end
  end
180

181 182
  describe '#get_issue' do
    let(:project) { create(:empty_project) }
183
    let!(:issue)  { create(:issue, project: project) }
184 185 186 187 188 189

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

190 191 192 193
      it 'returns count of open issues' do
        expect(project.open_issues_count).to eq(1)
      end

194 195 196 197 198 199 200 201 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
      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

227
  describe :update_merge_requests do
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
228
    let(:project) { create(:project) }
229 230 231 232
    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 }
233

234
    it 'should close merge request if last commit from source branch was pushed to target branch' do
235 236
      project.update_merge_requests(prev_commit_id, commit_id, "refs/heads/#{merge_request.target_branch}", key.user)
      merge_request.reload
237
      expect(merge_request.merged?).to be_truthy
238 239
    end

240
    it 'should update merge request commits with new one if pushed to source branch' do
241 242
      project.update_merge_requests(prev_commit_id, commit_id, "refs/heads/#{merge_request.source_branch}", key.user)
      merge_request.reload
243
      expect(merge_request.last_commit.id).to eq(commit_id)
244 245
    end
  end
246 247 248 249 250

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

254
      it { expect(Project.find_with_namespace('gitlab/gitlabhq')).to eq(@project) }
255
      it { expect(Project.find_with_namespace('GitLab/GitlabHQ')).to eq(@project) }
256
      it { expect(Project.find_with_namespace('gitlab-ci')).to be_nil }
257 258 259 260 261 262 263
    end
  end

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

Vinnie Okada's avatar
Vinnie Okada committed
267
      it { expect(@project.to_param).to eq('gitlabhq') }
268 269
    end
  end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
270

271
  describe :repository do
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
272 273
    let(:project) { create(:project) }

274
    it 'should return valid repo' do
275
      expect(project.repository).to be_kind_of(Repository)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
276 277
    end
  end
278

279
  describe :default_issues_tracker? do
280 281 282 283
    let(:project) { create(:project) }
    let(:ext_project) { create(:redmine_project) }

    it "should be true if used internal tracker" do
284
      expect(project.default_issues_tracker?).to be_truthy
285 286 287
    end

    it "should be false if used other tracker" do
288
      expect(ext_project.default_issues_tracker?).to be_falsey
289 290 291
    end
  end

Andrew8xx8's avatar
Andrew8xx8 committed
292 293 294 295
  describe :can_have_issues_tracker_id? do
    let(:project) { create(:project) }
    let(:ext_project) { create(:redmine_project) }

296
    it 'should be true for projects with external issues tracker if issues enabled' do
297
      expect(ext_project.can_have_issues_tracker_id?).to be_truthy
298
    end
Andrew8xx8's avatar
Andrew8xx8 committed
299

300
    it 'should be false for projects with internal issue tracker if issues enabled' do
301
      expect(project.can_have_issues_tracker_id?).to be_falsey
Andrew8xx8's avatar
Andrew8xx8 committed
302 303
    end

304
    it 'should be always false if issues disabled' do
Andrew8xx8's avatar
Andrew8xx8 committed
305 306 307
      project.issues_enabled = false
      ext_project.issues_enabled = false

308 309
      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
310 311
    end
  end
312 313

  describe :open_branches do
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
314
    let(:project) { create(:project) }
315 316 317 318 319

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

320 321
    it { expect(project.open_branches.map(&:name)).to include('feature') }
    it { expect(project.open_branches.map(&:name)).not_to include('master') }
322
  end
Ciro Santilli's avatar
Ciro Santilli committed
323

324 325
  describe '#star_count' do
    it 'counts stars from multiple users' do
Ciro Santilli's avatar
Ciro Santilli committed
326 327 328 329 330
      user1 = create :user
      user2 = create :user
      project = create :project, :public

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

Ciro Santilli's avatar
Ciro Santilli committed
332
      user1.toggle_star(project)
333 334
      expect(project.reload.star_count).to eq(1)

Ciro Santilli's avatar
Ciro Santilli committed
335
      user2.toggle_star(project)
336 337 338
      project.reload
      expect(project.reload.star_count).to eq(2)

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

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

348
    it 'counts stars on the right project' do
349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378
      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
379 380
    end
  end
381 382 383 384 385 386

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

    it 'should be true if avatar is image' do
      project.update_attribute(:avatar, 'uploads/avatar.png')
387
      expect(project.avatar_type).to be_truthy
388 389 390 391
    end

    it 'should be false if avatar is html page' do
      project.update_attribute(:avatar, 'uploads/avatar.html')
392
      expect(project.avatar_type).to eq(['only images allowed'])
393 394
    end
  end
sue445's avatar
sue445 committed
395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425

  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
  end
426 427 428

  describe :ci_commit do
    let(:project) { create :project }
429
    let(:commit) { create :ci_commit, project: project }
430 431 432

    it { expect(project.ci_commit(commit.sha)).to eq(commit) }
  end
433

434
  describe :builds_enabled do
435 436
    let(:project) { create :project }

437
    before { project.builds_enabled = true }
438

439 440 441
    subject { project.builds_enabled }

    it { expect(project.builds_enabled?).to be_truthy }
442
  end
443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471

  describe '.trending' do
    let(:group)    { create(:group) }
    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
472 473 474
          # 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)
475 476 477 478 479 480 481 482
        end
      end

      it 'sorts Projects by the amount of notes in descending order' do
        expect(subject).to eq([project2, project1])
      end
    end
  end
483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501

  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
502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522

  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) }
523 524
    let(:specific_runner) { create(:ci_runner) }
    let(:shared_runner) { create(:ci_runner, :shared) }
525 526 527

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

529 530 531
      it 'there are no runners available' do
        expect(project.any_runners?).to be_falsey
      end
532

533
      it 'there is a specific runner' do
534
        project.runners << specific_runner
535 536
        expect(project.any_runners?).to be_truthy
      end
537

538 539 540 541
      it 'there is a shared runner, but they are prohibited to use' do
        shared_runner
        expect(project.any_runners?).to be_falsey
      end
542

543
      it 'checks the presence of specific runner' do
544
        project.runners << specific_runner
545 546 547
        expect(project.any_runners? { |runner| runner == specific_runner }).to be_truthy
      end
    end
548

549 550
    context 'for shared runners enabled' do
      let(:shared_runners_enabled) { true }
551

552 553 554 555 556 557 558 559 560 561 562
      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
563 564

  describe '#visibility_level_allowed?' do
565
    let(:project) { create(:project, :internal) }
566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584

    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
      let(:forked_project) { create :forked_project_with_submodules }

      before do
        forked_project.build_forked_project_link(forked_to_project_id: forked_project.id, forked_from_project_id: project.id)
        forked_project.save
      end

      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
585 586 587 588 589 590 591 592
  end

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

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

594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636
    it 'returns projects with a partially matching name' do
      expect(described_class.search(project.name[0..2])).to eq([project])
    end

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

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

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

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

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

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

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

    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
637
  end
638 639 640 641 642 643 644 645 646 647 648 649 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 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700

  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
gitlabhq's avatar
gitlabhq committed
701
end