teste concluido

.env

@@ -0,0 +1,3 @@
+MONGODB_URI=mongodb+srv://finalfantasy:finalfantasyfinalfantasy@cluster0.p2mkkj6.mongodb.net/?retryWrites=true&w=majority
+
+AUTH_TOKEN=sakurataisenphantasystardreamcast

.gitignore

@@ -0,0 +1,23 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.js
+
+# testing
+/coverage
+
+# production
+/build
+
+# misc
+.DS_Store
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*

__tests__/_server.ts

@@ -0,0 +1,18 @@
+import cors from 'cors';
+import express from 'express';
+import { routes } from '../src/routes/routes';
+
+import db from '../src/database'
+
+db.connect();
+
+const _server = express();
+const port = 3333;
+
+_server.use(cors());
+_server.use(express.json());
+_server.use(express.urlencoded({ extended: true }));
+_server.use(routes);
+
+
+export { _server }

__tests__/e2e/auth/authController.spec.ts

@@ -0,0 +1,58 @@
+import request from "supertest";
+import { Server } from "http";
+import { UserDeleteService } from "../../../src/service/user/UserDeleteService";
+import { _server } from "../../_server";
+import { userFactory } from "../../utils/userFactory";
+import { URL_TEST } from "../../utils";
+import { UserInterface } from "../../../src/types/userTypes";
+
+describe("[e2e] - authController", () => {
+    let app: Server;
+
+    let userDeleteService: UserDeleteService;
+    let userAuthenticate: UserInterface;
+
+    beforeAll(async () => {
+        app = _server.listen(8055);
+
+        userDeleteService = new UserDeleteService;
+
+        const create = new userFactory().create()
+        const createUser = await request(app).post(URL_TEST.POST_CREATE_USER).send(create)
+
+        userAuthenticate = await createUser.body;
+    });
+
+    afterAll(async () => {
+        await userDeleteService.deleteMany();
+    });
+
+    it("should sign in", async () => {
+        const sign_in = await request(app).post(URL_TEST.POST_SIGN_IN).send(userAuthenticate);
+        expect(sign_in.status).toBe(200);
+
+    });
+
+    it("should fail in sign in", async () => {
+        const create = new userFactory().createEmptyValues();
+        const sign_in = await request(app).post(URL_TEST.POST_SIGN_IN).send(create);
+        expect(sign_in.status).toBe(500);
+
+    });
+    it("should auth by token", async () => {
+        const sign_in = await request(app).post(URL_TEST.POST_SIGN_IN).send(userAuthenticate);
+
+        const authUser = await request(app).post(URL_TEST.POST_AUTH_BY_TOKEN).send({ authorization: `Bearer ${await sign_in.body.token}` });
+
+        expect(authUser.status).toBe(200);
+
+    });
+
+    it("should fail in auth by token", async () => {
+        const authUser = await request(app).post(URL_TEST.POST_AUTH_BY_TOKEN).send({ authorization: `Bearer sign_in.body.token` });
+        expect(authUser.status).toBe(401);
+
+    });
+
+});
+

__tests__/e2e/user/userCreateController.spec.ts

@@ -0,0 +1,72 @@
+import { UserDeleteService } from "../../../src/service/user/UserDeleteService";
+import { _server } from "../../_server";
+import { Server } from "http";
+import { userFactory } from "../../utils/userFactory";
+import request from "supertest";
+import { URL_TEST } from "../../utils";
+
+
+describe("[e2e] - userCreateController", () => {
+    let app: Server;
+
+    let userDeleteService: UserDeleteService;
+
+    beforeAll(() => {
+        app = _server.listen(8888);
+        userDeleteService = new UserDeleteService;
+    });
+
+    afterAll(async () => {
+        await userDeleteService.deleteMany();
+    });
+
+
+    it("should create user", async () => {
+        const user = new userFactory().create()
+        const create = await request(app).post(URL_TEST.POST_CREATE_USER).send(user)
+
+        expect(create.status).toBe(201);
+    });
+
+    it("should fail in create with empty values", async () => {
+        const user = new userFactory().createEmptyValues()
+
+        await request(app).post(URL_TEST.POST_CREATE_USER).send(user)
+
+        const create = await request(app).post(URL_TEST.POST_CREATE_USER).send(user)
+
+        expect(create.status).toBe(500);
+    });
+
+    it("should fail in create same email", async () => {
+        const user = new userFactory().create()
+
+        await request(app).post(URL_TEST.POST_CREATE_USER).send(user)
+
+        const create = await request(app).post(URL_TEST.POST_CREATE_USER).send(user)
+
+        expect(create.status).toBe(500);
+    });
+
+    it("should fail in create user with password not equal", async () => {
+        const user = new userFactory().createWrongPassword()
+        const create = await request(app).post(URL_TEST.POST_CREATE_USER).send(user)
+        expect(create.status).toBe(500);
+    });
+
+    it("should fail in create user with email mal formated", async () => {
+        const user = new userFactory().createWithMalformatedEmail()
+        const create = await request(app).post(URL_TEST.POST_CREATE_USER).send(user)
+        expect(create.status).toBe(500);
+    });
+
+    it("should fail in create user with empty values", async () => {
+        const user = new userFactory().createEmptyValues()
+
+        const create = await request(app).post(URL_TEST.POST_CREATE_USER).send(user)
+
+        expect(create.status).toBe(500);
+    });
+
+});
+

__tests__/e2e/user/userDeleteController.spec.ts

@@ -0,0 +1,52 @@
+import request from "supertest";
+import { Server } from "http";
+import { UserDeleteService } from "../../../src/service/user/UserDeleteService";
+import { _server } from "../../_server";
+import { userFactory } from "../../utils/userFactory";
+import { URL_TEST } from "../../utils";
+import { UserInterface } from "../../../src/types/userTypes";
+
+describe("[e2e] - userDeleteController", () => {
+    let app: Server;
+
+    let userDeleteService: UserDeleteService;
+    let userToBeDeleted: UserInterface;
+
+    beforeAll(async () => {
+        app = _server.listen(9999);
+
+        userDeleteService = new UserDeleteService;
+        const create = new userFactory().create()
+        const createUser = await request(app).post(URL_TEST.POST_CREATE_USER).send(create)
+
+        userToBeDeleted = await createUser.body;
+    });
+
+    afterAll(async () => {
+        await userDeleteService.deleteMany();
+    });
+
+    it("should delete user by id", async () => {
+        const deleteById = await request(app).delete(URL_TEST.DELETE_DELTE_ONE).query({ id: userToBeDeleted._id })
+
+        expect(deleteById.status).toBe(204);
+
+    });
+
+    it("should fail in delete user by id", async () => {
+        const deleteById = await request(app).delete(URL_TEST.DELETE_DELTE_ONE).query({ id: 'userCreated.id' })
+        expect(deleteById.status).toBe(500);
+    });
+
+    it("delete all", async () => {
+        const deleteAll = await request(app).delete(URL_TEST.DELETE_DELETE_MANY)
+        expect(deleteAll.status).toBe(204);
+    });
+
+    it("delete all", async () => {
+        const deleteAll = await request(app).delete(URL_TEST.DELETE_DESTROYER)
+        expect(deleteAll.status).toBe(204);
+    });
+
+});
+

__tests__/e2e/user/userFindController.spec.ts

@@ -0,0 +1,48 @@
+import request from "supertest";
+import { Server } from "http";
+import { UserDeleteService } from "../../../src/service/user/UserDeleteService";
+import { _server } from "../../_server";
+import { userFactory } from "../../utils/userFactory";
+import { URL_TEST } from "../../utils";
+import { UserInterface } from "../../../src/types/userTypes";
+
+describe("[e2e] - userFindController", () => {
+    let app: Server;
+
+    let userDeleteService: UserDeleteService;
+    let userCreatedToBeFound: UserInterface;
+
+    beforeAll(async () => {
+        app = _server.listen(3344);
+
+        userDeleteService = new UserDeleteService;
+        const create = new userFactory().create()
+        const createUser = await request(app).post(URL_TEST.POST_CREATE_USER).send(create)
+
+        userCreatedToBeFound = await createUser.body;
+    });
+
+    afterAll(async () => {
+        await userDeleteService.deleteMany();
+    });
+
+    it("should find user", async () => {
+
+        const find = await request(app).get(URL_TEST.GET_FIND_BY_USER_ID).query({ id: userCreatedToBeFound._id })
+
+        expect(find.status).toBe(200);
+
+    });
+
+    it("should fail in find user with wrong id", async () => {
+        const find = await request(app).get(URL_TEST.GET_FIND_BY_USER_ID).query({ id: 'userCreated.id' })
+        expect(find.status).toBe(500);
+    });
+
+    it("find all", async () => {
+        const findAll = await request(app).get(URL_TEST.GET_FIND)
+        expect(findAll.status).toBe(200);
+    });
+
+});
+

__tests__/e2e/user/userUpdateController.spec.ts

@@ -0,0 +1,52 @@
+import request from "supertest";
+import { Server } from "http";
+import { UserDeleteService } from "../../../src/service/user/UserDeleteService";
+import { _server } from "../../_server";
+import { userFactory } from "../../utils/userFactory";
+import { URL_TEST } from "../../utils";
+import { UserInterface } from "../../../src/types/userTypes";
+
+describe("[e2e] - userUpdateController", () => {
+    let app: Server;
+
+    let userDeleteService: UserDeleteService;
+    let userToBeUpdate: UserInterface;
+
+    beforeAll(async () => {
+        app = _server.listen(8033);
+
+        userDeleteService = new UserDeleteService;
+        const create = new userFactory().create()
+        const createUser = await request(app).post(URL_TEST.POST_CREATE_USER).send(create)
+
+        userToBeUpdate = await createUser.body;
+    });
+
+    afterAll(async () => {
+        await userDeleteService.deleteMany();
+    });
+
+    it("should auth and update user", async () => {
+        const sign_in = await request(app).post(URL_TEST.POST_SIGN_IN).send(userToBeUpdate);
+
+        const preUpdate = new userFactory().createAndUpdate(sign_in.body, sign_in.body.token)
+
+        const afterUpdate = await request(app).put(URL_TEST.PUT_FIND_BY_ID_AND_UPDATE).send(preUpdate);
+
+
+        expect(afterUpdate.status).toBe(201);
+
+    });
+
+    it("should fail update with token", async () => {
+
+        const preUpdate = new userFactory().createAndUpdateWithoutToken()
+
+        const afterUpdate = await request(app).put(URL_TEST.PUT_FIND_BY_ID_AND_UPDATE).send(preUpdate);
+
+        expect(afterUpdate.status).toBe(409);
+    });
+
+
+});
+

__tests__/integration/userCreateService.spec.ts

@@ -0,0 +1,56 @@
+import { UserCreateService } from "../../src/service/user/UserCreateService";
+import { UserDeleteService } from "../../src/service/user/UserDeleteService";
+import { userFactory } from "../utils/userFactory";
+import { _server } from "../_server";
+
+describe("[integration] - userCreateService ", () => {
+    _server.listen(3333)
+
+    let userCreateService: UserCreateService;
+    let userDeleteService: UserDeleteService;
+
+    beforeAll(async () => {
+
+        userCreateService = new UserCreateService;
+        userDeleteService = new UserDeleteService;
+
+    });
+
+    afterAll(async () => {
+        await userDeleteService.deleteMany();
+    });
+
+
+    it("should create user", async () => {
+        const user = new userFactory().create()
+        const create = await userCreateService.create(user);
+        expect(create).toHaveProperty("id")
+    });
+
+
+    it("should fail in create user", async () => {
+        const user = new userFactory().createEmptyValues();
+        await expect(userCreateService.create(user)).rejects.toThrow()
+    });
+
+    it("should fail in create user with same email", async () => {
+        const user = new userFactory().create()
+
+        await userCreateService.create(user);
+
+        await expect(userCreateService.create(user)).rejects.toThrow()
+    });
+
+
+    it("should fail in create user with wrong role", async () => {
+        const user = new userFactory().createWrongRole() as any
+        await expect(userCreateService.create(user)).rejects.toThrow()
+    });
+
+
+
+
+
+
+
+});