BigW Consortium Gitlab

projects_controller_spec.rb 12.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
  describe "GET show" do
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
    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
27
            expect(assigns(:notification_setting).level).to eq("global")
28 29 30 31 32 33
          end
        end

        context "and has notification setting" do
          before do
            setting = user.notification_settings_for(public_project)
34
            setting.level = :watch
35 36 37 38 39
            setting.save
          end

          it "shows current notification setting" do
            get :show, namespace_id: public_project.namespace.path, id: public_project.path
40
            expect(assigns(:notification_setting).level).to eq("watch")
41 42 43
          end
        end
      end
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83

      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
84
    end
85

86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
    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

106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
    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

128 129
    context "rendering default project view" do
      render_views
130

131
      it "renders the activity view" do
132 133
        allow(controller).to receive(:current_user).and_return(user)
        allow(user).to receive(:project_view).and_return('activity')
134

135 136 137 138
        get :show, namespace_id: public_project.namespace.path, id: public_project.path
        expect(response).to render_template('_activity')
      end

139
      it "renders the readme view" do
140 141
        allow(controller).to receive(:current_user).and_return(user)
        allow(user).to receive(:project_view).and_return('readme')
142

143 144 145 146
        get :show, namespace_id: public_project.namespace.path, id: public_project.path
        expect(response).to render_template('_readme')
      end

147
      it "renders the files view" do
148 149
        allow(controller).to receive(:current_user).and_return(user)
        allow(user).to receive(:project_view).and_return('files')
150

151 152 153 154
        get :show, namespace_id: public_project.namespace.path, id: public_project.path
        expect(response).to render_template('_files')
      end
    end
155

156
    context "when requested with case sensitive namespace and project path" do
157 158 159
      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
160

161
          expect(assigns(:project)).to eq(public_project)
162
          expect(response).to have_http_status(200)
163
        end
164 165
      end

166 167 168 169 170 171 172 173
      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

174
        # MySQL queries are case insensitive by default, so this spec would fail.
175
        if Gitlab::Database.postgresql?
176 177
          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) }
178

179 180 181 182
            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)
183
              expect(response).to have_http_status(200)
184
            end
185 186
          end
        end
187 188
      end
    end
189 190

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

193
      it 'expects an error creating the project' do
194
        expect(public_project_with_dot_atom).not_to be_valid
195 196
      end
    end
197 198 199 200 201 202 203 204 205 206 207

    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
208
  end
209

210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
  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)
228
      expect(response).to have_http_status(200)
229 230 231
    end
  end

232 233 234 235 236 237 238 239 240 241 242
  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)
243
      expect(response).to have_http_status(302)
244 245
      expect(response).to redirect_to(dashboard_projects_path)
    end
246

Katarzyna Kobierska committed
247
    context "when the project is forked" do
248 249 250
      let(:project)      { create(:project) }
      let(:fork_project) { create(:project, forked_from_project: project) }
      let(:merge_request) do
251 252 253
        create(:merge_request,
          source_project: fork_project,
          target_project: project)
254 255 256
      end

      it "closes all related merge requests" do
257 258
        project.merge_requests << merge_request
        sign_in(admin)
259

260 261 262
        delete :destroy, namespace_id: fork_project.namespace.path, id: fork_project.path

        expect(merge_request.reload.state).to eq('closed')
263 264
      end
    end
265 266
  end

Ciro Santilli committed
267
  describe "POST #toggle_star" do
268
    it "toggles star if user is signed in" do
Ciro Santilli committed
269
      sign_in(user)
270
      expect(user.starred?(public_project)).to be_falsey
271 272
      post(:toggle_star,
           namespace_id: public_project.namespace.to_param,
Vinnie Okada committed
273
           id: public_project.to_param)
274
      expect(user.starred?(public_project)).to be_truthy
275 276
      post(:toggle_star,
           namespace_id: public_project.namespace.to_param,
Vinnie Okada committed
277
           id: public_project.to_param)
278
      expect(user.starred?(public_project)).to be_falsey
Ciro Santilli committed
279 280 281
    end

    it "does nothing if user is not signed in" do
282 283
      post(:toggle_star,
           namespace_id: project.namespace.to_param,
Vinnie Okada committed
284
           id: public_project.to_param)
285
      expect(user.starred?(public_project)).to be_falsey
286 287
      post(:toggle_star,
           namespace_id: project.namespace.to_param,
Vinnie Okada committed
288
           id: public_project.to_param)
289
      expect(user.starred?(public_project)).to be_falsey
Ciro Santilli committed
290 291
    end
  end
292

Douwe Maan committed
293
  describe "DELETE remove_fork" do
294 295 296 297 298 299 300 301
    context 'when signed in' do
      before do
        sign_in(user)
      end

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

302
        before do
303
          create(:forked_project_link, forked_to_project: project_fork)
304 305
        end

306
        it 'removes fork from project' do
307
          delete(:remove_fork,
308 309 310 311
              namespace_id: project_fork.namespace.to_param,
              id: project_fork.to_param, format: :js)

          expect(project_fork.forked?).to be_falsey
Douwe Maan committed
312
          expect(flash[:notice]).to eq('The fork relationship has been removed.')
313 314 315 316
          expect(response).to render_template(:remove_fork)
        end
      end

317 318
      context 'when project not forked' do
        let(:unforked_project) { create(:project, namespace: user.namespace) }
319

320
        it 'does nothing if project was not forked' do
321 322 323 324 325 326 327
          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
328 329 330 331
      end
    end

    it "does nothing if user is not signed in" do
332
      delete(:remove_fork,
333 334
          namespace_id: project.namespace.to_param,
          id: project.to_param, format: :js)
335
      expect(response).to have_http_status(401)
336 337
    end
  end
338 339

  describe "GET refs" do
340
    it "gets a list of branches and tags" do
341 342 343 344 345 346 347 348
      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

349
    it "gets a list of branches, tags and commits" do
350 351 352 353 354 355 356 357
      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
358
end