project_wiki_spec.rb 8.66 KB
Newer Older
1
2
require "spec_helper"

Douwe Maan's avatar
Douwe Maan committed
3
describe ProjectWiki, models: true do
4
  let(:project) { create(:empty_project) }
5
6
7
  let(:repository) { project.repository }
  let(:user) { project.owner }
  let(:gitlab_shell) { Gitlab::Shell.new }
8
  let(:project_wiki) { ProjectWiki.new(project, user) }
9

10
11
  subject { project_wiki }
  before { project_wiki.wiki }
12
13
14

  describe "#path_with_namespace" do
    it "returns the project path with namespace with the .wiki extension" do
15
      expect(subject.path_with_namespace).to eq(project.path_with_namespace + ".wiki")
16
17
18
    end
  end

19
20
21
22
23
24
  describe '#web_url' do
    it 'returns the full web URL to the wiki' do
      expect(subject.web_url).to eq("#{Gitlab.config.gitlab.url}/#{project.path_with_namespace}/wikis/home")
    end
  end

25
26
  describe "#url_to_repo" do
    it "returns the correct ssh url to the repo" do
27
      expect(subject.url_to_repo).to eq(gitlab_shell.url_to_repo(subject.path_with_namespace))
28
29
30
31
32
    end
  end

  describe "#ssh_url_to_repo" do
    it "equals #url_to_repo" do
33
      expect(subject.ssh_url_to_repo).to eq(subject.url_to_repo)
34
35
36
37
    end
  end

  describe "#http_url_to_repo" do
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
    let(:project) { create :empty_project }

    context 'when no user is given' do
      it 'returns the url to the repo without a username' do
        expected_url = "#{Gitlab.config.gitlab.url}/#{subject.path_with_namespace}.git"

        expect(project_wiki.http_url_to_repo).to eq(expected_url)
        expect(project_wiki.http_url_to_repo).not_to include('@')
      end
    end

    context 'when user is given' do
      it 'returns the url to the repo with the username' do
        user = build_stubbed(:user)

        expect(project_wiki.http_url_to_repo(user)).to start_with("http://#{user.username}@")
      end
55
56
57
    end
  end

58
59
  describe "#wiki_base_path" do
    it "returns the wiki base path" do
60
61
      wiki_base_path = "#{Gitlab.config.gitlab.relative_url_root}/#{project.path_with_namespace}/wikis"

62
63
64
65
      expect(subject.wiki_base_path).to eq(wiki_base_path)
    end
  end

66
67
  describe "#wiki" do
    it "contains a Gollum::Wiki instance" do
68
      expect(subject.wiki).to be_a Gollum::Wiki
69
70
71
    end

    it "creates a new wiki repo if one does not yet exist" do
72
      expect(project_wiki.create_page("index", "test content")).to be_truthy
73
74
75
    end

    it "raises CouldNotCreateWikiError if it can't create the wiki repository" do
76
      allow(project_wiki).to receive(:init_repo).and_return(false)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
77
      expect { project_wiki.send(:create_repo!) }.to raise_exception(ProjectWiki::CouldNotCreateWikiError)
78
79
80
    end
  end

Jacob Vosmaer's avatar
Jacob Vosmaer committed
81
82
83
  describe "#empty?" do
    context "when the wiki repository is empty" do
      before do
84
        allow_any_instance_of(Gitlab::Shell).to receive(:add_repository) do
Jacob Vosmaer's avatar
Jacob Vosmaer committed
85
86
          create_temp_repo("#{Rails.root}/tmp/test-git-base-path/non-existant.wiki.git")
        end
87
        allow(project).to receive(:path_with_namespace).and_return("non-existant")
Jacob Vosmaer's avatar
Jacob Vosmaer committed
88
89
      end

90
91
92
93
      describe '#empty?' do
        subject { super().empty? }
        it { is_expected.to be_truthy }
      end
Jacob Vosmaer's avatar
Jacob Vosmaer committed
94
95
96
97
    end

    context "when the wiki has pages" do
      before do
98
        project_wiki.create_page("index", "This is an awesome new Gollum Wiki")
Jacob Vosmaer's avatar
Jacob Vosmaer committed
99
100
      end

101
102
103
104
      describe '#empty?' do
        subject { super().empty? }
        it { is_expected.to be_falsey }
      end
Jacob Vosmaer's avatar
Jacob Vosmaer committed
105
106
107
    end
  end

108
109
110
111
112
113
114
115
116
117
118
  describe "#pages" do
    before do
      create_page("index", "This is an awesome new Gollum Wiki")
      @pages = subject.pages
    end

    after do
      destroy_page(@pages.first.page)
    end

    it "returns an array of WikiPage instances" do
119
      expect(@pages.first).to be_a WikiPage
120
121
122
    end

    it "returns the correct number of pages" do
123
      expect(@pages.count).to eq(1)
124
125
126
127
128
129
130
131
132
133
134
135
136
137
    end
  end

  describe "#find_page" do
    before do
      create_page("index page", "This is an awesome Gollum Wiki")
    end

    after do
      destroy_page(subject.pages.first.page)
    end

    it "returns the latest version of the page if it exists" do
      page = subject.find_page("index page")
138
      expect(page.title).to eq("index page")
139
140
141
    end

    it "returns nil if the page does not exist" do
142
      expect(subject.find_page("non-existant")).to eq(nil)
143
144
145
146
    end

    it "can find a page by slug" do
      page = subject.find_page("index-page")
147
      expect(page.title).to eq("index page")
148
149
150
151
    end

    it "returns a WikiPage instance" do
      page = subject.find_page("index page")
152
      expect(page).to be_a WikiPage
153
154
155
    end
  end

156
157
158
  describe '#find_file' do
    before do
      file = Gollum::File.new(subject.wiki)
159
160
      allow_any_instance_of(Gollum::Wiki).
                   to receive(:file).with('image.jpg', 'master', true).
161
                   and_return(file)
162
163
      allow_any_instance_of(Gollum::File).
                   to receive(:mime_type).
164
                   and_return('image/jpeg')
165
166
      allow_any_instance_of(Gollum::Wiki).
                   to receive(:file).with('non-existant', 'master', true).
167
168
169
170
                   and_return(nil)
    end

    after do
171
172
      allow_any_instance_of(Gollum::Wiki).to receive(:file).and_call_original
      allow_any_instance_of(Gollum::File).to receive(:mime_type).and_call_original
173
174
175
176
    end

    it 'returns the latest version of the file if it exists' do
      file = subject.find_file('image.jpg')
177
      expect(file.mime_type).to eq('image/jpeg')
178
179
180
    end

    it 'returns nil if the page does not exist' do
181
      expect(subject.find_file('non-existant')).to eq(nil)
182
183
184
185
    end

    it 'returns a Gollum::File instance' do
      file = subject.find_file('image.jpg')
186
      expect(file).to be_a Gollum::File
187
188
189
    end
  end

190
191
192
193
194
195
  describe "#create_page" do
    after do
      destroy_page(subject.pages.first.page)
    end

    it "creates a new wiki page" do
196
197
      expect(subject.create_page("test page", "this is content")).not_to eq(false)
      expect(subject.pages.count).to eq(1)
198
199
200
201
    end

    it "returns false when a duplicate page exists" do
      subject.create_page("test page", "content")
202
      expect(subject.create_page("test page", "content")).to eq(false)
203
204
205
206
    end

    it "stores an error message when a duplicate page exists" do
      2.times { subject.create_page("test page", "content") }
207
      expect(subject.error_message).to match(/Duplicate page:/)
208
209
210
211
    end

    it "sets the correct commit message" do
      subject.create_page("test page", "some content", :markdown, "commit message")
212
      expect(subject.pages.first.page.version.message).to eq("commit message")
213
    end
214
215
216
217
218
219

    it 'updates project activity' do
      expect(subject).to receive(:update_project_activity)

      subject.create_page('Test Page', 'This is content')
    end
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
  end

  describe "#update_page" do
    before do
      create_page("update-page", "some content")
      @gollum_page = subject.wiki.paged("update-page")
      subject.update_page(@gollum_page, "some other content", :markdown, "updated page")
      @page = subject.pages.first.page
    end

    after do
      destroy_page(@page)
    end

    it "updates the content of the page" do
235
      expect(@page.raw_data).to eq("some other content")
236
237
238
    end

    it "sets the correct commit message" do
239
      expect(@page.version.message).to eq("updated page")
240
    end
241
242
243
244
245
246

    it 'updates project activity' do
      expect(subject).to receive(:update_project_activity)

      subject.update_page(@gollum_page, 'Yet more content', :markdown, 'Updated page again')
    end
247
248
249
250
251
252
253
254
255
256
  end

  describe "#delete_page" do
    before do
      create_page("index", "some content")
      @page = subject.wiki.paged("index")
    end

    it "deletes the page" do
      subject.delete_page(@page)
257
      expect(subject.pages.count).to eq(0)
258
    end
259
260
261
262
263
264

    it 'updates project activity' do
      expect(subject).to receive(:update_project_activity)

      subject.delete_page(@page)
    end
265
266
  end

267
268
269
270
271
272
273
274
275
276
277
278
  describe '#create_repo!' do
    it 'creates a repository' do
      expect(subject).to receive(:init_repo).
        with(subject.path_with_namespace).
        and_return(true)

      expect(subject.repository).to receive(:after_create)

      expect(subject.create_repo!).to be_an_instance_of(Gollum::Wiki)
    end
  end

279
280
281
282
283
284
285
  describe '#hook_attrs' do
    it 'returns a hash with values' do
      expect(subject.hook_attrs).to be_a Hash
      expect(subject.hook_attrs.keys).to contain_exactly(:web_url, :git_ssh_url, :git_http_url, :path_with_namespace, :default_branch)
    end
  end

286
287
288
289
  private

  def create_temp_repo(path)
    FileUtils.mkdir_p path
290
    system(*%W(#{Gitlab.config.git.bin_path} init --quiet --bare -- #{path}))
291
292
293
294
295
296
297
  end

  def remove_temp_repo(path)
    FileUtils.rm_rf path
  end

  def commit_details
298
    { name: user.name, email: user.email, message: "test commit" }
299
300
301
302
303
304
305
306
307
  end

  def create_page(name, content)
    subject.wiki.write_page(name, :markdown, content, commit_details)
  end

  def destroy_page(page)
    subject.wiki.delete_page(page, commit_details)
  end
308
end