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

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

RSpec.describe TasksController, type: :controller do
  let(:user) { create(:user) }
  let(:other_user) { create(:user) }
  let(:project) { create(:project, user: user) }
  let(:other_project) { create(:project, user: other_user) }
  let(:task) { create(:task, project: project) }
  let(:other_task) { create(:task, project: other_project) }
  let(:valid_attributes) { attributes_for(:task) }
  let(:new_attributes) { { title: 'Updated Task', description: 'Updated Description' } }
  let(:invalid_attributes) { { title: '' } }

  describe "GET #index" do
    subject { get :index, params: params }
    let(:params) { { project_id: project.id } }

    describe "without login" do
      it "redirects to login page" do
        subject
        expect(response).to redirect_to(new_user_session_path)
      end
    end

    describe "with login" do
      before { sign_in user }

      context "with user's project" do
        it "returns a success response" do
          subject
          expect(response).to be_successful
        end

        it "groups tasks by status" do
          create(:task, project: project, status: "To Do")
          create(:task, project: project, status: "In Progress")
          subject
          expect(assigns(:tasks_by_status).keys).to include("To Do", "In Progress")
        end

        it "sets available statuses" do
          subject
          expect(assigns(:statuses)).to eq([ "To Do", "In Progress", "In Testing", "Rejected", "Done" ])
        end
      end

      context "with other user's project" do
        let(:params) { { project_id: other_project.id } }

        it "redirects to root path" do
          subject
          expect(response).to redirect_to(root_path)
        end
      end
    end
  end

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

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

    context "with other user's task" do
      let(:params) { { project_id: other_project.id, id: other_task.id } }

      it "redirects to root path" do
        subject
        expect(response).to redirect_to(root_path)
      end
    end
  end

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

    context "with current user's project" do
      let(:params) { { project_id: project.id } }
      it "redirect to project tasks path" do
        subject
        expect(response).to redirect_to(project_tasks_path)
      end
    end

    context "with other user's project" do
      let(:params) { { project_id: other_project.id } }
      it "redirect to root path" do
        subject
        expect(response).to redirect_to(root_path)
      end
    end
  end

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

    context "with valid params" do
      let(:params) { { project_id: project.id, task: valid_attributes } }

      it "creates a new Task" do
        expect { subject }.to change(Task, :count).by(1)
      end

      it "sets default status to 'To Do'" do
        subject
        expect(Task.last.status).to eq("To Do")
      end

      it "redirects to project tasks path" do
        subject
        expect(response).to redirect_to(project_tasks_path(project))
      end
    end

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

      it "does not create a new Task" do
        expect { subject }.not_to change(Task, :count)
      end

      it "redirects to project tasks path" do
        subject
        expect(response).to redirect_to(project_tasks_path(project))
      end
    end

    context "with other user's project" do
      let(:params) { { project_id: other_project.id, task: valid_attributes } }

      it "does not create a task" do
        expect { subject }.not_to change(Task, :count)
      end

      it "redirects to root path" do
        subject
        expect(response).to redirect_to(root_path)
      end
    end
  end

  describe "GET #edit" do
    subject { get :edit, params: params }
    let(:params) { { project_id: project.id, id: task.id } }
    before { sign_in user }

    it "redirected to project tasks path" do
      subject
      expect(response).to redirect_to(project_tasks_path)
    end

    context "with other user's task" do
      let(:params) { { project_id: other_project.id, id: other_task.id } }

      it "redirects to root path" 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
      let(:params) { { project_id: project.id, id: task.id, task: new_attributes } }

      it "updates the requested task" do
        subject
        task.reload
        expect(task.title).to eq('Updated Task')
        expect(task.description).to eq('Updated Description')
      end

      it "redirects to project tasks path" do
        subject
        expect(response).to redirect_to(project_tasks_path(project))
      end
    end

    context "with invalid params" do
      let(:params) { { project_id: project.id, id: task.id, task: invalid_attributes } }
      let(:original_title) { task.title }

      it "does not update the task" do
        subject
        task.reload
        expect(task.title).to eq(original_title)
      end
    end

    context "with other user's task" do
      let(:params) { { project_id: other_project.id, id: other_task.id, task: new_attributes } }
      let(:original_title) { other_task.title }

      it "does not update the task" do
        subject
        other_task.reload
        expect(other_task.title).to eq(original_title)
      end

      it "redirects to root path" do
        subject
        expect(response).to redirect_to(root_path)
      end
    end
  end

  describe "DELETE #destroy" do
    subject { delete :destroy, params: params }
    let(:params) { { project_id: project.id, id: task.id } }

    before { sign_in user }

    context "with user's task" do
      let!(:task) { create(:task, project: project) }

      it "destroys the requested task" do
        expect { subject }.to change(Task, :count).by(-1)
      end

      it "redirects to project tasks path" do
        subject
        expect(response).to redirect_to(project_tasks_path(project))
      end
    end

    context "with other user's task" do
      let(:params) { { project_id: other_project.id, id: other_task.id } }
      let!(:other_task) { create(:task, project: other_project) }

      it "does not destroy the task" do
        expect { subject }.not_to change(Task, :count)
      end

      it "redirects to root path" do
        subject
        expect(response).to redirect_to(root_path)
      end
    end
  end

  describe "PATCH #update_status" do
    subject { patch :update_status, params: params, format: :json }
    before { sign_in user }

    context "with valid status transition" do
      let(:task) { create(:task, project: project, status: "To Do") }
      let(:params) { { project_id: project.id, id: task.id, task: { status: "In Progress" } } }

      it "updates the task status" do
        subject
        task.reload
        expect(task.status).to eq("In Progress")
      end

      it "returns success response" do
        subject
        expect(response).to have_http_status(:ok)
      end
    end

    context "with invalid status transition" do
      let(:task) { create(:task, project: project, status: "To Do") }
      let(:params) { { project_id: project.id, id: task.id, task: { status: "Done" } } }

      it "does not update the task status" do
        subject
        task.reload
        expect(task.status).to eq("To Do")
      end

      it "returns unprocessable_entity response" do
        subject
        expect(response).to have_http_status(:unprocessable_entity)
      end
    end

    context "with same status" do
      let(:task) { create(:task, project: project, status: "To Do") }
      let(:params) { { project_id: project.id, id: task.id, task: { status: "To Do" } } }

      it "returns ok response with message" do
        subject
        expect(response).to have_http_status(:ok)
      end
    end

    context "with other user's task" do
      let(:other_task) { create(:task, project: other_project, status: "To Do") }
      let(:params) { { project_id: other_project.id, id: other_task.id, task: { status: "In Progress" } } }

      it "does not update the task status" do
        subject
        other_task.reload
        expect(other_task.status).to eq("To Do")
      end

      it "redirects to root path" do
        subject
        expect(response).to redirect_to(root_path)
      end
    end
  end
end