api/tests: fix ava loading paths & add/rework user specs

Pedro Lucas Porcellis porcellis@eletrotupi.com 2 months ago 1d108862effda2b34ab10ccce2ba8799782afec0

Parents: ad58511

7 file(s) changed

api/ava.config.mjs +8 -17
api/tests/database-auth.test.ts +6 -0
api/tests/users/create.test.ts +125 -0
api/tests/users/delete.test.ts +58 -0
api/tests/users/fetch.test.ts +68 -0
api/tests/users/update.test.ts +85 -0
api/tsconfig.test.json +15 -0

api/ava.config.mjs

@@ -1,27 +1,19 @@
    export default {
  -   "typescript": {
  -     "extensions": [
  -       "ts",
  -       "tsx"
  -     ],
  -     "rewritePaths": {
  -       "src/": "dist/"
  -     },
  -     compile: false
  +   extensions: {
  +     ts: 'commonjs'
      },
  -  // extensions: {
  -  //   ts: 'module'
  -  // },
  -  // nodeArguments: [
  -  //   '--import=tsx'
  -  // ],
  +   nodeArguments: [
  +     '--require=tsx/cjs',
  +     '--require=tsconfig-paths/register'
  +   ],
      files: [
        'tests/**/*.test.ts'
      ],
      environmentVariables: {
  -     NODE_ENV: 'test'
  +     NODE_ENV: 'test',
  +     TS_NODE_PROJECT: './tsconfig.json'
      },
      timeout: '30s',
      concurrency: 1, // Run tests serially to avoid database conflicts
      verbose: true
  - };
  + };

api/tests/database-auth.test.ts

@@ -24,6 +24,12 @@ }
    });
    
    test.after.always(async () => {
  +   const deleteUsers = prisma.user.deleteMany();
  + 
  +   await prisma.$transaction([
  +     deleteUsers
  +   ])
  + 
      await prisma?.$disconnect();
    });
    

api/tests/users/create.test.ts

@@ -0,0 +1,125 @@
  + import test from "ava";
  + import { PrismaClient } from '@prisma/client';
  + import { PrismaPg } from '@prisma/adapter-pg';
  + import request from 'supertest';
  + import jwt from 'jsonwebtoken';
  + import 'dotenv/config';
  + import { Express } from 'express';
  + import { createApp } from '../../src/createApp';
  + 
  + let prisma: PrismaClient;
  + let app: Express;
  + 
  + test.before(() => {
  +   process.env.NODE_ENV = 'test';
  +   process.env.JWT_SECRET = 'test-secret-key';
  + 
  +   const connectionString = process.env.DATABASE_URL || 'postgres://user:password@orbit_db:5432/orbit_test';
  +   const adapter = new PrismaPg({ connectionString });
  +   prisma = new PrismaClient({ adapter });
  + 
  +   // Create Express app with test Prisma client
  +   app = createApp(prisma);
  + });
  + 
  + test.beforeEach(async () => {
  +   // Clean database before each test
  +   try {
  +     await prisma.user.deleteMany({});
  +   } catch (err) {
  +     console.error('Error cleaning test DB:', err);
  +   }
  + });
  + 
  + test.after.always(async () => {
  +   await prisma?.$disconnect();
  + });
  + 
  + test("POST /users creates a new user and returns JWT token", async (t) => {
  +   const userData = {
  +     email: "falamansa@example.com",
  +     firstName: "Fala",
  +     lastName: "Mansa",
  +     password: "IscreviSeuNomeNaAreia"
  +   };
  + 
  +   const response = await request(app)
  +     .post('/users')
  +     .send(userData)
  +     .expect('Content-Type', /json/)
  +     .expect(201);
  + 
  +   // Should return a JWT token
  +   t.truthy(response.body.token);
  + 
  +   // Verify the token is valid
  +   const decoded = jwt.verify(response.body.token, process.env.JWT_SECRET!) as any;
  +   t.is(decoded.email, userData.email);
  +   t.truthy(decoded.userId);
  + 
  +   // Verify user was created in database
  +   const dbUser = await prisma.user.findUnique({
  +     where: { email: userData.email }
  +   });
  +   t.truthy(dbUser);
  +   t.is(dbUser!.email, userData.email);
  +   t.is(dbUser!.firstName, userData.firstName);
  +   t.is(dbUser!.lastName, userData.lastName);
  + });
  + 
  + test("POST /users returns 400 for missing required fields", async (t) => {
  +   const response = await request(app)
  +     .post('/users')
  +     .send({
  +       email: "invalid@example.com"
  +       // Missing firstName and password
  +     })
  +     .expect('Content-Type', /json/)
  +     .expect(400);
  + 
  +   t.truthy(response.body.error);
  +   t.is(response.body.error, "Campos faltantes"); // TODO: i18n?
  +   t.truthy(response.body.missing);
  +   t.true(response.body.missing.includes('password'));
  +   t.true(response.body.missing.includes('firstName'));
  + });
  + 
  + test("POST /users returns 409 for duplicate email", async (t) => {
  +   const email = "duplicate@example.com";
  + 
  +   // Create first user
  +   await prisma.user.create({
  +     data: {
  +       email,
  +       firstName: "First",
  +       lastName: "User",
  +       encryptedPassword: "$2a$10$test"
  +     }
  +   });
  + 
  +   // Try to create second user with same email
  +   const response = await request(app)
  +     .post('/users')
  +     .send({
  +       email,
  +       firstName: "Second",
  +       lastName: "User",
  +       password: "hunter2"
  +     })
  +     .expect('Content-Type', /json/)
  +     .expect(409);
  + 
  +   t.truthy(response.body.error);
  + });
  + 
  + test("createApp successfully integrates with Prisma and Express", async (t) => {
  +   // Test that the app factory works correctly
  +   const testApp = createApp(prisma);
  + 
  +   t.truthy(testApp);
  +   t.is(typeof testApp.use, 'function');
  +   t.is(typeof testApp.listen, 'function');
  + 
  +   // Verify the app has the prisma client in locals
  +   t.is(testApp.locals.prisma, prisma);
  + });

api/tests/users/delete.test.ts

@@ -0,0 +1,58 @@
  + import test from "ava";
  + import { PrismaClient } from '@prisma/client';
  + import { PrismaPg } from '@prisma/adapter-pg';
  + import request from 'supertest';
  + import bcrypt from 'bcryptjs';
  + import 'dotenv/config';
  + import { Express } from 'express';
  + import { createApp } from '../../src/createApp';
  + 
  + let prisma: PrismaClient;
  + let app: Express;
  + 
  + test.before(() => {
  +   process.env.NODE_ENV = 'test';
  + 
  +   const connectionString = process.env.DATABASE_URL || 'postgres://user:password@orbit_db:5432/orbit_test';
  +   const adapter = new PrismaPg({ connectionString });
  +   prisma = new PrismaClient({ adapter });
  + 
  +   // Create Express app with test Prisma client
  +   app = createApp(prisma);
  + });
  + 
  + test.beforeEach(async () => {
  +   // Clean database before each test
  +   try {
  +     await prisma.user.deleteMany({});
  +   } catch (err) {
  +     console.error('Error cleaning test DB:', err);
  +   }
  + });
  + 
  + test.after.always(async () => {
  +   await prisma?.$disconnect();
  + });
  + 
  + //test("DELETE /users/:id deletes a user", async (t) => {
  + //  t.pass()
  + //  // Create a user first
  + //  const user = await prisma.user.create({
  + //    data: {
  + //      email: "delete@example.com",
  + //      firstName: "Delete",
  + //      lastName: "Me",
  + //      encryptedPassword: bcrypt.hashSync("password", 10)
  + //    }
  + //  });
  + //
  + //  await request(app)
  + //    .delete(`/users/${user.id}`)
  + //    .expect(204);
  + //
  + //  // Verify user was deleted
  + //  const dbUser = await prisma.user.findUnique({
  + //    where: { id: user.id }
  + //  });
  + //  t.is(dbUser, null);
  + //});

api/tests/users/fetch.test.ts

@@ -0,0 +1,68 @@
  + import test from "ava";
  + import { PrismaClient } from '@prisma/client';
  + import { PrismaPg } from '@prisma/adapter-pg';
  + import request from 'supertest';
  + import bcrypt from 'bcryptjs';
  + import 'dotenv/config';
  + import { Express } from 'express';
  + import { createApp } from '../../src/createApp';
  + 
  + let prisma: PrismaClient;
  + let app: Express;
  + 
  + test.before(() => {
  +   process.env.NODE_ENV = 'test';
  + 
  +   const connectionString = process.env.DATABASE_URL || 'postgres://user:password@orbit_db:5432/orbit_test';
  +   const adapter = new PrismaPg({ connectionString });
  +   prisma = new PrismaClient({ adapter });
  + 
  +   // Create Express app with test Prisma client
  +   app = createApp(prisma);
  + });
  + 
  + test.beforeEach(async () => {
  +   // Clean database before each test
  +   try {
  +     await prisma.user.deleteMany({});
  +   } catch (err) {
  +     console.error('Error cleaning test DB:', err);
  +   }
  + });
  + 
  + test.after.always(async () => {
  +   await prisma?.$disconnect();
  + });
  + 
  + //test("GET /users/:id retrieves a user", async (t) => {
  + //  t.pass()
  + //  // Create a user first
  + //  const user = await prisma.user.create({
  + //    data: {
  + //      email: "get@example.com",
  + //      firstName: "Get",
  + //      lastName: "User",
  + //      encryptedPassword: bcrypt.hashSync("password", 10)
  + //    }
  + //  });
  + //
  + //  const response = await request(app)
  + //    .get(`/users/${user.id}`)
  + //    .expect('Content-Type', /json/)
  + //    .expect(200);
  + //
  + //  t.is(response.body.id, user.id);
  + //  t.is(response.body.email, user.email);
  + //  t.is(response.body.firstName, user.firstName);
  + //  t.is(response.body.lastName, user.lastName);
  + //  t.falsy(response.body.encryptedPassword); // Should not expose password
  + //});
  + //
  + //test("GET /users/:id returns 404 for non-existent user", async (t) => {
  + //  const response = await request(app)
  + //    .get('/users/999999')
  + //    .expect('Content-Type', /json/)
  + //    .expect(404);
  + //
  + //  t.truthy(response.body.error);
  + //});

api/tests/users/update.test.ts

@@ -0,0 +1,85 @@
  + import test from "ava";
  + import { PrismaClient } from '@prisma/client';
  + import { PrismaPg } from '@prisma/adapter-pg';
  + import request from 'supertest';
  + import bcrypt from 'bcryptjs';
  + import 'dotenv/config';
  + import { Express } from 'express';
  + import { createApp } from '../../src/createApp';
  + 
  + let prisma: PrismaClient;
  + let app: Express;
  + 
  + test.before(() => {
  +   process.env.NODE_ENV = 'test';
  + 
  +   const connectionString = process.env.DATABASE_URL || 'postgres://user:password@orbit_db:5432/orbit_test';
  +   const adapter = new PrismaPg({ connectionString });
  +   prisma = new PrismaClient({ adapter });
  + 
  +   // Create Express app with test Prisma client
  +   app = createApp(prisma);
  + });
  + 
  + test.beforeEach(async () => {
  +   // Clean database before each test
  +   try {
  +     await prisma.user.deleteMany({});
  +   } catch (err) {
  +     console.error('Error cleaning test DB:', err);
  +   }
  + });
  + 
  + test.after.always(async () => {
  +   await prisma?.$disconnect();
  + });
  + 
  + test("PUT /users/:id updates user profile", async (t) => {
  +   // Create a user first
  +   const user = await prisma.user.create({
  +     data: {
  +       email: "update@example.com",
  +       firstName: "Original",
  +       lastName: "Name",
  +       encryptedPassword: bcrypt.hashSync("password", 10)
  +     }
  +   });
  + 
  +   const updateData = {
  +     firstName: "Updated",
  +     lastName: "Profile"
  +   };
  + 
  +   // TODO: Gotta check why its failing. Most likely due to the
  +   // cors/credentials: true line
  +   const response = await request(app)
  +     .put(`/users/${user.id}`)
  +     .send(updateData)
  +     .expect('Content-Type', /json/)
  +     .expect(200);
  + 
  +   t.is(response.body.user.firstName, updateData.firstName);
  +   t.is(response.body.user.lastName, updateData.lastName);
  +   t.is(response.body.user.email, user.email); // Should remain unchanged
  + 
  +   // Verify in database
  +   const dbUser = await prisma.user.findUnique({
  +     where: { id: user.id }
  +   });
  + 
  +   t.is(dbUser!.firstName, updateData.firstName);
  +   t.is(dbUser!.lastName, updateData.lastName);
  + });
  + 
  + test("PUT /users/:id returns 404 for non-existent user", async (t) => {
  +   const response = await request(app)
  +     .put('/users/999999')
  +     .send({
  +       firstName: "Updated",
  +       lastName: "Name"
  +     })
  +     .expect('Content-Type', /json/)
  +     .expect(404);
  + 
  +   t.truthy(response.body.error);
  + });

api/tsconfig.test.json

@@ -0,0 +1,16 @@
  + {
  +   "extends": "./tsconfig.json",
  +   "compilerOptions": {
  +     "module": "ESNext",
  +     "moduleResolution": "node",
  +     "allowImportingTsExtensions": true,
  +     "resolveJsonModule": true,
  +     "noEmit": true
  +   },
  +   "ts-node": {
  +     "esm": true,
  +     "experimentalSpecifierResolution": "node",
  +     "transpileOnly": true,
  +     "require": ["tsconfig-paths/register"]
  +   }
  + }