project_spec.rb 23.8 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) }
Stan Hu's avatar
Stan Hu committed
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

Stan Hu's avatar
Stan Hu committed
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
Yorick Peterse's avatar
Yorick Peterse committed
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
638
639
640
641
642

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

      expect(relation.search(project.namespace.name)).to eq([project])
    end
643
  end
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
701
702
703
704
705
706

  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
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722

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