Merge pull request #5 from calcom/feat/users-teams

Feature: adds users and teams tests

__tests__/teams/[id]/team.id.test.edit.ts

@@ -0,0 +1,93 @@
+import handleTeamEdit from "@api/teams/[id]/edit";
+import { createMocks } from "node-mocks-http";
+
+import prisma from "@calcom/prisma";
+
+describe("PATCH /api/teams/[id]/edit with valid id and body updates a team", () => {
+  it("returns a message with the specified teams", async () => {
+    const { req, res } = createMocks({
+      method: "PATCH",
+      query: {
+        id: "1",
+      },
+      body: {
+        name: "Updated team",
+        slug: "updated-team",
+      },
+    });
+    const team = await prisma.team.findUnique({ where: { id: parseInt(req.query.id) } });
+    await handleTeamEdit(req, res);
+
+    expect(res._getStatusCode()).toBe(200);
+    // if (team) team.name = "Updated name";
+    expect(JSON.parse(res._getData())).toStrictEqual({ data: team });
+  });
+});
+
+describe("PATCH /api/teams/[id]/edit with invalid id returns 404", () => {
+  it("returns a message with the specified teams", async () => {
+    const { req, res } = createMocks({
+      method: "PATCH",
+      query: {
+        id: "0",
+      },
+      body: {
+        name: "Updated name",
+        slug: "updated-slug",
+      },
+    });
+    const team = await prisma.team.findUnique({ where: { id: parseInt(req.query.id) } });
+    await handleTeamEdit(req, res);
+
+    expect(res._getStatusCode()).toBe(404);
+    expect(JSON.parse(res._getData())).toStrictEqual({       "error":  {
+        "clientVersion": "3.10.0",
+        "code": "P2025",
+        "meta":  {
+          "cause": "Record to update not found.",
+          },
+      },
+      "message": "Event type with ID 0 not found and wasn't updated", });
+  });
+});
+
+describe("PATCH /api/teams/[id]/edit with valid id and no body returns 400 error and zod validation errors", () => {
+  it("returns a message with the specified teams", async () => {
+    const { req, res } = createMocks({
+      method: "PATCH",
+      query: {
+        id: "2",
+      },
+    });
+    await handleTeamEdit(req, res);
+
+    expect(res._getStatusCode()).toBe(400);
+
+    // Ugly parsing of zod validation errors, not for final production but works for testing
+    expect(JSON.parse(res._getData())).toStrictEqual([{"code": "invalid_type", "expected": "string", "message": "Required", "path": ["slug"], "received": "undefined"}, {"code": "invalid_type", "expected": "string", "message": "Required", "path": ["name"], "received": "undefined"}]);
+  });
+});
+
+describe("POST /api/teams/[id]/edit fails, only PATCH allowed", () => {
+  it("returns a message with the specified teams", async () => {
+    const { req, res } = createMocks({
+      method: "POST", // This POST method is not allowed
+      query: {
+        id: "1",
+      },
+      body: {
+        name: "Updated name",
+        slug: "updated-slug",
+      },
+    });
+    await handleTeamEdit(req, res);
+
+    expect(res._getStatusCode()).toBe(405);
+    expect(JSON.parse(res._getData())).toStrictEqual({ message: "Only PATCH Method allowed for updating teams" });
+  });
+});
+
+afterAll((done) => {
+  prisma.$disconnect().then();
+  done();
+});

__tests__/teams/[id]/team.id.test.index.ts

@@ -0,0 +1,80 @@
+import handleTeam from "@api/teams/[id]";
+import { createMocks } from "node-mocks-http";
+
+import prisma from "@calcom/prisma";
+
+describe("GET /api/teams/[id] with valid id as string returns an team-type", () => {
+  it("returns a message with the specified events", async () => {
+    const { req, res } = createMocks({
+      method: "GET",
+      query: {
+        id: "1",
+      },
+    });
+    const team = await prisma.team.findUnique({ where: { id: 1 } });
+    await handleTeam(req, res);
+
+    expect(res._getStatusCode()).toBe(200);
+    expect(JSON.parse(res._getData())).toStrictEqual({ data: team });
+  });
+});
+
+// This can never happen under our normal nextjs setup where query is always a string | string[].
+// But seemed a good example for testing an error validation
+describe("GET /api/teams/[id] errors if query id is number, requires a string", () => {
+  it("returns a message with the specified events", async () => {
+    const { req, res } = createMocks({
+      method: "GET",
+      query: {
+        id: 1, // passing query as a number, which should fail as nextjs will try to parse it as a string
+      },
+    });
+    await handleTeam(req, res);
+
+    expect(res._getStatusCode()).toBe(400);
+    expect(JSON.parse(res._getData())).toStrictEqual([
+      {
+        code: "invalid_type",
+        expected: "string",
+        received: "number",
+        path: ["id"],
+        message: "Expected string, received number",
+      },
+    ]);
+  });
+});
+
+describe("GET /api/teams/[id] an id not present in db like 0, throws 404 not found", () => {
+  it("returns a message with the specified events", async () => {
+    const { req, res } = createMocks({
+      method: "GET",
+      query: {
+        id: "0", // There's no team type with id 0
+      },
+    });
+    await handleTeam(req, res);
+
+    expect(res._getStatusCode()).toBe(404);
+    expect(JSON.parse(res._getData())).toStrictEqual({ message: "Event type not found" });
+  });
+});
+
+describe("POST /api/teams/[id] fails, only GET allowed", () => {
+  it("returns a message with the specified events", async () => {
+    const { req, res } = createMocks({
+      method: "POST", // This POST method is not allowed
+      query: {
+        id: "1",
+      },
+    });
+    await handleTeam(req, res);
+
+    expect(res._getStatusCode()).toBe(405);
+    expect(JSON.parse(res._getData())).toStrictEqual({ message: "Only GET Method allowed" });
+  });
+});
+
+afterAll((done) => {
+  prisma.$disconnect().then();
+  done();
+});

__tests__/users/[id]/user.id.test.edit.ts

@@ -0,0 +1,95 @@
+import handleEventTypeEdit from "@api/event-types/[id]/edit";
+import { createMocks } from "node-mocks-http";
+
+import prisma from "@calcom/prisma";
+
+describe("PATCH /api/event-types/[id]/edit with valid id and body updates an event-type", () => {
+  it("returns a message with the specified events", async () => {
+    const { req, res } = createMocks({
+      method: "PATCH",
+      query: {
+        id: "2",
+      },
+      body: {
+        title: "Updated title",
+        slug: "updated-slug",
+        length: 1,
+      },
+    });
+    const event = await prisma.eventType.findUnique({ where: { id: parseInt(req.query.id) } });
+    await handleEventTypeEdit(req, res);
+
+    expect(res._getStatusCode()).toBe(200);
+    if (event) event.title = "Updated title";
+    expect(JSON.parse(res._getData())).toStrictEqual({ data: event });
+  });
+});
+
+describe("PATCH /api/event-types/[id]/edit with invalid id returns 404", () => {
+  it("returns a message with the specified events", async () => {
+    const { req, res } = createMocks({
+      method: "PATCH",
+      query: {
+        id: "0",
+      },
+      body: {
+        title: "Updated title",
+        slug: "updated-slug",
+        length: 1,
+      },
+    });
+    const event = await prisma.eventType.findUnique({ where: { id: parseInt(req.query.id) } });
+    await handleEventTypeEdit(req, res);
+
+    expect(res._getStatusCode()).toBe(404);
+    if (event) event.title = "Updated title";
+    expect(JSON.parse(res._getData())).toStrictEqual({       "error":  {
+        "clientVersion": "3.10.0",
+        "code": "P2025",
+        "meta":  {
+          "cause": "Record to update not found.",
+          },
+      },
+      "message": "Event type with ID 0 not found and wasn't updated", });
+  });
+});
+
+describe("PATCH /api/event-types/[id]/edit with valid id and no body returns 400 error and zod validation errors", () => {
+  it("returns a message with the specified events", async () => {
+    const { req, res } = createMocks({
+      method: "PATCH",
+      query: {
+        id: "2",
+      },
+    });
+    await handleEventTypeEdit(req, res);
+
+    expect(res._getStatusCode()).toBe(400);
+    expect(JSON.parse(res._getData())).toStrictEqual([{"code": "invalid_type", "expected": "string", "message": "Required", "path": ["title"], "received": "undefined"}, {"code": "invalid_type", "expected": "string", "message": "Required", "path": ["slug"], "received": "undefined"}, {"code": "invalid_type", "expected": "number", "message": "Required", "path": ["length"], "received": "undefined"}]);
+  });
+});
+
+describe("POST /api/event-types/[id]/edit fails, only PATCH allowed", () => {
+  it("returns a message with the specified events", async () => {
+    const { req, res } = createMocks({
+      method: "POST", // This POST method is not allowed
+      query: {
+        id: "1",
+      },
+      body: {
+        title: "Updated title",
+        slug: "updated-slug",
+        length: 1,
+      },
+    });
+    await handleEventTypeEdit(req, res);
+
+    expect(res._getStatusCode()).toBe(405);
+    expect(JSON.parse(res._getData())).toStrictEqual({ message: "Only PATCH Method allowed for updating event-types" });
+  });
+});
+
+afterAll((done) => {
+  prisma.$disconnect().then();
+  done();
+});

__tests__/users/[id]/user.id.test.index.ts

@@ -0,0 +1,81 @@
+import handleUser from "@api/users/[id]";
+import { createMocks } from "node-mocks-http";
+
+import prisma from "@calcom/prisma";
+import { stringifyISODate } from "@lib/utils/stringifyISODate";
+
+describe("GET /api/users/[id] with valid id as string returns an user-type", () => {
+  it("returns a message with the specified events", async () => {
+    const { req, res } = createMocks({
+      method: "GET",
+      query: {
+        id: "1",
+      },
+    });
+    const user = await prisma.user.findUnique({ where: { id: 1 } });
+    await handleUser(req, res);
+
+    expect(res._getStatusCode()).toBe(200);
+    expect(JSON.parse(res._getData())).toEqual({ data: {...user, createdDate: stringifyISODate(user?.createdDate), emailVerified: stringifyISODate(user?.emailVerified)} });
+  });
+});
+
+// This can never happen under our normal nextjs setup where query is always a string | string[].
+// But seemed a good example for testing an error validation
+describe("GET /api/users/[id] errors if query id is number, requires a string", () => {
+  it("returns a message with the specified events", async () => {
+    const { req, res } = createMocks({
+      method: "GET",
+      query: {
+        id: 1, // passing query as a number, which should fail as nextjs will try to parse it as a string
+      },
+    });
+    await handleUser(req, res);
+
+    expect(res._getStatusCode()).toBe(400);
+    expect(JSON.parse(res._getData())).toStrictEqual([
+      {
+        code: "invalid_type",
+        expected: "string",
+        received: "number",
+        path: ["id"],
+        message: "Expected string, received number",
+      },
+    ]);
+  });
+});
+
+describe("GET /api/users/[id] an id not present in db like 0, throws 404 not found", () => {
+  it("returns a message with the specified events", async () => {
+    const { req, res } = createMocks({
+      method: "GET",
+      query: {
+        id: "0", // There's no user type with id 0
+      },
+    });
+    await handleUser(req, res);
+
+    expect(res._getStatusCode()).toBe(404);
+    expect(JSON.parse(res._getData())).toStrictEqual({ message: "Event type not found" });
+  });
+});
+
+describe("POST /api/users/[id] fails, only GET allowed", () => {
+  it("returns a message with the specified events", async () => {
+    const { req, res } = createMocks({
+      method: "POST", // This POST method is not allowed
+      query: {
+        id: "1",
+      },
+    });
+    await handleUser(req, res);
+
+    expect(res._getStatusCode()).toBe(405);
+    expect(JSON.parse(res._getData())).toStrictEqual({ message: "Only GET Method allowed" });
+  });
+});
+
+afterAll((done) => {
+  prisma.$disconnect().then();
+  done();
+});

jest.config.ts

@@ -7,7 +7,9 @@ const config = {
   clearMocks: true,
   coverageDirectory: "./coverage",
   collectCoverage: true,
-
+  "collectCoverageFrom": [
+    "pages/api/**/*.ts"
+  ],
   // An array of regexp pattern strings used to skip coverage collection
   // coveragePathIgnorePatterns: [
   //   "/node_modules/"

pages/api/api-keys/[id]/delete.ts

@@ -1,7 +1,7 @@
 import prisma from "@calcom/prisma";
 import { NextApiRequest, NextApiResponse } from "next";
 
-import { schemaQueryId, withValidQueryIdString } from "@lib/validations/queryIdString";
+import { schemaQueryIdAsString, withValidQueryIdString } from "@lib/validations/queryIdString";
 
 type ResponseData = {
   message?: string;
@@ -10,7 +10,7 @@ type ResponseData = {
 
 export async function apiKey(req: NextApiRequest, res: NextApiResponse<ResponseData>) {
   const { query, method } = req;
-  const safe = await schemaQueryId.safeParse(query);
+  const safe = await schemaQueryIdAsString.safeParse(query);
   if (safe.success) {
     if (method === "DELETE") {
       // DELETE WILL DELETE THE EVENT TYPE

pages/api/teams/[id]/edit.ts

@@ -30,7 +30,7 @@ export async function editTeam(req: NextApiRequest, res: NextApiResponse<Respons
     }
   } else {
     // Reject any other HTTP method than POST
-    res.status(405).json({ message: "Only PATCH Method allowed for updating team-types"  });
+    res.status(405).json({ message: "Only PATCH Method allowed for updating teams"  });
   }
 }
 

pages/api/users/[id]/edit.ts

@@ -30,7 +30,7 @@ export async function editUser(req: NextApiRequest, res: NextApiResponse<Respons
     }
   } else {
     // Reject any other HTTP method than POST
-    res.status(405).json({ message: "Only PATCH Method allowed for updating user-types"  });
+    res.status(405).json({ message: "Only PATCH Method allowed for updating users"  });
   }
 }