feat: User tests

data/users/user.js

@@ -21,7 +21,7 @@ const simpleUserWalletAddress = CSL.RewardAddress.new(
   .to_bech32();
 
   const userDeletePrivateKey = CSL.PrivateKey.from_normal_bytes(
-    new Array(32).fill(1)
+    new Array(32).fill(2)
   );
   const userDeleteWalletAddress = CSL.RewardAddress.new(
     CSL.NetworkId.mainnet().kind(),

package.json

@@ -10,7 +10,7 @@
     "build": "next build",
     "start": "next start",
     "lint": "next lint",
-    "test": "jest"
+    "test": "node ./seed.js && jest"
   },
   "dependencies": {
     "@chakra-ui/icons": "^2.0.17",

src/pages/api/admin/users/[userId].ts

@@ -1,6 +1,7 @@
 import { NextApiRequest, NextApiResponse } from "next";
 import { getToken } from "next-auth/jwt";
 import mongoose from "mongoose";
+import * as yup from "yup";
 import * as userService from "@/services/user";
 import { handleError, HTTPError } from "@/utils/error";
 import { ApiDataResponse, ApiResponse } from "@/types/api";
@@ -13,7 +14,12 @@ export default async function handler(
 ) {
   const token = await getToken({ req });
 
-  if (!token || token.sub === undefined) {
+  if (
+    !token ||
+    token.sub === undefined ||
+    !token.role ||
+    token.role !== "admin"
+  ) {
     return handleError(res, new HTTPError(401));
   }
 
@@ -45,24 +51,57 @@ export default async function handler(
         await userToDelete.delete();
       }
       res.send({ message: "SUCCESS" });
+      break;
     case "PATCH":
-      let user = await userService.findUserById(
-        new mongoose.Types.ObjectId(userId)
-      );
+      try {
+        const userPatchRequest = yup.object({
+          name: yup.string().required(),
+          email: yup.string().required().email(),
+          walletAddress: yup.string().required(),
+          role: yup.string().required().oneOf(["admin", "user"]),
+        });
+
+        const usePatchData = await userPatchRequest.validate(req.body, {
+          abortEarly: false,
+          stripUnknown: true,
+        });
+
+        const user = await userService.findUserById(
+          new mongoose.Types.ObjectId(userId)
+        );
+
+        const userSameEmail = await userService.findUserByEmail(
+          usePatchData.email
+        );
+
+        if (userSameEmail && userSameEmail._id !== user?._id) {
+          throw new HTTPError(400, "EMAIL_ALREADY_EXISTS");
+        }
+
+        const userSameWalletAddress = await userService.findUserByWalletAddress(
+          usePatchData.walletAddress
+        );
+
+        if (userSameWalletAddress && userSameWalletAddress._id !== user?._id) {
+          throw new HTTPError(400, "WALLET_ADDRESS_ALREADY_EXISTS");
+        }
 
-      if (user) {
-        user.name = req.body.name;
-        user.email = req.body.email;
-        user.walletAddress = req.body.walletAddress;
-        user.role = req.body.role;
-        try {
-          await user.save();
-          res.send({ message: "SUCCESS" });
-        } catch (e) {
-          handleError(res, e);
+        if (user) {
+          user.name = req.body.name;
+          user.email = req.body.email;
+          user.walletAddress = req.body.walletAddress;
+          user.role = req.body.role;
+          try {
+            await user.save();
+            res.send({ message: "SUCCESS" });
+          } catch (e) {
+            handleError(res, e);
+          }
+        } else {
+          return handleError(res, new HTTPError(422));
         }
-      } else {
-        return handleError(res, new HTTPError(422));
+      } catch (e) {
+        return handleError(res, e);
       }
       break;
     default:

src/pages/api/admin/users/index.ts

@@ -1,5 +1,6 @@
 import { NextApiRequest, NextApiResponse } from "next";
 import { getToken } from "next-auth/jwt";
+import * as yup from "yup";
 import * as userService from "@/services/user";
 import mongoose from "mongoose";
 import { ApiDataResponse, ApiResponse } from "@/types/api";
@@ -9,7 +10,9 @@ import UserModel from "@/models/UserModel";
 
 export default async function handler(
   req: NextApiRequest,
-  res: NextApiResponse<ApiResponse | ApiDataResponse<mongoose.PaginateModel<User>>>
+  res: NextApiResponse<
+    ApiResponse | ApiDataResponse<mongoose.PaginateResult<User>>
+  >
 ) {
   const token = await getToken({ req });
 
@@ -27,8 +30,8 @@ export default async function handler(
       res.send({
         message: "SUCCESS",
         data: await userService.findAll(
-          Number(req.query.page as string),
-          Number(req.query.limit as string),
+          Number((req.query.page as string) ?? 0),
+          Number((req.query.limit as string) ?? 10),
           req.query["sort[]"],
           req.query["order[]"],
           req.query["filterId[]"],
@@ -37,16 +40,52 @@ export default async function handler(
       } as ApiDataResponse<mongoose.PaginateResult<User>>);
       break;
     case "POST":
-      const userToPost = new UserModel({
-        name: req.body.name,
-        email: req.body.email,
-        walletAddress: req.body.walletAddress,
-        role: req.body.role,
-      });
-
       try {
+        const userPostRequest = yup.object({
+          name: yup.string().required(),
+          email: yup.string().required().email(),
+          walletAddress: yup.string().required(),
+          role: yup.string().required().oneOf(["admin", "user"]),
+        });
+
+        const userPostData = await userPostRequest.validate(req.body, {
+          stripUnknown: true,
+          abortEarly: false,
+        });
+
+        const userWithSameEmail = await userService.findUserByEmail(userPostData.email);
+
+        if (userWithSameEmail) {
+          throw new HTTPError(400, "EMAIL_ALREADY_EXISTS");
+        }
+
+        const userWithSameWalletAddress = await userService.findUserByWalletAddress(userPostData.walletAddress);
+
+        if (userWithSameWalletAddress) {
+          throw new HTTPError(400, "WALLET_ADDRESS_ALREADY_EXISTS");
+        }
+
+        const userToPost = new UserModel({
+          name: userPostData.name,
+          email: userPostData.email,
+          walletAddress: userPostData.walletAddress,
+          role: userPostData.role,
+        });
+
         await userToPost.save();
-        res.send({ message: "SUCCESS" });
+        res.send({
+          message: "SUCCESS",
+          data: {
+            docs: [userToPost as User],
+            totalDocs: 1,
+            totalPages: 1,
+            limit: 10,
+            offset: 0,
+            pagingCounter: 1,
+            hasNextPage: false,
+            hasPrevPage: false,
+          },
+        });
       } catch (e) {
         handleError(res, e);
       }

src/pages/api/auth/[...nextauth].ts

@@ -46,7 +46,7 @@ export const authOptions: AuthOptions = {
             signature
           );
 
-          const user = await userService.findUserByWalleAddress(walletAddress);
+          const user = await userService.findUserByWalletAddress(walletAddress);
 
           if (user) {
             return {

src/pages/api/profile.ts

@@ -4,6 +4,7 @@ import * as userService from "@/services/user";
 import mongoose from "mongoose";
 import { handleError, HTTPError } from "@/utils/error";
 import { ApiDataResponse, ApiResponse } from "@/types/api";
+import * as yup from "yup";
 import User from "@/types/user";
 
 export default async function handler(
@@ -30,19 +31,32 @@ export default async function handler(
       });
       break;
     case "PATCH":
-      const user = await userService.findUserById(
-        new mongoose.Types.ObjectId(token.sub)
-      );
+      try {
+        const profilePatchRequest = yup.object({
+          name: yup.string().required(),
+        });
+
+        const patchData = await profilePatchRequest.validate(req.body, {
+          stripUnknown: true,
+          abortEarly: false,
+        });
+
+        const user = await userService.findUserById(
+          new mongoose.Types.ObjectId(token.sub)
+        );
 
-      if (user) {
-        user.name = req.body.name;
-        user.save();
-        res.send({ message: "SUCCESS" });
-      } else {
-        return handleError(res, new HTTPError(422, "USER_ERROR"));
+        if (user) {
+          user.name = patchData.name;
+          user.save();
+          res.send({ message: "SUCCESS" });
+        } else {
+          return handleError(res, new HTTPError(422, "USER_ERROR"));
+        }
+      } catch (e) {
+        handleError(res, e);
       }
       break;
     default:
-      res.status(400).end();
+      return handleError(res, new HTTPError(405));
   }
 }

src/services/user.ts

@@ -22,7 +22,7 @@ export async function findUserByEmail(email: string) {
  * Finds user by ID
  * @param {string} id - user´s id
  */
-export async function findUserByWalleAddress(walletAddress: string) {
+export async function findUserByWalletAddress(walletAddress: string) {
   const user = await UserModel.findOne(
     {
       walletAddress,

test/auth.test.ts

@@ -469,6 +469,5 @@ afterAll(async () => {
 
   await Promise.all(promises);
 
-  console.log("Close connection");
   await mongoose.connection.close();
 });