spec/controllers/projects_controller_spec.rb - master - kickrich/ProjectUniversityPractice

spec/controllers/projects_controller_spec.rb
260 строк9 KB
kickrich
add tests for projects controller and tasks controller
18 июл 2025, 01:43
18 июл 2025, 01:432c3bf7e
require "rails_helper"

RSpec.describe ProjectsController, type: :controller do
      let(:user) { create(:user) }
      let(:project) { create(:project, user: user) }
      let(:other_user) { create(:user) }
      let(:other_project) { create(:project, user: other_user) }
      let(:valid_attributes) { attributes_for(:project) }
      let(:new_attributes) { { name: 'Updated Project', description: 'Updated Description' } }
      let(:invalid_attributes) { { name: '' } }

      describe "GET #index" do
        subject { get :index, params: params }
        let(:params) { { search: nil } }

        describe "without login" do
          context "when user is not logged in" do
            it "redirects to login page" do
              subject
              expect(response).to redirect_to(new_user_session_path)
            end
          end
        end

        describe "with login" do
          before { sign_in user }

          context "when user is logged in" do
            it "returns a success response" do
              subject
              expect(response).to render_template(root_path)
            end
          end

          context "assigns the user's projects ordered by creation date" do
            let(:project1) { create(:project, user: user, created_at: 1.day.ago) }
            let(:project2) { create(:project, user: user, created_at: Time.current) }
            it "return projects in the correct sequence" do
              subject
              expect(assigns(:projects)).to eq([ project2, project1 ])
            end
          end

          context "when user search projects by name" do
            let(:project1) { create(:project, user: user, name: "Rails") }
            let(:project2) { create(:project, user: user, name: "React") }
            let(:params) { { search: "rails" } }
            it "filter projects by name" do
              subject
              expect(assigns(:projects)).to include(project1)
              expect(assigns(:projects)).not_to include(project2)
            end
          end

          context "user does not show other users project" do
            let!(:other_user_project) { create(:project) }
            it "does not see other users projects" do
              subject
              expect(assigns(:projects)).not_to include(other_user_project)
            end
          end

          context "with XSS-malicious search parameter" do
            let(:params) { { search: "<script>alert('xss')</script>" } }
            it "handles malicious parameter safely without errors" do
              expect { subject }.not_to raise_error
            end
          end

          context "with SQL-malicious in search parameter" do
            let(:params) { { search: "'; DROP TABLE projects; --" } }

            it "does not execute malicious SQL" do
              expect { subject }.not_to raise_error
              expect(assigns(:projects).to_sql).not_to include("DROP TABLE")
            end
          end
        end
      end

      describe "GET #show" do
        subject { get :show, params: params }
        before { sign_in user }

        context "with user's project" do
          let(:params) { { id: project.id } }
          it "redirects to projects index" do
            subject
            expect(response).to redirect_to(projects_path)
          end
        end

        context "with other user's project" do
          let(:params) { { id: other_project.id } }
          it "redirects to root if project doesn't belong to user" do
            subject
            expect(response).to redirect_to(root_path)
          end
        end
      end

      describe "GET #edit" do
        subject { get :edit, params: params }
        before { sign_in user }

        context "with user's project" do
          let(:params) { { id: project.id } }
          it "returns a success response" do
            subject
            expect(response).to be_successful
          end
        end

        context "with other user's project" do
          let(:params) { { id: other_project.id } }
           it "redirects to root if project doesn't belong to user" do
            subject
            expect(response).to redirect_to(root_path)
          end
        end

        context "when project doesn't exist" do
          let(:params) { { id: "0" } }
          it "redirects to root" do
            subject
            expect(response).to redirect_to(root_path)
          end
        end
      end

      describe "PUT #update" do
        subject { put :update, params: params }
        before { sign_in user }

        context "with valid params" do
          context "when user want to change project's params with new attributes" do
            let(:params) { { id: project.id, project: new_attributes } }
            it "updates the requested project" do
              subject
              project.reload
              expect(project.name).to eq('Updated Project')
              expect(project.description).to eq('Updated Description')
            end
          end

          context "when user want to change project's params with the same attributes" do
            let(:params) { { id: project.id, project: valid_attributes } }
            it "redirects to the projects list" do
              subject
              expect(response).to redirect_to(projects_path)
            end
          end

          context "when user want to change other user project" do
            let(:params) { { id: other_project.id, project: new_attributes } }
            it "redirects to root if project doesn't belong to user" do
              subject
              expect(response).to redirect_to(root_path)
            end
          end
        end

        context "with invalid params" do
          let(:params) { { id: project.id, project: invalid_attributes } }
          let(:original_name) { project.name }

          it "renders the 'edit' template" do
            subject
            expect(response).to render_template(:edit)
          end

          it "does not update the project" do
            subject
            project.reload
            expect(project.name).to eq(original_name)
          end
        end
      end

      describe "GET #new" do
        subject { get :new }
        before { sign_in user }

        it "returns a success response" do
          subject
          expect(response).to be_successful
        end

        it "assigns a new project for current user" do
          subject
          expect(assigns(:project)).to be_a_new(Project)
          expect(assigns(:project).user).to eq(user)
        end
      end

      describe "POST #create" do
        subject { post :create, params: params }
        before { sign_in user }

        context "with valid params" do
          let(:params) { { project: valid_attributes } }
          it "creates a new Project" do
            expect { subject }.to change(Project, :count).by(1)
          end

          it "redirects to the projects list" do
            subject
            expect(response).to redirect_to(projects_path)
          end

          it "sets the current user as project owner" do
            subject
            expect(Project.last.user).to eq(user)
          end
        end

        context "with invalid params" do
          let(:params) { { project: invalid_attributes } }
          it "does not create a new Project" do
            expect { subject }.not_to change(Project, :count)
          end

          it "renders the 'new' template" do
            subject
            expect(response).to render_template(:new)
          end
        end
      end

      describe "DELETE #destroy" do
        subject { delete :destroy, params: params }
        before { sign_in user }

        context "with current user's project" do
          let!(:project_to_delete) { create(:project, user: user) }
          let(:params) { { id: project_to_delete.id } }
          it "destroys the requested project" do
            expect { subject }.to change(Project, :count).by(-1)
          end

          it "redirects to the projects list" do
            subject
            expect(response).to redirect_to(projects_path)
          end
        end

        context "with other user's project" do
          let!(:other_user_project_to_delete) { create(:project, user: other_user) }
          let(:params) { { id: other_user_project_to_delete.id } }
          it "does not destroy other user's projects" do
            expect { subject }.not_to change(Project, :count)
          end

          it "redirects to root when trying to delete other user's project" do
            subject
            expect(response).to redirect_to(root_path)
          end
        end
      end
end