@anthonylzq/simba.js 7.2.0 → 8.0.0

package/lib/src/functions/tests.js

@@ -2,7 +2,6 @@ const { platform } = require('os')
 const { promisify } = require('util')
 const exec = promisify(require('child_process').exec)
 const writeFile = require('../utils/writeFile')
-const { ENVIRONMENTS_WITH_DB_URI } = require('../utils/constants')
 
 /**
  * @param {Object} args
@@ -13,7 +12,6 @@ const { ENVIRONMENTS_WITH_DB_URI } = require('../utils/constants')
  */
 module.exports = async ({ projectName, graphql, dbIsSQL }) => {
   const createFoldersCommand = `mkdir ${projectName}/test`
-  const dbURI = dbIsSQL ? process.env.DB_URI : process.env.MONGO_URI
 
   if (platform() === 'win32')
     await exec(createFoldersCommand.replaceAll('/', '\\'))
@@ -28,7 +26,6 @@ const config: Config.InitialOptions = {
   preset: 'ts-jest',
   testEnvironment: 'node',
   testTimeout: 1 * 60 * 1000,
-  globalSetup: './test/jestGlobalSetup.ts',
   modulePaths: ['<rootDir>/src', '<rootDir>/node_modules'],
   roots: ['.'],
   moduleFileExtensions: ['js', 'json', 'ts'],
@@ -46,32 +43,18 @@ export default config
       index: {
         content: graphql
           ? `import axios from 'axios'
-import { Static, TObject, TProperties, Type } from '@sinclair/typebox'
-import Ajv from 'ajv'
-import addFormats from 'ajv-formats'
+import z from 'zod'
 
 import { Server } from '../src/network'
 import { userDto } from '../src/schemas'
 
-const ajv = addFormats(new Ajv(), ['email'])
-  .addKeyword('kind')
-  .addKeyword('modifier')
-
-const BASE_URL = 'http://localhost:${process.env.PORT || 1996}'
-const validator = <T extends TProperties>(
-  schema: TObject<T>,
-  object: unknown
-) => {
-  const validate = ajv.compile(schema)
-
-  return validate(object)
-}
-const baseResponseDto = Type.Object({
-  error: Type.Boolean(),
-  message: Type.String()
+const BASE_URL = \`http://localhost:\${process.env.PORT || 1996}\`
+const baseResponseDto = z.object({
+  error: z.boolean(),
+  message: z.string()
 })
 
-type BaseResponseDTO = Static<typeof baseResponseDto>
+type BaseResponseDTO = z.infer<typeof baseResponseDto>
 
 describe('Simba.js tests', () => {
   beforeAll(async () => {
@@ -82,40 +65,28 @@ describe('Simba.js tests', () => {
     let userID = ${dbIsSQL ? 0 : "''"}
 
     describe('API: GET /', () => {
-      let data: BaseResponseDTO
-
-      test('Should return 200 as status code', async () => {
+      it('Should return 200 with a successful operation', async () => {
         const result = await axios.get<BaseResponseDTO>(BASE_URL)
 
-        data = result.data
         expect(result.status).toBe(200)
-      })
-
-      test('Should be a successfully operation', () => {
-        expect(data.error).toBe(false)
-      })
-
-      test('Should be return baseResponseDto', () => {
-        expect(validator(baseResponseDto, data)).toBe(true)
+        expect(result.data.error).toBe(false)
+        expect(baseResponseDto.parse(result.data).error).toBe(false)
       })
     })
 
     describe('API: storeUser mutation', () => {
-      const storeUserResponse = Type.Object({
-        data: Type.Object({
+      const storeUserResponse = z.object({
+        data: z.object({
           user: userDto
         })
       })
 
-      type StoreUserDTO = Static<typeof storeUserResponse>
-
-      let data: StoreUserDTO
-      let status: number
+      type StoreUserDTO = z.infer<typeof storeUserResponse>
 
-      test('Should return 200 as status code', async () => {
-        const result = await axios.post<StoreUserDTO>(\`\${BASE_URL}/api\`, {
-          query: \`mutation storeUser($user: StoreUserInput!) {
-            user: storeUser(user: $user) {
+      it('Should create a user successfully', async () => {
+        const result = await axios.post<StoreUserDTO>(\`\${BASE_URL}/graphql\`, {
+          query: \`mutation store($user: UserInput!) {
+            user: store(user: $user) {
               id
               name
               lastName
@@ -131,68 +102,26 @@ describe('Simba.js tests', () => {
           }
         })
 
-        data = result.data
-        status = result.status
         userID = result.data.data.user.id ?? userID
-        expect(status).toBe(200)
-      })
-
-      test('Should return storeUserResponse', () => {
-        expect(validator(storeUserResponse, data)).toBe(true)
-      })
-    })
-
-    describe('API: getUsers query', () => {
-      const getUsersResponse = Type.Object({
-        data: Type.Object({
-          users: Type.Array(userDto)
-        })
-      })
-
-      type GetAllUsersDTO = Static<typeof getUsersResponse>
-
-      let data: GetAllUsersDTO
-      let status: number
-
-      test('Should return 200 as status code', async () => {
-        const result = await axios.post<GetAllUsersDTO>(\`\${BASE_URL}/api\`, {
-          query: \`query getUsers {
-            users: getUsers {
-              id
-              name
-              lastName
-              createdAt
-              updatedAt
-            }
-          }\`
-        })
-
-        data = result.data
-        status = result.status
-        expect(status).toBe(200)
-      })
-
-      test('Should return getUsersResponse', () => {
-        expect(validator(getUsersResponse, data)).toBe(true)
+        expect(userID).toBeTruthy()
+        expect(result.status).toBe(200)
+        expect(storeUserResponse.safeParse(result.data).success).toBe(true)
       })
     })
 
     describe('API: getUser query', () => {
-      const getUserResponse = Type.Object({
-        data: Type.Object({
+      const getUserResponse = z.object({
+        data: z.object({
           user: userDto
         })
       })
 
-      type GetOneUserDTO = Static<typeof getUserResponse>
+      type GetOneUserDTO = z.infer<typeof getUserResponse>
 
-      let data: GetOneUserDTO
-      let status: number
-
-      test('Should return 200 as status code', async () => {
-        const result = await axios.post<GetOneUserDTO>(\`\${BASE_URL}/api\`, {
-          query: \`query getUser($id: ${dbIsSQL ? 'Int' : 'ID'}!) {
-            user: getUser(id: $id) {
+      it('Should return a user', async () => {
+        const result = await axios.post<GetOneUserDTO>(\`\${BASE_URL}/graphql\`, {
+          query: \`query getById($id: ${dbIsSQL ? 'Float' : 'String'}!) {
+            user: getById(id: $id) {
               id
               name
               lastName
@@ -205,32 +134,26 @@ describe('Simba.js tests', () => {
           }
         })
 
-        data = result.data
-        status = result.status
-        expect(status).toBe(200)
-      })
-
-      test('Should return getOneUserResponse', () => {
-        expect(validator(getUserResponse, data)).toBe(true)
+        expect(result.status).toBe(200)
+        expect(getUserResponse.safeParse(result.data).success).toBe(true)
       })
     })
 
     describe('API: updateUser mutation', () => {
-      const updateUserResponse = Type.Object({
-        data: Type.Object({
+      const updateUserResponse = z.object({
+        data: z.object({
           user: userDto
         })
       })
 
-      type UpdateUserDTO = Static<typeof updateUserResponse>
+      type UpdateUserDTO = z.infer<typeof updateUserResponse>
 
-      let data: UpdateUserDTO
-      let status: number
-
-      test('Should return 200 as status code', async () => {
-        const result = await axios.post<UpdateUserDTO>(\`\${BASE_URL}/api\`, {
-          query: \`mutation updateUser($user: UpdateUserInput!) {
-            user: updateUser(user: $user) {
+      it('Should update a user successfully', async () => {
+        const result = await axios.post<UpdateUserDTO>(\`\${BASE_URL}/graphql\`, {
+          query: \`mutation update($id: ${
+            dbIsSQL ? 'Float' : 'String'
+          }!, $user: UserInput!) {
+            user: update(id: $id, user: $user) {
               id
               name
               lastName
@@ -239,100 +162,40 @@ describe('Simba.js tests', () => {
             }
           }\`,
           variables: {
+            id: userID,
             user: {
-              id: userID,
               lastName: 'Luzquiños',
               name: 'Anthony'
             }
           }
         })
 
-        data = result.data
-        status = result.status
-        expect(status).toBe(200)
-      })
-
-      test('Should return updateUserResponse', () => {
-        expect(validator(updateUserResponse, data)).toBe(true)
+        expect(result.status).toBe(200)
+        expect(updateUserResponse.safeParse(result.data).success).toBe(true)
       })
     })
 
     describe('API: deleteUser mutation', () => {
-      const deleteUserResponse = Type.Object({
-        data: Type.Object({
-          result: Type.String()
+      const deleteUserResponse = z.object({
+        data: z.object({
+          result: z.string()
         })
       })
 
-      type DeleteUserDTO = Static<typeof deleteUserResponse>
-
-      let data: DeleteUserDTO
-      let status: number
+      type DeleteUserDTO = z.infer<typeof deleteUserResponse>
 
-      test('Should return 200 as status code', async () => {
-        const result = await axios.post<DeleteUserDTO>(\`\${BASE_URL}/api\`, {
-          query: \`mutation deleteUser($id: ${dbIsSQL ? 'Int' : 'ID'}!) {
-            result: deleteUser(id: $id)
+      it('Should delete the created user', async () => {
+        const result = await axios.post<DeleteUserDTO>(\`\${BASE_URL}/graphql\`, {
+          query: \`mutation deleteById($id: ${dbIsSQL ? 'Float' : 'String'}!) {
+            result: deleteById(id: $id)
           }\`,
           variables: {
             id: userID
           }
         })
 
-        data = result.data
-        status = result.status
-        expect(status).toBe(200)
-      })
-
-      test('Should return deleteUserResponse', () => {
-        expect(validator(deleteUserResponse, data)).toBe(true)
-      })
-    })
-
-    describe('API: deleteAllUsers mutation', () => {
-      const deleteAllUserResponse = Type.Object({
-        data: Type.Object({
-          result: Type.String()
-        })
-      })
-
-      type DeleteAllUsersDTO = Static<typeof deleteAllUserResponse>
-
-      let data: DeleteAllUsersDTO
-      let status: number
-
-      test('Should return 200 as status code', async () => {
-        await axios.post(\`\${BASE_URL}/api\`, {
-          query: \`mutation storeUser($user: StoreUserInput!) {
-            user: storeUser(user: $user) {
-              id
-              name
-              lastName
-              createdAt
-              updatedAt
-            }
-          }\`,
-          variables: {
-            user: {
-              lastName: 'Lzq',
-              name: 'Anthony'
-            }
-          }
-        })
-
-        const result = await axios.post<DeleteAllUsersDTO>(\`\${BASE_URL}/api\`, {
-          query: \`mutation deleteAllUsers {
-            result: deleteAllUsers
-          }\`
-        })
-
-        data = result.data
-        status = result.status
-        expect(status).toBe(200)
-      })
-
-      test('Should return deleteAllUsersResponse', () => {
-        expect(validator(deleteAllUserResponse, data)).toBe(true)
+        expect(result.status).toBe(200)
+        expect(deleteUserResponse.safeParse(result.data).success).toBe(true)
       })
     })
   })
@@ -340,37 +203,20 @@ describe('Simba.js tests', () => {
   afterAll(async () => {
     await Server.stop()
   })
-})
-`
+})\n`
           : `import axios from 'axios'
-import { Static, TObject, TProperties, Type } from '@sinclair/typebox'
-import Ajv from 'ajv'
+import z from 'zod'
 
 import { Server } from '../src/network'
 import { userDto } from '../src/schemas'
 
-const ajv = new Ajv({
-  removeAdditional: true,
-  useDefaults: true,
-  coerceTypes: true,
-  nullable: true
+const BASE_URL = \`http://localhost:\${process.env.PORT || 1996}\`
+const baseResponseDto = z.object({
+  error: z.boolean(),
+  message: z.string()
 })
 
-const BASE_URL = 'http://localhost:${process.env.PORT || 1996}'
-const validator = <T extends TProperties>(
-  schema: TObject<T>,
-  object: unknown
-) => {
-  const validate = ajv.compile(schema)
-
-  return validate(object)
-}
-const baseResponseDto = Type.Object({
-  error: Type.Boolean(),
-  message: Type.String()
-})
-
-type BaseResponseDTO = Static<typeof baseResponseDto>
+type BaseResponseDTO = z.infer<typeof baseResponseDto>
 
 describe('Simba.js tests', () => {
   beforeAll(async () => {
@@ -381,36 +227,24 @@ describe('Simba.js tests', () => {
     let userID = ${dbIsSQL ? 0 : "''"}
 
     describe('API: GET /', () => {
-      let data: BaseResponseDTO
-
-      test('Should return 200 as status code', async () => {
+      it('Should return 200 with a successful operation', async () => {
         const result = await axios.get<BaseResponseDTO>(BASE_URL)
 
-        data = result.data
         expect(result.status).toBe(200)
-      })
-
-      test('Should be a successfully operation', () => {
-        expect(data.error).toBe(false)
-      })
-
-      test('Should be return baseResponseDto', () => {
-        expect(validator(baseResponseDto, data)).toBe(true)
+        expect(result.data.error).toBe(false)
+        expect(baseResponseDto.parse(result.data).error).toBe(false)
       })
     })
 
     describe('API: POST /api/users', () => {
-      const storeUserResponse = Type.Object({
-        error: Type.Boolean(),
+      const storeUserResponse = z.object({
+        error: z.boolean(),
         message: userDto
       })
 
-      type StoreUserDTO = Static<typeof storeUserResponse>
+      type StoreUserDTO = z.infer<typeof storeUserResponse>
 
-      let data: StoreUserDTO
-      let status: number
-
-      test('Should return 201 as status code', async () => {
+      it('Should create a user successfully', async () => {
         const result = await axios.post<StoreUserDTO>(\`\${BASE_URL}/api/users\`, {
           args: {
             lastName: 'Lzq',
@@ -418,91 +252,42 @@ describe('Simba.js tests', () => {
           }
         })
 
-        data = result.data
-        status = result.status
         userID = result.data.message.id ?? userID
-        expect(status).toBe(201)
-      })
-
-      test('Should be a successfully operation', () => {
-        expect(data.error).toBe(false)
-      })
-
-      test('Should return storeUserResponse', () => {
-        expect(validator(storeUserResponse, data)).toBe(true)
-      })
-    })
-
-    describe('API: GET /api/users', () => {
-      const getAllUsersResponse = Type.Object({
-        error: Type.Boolean(),
-        message: Type.Array(userDto)
-      })
-
-      type GetAllUsersDTO = Static<typeof getAllUsersResponse>
-
-      let data: GetAllUsersDTO
-      let status: number
-
-      test('Should return 200 as status code', async () => {
-        const result = await axios.get<GetAllUsersDTO>(\`\${BASE_URL}/api/users\`)
-
-        data = result.data
-        status = result.status
-        expect(status).toBe(200)
-      })
-
-      test('Should be a successfully operation', () => {
-        expect(data.error).toBe(false)
-      })
-
-      test('Should return getAllUsersResponse', () => {
-        expect(validator(getAllUsersResponse, data)).toBe(true)
+        expect(userID).toBeTruthy()
+        expect(result.status).toBe(201)
+        expect(result.data.error).toBe(false)
+        expect(storeUserResponse.parse(result.data).error).toBe(false)
       })
     })
 
     describe('API: GET /api/user/:id', () => {
-      const getOneUserResponse = Type.Object({
-        error: Type.Boolean(),
+      const getOneUserResponse = z.object({
+        error: z.boolean(),
         message: userDto
       })
 
-      type GetOneUserDTO = Static<typeof getOneUserResponse>
+      type GetOneUserDTO = z.infer<typeof getOneUserResponse>
 
-      let data: GetOneUserDTO
-      let status: number
-
-      test('Should return 200 as status code', async () => {
+      it('Should return a user', async () => {
         const result = await axios.get<GetOneUserDTO>(
           \`\${BASE_URL}/api/user/\${userID}\`
         )
 
-        data = result.data
-        status = result.status
-        expect(status).toBe(200)
-      })
-
-      test('Should be a successfully operation', () => {
-        expect(data.error).toBe(false)
-      })
-
-      test('Should return getOneUserResponse', () => {
-        expect(validator(getOneUserResponse, data)).toBe(true)
+        expect(result.status).toBe(200)
+        expect(result.data.error).toBe(false)
+        expect(getOneUserResponse.parse(result.data).error).toBe(false)
       })
     })
 
     describe('API: PATCH /api/user/:id', () => {
-      const updateUserResponse = Type.Object({
-        error: Type.Boolean(),
+      const updateUserResponse = z.object({
+        error: z.boolean(),
         message: userDto
       })
 
-      type UpdateUserDTO = Static<typeof updateUserResponse>
+      type UpdateUserDTO = z.infer<typeof updateUserResponse>
 
-      let data: UpdateUserDTO
-      let status: number
-
-      test('Should return 200 as status code', async () => {
+      it('Should update a user successfully', async () => {
         const result = await axios.patch<UpdateUserDTO>(
           \`\${BASE_URL}/api/user/\${userID}\`,
           {
@@ -513,70 +298,21 @@ describe('Simba.js tests', () => {
           }
         )
 
-        data = result.data
-        status = result.status
-        expect(status).toBe(200)
-      })
-
-      test('Should be a successfully operation', () => {
-        expect(data.error).toBe(false)
-      })
-
-      test('Should return updateUserResponse', () => {
-        expect(validator(updateUserResponse, data)).toBe(true)
+        expect(result.status).toBe(200)
+        expect(result.data.error).toBe(false)
+        expect(updateUserResponse.parse(result.data).error).toBe(false)
       })
     })
 
     describe('API: DELETE /api/user/:id', () => {
-      let data: BaseResponseDTO
-      let status: number
-
-      test('Should return 200 as status code', async () => {
+      it('Should delete the created user', async () => {
         const result = await axios.delete<BaseResponseDTO>(
           \`\${BASE_URL}/api/user/\${userID}\`
         )
 
-        data = result.data
-        status = result.status
-        expect(status).toBe(200)
-      })
-
-      test('Should be a successfully operation', () => {
-        expect(data.error).toBe(false)
-      })
-
-      test('Should return deleteUserResponse', () => {
-        expect(validator(baseResponseDto, data)).toBe(true)
-      })
-    })
-
-    describe('API: DELETE /api/users', () => {
-      let data: BaseResponseDTO
-      let status: number
-
-      test('Should return 200 as status code', async () => {
-        await axios.post(\`\${BASE_URL}/api/users\`, {
-          args: {
-            lastName: 'Lzq',
-            name: 'Anthony'
-          }
-        })
-
-        const result = await axios.delete<BaseResponseDTO>(
-          \`\${BASE_URL}/api/users\`
-        )
-
-        data = result.data
-        status = result.status
-        expect(status).toBe(200)
-      })
-
-      test('Should be a successfully operation', () => {
-        expect(data.error).toBe(false)
-      })
-
-      test('Should return deleteAllUsersResponse', () => {
-        expect(validator(baseResponseDto, data)).toBe(true)
+        expect(result.status).toBe(200)
+        expect(result.data.error).toBe(false)
+        expect(baseResponseDto.parse(result.data).error).toBe(false)
       })
     })
   })
@@ -584,37 +320,14 @@ describe('Simba.js tests', () => {
   afterAll(async () => {
     await Server.stop()
   })
-})
-`,
+})\n`,
         file: `${projectName}/test/index.test.ts`
-      },
-      jestGlobalSetup: {
-        content: `module.exports = () => {
-  if (process.env.NODE_ENV === 'local') require('./setEnvVars')
-}
-`,
-        file: `${projectName}/test/jestGlobalSetup.ts`
-      },
-      setEnvVars: {
-        content: `process.env.DB_URI =\n${
-          ENVIRONMENTS_WITH_DB_URI.includes(process.env.NODE_ENV)
-            ? `  '${dbURI}'\n`
-            : dbIsSQL
-            ? `  'postgres://postgres:postgres@postgres:5432/${projectName}'\n`
-            : `  'mongodb://mongo:mongo@mongo:27017/${projectName}'\n`
-        }`,
-        file: `${projectName}/test/setEnvVars.ts`
       }
     }
   }
 
   await Promise.all([
     writeFile(data.jestConfig.file, data.jestConfig.content),
-    writeFile(data.test.index.file, data.test.index.content),
-    writeFile(
-      data.test.jestGlobalSetup.file,
-      data.test.jestGlobalSetup.content
-    ),
-    writeFile(data.test.setEnvVars.file, data.test.setEnvVars.content)
+    writeFile(data.test.index.file, data.test.index.content)
   ])
 }