@@ -64,7 +73,7 @@ export const index = (req: Request, res: Response) => {
description
status TaskStatus
userId (FK → User)
- createdAt / updatedAt
+ created_at / updatedAt
@@ -84,13 +93,14 @@ export const index = (req: Request, res: Response) => {
Auth
- - POST /register
+ - GET /user
+ - POST /user
- POST /login
- - GET /validate
Tasks
- GET /tasks
+ - GET /tasks/:id
- POST /tasks
- PUT /tasks/:id
- DELETE /tasks/:id
diff --git a/src/controller/task.ts b/src/controller/task.ts
index 89bbc83..b21a49c 100644
--- a/src/controller/task.ts
+++ b/src/controller/task.ts
@@ -1,10 +1,14 @@
import { Response } from "express";
-import { Task } from "@/generated/client";
-import { idTaskSchema, taskSchema, updateTaskSchema } from "~/zod/taskSchema";
-import { AuthenticatedRequest } from "~/middleware/authenticate";
-import { canRequest } from "~/models/authorization";
-import { CustomResponse } from "~/models/customResponse";
-import { taskModel } from "~/models/task";
+import { Task } from "@/generated/client.js";
+import {
+ idTaskSchema,
+ taskSchema,
+ updateTaskSchema,
+} from "~/zod/taskSchema.js";
+import { AuthenticatedRequest } from "~/middleware/authenticate.js";
+import { canRequest } from "~/models/authorization.js";
+import { CustomResponse } from "~/models/customResponse.js";
+import { taskModel } from "~/models/task.js";
export const getAllTasks = async (req: AuthenticatedRequest, res: Response) => {
const response = new CustomResponse(res);
@@ -40,7 +44,10 @@ export const insertTask = async (req: AuthenticatedRequest, res: Response) => {
try {
const task = await taskModel.create(result.data, user.id);
- response.created(`Task ${task.id} adicionada com sucesso!`, task);
+ response.created({
+ message: `Task ${task.id} adicionada com sucesso!`,
+ data: task,
+ });
} catch (error) {
console.error("Erro ao inserir task: ", error);
response.internalServerError();
@@ -65,7 +72,10 @@ export const updateTask = async (req: AuthenticatedRequest, res: Response) => {
if (!userCanRequest(req, response, task)) return;
const updatedTask = await taskModel.update(taskId, result.data);
- response.created(`Task ${taskId} atualizada.`, updatedTask);
+ response.created({
+ message: `Task ${taskId} atualizada.`,
+ data: updatedTask,
+ });
} catch (error) {
console.error("Erro ao atualizar tasks: ", error);
response.internalServerError();
diff --git a/src/controller/user.ts b/src/controller/user.ts
index 3265551..1476d9c 100644
--- a/src/controller/user.ts
+++ b/src/controller/user.ts
@@ -1,13 +1,12 @@
import { Request, Response } from "express";
-import { loginSchema } from "~/zod/userSchema";
-import { registerSchema } from "~/zod/userSchema";
-import { AuthenticatedUser, validateSession } from "~/models/session";
-import { registerUser, login } from "~/models/user";
-import { CustomResponse } from "~/models/customResponse";
-import { CookieResponse } from "~/models/cookieResponse";
+import { loginSchema } from "~/zod/userSchema.js";
+import { registerSchema } from "~/zod/userSchema.js";
+import { AuthenticatedUser, validateSession } from "~/models/session.js";
+import { registerUser, login } from "~/models/user.js";
+import { CookieResponse } from "~/models/cookieResponse.js";
export const register = async (req: Request, res: Response) => {
- const response = new CustomResponse(res);
+ const response = new CookieResponse(res);
const result = registerSchema.safeParse(req.body);
if (result.error) {
@@ -17,7 +16,7 @@ export const register = async (req: Request, res: Response) => {
try {
const registeredUser = await registerUser(result.data);
- response.success({
+ response.created({
message: `Usuário '${registeredUser.name}' criado com sucesso!`,
});
} catch (error: any) {
@@ -29,14 +28,14 @@ export const register = async (req: Request, res: Response) => {
export const authentication = async (req: Request, res: Response) => {
const result = loginSchema.safeParse(req.body);
- const response = new CustomResponse(res);
+ const response = new CookieResponse(res);
if (result.error) {
response.badRequest(result.error);
return;
}
try {
const sessionObject = await login(result.data);
- if (!sessionObject.success) {
+ if (!sessionObject) {
response.unauthorized(
"Verifique os dados enviados e tente novamente",
"Email ou senha inválido",
@@ -44,8 +43,8 @@ export const authentication = async (req: Request, res: Response) => {
return;
}
- new CookieResponse(res).setCookie("session", sessionObject.session);
- response.success({ message: "Usuário autenticado!" });
+ new CookieResponse(res).setCookie("session", sessionObject.id);
+ response.created({ message: "Usuário autenticado!" });
} catch (error) {
console.error("Erro insperado ao efetuar login: ", error);
response.internalServerError();
diff --git a/src/index.ts b/src/index.ts
index 3f533ac..6ae84da 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,7 +1,7 @@
import express from "express";
import cors from "cors";
import cookieParser from "cookie-parser";
-import router from "~/router/router";
+import router from "~/router/router.js";
export const app = express();
app.use(cors({ credentials: true }));
diff --git a/src/infra/compose.yaml b/src/infra/compose.yaml
index d43d72a..99442a7 100644
--- a/src/infra/compose.yaml
+++ b/src/infra/compose.yaml
@@ -1,8 +1,10 @@
services:
database-task:
container_name: "postgres-task"
- image: "postgres:18-alpine3.22"
- env_file:
- - ../../.env
+ image: "postgres:17-alpine"
+ environment:
+ - POSTGRES_PASSWORD=local_password
+ - POSTGRES_USER=local_user
+ - POSTGRES_DB=local_db
ports:
- "5432:5432"
diff --git a/src/infra/database.ts b/src/infra/database.ts
index 65f9fac..a206f99 100644
--- a/src/infra/database.ts
+++ b/src/infra/database.ts
@@ -1,6 +1,6 @@
import { PrismaPg } from "@prisma/adapter-pg";
-import { PrismaClient } from "@/generated/client";
-import { env } from "~/config/env";
+import { PrismaClient } from "@/generated/client.js";
+import { env } from "~/config/env.js";
export const prisma = new PrismaClient({
adapter: new PrismaPg({ connectionString: env.DATABASE_URL }),
diff --git a/src/infra/scripts/migrator.ts b/src/infra/scripts/migrator.ts
new file mode 100644
index 0000000..eaf7249
--- /dev/null
+++ b/src/infra/scripts/migrator.ts
@@ -0,0 +1,9 @@
+import { runScript } from "./runScript.js";
+
+export async function resetDatabase() {
+ await runScript("migrations:reset");
+}
+
+export async function runPendingMigrations() {
+ await runScript("migrations:up");
+}
diff --git a/src/infra/scripts/runScript.ts b/src/infra/scripts/runScript.ts
new file mode 100644
index 0000000..d54a785
--- /dev/null
+++ b/src/infra/scripts/runScript.ts
@@ -0,0 +1,44 @@
+import { spawn } from "node:child_process";
+
+function npmBin() {
+ return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+
+function cleanServices(service: string) {
+ console.log(`Serviço '${service}' encerrado`);
+ const stopServices = spawn(npmBin(), ["run", "services:stop"], {
+ stdio: "inherit",
+ shell: true,
+ });
+ stopServices.on("exit", () => {
+ console.log("Serviços finalizados com sucesso!");
+ });
+}
+
+export function runScript(script: string, service?: string): Promise {
+ return new Promise((resolve, reject) => {
+ const runStartScript = spawn(npmBin(), ["run", script], {
+ shell: true,
+ stdio: "inherit",
+ });
+
+ runStartScript.on("error", (err) => {
+ reject(err);
+ });
+
+ runStartScript.on("exit", (code) => {
+ if (service) cleanServices(service);
+
+ if (code === 0) resolve();
+ else reject(new Error(`Script ${script} falhou com codigo ${code}`));
+ });
+
+ const handleSignal = (signal: NodeJS.Signals) => {
+ if (runStartScript.killed) return;
+ runStartScript.kill(signal);
+ };
+
+ process.on("SIGINT", () => handleSignal("SIGINT"));
+ process.on("SIGTERM", () => handleSignal("SIGTERM"));
+ });
+}
diff --git a/src/infra/scripts/wait-for-postgres.ts b/src/infra/scripts/wait-for-postgres.ts
index ff1cf6b..11791bb 100644
--- a/src/infra/scripts/wait-for-postgres.ts
+++ b/src/infra/scripts/wait-for-postgres.ts
@@ -1,17 +1,26 @@
import { exec } from "node:child_process";
+let attempts = 0;
+const MAX_ATTEMPTS = 30;
+
function checkPostgres() {
- exec("docker exec postgres-task pg_isready --host localhost", handleReturn);
- function handleReturn(error: any, stdout: any) {
- if (stdout.search("accepting connections") === -1) {
- process.stdout.write(".");
- checkPostgres();
- return;
+ exec("docker exec postgres-task pg_isready", (error, stdout) => {
+ attempts++;
+
+ if (stdout.includes("accepting connections")) {
+ console.log("\n✅ Postgres pronto para conexões!");
+ process.exit(0);
}
- console.log("\nPostgres pronto!\n");
- }
-}
-process.stdout.write("\n\nAguardando Postgres");
+ if (attempts >= MAX_ATTEMPTS) {
+ console.error("\n❌ Erro: O Postgres não ficou pronto a tempo.");
+ process.exit(1);
+ }
+
+ process.stdout.write(".");
+ setTimeout(checkPostgres, 1000);
+ });
+}
+process.stdout.write("\n⏳ Aguardando Postgres");
checkPostgres();
diff --git a/src/middleware/authenticate.ts b/src/middleware/authenticate.ts
index e36a07d..b8c863e 100644
--- a/src/middleware/authenticate.ts
+++ b/src/middleware/authenticate.ts
@@ -1,6 +1,6 @@
import { Request, Response, NextFunction } from "express";
-import { CookieResponse } from "~/models/cookieResponse";
-import { AuthenticatedUser, validateSession } from "~/models/session";
+import { CookieResponse } from "~/models/cookieResponse.js";
+import { AuthenticatedUser, validateSession } from "~/models/session.js";
export interface AuthenticatedRequest extends Request {
context?: {
diff --git a/src/models/cookieResponse.ts b/src/models/cookieResponse.ts
index 4209dbb..dde3c49 100644
--- a/src/models/cookieResponse.ts
+++ b/src/models/cookieResponse.ts
@@ -1,6 +1,6 @@
import { CookieOptions } from "express";
-import { CustomResponse } from "./customResponse";
-import { env } from "~/config/env";
+import { CustomResponse } from "./customResponse.js";
+import { env } from "~/config/env.js";
export class CookieResponse extends CustomResponse {
private cookieOptions: CookieOptions = {
diff --git a/src/models/customResponse.ts b/src/models/customResponse.ts
index 86e9a8d..7d06c61 100644
--- a/src/models/customResponse.ts
+++ b/src/models/customResponse.ts
@@ -44,18 +44,18 @@ export class CustomResponse {
badRequest(error: any) {
const errorMessage = this.errorHandler(error);
- this.response.status(400).json({ message: errorMessage });
+ this.response.status(400).json({ error: errorMessage });
}
success(data: object) {
this.response.status(200).json(data);
}
- created(message: string, data?: any) {
- this.response.status(201).json({ message, data });
+ created(data?: object) {
+ this.response.status(201).json(data);
}
noContent() {
- this.response.status(204);
+ this.response.status(204).json();
}
}
diff --git a/src/models/password.ts b/src/models/password.ts
index 5a7a276..a34ff02 100644
--- a/src/models/password.ts
+++ b/src/models/password.ts
@@ -1,5 +1,5 @@
import { hash, compare } from "bcrypt";
-import { env } from "~/config/env";
+import { env } from "~/config/env.js";
export const hashPassword = async (password: string) => {
const salt = genSalt();
diff --git a/src/models/session.ts b/src/models/session.ts
index e96ab12..9bd3d69 100644
--- a/src/models/session.ts
+++ b/src/models/session.ts
@@ -1,12 +1,12 @@
import { randomUUID } from "node:crypto";
-import { env } from "~/config/env";
-import { prisma } from "~/infra/database";
+import { env } from "~/config/env.js";
+import { prisma } from "~/infra/database.js";
export const createSession = async (userId: string) => {
const sessionId = randomUUID();
const now = new Date();
- await prisma.userSession.create({
+ const session = await prisma.userSession.create({
data: {
id: sessionId,
user_id: userId,
@@ -14,7 +14,7 @@ export const createSession = async (userId: string) => {
last_active_at: now,
},
});
- return sessionId;
+ return session;
};
export const validateSession = async (sessionId: string) => {
@@ -43,8 +43,8 @@ export const validateSession = async (sessionId: string) => {
data: { last_active_at: now },
});
- const { email, id, name, createdAt, updatedAt } = userDb;
- const secureObjectValue = { id, email, name, createdAt, updatedAt };
+ const { email, id, name, created_at, updated_at } = userDb;
+ const secureObjectValue = { id, email, name, created_at, updated_at };
return secureObjectValue;
};
@@ -52,6 +52,8 @@ export type AuthenticatedUser = {
id: string;
email: string;
name: string;
- createdAt: Date;
- updatedAt: Date;
+ created_at: Date;
+ updated_at: Date;
};
+
+export type UserSession = Awaited>;
diff --git a/src/models/task.ts b/src/models/task.ts
index 13f9da2..8008149 100644
--- a/src/models/task.ts
+++ b/src/models/task.ts
@@ -1,6 +1,6 @@
-import { TaskDelegate } from "@/generated/models";
-import { prisma } from "~/infra/database";
-import { Task as TaskEnt, UpdateTask } from "~/zod/taskSchema";
+import { TaskDelegate } from "@/generated/models.js";
+import { prisma } from "~/infra/database.js";
+import { Task as TaskEnt, UpdateTask } from "~/zod/taskSchema.js";
class TaskModel {
private model: TaskDelegate;
diff --git a/src/models/user.ts b/src/models/user.ts
index 52b14a2..03eec83 100644
--- a/src/models/user.ts
+++ b/src/models/user.ts
@@ -1,7 +1,7 @@
-import { LoginInput, UserInput } from "~/zod/userSchema";
-import { createSession } from "~/models/session";
-import { comparePassword, hashPassword } from "./password";
-import { prisma } from "~/infra/database";
+import { LoginInput, UserInput } from "~/zod/userSchema.js";
+import { createSession } from "~/models/session.js";
+import { comparePassword, hashPassword } from "./password.js";
+import { prisma } from "~/infra/database.js";
export const registerUser = async (userInputValues: UserInput) => {
const password = await hashPassword(userInputValues.password);
@@ -13,29 +13,21 @@ export const registerUser = async (userInputValues: UserInput) => {
};
export const login = async (userInputValues: LoginInput) => {
- const result = {
- session: null,
- success: false,
- };
-
const user = await prisma.user.findUnique({
where: { email: userInputValues.email },
});
- if (!user) {
- return result;
- }
+ if (!user) return false;
const isValid = await comparePassword(
userInputValues.password,
user.password,
);
- if (!isValid) {
- return result;
- }
+ if (!isValid) return false;
const session = await createSession(user.id);
+ if (!session) return false;
- return { session, success: true };
+ return session;
};
diff --git a/src/router/router.ts b/src/router/router.ts
index 666096b..58e5234 100644
--- a/src/router/router.ts
+++ b/src/router/router.ts
@@ -1,9 +1,9 @@
import { Router } from "express";
-import { index } from "~/controller";
-import * as userCtrl from "~/controller/user";
-import * as taskCtrl from "~/controller/task";
+import { index } from "~/controller/index.js";
+import * as userCtrl from "~/controller/user.js";
+import * as taskCtrl from "~/controller/task.js";
-import { authenticate } from "~/middleware/authenticate";
+import { authenticate } from "~/middleware/authenticate.js";
const router = Router();
diff --git a/src/server.ts b/src/server.ts
index c610667..d50e695 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -1,3 +1,3 @@
-import { app } from ".";
+import { app } from "./index.js";
app.listen(5001, () => console.log("🚀 Servidor on na porta 5001"));
diff --git a/src/zod/taskSchema.ts b/src/zod/taskSchema.ts
index ff00716..2f74a87 100644
--- a/src/zod/taskSchema.ts
+++ b/src/zod/taskSchema.ts
@@ -4,7 +4,7 @@ z.config(pt());
export const taskSchema = z.object({
title: z.string("Coluna 'title' é obrigatório!"),
- description: z.string("coluna 'description' é obrigatória!"),
+ description: z.string("Coluna 'description' é obrigatória!"),
status: z.enum(["pending", "in_progress", "done"]).optional(),
});
diff --git a/src/zod/userSchema.ts b/src/zod/userSchema.ts
index 694a52a..40b4f24 100644
--- a/src/zod/userSchema.ts
+++ b/src/zod/userSchema.ts
@@ -6,12 +6,12 @@ export const registerSchema = z.object({
name: z
.string("Nome é obrigatório.")
.min(3, "Nome deve ter no mínimo 3 caracteres.")
- .max(20, "Nome deve ter no máximo 20 caracteres."),
+ .max(30, "Nome deve ter no máximo 30 caracteres."),
email: z.email("Email não enviado ou inválido."),
password: z
.string("Senha é obrigátoria.")
.min(8, "Senha deve ter no mínimo 8 caracteres.")
- .max(15, "Senha deve ter no máximo 15 caracteres."),
+ .max(60, "Senha deve ter no máximo 60 caracteres."),
});
export type UserInput = z.infer;
diff --git a/tests/controller/task/delete.test.ts b/tests/controller/task/delete.test.ts
new file mode 100644
index 0000000..3f73c0a
--- /dev/null
+++ b/tests/controller/task/delete.test.ts
@@ -0,0 +1,122 @@
+import { UserSession } from "@/generated/client.js";
+import { AuthenticatedUser } from "~/models/session.js";
+import {
+ API,
+ createSession,
+ createTask,
+ createUser,
+ waitForAllServices,
+} from "$/orchestrator.js";
+
+beforeAll(async () => {
+ await waitForAllServices();
+});
+
+describe("DELETE `/tasks`", () => {
+ test("Sem usuário logado", async () => {
+ const fakeTaskId = crypto.randomUUID();
+
+ const response = await fetch(`${API.task}/${fakeTaskId}`, {
+ method: "DELETE",
+ });
+
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(401);
+
+ const responseBody = await response.json();
+ expect(responseBody).toEqual({
+ message: "Não autorizado.",
+ action: "Faça o login.",
+ });
+ });
+
+ let defaultUser: AuthenticatedUser;
+ let defaultSession: UserSession;
+ test("Com usuário logado porém `task` com ID inválido", async () => {
+ const idInvalido = "id-no-formato-invalido";
+ defaultUser = await createUser();
+ defaultSession = await createSession(defaultUser);
+ const response = await fetch(`${API.task}/${idInvalido}`, {
+ method: "DELETE",
+ headers: {
+ Cookie: `session=${defaultSession.id}`,
+ },
+ });
+
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(400);
+
+ const responseBody = await response.json();
+ expect(responseBody).toEqual({
+ error: "Id da task deve ser do tipo UUID.",
+ });
+ });
+
+ test("Com usuário logado porém `task` com ID válido porém inexistente no banco", async () => {
+ const fakeTaskId = crypto.randomUUID();
+
+ const response = await fetch(`${API.task}/${fakeTaskId}`, {
+ method: "DELETE",
+ headers: {
+ Cookie: `session=${defaultSession.id}`,
+ },
+ });
+
+ expect(response.ok).toBe(true);
+ expect(response.status).toBe(204);
+ });
+
+ test("Com usuário logado e `task` com ID existente", async () => {
+ const task = await createTask(
+ {
+ title: "Teste deletar",
+ description: "Enviando uma task existente para deletar!",
+ },
+ defaultUser,
+ );
+
+ const response = await fetch(`${API.task}/${task.id}`, {
+ method: "DELETE",
+ headers: {
+ Cookie: `session=${defaultSession.id}`,
+ },
+ });
+
+ expect(response.ok).toBe(true);
+ expect(response.status).toBe(200);
+
+ const responseBody = await response.json();
+ expect(responseBody).toEqual({
+ message: `Task ${task.id} deletada com sucesso!`,
+ });
+ });
+
+ test("Com um usuário tentando excluir `task` de outro usuário", async () => {
+ const task = await createTask(
+ {
+ title: "Task do usuário padrão",
+ description:
+ "Enviando uma task existente para outro usuário tentar deletar!",
+ },
+ defaultUser,
+ );
+
+ const otherUser = await createUser();
+ const otherSession = await createSession(otherUser);
+
+ const response = await fetch(`${API.task}/${task.id}`, {
+ method: "DELETE",
+ headers: {
+ Cookie: `session=${otherSession.id}`,
+ },
+ });
+
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(403);
+
+ const responseBody = await response.json();
+ expect(responseBody).toEqual({
+ message: "Voce não tem permissão executar essa ação.",
+ });
+ });
+});
diff --git a/tests/controller/task/get.test.ts b/tests/controller/task/get.test.ts
new file mode 100644
index 0000000..19f0ba2
--- /dev/null
+++ b/tests/controller/task/get.test.ts
@@ -0,0 +1,123 @@
+import { Task, UserSession } from "@/generated/client.js";
+import { AuthenticatedUser } from "~/models/session.js";
+import {
+ API,
+ createSession,
+ createTask,
+ createUser,
+ waitForAllServices,
+} from "$/orchestrator.js";
+
+beforeAll(async () => {
+ await waitForAllServices();
+});
+
+let newUser: AuthenticatedUser;
+let session: UserSession;
+let newTask: Task;
+describe("GET `/tasks`", () => {
+ test("Sem usuário logado", async () => {
+ const response = await fetch(API.task);
+
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(401);
+
+ const responseBody = await response.json();
+ expect(responseBody).toEqual({
+ message: "Não autorizado.",
+ action: "Faça o login.",
+ });
+ });
+
+ test("Com usuário logado porém sem `tasks` no banco", async () => {
+ newUser = await createUser();
+ session = await createSession(newUser);
+
+ const response = await fetch(API.task, {
+ headers: {
+ Cookie: `session=${session.id}`,
+ },
+ });
+
+ expect(response.ok).toBe(true);
+ expect(response.status).toBe(204);
+ });
+
+ test("Com usuário logado e uma `task` no banco", async () => {
+ const task = {
+ title: "Teste um",
+ description: "Testa se a API devolverá essa task",
+ };
+ newTask = await createTask(task, newUser);
+
+ const response = await fetch(API.task, {
+ headers: {
+ Cookie: `session=${session.id}`,
+ },
+ });
+
+ expect(response.ok).toBe(true);
+ expect(response.status).toBe(200);
+
+ const responseBody = await response.json();
+ expect(Array.isArray(responseBody.data)).toBe(true);
+ expect(responseBody.data[0]).toEqual({
+ ...newTask,
+ created_at: newTask.created_at.toISOString(),
+ updated_at: newTask.updated_at.toISOString(),
+ });
+ expect(responseBody.message).toContain("1");
+ });
+});
+
+describe("GET `/tasks/:id`", () => {
+ test("Sem usuário logado", async () => {
+ const response = await fetch(`${API.task}/${newTask.id}`);
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(401);
+
+ const responseBody = await response.json();
+ expect(responseBody).toEqual({
+ action: "Faça o login.",
+ message: "Não autorizado.",
+ });
+ });
+
+ test("Com usuário logado", async () => {
+ const response = await fetch(`${API.task}/${newTask.id}`, {
+ headers: {
+ Cookie: `session=${session.id}`,
+ },
+ });
+ expect(response.ok).toBe(true);
+ expect(response.status).toBe(200);
+
+ const responseBody = await response.json();
+ expect(responseBody).toEqual({
+ task: {
+ ...newTask,
+ created_at: newTask.created_at.toISOString(),
+ updated_at: newTask.updated_at.toISOString(),
+ },
+ });
+ });
+
+ test("Com um usuário tentando buscar de outro usuário", async () => {
+ const otherUser = await createUser();
+ const otherSession = await createSession(otherUser);
+
+ const response = await fetch(`${API.task}/${newTask.id}`, {
+ headers: {
+ Cookie: `session=${otherSession.id}`,
+ },
+ });
+
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(403);
+
+ const responseBody = await response.json();
+ expect(responseBody).toEqual({
+ message: "Voce não tem permissão executar essa ação.",
+ });
+ });
+});
diff --git a/tests/controller/task/patch.test.ts b/tests/controller/task/patch.test.ts
new file mode 100644
index 0000000..dc7f0f3
--- /dev/null
+++ b/tests/controller/task/patch.test.ts
@@ -0,0 +1,182 @@
+import {
+ API,
+ createSession,
+ createTask,
+ createUser,
+ waitForAllServices,
+} from "$/orchestrator.js";
+import { AuthenticatedUser, UserSession } from "~/models/session.js";
+
+beforeAll(async () => {
+ await waitForAllServices();
+});
+
+describe("PATCH `/tasks/:id`", () => {
+ test("Sem usuário logado", async () => {
+ const fakeTaskId = crypto.randomUUID();
+
+ const taskForUpdate = {
+ title: "Atualização da task sem usuário",
+ description: "O sistema deve bloquear essa ação!",
+ };
+
+ const response = await fetch(`${API.task}/${fakeTaskId}`, {
+ method: "PATCH",
+ body: JSON.stringify(taskForUpdate),
+ headers: {
+ "Content-Type": "application/json",
+ },
+ });
+
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(401);
+
+ const responseBody = await response.json();
+ expect(responseBody).toEqual({
+ message: "Não autorizado.",
+ action: "Faça o login.",
+ });
+ });
+
+ let defaultUser: AuthenticatedUser;
+ let defaultSession: UserSession;
+ test("Com usuário logado porém `task` com `ID` inválido", async () => {
+ defaultUser = await createUser();
+ defaultSession = await createSession(defaultUser);
+ const invalidId = "id-no-formato-invalido";
+
+ const taskForUpdate = {
+ title: "Atualização com ID inválido",
+ description: "O sistema deve bloquear essa ação!",
+ };
+
+ const response = await fetch(`${API.task}/${invalidId}`, {
+ method: "PATCH",
+ body: JSON.stringify(taskForUpdate),
+ headers: {
+ "Content-Type": "application/json",
+ Cookie: `session=${defaultSession.id}`,
+ },
+ });
+
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(400);
+
+ const responseBody = await response.json();
+ expect(responseBody).toEqual({
+ error: "Id da task deve ser do tipo UUID.",
+ });
+ });
+
+ test("Com usuário logado porém `task` com `ID` inexistente no banco", async () => {
+ const fakeTaskId = crypto.randomUUID();
+
+ const taskForUpdate = {
+ title: "Atualização da task sem usuário",
+ description: "O sistema deve bloquear essa ação!",
+ };
+
+ const response = await fetch(`${API.task}/${fakeTaskId}`, {
+ method: "PATCH",
+ body: JSON.stringify(taskForUpdate),
+ headers: {
+ "Content-Type": "application/json",
+ Cookie: `session=${defaultSession.id}`,
+ },
+ });
+
+ expect(response.ok).toBe(true);
+ expect(response.status).toBe(204);
+ });
+
+ test("Com usuário logado e `task` com `ID` existente no banco", async () => {
+ const task = {
+ title: "Atualização da task",
+ description: "O sistema deve aceitar essa ação!",
+ };
+ const taskForUpdate = await createTask(task, defaultUser);
+
+ const response = await fetch(`${API.task}/${taskForUpdate.id}`, {
+ method: "PATCH",
+ body: JSON.stringify({
+ title: "Task atualizada!",
+ description: "O sistema aceitou a atualização!",
+ status: "done",
+ }),
+ headers: {
+ "Content-Type": "application/json",
+ Cookie: `session=${defaultSession.id}`,
+ },
+ });
+
+ expect(response.ok).toBe(true);
+ expect(response.status).toBe(201);
+
+ const responseBody = await response.json();
+ expect(responseBody.data.title).not.toBe(task.title);
+ expect(responseBody.data.description).not.toBe(task.description);
+ expect(new Date(responseBody.data.updated_at).getTime()).toBeGreaterThan(
+ new Date(responseBody.data.created_at).getTime(),
+ );
+ });
+
+ test("Com usuário logado e `task` com `status` inexistente", async () => {
+ const task = {
+ title: "Atualização da task",
+ description: "O sistema deve aceitar essa ação!",
+ };
+
+ const taskForUpdate = await createTask(task, defaultUser);
+
+ const response = await fetch(`${API.task}/${taskForUpdate.id}`, {
+ method: "PATCH",
+ body: JSON.stringify({
+ status: "este_status_nao_existe",
+ }),
+ headers: {
+ "Content-Type": "application/json",
+ Cookie: `session=${defaultSession.id}`,
+ },
+ });
+
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(400);
+
+ const responseBody = await response.json();
+ expect(responseBody).toEqual({
+ error: 'Opção inválida: esperada uma das "pending"|"in_progress"|"done"',
+ });
+ });
+
+ test("Com um usuário tentando alterar `task` de outro usuário", async () => {
+ const task = {
+ title: "Criação da task",
+ description: "O sistema deve aceitar essa ação!",
+ };
+
+ const taskForUpdate = await createTask(task, defaultUser);
+
+ const otherUser = await createUser();
+ const otherSession = await createSession(otherUser);
+
+ const response = await fetch(`${API.task}/${taskForUpdate.id}`, {
+ method: "PATCH",
+ body: JSON.stringify({
+ title: "Alterado por outro usuário?",
+ description: "O sistema não pode aceitar esta ação!",
+ }),
+ headers: {
+ "Content-Type": "application/json",
+ Cookie: `session=${otherSession.id}`,
+ },
+ });
+
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(403);
+
+ const responseBody = await response.json();
+ expect(responseBody).toEqual({
+ message: "Voce não tem permissão executar essa ação.",
+ });
+ });
+});
diff --git a/tests/controller/task/post.test.ts b/tests/controller/task/post.test.ts
new file mode 100644
index 0000000..7b3f49b
--- /dev/null
+++ b/tests/controller/task/post.test.ts
@@ -0,0 +1,163 @@
+import {
+ API,
+ createSession,
+ createUser,
+ waitForAllServices,
+} from "$/orchestrator.js";
+import { AuthenticatedUser, UserSession } from "~/models/session.js";
+
+beforeAll(async () => {
+ await waitForAllServices();
+});
+
+describe("POST `/tasks`", () => {
+ test("Sem usuário logado", async () => {
+ const response = await fetch(API.task, {
+ method: "POST",
+ body: JSON.stringify({
+ title: "Usuário sem sessão",
+ description: "O sistema deve bloquear esta ação!",
+ }),
+ });
+
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(401);
+
+ const responseBody = await response.json();
+ expect(responseBody).toEqual({
+ message: "Não autorizado.",
+ action: "Faça o login.",
+ });
+ });
+
+ let defaultUser: AuthenticatedUser;
+ let defaultSession: UserSession;
+ test("Com usuário logado e todos os dados corretos", async () => {
+ const newTask = {
+ title: "Task com usuário logado",
+ description: "O sistema deve aceitar esta ação!",
+ status: "in_progress",
+ };
+
+ defaultUser = await createUser();
+ defaultSession = await createSession(defaultUser);
+
+ const response = await fetch(API.task, {
+ method: "POST",
+ body: JSON.stringify(newTask),
+ headers: {
+ "Content-Type": "application/json",
+ Cookie: `session=${defaultSession.id}`,
+ },
+ });
+
+ expect(response.ok).toBe(true);
+ expect(response.status).toBe(201);
+
+ const responseBody = await response.json();
+ expect(responseBody).toHaveProperty("message");
+ expect(responseBody.data).toHaveProperty(
+ "description",
+ newTask.description,
+ );
+ expect(responseBody.data).toHaveProperty("title", newTask.title);
+ expect(responseBody.data).toHaveProperty("id");
+ expect(responseBody.data).toHaveProperty("created_at");
+ expect(responseBody.data).toHaveProperty("updated_at");
+ expect(responseBody.data).toHaveProperty("status");
+ expect(responseBody.data.user_id).toBe(defaultUser.id);
+ });
+
+ test("Com usuário logado e sem a propriedade `title`", async () => {
+ const newTaskWithNoTitle = {
+ description: "O sistema deve negar esta ação!",
+ };
+
+ const response = await fetch(API.task, {
+ method: "POST",
+ body: JSON.stringify(newTaskWithNoTitle),
+ headers: {
+ "Content-Type": "application/json",
+ Cookie: `session=${defaultSession.id}`,
+ },
+ });
+
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(400);
+
+ const responseBody = await response.json();
+ expect(responseBody).toHaveProperty("error");
+
+ expect(responseBody.error).toBe("Coluna 'title' é obrigatório!");
+ });
+
+ test("Com usuário logado e sem a propriedade `description`", async () => {
+ const newTaskWithNoDescription = {
+ title: "Bad request!",
+ };
+
+ const response = await fetch(API.task, {
+ method: "POST",
+ body: JSON.stringify(newTaskWithNoDescription),
+ headers: {
+ "Content-Type": "application/json",
+ Cookie: `session=${defaultSession.id}`,
+ },
+ });
+
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(400);
+
+ const responseBody = await response.json();
+ expect(responseBody).toHaveProperty("error");
+
+ expect(responseBody.error).toBe("Coluna 'description' é obrigatória!");
+ });
+
+ test("Com usuário logado e sem as propriedades `title` e `description`", async () => {
+ const emptyObject = {};
+
+ const response = await fetch(API.task, {
+ method: "POST",
+ body: JSON.stringify(emptyObject),
+ headers: {
+ "Content-Type": "application/json",
+ Cookie: `session=${defaultSession.id}`,
+ },
+ });
+
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(400);
+
+ const responseBody = await response.json();
+ expect(responseBody).toHaveProperty("error");
+
+ expect(responseBody.error).toBe(
+ "Coluna 'title' é obrigatório! | Coluna 'description' é obrigatória!",
+ );
+ });
+
+ test("Com usuário logado e com `status` inválido", async () => {
+ const newTaskWithInvalidStatus = {
+ title: "Tarefa com status invalido",
+ description: "O sistema deve obrigatóriamente bloquear esta ação.",
+ status: "status_inválido",
+ };
+ const response = await fetch(API.task, {
+ method: "POST",
+ body: JSON.stringify(newTaskWithInvalidStatus),
+ headers: {
+ "Content-Type": "application/json",
+ Cookie: `session=${defaultSession.id}`,
+ },
+ });
+
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(400);
+
+ const responseBody = await response.json();
+ expect(responseBody).toEqual({
+ error: 'Opção inválida: esperada uma das "pending"|"in_progress"|"done"',
+ });
+ });
+});
diff --git a/tests/controller/user/get.test.ts b/tests/controller/user/get.test.ts
new file mode 100644
index 0000000..efbea10
--- /dev/null
+++ b/tests/controller/user/get.test.ts
@@ -0,0 +1,122 @@
+import {
+ API,
+ createSession,
+ createUser,
+ waitForAllServices,
+} from "$/orchestrator.js";
+
+import { env } from "~/config/env.js";
+
+beforeAll(async () => {
+ await waitForAllServices();
+});
+
+describe("GET `/user`", () => {
+ beforeEach(() => {
+ vi.useFakeTimers();
+ });
+
+ afterEach(() => {
+ vi.useRealTimers();
+ });
+
+ test("Sem sessão vinculada", async () => {
+ const response = await fetch(API.user);
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(401);
+
+ const responseBody = await response.json();
+ expect(responseBody).toEqual({
+ message: "Não autorizado.",
+ action: "Verifique se está logado e tente novamente.",
+ });
+ });
+
+ test("Com Sessão vinculada", async () => {
+ const newUser = await createUser();
+ const session = await createSession(newUser);
+ const response = await fetch(API.user, {
+ headers: {
+ Cookie: `session=${session.id}`,
+ },
+ });
+
+ expect(response.ok).toBe(true);
+ expect(response.status).toBe(200);
+
+ const responseBody = await response.json();
+ expect(responseBody).toEqual({
+ user: {
+ id: newUser.id,
+ name: newUser.name,
+ email: newUser.email,
+ created_at: newUser.created_at.toISOString(),
+ updated_at: newUser.updated_at.toISOString(),
+ },
+ });
+ });
+
+ test("Com sessão quase expirada", async () => {
+ const horaAtual = new Date();
+ const horaSessaoExpirada = new Date(
+ horaAtual.getTime() - env.INACTIVITY_TIMEOUT / 2,
+ );
+ vi.setSystemTime(horaSessaoExpirada);
+
+ const newUser = await createUser();
+ const session = await createSession(newUser);
+
+ vi.useRealTimers();
+ const response = await fetch(API.user, {
+ headers: {
+ Cookie: `session=${session.id}`,
+ },
+ });
+
+ expect(response.ok).toBe(true);
+ expect(response.status).toBe(200);
+
+ const responseBody = await response.json();
+ expect(responseBody).toEqual({
+ user: {
+ id: newUser.id,
+ name: newUser.name,
+ email: newUser.email,
+ created_at: newUser.created_at.toISOString(),
+ updated_at: newUser.updated_at.toISOString(),
+ },
+ });
+
+ expect(new Date(session.expires_at).getTime()).greaterThan(
+ horaAtual.getTime(),
+ );
+ expect(session.created_at.getTime()).toBeLessThan(horaAtual.getTime());
+ });
+
+ test("Com sessão expirada", async () => {
+ const horaAtual = new Date();
+ const horaSessaoExpirada = new Date(
+ horaAtual.getTime() - env.INACTIVITY_TIMEOUT,
+ );
+ vi.setSystemTime(horaSessaoExpirada);
+
+ const newUser = await createUser();
+ const session = await createSession(newUser);
+
+ vi.useRealTimers();
+ const response = await fetch(API.user, {
+ headers: {
+ Cookie: `session=${session.id}`,
+ },
+ });
+
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(401);
+
+ const responseBody = await response.json();
+ expect(responseBody).toEqual({
+ message: "Sessão inválida ou expirada.",
+ action: "Por favor, realize o login novamente.",
+ });
+ });
+});
diff --git a/tests/controller/user/post.test.ts b/tests/controller/user/post.test.ts
new file mode 100644
index 0000000..a7dff01
--- /dev/null
+++ b/tests/controller/user/post.test.ts
@@ -0,0 +1,172 @@
+import { API, clearDatabase, waitForAllServices } from "$/orchestrator.js";
+import crypto from "node:crypto";
+
+beforeAll(async () => {
+ await waitForAllServices();
+});
+
+describe("POST `/user`", () => {
+ test("Com todos os dados corretos", async () => {
+ const userData = {
+ name: "Teste Usuario",
+ email: "email@teste.com",
+ password: "senha@teste",
+ };
+
+ const response = await fetch(API.user, {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify(userData),
+ });
+
+ expect(response.ok).toBe(true);
+ expect(response.status).toBe(201);
+ const responseBody = await response.json();
+
+ expect(responseBody).toHaveProperty("message");
+ expect(responseBody.message).toContain(userData.name);
+ });
+
+ test("Com `email` inválido", async () => {
+ const userData = {
+ name: "Email Inválido",
+ email: "emailnaovalido",
+ password: "email@invalido",
+ };
+
+ const response = await fetch(API.user, {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify(userData),
+ });
+
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(400);
+
+ const responseBody = await response.json();
+ expect(responseBody).toHaveProperty("error");
+ expect(responseBody).toEqual({ error: "Email não enviado ou inválido." });
+ });
+
+ test("Com `nome` excedendo 30 caracteres", async () => {
+ const userData = {
+ name: "Nome do Usuario Muito Grande e Inválido ",
+ email: "nome@invalido.com",
+ password: "nome-invalido",
+ };
+
+ const response = await fetch(API.user, {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify(userData),
+ });
+
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(400);
+
+ const responseBody = await response.json();
+ expect(responseBody).toHaveProperty("error");
+ expect(responseBody).toEqual({
+ error: "Nome deve ter no máximo 30 caracteres.",
+ });
+ });
+
+ test("Com `senha` excedendo 60 caracteres", async () => {
+ const password = crypto.randomBytes(31).toString("hex"); //gera um string de 62 caracteres
+
+ const userData = {
+ name: "Com Senha Inválida ",
+ email: "senha@invalida.com",
+ password,
+ };
+
+ const response = await fetch(API.user, {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify(userData),
+ });
+
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(400);
+
+ const responseBody = await response.json();
+ expect(responseBody).toHaveProperty("error");
+ expect(responseBody).toEqual({
+ error: "Senha deve ter no máximo 60 caracteres.",
+ });
+ });
+
+ test("Sem a propriedade `name`", async () => {
+ const userData = {
+ email: "usuario@sem-nome.com",
+ password: "semNomeDeUsuario",
+ };
+
+ const response = await fetch(API.user, {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify(userData),
+ });
+
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(400);
+
+ const responseBody = await response.json();
+ expect(responseBody).toHaveProperty("error");
+ expect(responseBody).toEqual({ error: "Nome é obrigatório." });
+ });
+
+ test("Sem a propriedade `email`", async () => {
+ const userData = {
+ name: "Usuario Sem Email",
+ password: "semNomeDeUsuario",
+ };
+
+ const response = await fetch(API.user, {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify(userData),
+ });
+
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(400);
+
+ const responseBody = await response.json();
+ expect(responseBody).toHaveProperty("error");
+ expect(responseBody).toEqual({ error: "Email não enviado ou inválido." });
+ });
+
+ test("Sem a propriedade `password`", async () => {
+ const userData = {
+ name: "Usuario Sem Senha",
+ email: "usuario@sem-senha.com",
+ };
+
+ const response = await fetch(API.user, {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify(userData),
+ });
+
+ expect(response.ok).toBe(false);
+ expect(response.status).toBe(400);
+
+ const responseBody = await response.json();
+ expect(responseBody).toHaveProperty("error");
+ expect(responseBody).toEqual({ error: "Senha é obrigátoria." });
+ });
+});
diff --git a/tests/orchestrator.ts b/tests/orchestrator.ts
new file mode 100644
index 0000000..0f3473c
--- /dev/null
+++ b/tests/orchestrator.ts
@@ -0,0 +1,51 @@
+import retry from "async-retry";
+import { faker } from "@faker-js/faker";
+import { resetDatabase } from "~/infra/scripts/migrator.js";
+import { registerUser } from "~/models/user.js";
+import { UserInput } from "~/zod/userSchema.js";
+import * as session from "~/models/session.js";
+import { taskModel } from "~/models/task.js";
+import { Task } from "~/zod/taskSchema.js";
+
+const apiBaseUrl = "http://localhost:5001";
+
+export const API = {
+ user: `${apiBaseUrl}/user`,
+ login: `${apiBaseUrl}/login`,
+ task: `${apiBaseUrl}/tasks`,
+};
+
+export async function waitForAllServices() {
+ await waitForWebServer();
+
+ async function waitForWebServer() {
+ return retry(fetchIndexPage, {
+ retries: 100,
+ maxTimeout: 1000,
+ });
+ }
+ async function fetchIndexPage() {
+ const response = await fetch(apiBaseUrl);
+ if (response.status !== 200) throw Error();
+ }
+}
+
+export async function clearDatabase() {
+ await resetDatabase();
+}
+
+export async function createUser(userValues?: UserInput) {
+ return await registerUser({
+ name: userValues?.name ?? faker.person.fullName(),
+ email: userValues?.email ?? faker.internet.email(),
+ password: userValues?.password ?? "ValidPassword",
+ });
+}
+
+export async function createSession(user: session.AuthenticatedUser) {
+ return await session.createSession(user.id);
+}
+
+export async function createTask(task: Task, user: session.AuthenticatedUser) {
+ return await taskModel.create(task, user.id);
+}
diff --git a/tsconfig.json b/tsconfig.json
index 6954797..b47a199 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -14,10 +14,11 @@
"rootDir": ".",
"paths": {
"~/*": ["./src/*"],
- "@/*": ["./prisma/*"]
+ "@/*": ["./prisma/*"],
+ "$/*": ["./tests/*"]
},
- "types": ["node"]
+ "types": ["node", "vitest/globals"]
},
- "include": ["src/**/*"],
+ "include": ["src", "tests", "prisma"],
"exclude": ["node_modules", "dist"]
}
diff --git a/vitest.config.ts b/vitest.config.ts
new file mode 100644
index 0000000..3699152
--- /dev/null
+++ b/vitest.config.ts
@@ -0,0 +1,18 @@
+import { defineConfig } from "vitest/config";
+import path from "path";
+
+export default defineConfig({
+ test: {
+ alias: {
+ "~": path.resolve(__dirname, "./src"),
+ "@": path.resolve(__dirname, "./prisma"),
+ $: path.resolve(__dirname, "./tests"),
+ },
+ testTimeout: 60_000,
+ environment: "node",
+ globals: true,
+ pool: "threads",
+ maxConcurrency: 1,
+ exclude: ["node_modules", "dist", ".idea", ".git", ".cache"],
+ },
+});