BigW Consortium Gitlab

projects_controller_spec.rb 13.1 KB
Newer Older
1 2 3 4
require('spec_helper')

describe ProjectsController do
  let(:project) { create(:project) }
Ciro Santilli committed
5
  let(:public_project) { create(:project, :public) }
6 7
  let(:user)    { create(:user) }
  let(:jpg)     { fixture_file_upload(Rails.root + 'spec/fixtures/rails_sample.jpg', 'image/jpg') }
Marin Jankovski committed
8
  let(:txt)     { fixture_file_upload(Rails.root + 'spec/fixtures/doc_sample.txt', 'text/plain') }
9

10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
  describe 'GET index' do
    context 'as a user' do
      it 'redirects to root page' do
        sign_in(user)

        get :index

        expect(response).to redirect_to(root_path)
      end
    end

    context 'as a guest' do
      it 'redirects to Explore page' do
        get :index

        expect(response).to redirect_to(explore_root_path)
      end
    end
  end

30
  describe "GET show" do
31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
    context "user not project member" do
      before { sign_in(user) }

      context "user does not have access to project" do
        let(:private_project) { create(:project, :private) }

        it "does not initialize notification setting" do
          get :show, namespace_id: private_project.namespace.path, id: private_project.path
          expect(assigns(:notification_setting)).to be_nil
        end
      end

      context "user has access to project" do
        context "and does not have notification setting" do
          it "initializes notification as disabled" do
            get :show, namespace_id: public_project.namespace.path, id: public_project.path
47
            expect(assigns(:notification_setting).level).to eq("global")
48 49 50 51 52 53
          end
        end

        context "and has notification setting" do
          before do
            setting = user.notification_settings_for(public_project)
54
            setting.level = :watch
55 56 57 58 59
            setting.save
          end

          it "shows current notification setting" do
            get :show, namespace_id: public_project.namespace.path, id: public_project.path
60
            expect(assigns(:notification_setting).level).to eq("watch")
61 62 63
          end
        end
      end
64 65 66 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

      describe "when project repository is disabled" do
        render_views

        before do
          project.team << [user, :developer]
          project.project_feature.update_attribute(:repository_access_level, ProjectFeature::DISABLED)
        end

        it 'shows wiki homepage' do
          get :show, namespace_id: project.namespace.path, id: project.path

          expect(response).to render_template('projects/_wiki')
        end

        it 'shows issues list page if wiki is disabled' do
          project.project_feature.update_attribute(:wiki_access_level, ProjectFeature::DISABLED)

          get :show, namespace_id: project.namespace.path, id: project.path

          expect(response).to render_template('projects/issues/_issues')
        end

        it 'shows customize workflow page if wiki and issues are disabled' do
          project.project_feature.update_attribute(:wiki_access_level, ProjectFeature::DISABLED)
          project.project_feature.update_attribute(:issues_access_level, ProjectFeature::DISABLED)

          get :show, namespace_id: project.namespace.path, id: project.path

          expect(response).to render_template("projects/_customize_workflow")
        end

        it 'shows activity if enabled by user' do
          user.update_attribute(:project_view, 'activity')

          get :show, namespace_id: project.namespace.path, id: project.path

          expect(response).to render_template("projects/_activity")
        end
      end
104
    end
105

106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
    context "project with empty repo" do
      let(:empty_project) { create(:project_empty_repo, :public) }

      before { sign_in(user) }

      User.project_views.keys.each do |project_view|
        context "with #{project_view} view set" do
          before do
            user.update_attributes(project_view: project_view)

            get :show, namespace_id: empty_project.namespace.path, id: empty_project.path
          end

          it "renders the empty project view" do
            expect(response).to render_template('empty')
          end
        end
      end
    end

126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
    context "project with broken repo" do
      let(:empty_project) { create(:project_broken_repo, :public) }

      before { sign_in(user) }

      User.project_views.keys.each do |project_view|
        context "with #{project_view} view set" do
          before do
            user.update_attributes(project_view: project_view)

            get :show, namespace_id: empty_project.namespace.path, id: empty_project.path
          end

          it "renders the empty project view" do
            allow(Project).to receive(:repo).and_raise(Gitlab::Git::Repository::NoRepository)

            expect(response).to render_template('projects/no_repo')
          end
        end
      end
    end

148 149
    context "rendering default project view" do
      render_views
150

151
      it "renders the activity view" do
152 153
        allow(controller).to receive(:current_user).and_return(user)
        allow(user).to receive(:project_view).and_return('activity')
154

155 156 157 158
        get :show, namespace_id: public_project.namespace.path, id: public_project.path
        expect(response).to render_template('_activity')
      end

159
      it "renders the readme view" do
160 161
        allow(controller).to receive(:current_user).and_return(user)
        allow(user).to receive(:project_view).and_return('readme')
162

163 164 165 166
        get :show, namespace_id: public_project.namespace.path, id: public_project.path
        expect(response).to render_template('_readme')
      end

167
      it "renders the files view" do
168 169
        allow(controller).to receive(:current_user).and_return(user)
        allow(user).to receive(:project_view).and_return('files')
170

171 172 173 174
        get :show, namespace_id: public_project.namespace.path, id: public_project.path
        expect(response).to render_template('_files')
      end
    end
175

176
    context "when requested with case sensitive namespace and project path" do
177 178 179
      context "when there is a match with the same casing" do
        it "loads the project" do
          get :show, namespace_id: public_project.namespace.path, id: public_project.path
180

181
          expect(assigns(:project)).to eq(public_project)
182
          expect(response).to have_http_status(200)
183
        end
184 185
      end

186 187 188 189 190 191 192 193
      context "when there is a match with different casing" do
        it "redirects to the normalized path" do
          get :show, namespace_id: public_project.namespace.path, id: public_project.path.upcase

          expect(assigns(:project)).to eq(public_project)
          expect(response).to redirect_to("/#{public_project.path_with_namespace}")
        end

194
        # MySQL queries are case insensitive by default, so this spec would fail.
195
        if Gitlab::Database.postgresql?
196 197
          context "when there is also a match with the same casing" do
            let!(:other_project) { create(:project, :public, namespace: public_project.namespace, path: public_project.path.upcase) }
198

199 200 201 202
            it "loads the exactly matched project" do
              get :show, namespace_id: public_project.namespace.path, id: public_project.path.upcase

              expect(assigns(:project)).to eq(other_project)
203
              expect(response).to have_http_status(200)
204
            end
205 206
          end
        end
207 208
      end
    end
209 210

    context "when the url contains .atom" do
211
      let(:public_project_with_dot_atom) { build(:project, :public, name: 'my.atom', path: 'my.atom') }
212

213
      it 'expects an error creating the project' do
214
        expect(public_project_with_dot_atom).not_to be_valid
215 216
      end
    end
217 218 219 220 221 222 223 224 225 226 227

    context 'when the project is pending deletions' do
      it 'renders a 404 error' do
        project = create(:project, pending_delete: true)
        sign_in(user)

        get :show, namespace_id: project.namespace.path, id: project.path

        expect(response.status).to eq 404
      end
    end
228
  end
229

230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247
  describe "#update" do
    render_views

    let(:admin) { create(:admin) }

    it "sets the repository to the right path after a rename" do
      new_path = 'renamed_path'
      project_params = { path: new_path }
      controller.instance_variable_set(:@project, project)
      sign_in(admin)

      put :update,
          namespace_id: project.namespace.to_param,
          id: project.id,
          project: project_params

      expect(project.repository.path).to include(new_path)
      expect(assigns(:repository).path).to eq(project.repository.path)
248
      expect(response).to have_http_status(200)
249 250 251
    end
  end

252 253 254 255 256 257 258 259 260 261 262
  describe "#destroy" do
    let(:admin) { create(:admin) }

    it "redirects to the dashboard" do
      controller.instance_variable_set(:@project, project)
      sign_in(admin)

      orig_id = project.id
      delete :destroy, namespace_id: project.namespace.path, id: project.path

      expect { Project.find(orig_id) }.to raise_error(ActiveRecord::RecordNotFound)
263
      expect(response).to have_http_status(302)
264 265
      expect(response).to redirect_to(dashboard_projects_path)
    end
266

Katarzyna Kobierska committed
267
    context "when the project is forked" do
268 269 270
      let(:project)      { create(:project) }
      let(:fork_project) { create(:project, forked_from_project: project) }
      let(:merge_request) do
271 272 273
        create(:merge_request,
          source_project: fork_project,
          target_project: project)
274 275 276
      end

      it "closes all related merge requests" do
277 278
        project.merge_requests << merge_request
        sign_in(admin)
279

280 281 282
        delete :destroy, namespace_id: fork_project.namespace.path, id: fork_project.path

        expect(merge_request.reload.state).to eq('closed')
283 284
      end
    end
285 286
  end

287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
  describe 'PUT #new_issue_address' do
    subject do
      put :new_issue_address,
        namespace_id: project.namespace.to_param,
        id: project.to_param
      user.reload
    end

    before do
      sign_in(user)
      project.team << [user, :developer]
      allow(Gitlab.config.incoming_email).to receive(:enabled).and_return(true)
    end

    it 'has http status 200' do
      expect(response).to have_http_status(200)
    end

    it 'changes the user incoming email token' do
      expect { subject }.to change { user.incoming_email_token }
    end

    it 'changes projects new issue address' do
      expect { subject }.to change { project.new_issue_address(user) }
    end
  end

Ciro Santilli committed
314
  describe "POST #toggle_star" do
315
    it "toggles star if user is signed in" do
Ciro Santilli committed
316
      sign_in(user)
317
      expect(user.starred?(public_project)).to be_falsey
318 319
      post(:toggle_star,
           namespace_id: public_project.namespace.to_param,
Vinnie Okada committed
320
           id: public_project.to_param)
321
      expect(user.starred?(public_project)).to be_truthy
322 323
      post(:toggle_star,
           namespace_id: public_project.namespace.to_param,
Vinnie Okada committed
324
           id: public_project.to_param)
325
      expect(user.starred?(public_project)).to be_falsey
Ciro Santilli committed
326 327 328
    end

    it "does nothing if user is not signed in" do
329 330
      post(:toggle_star,
           namespace_id: project.namespace.to_param,
Vinnie Okada committed
331
           id: public_project.to_param)
332
      expect(user.starred?(public_project)).to be_falsey
333 334
      post(:toggle_star,
           namespace_id: project.namespace.to_param,
Vinnie Okada committed
335
           id: public_project.to_param)
336
      expect(user.starred?(public_project)).to be_falsey
Ciro Santilli committed
337 338
    end
  end
339

Douwe Maan committed
340
  describe "DELETE remove_fork" do
341 342 343 344 345 346 347 348
    context 'when signed in' do
      before do
        sign_in(user)
      end

      context 'with forked project' do
        let(:project_fork) { create(:project, namespace: user.namespace) }

349
        before do
350
          create(:forked_project_link, forked_to_project: project_fork)
351 352
        end

353
        it 'removes fork from project' do
354
          delete(:remove_fork,
355 356 357 358
              namespace_id: project_fork.namespace.to_param,
              id: project_fork.to_param, format: :js)

          expect(project_fork.forked?).to be_falsey
Douwe Maan committed
359
          expect(flash[:notice]).to eq('The fork relationship has been removed.')
360 361 362 363
          expect(response).to render_template(:remove_fork)
        end
      end

364 365
      context 'when project not forked' do
        let(:unforked_project) { create(:project, namespace: user.namespace) }
366

367
        it 'does nothing if project was not forked' do
368 369 370 371 372 373 374
          delete(:remove_fork,
              namespace_id: unforked_project.namespace.to_param,
              id: unforked_project.to_param, format: :js)

          expect(flash[:notice]).to be_nil
          expect(response).to render_template(:remove_fork)
        end
375 376 377 378
      end
    end

    it "does nothing if user is not signed in" do
379
      delete(:remove_fork,
380 381
          namespace_id: project.namespace.to_param,
          id: project.to_param, format: :js)
382
      expect(response).to have_http_status(401)
383 384
    end
  end
385 386

  describe "GET refs" do
387
    it "gets a list of branches and tags" do
388 389 390 391 392 393 394 395
      get :refs, namespace_id: public_project.namespace.path, id: public_project.path

      parsed_body = JSON.parse(response.body)
      expect(parsed_body["Branches"]).to include("master")
      expect(parsed_body["Tags"]).to include("v1.0.0")
      expect(parsed_body["Commits"]).to be_nil
    end

396
    it "gets a list of branches, tags and commits" do
397 398 399 400 401 402 403 404
      get :refs, namespace_id: public_project.namespace.path, id: public_project.path, ref: "123456"

      parsed_body = JSON.parse(response.body)
      expect(parsed_body["Branches"]).to include("master")
      expect(parsed_body["Tags"]).to include("v1.0.0")
      expect(parsed_body["Commits"]).to include("123456")
    end
  end
405
end