Read about our upcoming Code of Conduct on this issue

projects_helper_spec.rb 10.1 KB
Newer Older
1
2
3
require 'spec_helper'

describe ProjectsHelper do
Valery Sizov's avatar
Valery Sizov committed
4
5
  describe "#project_status_css_class" do
    it "returns appropriate class" do
6
7
8
      expect(project_status_css_class("started")).to eq("active")
      expect(project_status_css_class("failed")).to eq("danger")
      expect(project_status_css_class("finished")).to eq("success")
Valery Sizov's avatar
Valery Sizov committed
9
10
    end
  end
Valery Sizov's avatar
Valery Sizov committed
11
12

  describe "can_change_visibility_level?" do
13
    let(:project) { create(:project, :repository) }
14
    let(:user) { create(:project_member, :reporter, user: create(:user), project: project).user }
Douwe Maan's avatar
Douwe Maan committed
15
    let(:fork_project) { Projects::ForkService.new(project, user).execute }
Valery Sizov's avatar
Valery Sizov committed
16

17
    it "returns false if there are no appropriate permissions" do
Valery Sizov's avatar
Valery Sizov committed
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
      allow(helper).to receive(:can?) { false }

      expect(helper.can_change_visibility_level?(project, user)).to be_falsey
    end

    it "returns true if there are permissions and it is not fork" do
      allow(helper).to receive(:can?) { true }

      expect(helper.can_change_visibility_level?(project, user)).to be_truthy
    end

    context "forks" do
      it "returns false if there are permissions and origin project is PRIVATE" do
        allow(helper).to receive(:can?) { true }

        project.update visibility_level:  Gitlab::VisibilityLevel::PRIVATE

        expect(helper.can_change_visibility_level?(fork_project, user)).to be_falsey
      end

      it "returns true if there are permissions and origin project is INTERNAL" do
        allow(helper).to receive(:can?) { true }

        project.update visibility_level:  Gitlab::VisibilityLevel::INTERNAL

        expect(helper.can_change_visibility_level?(fork_project, user)).to be_truthy
      end
    end
  end
47
48
49
50
51
52
53
54
55

  describe "readme_cache_key" do
    let(:project) { create(:project) }

    before do
      helper.instance_variable_set(:@project, project)
    end

    it "returns a valid cach key" do
56
      expect(helper.send(:readme_cache_key)).to eq("#{project.path_with_namespace}-#{project.commit.id}-readme")
57
58
59
60
61
    end

    it "returns a valid cache key if HEAD does not exist" do
      allow(project).to receive(:commit) { nil }

62
      expect(helper.send(:readme_cache_key)).to eq("#{project.path_with_namespace}-nil-readme")
63
64
    end
  end
65

66
  describe "#project_list_cache_key", redis: true do
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
    let(:project) { create(:project) }

    it "includes the namespace" do
      expect(helper.project_list_cache_key(project)).to include(project.namespace.cache_key)
    end

    it "includes the project" do
      expect(helper.project_list_cache_key(project)).to include(project.cache_key)
    end

    it "includes the controller name" do
      expect(helper.controller).to receive(:controller_name).and_return("testcontroller")

      expect(helper.project_list_cache_key(project)).to include("testcontroller")
    end

    it "includes the controller action" do
      expect(helper.controller).to receive(:action_name).and_return("testaction")

      expect(helper.project_list_cache_key(project)).to include("testaction")
    end

    it "includes the application settings" do
      settings = Gitlab::CurrentSettings.current_application_settings

      expect(helper.project_list_cache_key(project)).to include(settings.cache_key)
    end

    it "includes a version" do
      expect(helper.project_list_cache_key(project)).to include("v2.3")
    end

    it "includes the pipeline status when there is a status" do
      create(:ci_pipeline, :success, project: project, sha: project.commit.sha)

      expect(helper.project_list_cache_key(project)).to include("pipeline-status/#{project.commit.sha}-success")
    end
  end
105

106
107
108
109
110
111
112
113
114
115
116
117
  describe '#load_pipeline_status' do
    it 'loads the pipeline status in batch' do
      project = build(:empty_project)

      helper.load_pipeline_status([project])
      # Skip lazy loading of the `pipeline_status` attribute
      pipeline_status = project.instance_variable_get('@pipeline_status')

      expect(pipeline_status).to be_a(Gitlab::Cache::Ci::ProjectPipelineStatus)
    end
  end

118
119
120
121
122
123
124
125
126
  describe 'link_to_member' do
    let(:group)   { create(:group) }
    let(:project) { create(:empty_project, group: group) }
    let(:user)    { create(:user) }

    describe 'using the default options' do
      it 'returns an HTML link to the user' do
        link = helper.link_to_member(project, user)

127
        expect(link).to match(%r{/#{user.username}})
128
129
130
      end
    end
  end
131
132

  describe 'default_clone_protocol' do
133
    context 'when user is not logged in and gitlab protocol is HTTP' do
134
      it 'returns HTTP' do
135
        allow(helper).to receive(:current_user).and_return(nil)
136
137
138
139
140

        expect(helper.send(:default_clone_protocol)).to eq('http')
      end
    end

141
    context 'when user is not logged in and gitlab protocol is HTTPS' do
142
      it 'returns HTTPS' do
143
144
        stub_config_setting(protocol: 'https')
        allow(helper).to receive(:current_user).and_return(nil)
145
146
147
148
149

        expect(helper.send(:default_clone_protocol)).to eq('https')
      end
    end
  end
150
151

  describe '#license_short_name' do
152
    let(:project) { create(:empty_project) }
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175

    context 'when project.repository has a license_key' do
      it 'returns the nickname of the license if present' do
        allow(project.repository).to receive(:license_key).and_return('agpl-3.0')

        expect(helper.license_short_name(project)).to eq('GNU AGPLv3')
      end

      it 'returns the name of the license if nickname is not present' do
        allow(project.repository).to receive(:license_key).and_return('mit')

        expect(helper.license_short_name(project)).to eq('MIT License')
      end
    end

    context 'when project.repository has no license_key but a license_blob' do
      it 'returns LICENSE' do
        allow(project.repository).to receive(:license_key).and_return(nil)

        expect(helper.license_short_name(project)).to eq('LICENSE')
      end
    end
  end
176
177

  describe '#sanitized_import_error' do
178
179
180
181
    let(:project) { create(:project) }

    before do
      allow(project).to receive(:repository_storage_path).and_return('/base/repo/path')
182
      allow(Settings.shared).to receive(:[]).with('path').and_return('/base/repo/export/path')
183
184
    end

185
    it 'removes the repo path' do
186
      repo = '/base/repo/path/namespace/test.git'
187
188
      import_error = "Could not clone #{repo}\n"

189
      expect(sanitize_repo_path(project, import_error)).to eq('Could not clone [REPOS PATH]/namespace/test.git')
190
    end
191
192
193
194
195
196
197

    it 'removes the temporary repo path used for uploads/exports' do
      repo = '/base/repo/export/path/tmp/project_exports/uploads/test.tar.gz'
      import_error = "Unable to decompress #{repo}\n"

      expect(sanitize_repo_path(project, import_error)).to eq('Unable to decompress [REPO EXPORT PATH]/uploads/test.tar.gz')
    end
198
  end
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
227
228
229
230
231
232
233
234
235
236

  describe '#last_push_event' do
    let(:user) { double(:user, fork_of: nil) }
    let(:project) { double(:project, id: 1) }

    before do
      allow(helper).to receive(:current_user).and_return(user)
      helper.instance_variable_set(:@project, project)
    end

    context 'when there is no current_user' do
      let(:user) { nil }

      it 'returns nil' do
        expect(helper.last_push_event).to eq(nil)
      end
    end

    it 'returns recent push on the current project' do
      event = double(:event)
      expect(user).to receive(:recent_push).with([project.id]).and_return(event)

      expect(helper.last_push_event).to eq(event)
    end

    context 'when current user has a fork of the current project' do
      let(:fork) { double(:fork, id: 2) }

      it 'returns recent push considering fork events' do
        expect(user).to receive(:fork_of).with(project).and_return(fork)

        event_on_fork = double(:event)
        expect(user).to receive(:recent_push).with([project.id, fork.id]).and_return(event_on_fork)

        expect(helper.last_push_event).to eq(event_on_fork)
      end
    end
  end
Felipe Artur's avatar
Felipe Artur committed
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279

  describe "#project_feature_access_select" do
    let(:project) { create(:empty_project, :public) }
    let(:user)    { create(:user) }

    context "when project is internal or public" do
      it "shows all options" do
        helper.instance_variable_set(:@project, project)
        result = helper.project_feature_access_select(:issues_access_level)
        expect(result).to include("Disabled")
        expect(result).to include("Only team members")
        expect(result).to include("Everyone with access")
      end
    end

    context "when project is private" do
      before { project.update_attributes(visibility_level: Gitlab::VisibilityLevel::PRIVATE) }

      it "shows only allowed options" do
        helper.instance_variable_set(:@project, project)
        result = helper.project_feature_access_select(:issues_access_level)
        expect(result).to include("Disabled")
        expect(result).to include("Only team members")
        expect(result).not_to include("Everyone with access")
      end
    end

    context "when project moves from public to private" do
      before do
        project.update_attributes(visibility_level: Gitlab::VisibilityLevel::PRIVATE)
      end

      it "shows the highest allowed level selected" do
        helper.instance_variable_set(:@project, project)
        result = helper.project_feature_access_select(:issues_access_level)

        expect(result).to include("Disabled")
        expect(result).to include("Only team members")
        expect(result).not_to include("Everyone with access")
        expect(result).to have_selector('option[selected]', text: "Only team members")
      end
    end
  end
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302

  describe "#visibility_select_options" do
    let(:project) { create(:project, :repository) }
    let(:user)    { create(:user) }

    before do
      allow(helper).to receive(:current_user).and_return(user)

      stub_application_setting(restricted_visibility_levels: [Gitlab::VisibilityLevel::PUBLIC])
    end

    it "does not include the Public restricted level" do
      expect(helper.send(:visibility_select_options, project, Gitlab::VisibilityLevel::PRIVATE)).not_to include('Public')
    end

    it "includes the Internal level" do
      expect(helper.send(:visibility_select_options, project, Gitlab::VisibilityLevel::PRIVATE)).to include('Internal')
    end

    it "includes the Private level" do
      expect(helper.send(:visibility_select_options, project, Gitlab::VisibilityLevel::PRIVATE)).to include('Private')
    end
  end
303
end