feat: adds bookings and more tests

tests/api-keys/[id]/api-key.id.delete.test.ts

@@ -0,0 +1,88 @@
+import handleDeleteApiKey from "@api/api-keys/[id]/delete";
+import { createMocks } from "node-mocks-http";
+
+import prisma from "@calcom/prisma";
+
+describe("DELETE /api/api-keys/[id]/delete with valid id as string returns an apiKey", () => {
+  it("returns a message with the specified apiKeys", async () => {
+    const apiKey = await prisma.apiKey.findFirst()
+    const { req, res } = createMocks({
+      method: "DELETE",
+      query: {
+        id: apiKey?.id,
+      },
+    });
+    // const apiKey = await prisma.apiKey.findUnique({ where: { id: req.query.id} });
+    await handleDeleteApiKey(req, res);
+
+    // console.log(res)
+    expect(res._getStatusCode()).toBe(204);
+    expect(JSON.parse(res._getData())).toEqual({message: `api-key with id: ${apiKey?.id} deleted successfully`});
+  });
+});
+
+// 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("DELETE /api/api-keys/[id]/delete errors if query id is number, requires a string", () => {
+  it("returns a message with the specified apiKeys", async () => {
+    const { req, res } = createMocks({
+      method: "DELETE",
+      query: {
+        id: 1, // passing query as a number, which should fail as nextjs will try to parse it as a string
+      },
+    });
+    await handleDeleteApiKey(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("DELETE /api/api-keys/[id]/delete an id not present in db like 0, throws 404 not found", () => {
+  it("returns a message with the specified apiKeys", async () => {
+    const { req, res } = createMocks({
+      method: "DELETE",
+      query: {
+        id: "0", // There's no apiKey  with id 0
+      },
+    });
+    await handleDeleteApiKey(req, res);
+
+    expect(res._getStatusCode()).toBe(404);
+    expect(JSON.parse(res._getData())).toStrictEqual({
+      "error": {
+     "clientVersion": "3.10.0",
+     "code": "P2025",
+     "meta": {
+       "cause": "Record to delete does not exist.",
+     },
+   },
+   "message": "Resource with id:0 was not found",
+     });
+  });
+});
+
+describe("POST /api/api-keys/[id]/delete fails, only DELETE allowed", () => {
+  it("returns a message with the specified apiKeys", async () => {
+    const { req, res } = createMocks({
+      method: "POST", // This POST method is not allowed
+      query: {
+        id: "1",
+      },
+    });
+    await handleDeleteApiKey(req, res);
+
+    expect(res._getStatusCode()).toBe(405);
+    expect(JSON.parse(res._getData())).toStrictEqual({ message: "Only DELETE Method allowed" });
+  });
+});
+
+

tests/api-keys/[id]/api-key.id.edit.test.ts

@@ -0,0 +1,89 @@
+import handleapiKeyEdit from "@api/api-keys/[id]/edit";
+import { createMocks } from "node-mocks-http";
+
+import prisma from "@calcom/prisma";
+import {stringifyISODate} from "@lib/utils/stringifyISODate";
+
+describe("PATCH /api/api-keys/[id]/edit with valid id and body with note", () => {
+  it("returns a 200 and the updated apiKey note", async () => {
+    const { req, res } = createMocks({
+      method: "PATCH",
+      query: {
+        id: "cl16zg6860000wwylnsgva00b",
+      },
+      body: {
+        note: "Updated note",
+      },
+    });
+    const apiKey = await prisma.apiKey.findUnique({ where: { id: req.query.id } });
+    await handleapiKeyEdit(req, res);
+
+    expect(res._getStatusCode()).toBe(200);
+    expect(JSON.parse(res._getData())).toEqual({ data: {...apiKey, createdAt: stringifyISODate(apiKey?.createdAt), expiresAt: stringifyISODate(apiKey?.expiresAt)} });
+  });
+});
+
+describe("PATCH /api/api-keys/[id]/edit with invalid id returns 404", () => {
+  it("returns a message with the specified apiKeys", async () => {
+    const { req, res } = createMocks({
+      method: "PATCH",
+      query: {
+        id: "cl16zg6860000wwylnsgva00a",
+      },
+      body: {
+        note: "Updated note",
+      },
+    });
+    const apiKey = await prisma.apiKey.findUnique({ where: { id: req.query.id } });
+    await handleapiKeyEdit(req, res);
+
+    expect(res._getStatusCode()).toBe(404);
+    if (apiKey) apiKey.note = "Updated note";
+    expect(JSON.parse(res._getData())).toStrictEqual({       "error":  {
+        "clientVersion": "3.10.0",
+        "code": "P2025",
+        "meta":  {
+          "cause": "Record to update not found.",
+          },
+      },
+      "message": "apiKey with ID cl16zg6860000wwylnsgva00a not found and wasn't updated", });
+  });
+});
+
+describe("PATCH /api/api-keys/[id]/edit with valid id and no body returns 200 with an apiKey with no note and default expireAt", () => {
+  it("returns a message with the specified apiKeys", async () => {
+    const apiKey = await prisma.apiKey.create({data:{} });
+    const { req, res } = createMocks({
+      method: "PATCH",
+      query: {
+        id: apiKey?.id,
+      },
+    });
+    await handleapiKeyEdit(req, res);
+
+    expect(apiKey?.note).toBeNull();
+    expect(res._getStatusCode()).toBe(200);
+    expect(JSON.parse(res._getData())).toEqual({ data: {...apiKey, createdAt: stringifyISODate(apiKey?.createdAt), expiresAt: stringifyISODate(apiKey?.expiresAt)} });
+  
+  });
+});
+
+describe("POST /api/api-keys/[id]/edit fails, only PATCH allowed", () => {
+  it("returns a message with the specified apiKeys", async () => {
+    const { req, res } = createMocks({
+      method: "POST", // This POST method is not allowed
+      query: {
+        id: "cl16zg6860000wwylnsgva00b",
+      },
+      body: {
+        note: "Updated note",
+      },
+    });
+    await handleapiKeyEdit(req, res);
+
+    expect(res._getStatusCode()).toBe(405);
+    expect(JSON.parse(res._getData())).toStrictEqual({ message: "Only PATCH Method allowed for updating API keys" });
+  });
+});
+
+

tests/api-keys/[id]/api-key.id.index.test.ts

@@ -0,0 +1,78 @@
+import handleApiKey from "@api/api-keys/[id]";
+import { createMocks } from "node-mocks-http";
+
+import prisma from "@calcom/prisma";
+import {stringifyISODate} from "@lib/utils/stringifyISODate";
+
+describe("GET /api/api-keys/[id] with valid id as string returns an apiKey", () => {
+  it("returns a message with the specified apiKeys", async () => {
+    const { req, res } = createMocks({
+      method: "GET",
+      query: {
+        id: "cl16zg6860000wwylnsgva00b",
+      },
+    });
+    const apiKey = await prisma.apiKey.findUnique({ where: { id: req.query.id} });
+    await handleApiKey(req, res);
+
+    expect(res._getStatusCode()).toBe(200);
+    expect(JSON.parse(res._getData())).toEqual({ data: {...apiKey, createdAt: stringifyISODate(apiKey?.createdAt), expiresAt: stringifyISODate(apiKey?.expiresAt)} });
+  });
+});
+
+// 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/api-keys/[id] errors if query id is number, requires a string", () => {
+  it("returns a message with the specified apiKeys", 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 handleApiKey(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/api-keys/[id] an id not present in db like 0, throws 404 not found", () => {
+  it("returns a message with the specified apiKeys", async () => {
+    const { req, res } = createMocks({
+      method: "GET",
+      query: {
+        id: "0", // There's no apiKey  with id 0
+      },
+    });
+    await handleApiKey(req, res);
+
+    expect(res._getStatusCode()).toBe(404);
+    expect(JSON.parse(res._getData())).toStrictEqual({ message: "API key was not found" });
+  });
+});
+
+describe("POST /api/api-keys/[id] fails, only GET allowed", () => {
+  it("returns a message with the specified apiKeys", async () => {
+    const { req, res } = createMocks({
+      method: "POST", // This POST method is not allowed
+      query: {
+        id: "1",
+      },
+    });
+    await handleApiKey(req, res);
+
+    expect(res._getStatusCode()).toBe(405);
+    expect(JSON.parse(res._getData())).toStrictEqual({ message: "Only GET Method allowed" });
+  });
+});
+
+

tests/api-keys/api-key.index.test.ts

@@ -0,0 +1,31 @@
+import handleApiKeys from "@api/api-keys";
+import { createMocks } from "node-mocks-http";
+
+import prisma from "@calcom/prisma";
+import {stringifyISODate} from "@lib/utils/stringifyISODate";
+
+describe("GET /api/api-keys without any params", () => {
+  it("returns a message with the specified apiKeys", async () => {
+    const { req, res } = createMocks({
+      method: "GET",
+      query: {},
+    });
+    let apiKeys = await prisma.apiKey.findMany();
+    await handleApiKeys(req, res);
+
+    expect(res._getStatusCode()).toBe(200);
+    apiKeys = apiKeys.map(apiKey => (apiKey = {...apiKey, createdAt: stringifyISODate(apiKey?.createdAt), expiresAt: stringifyISODate(apiKey?.expiresAt)}));
+    expect(JSON.parse(res._getData())).toStrictEqual(JSON.parse(JSON.stringify({ data: {...apiKeys} })));
+  });
+});
+
+describe("POST /api/api-keys/ fails, only GET allowed", () => {
+  it("returns a message with the specified apiKeys", async () => {
+    const { req, res } = createMocks({
+      method: "POST", // This POST method is not allowed
+    });
+    await handleApiKeys(req, res);
+    expect(res._getStatusCode()).toBe(405);
+    expect(JSON.parse(res._getData())).toStrictEqual({ message: "Only GET Method allowed" });
+  });
+});

tests/api-keys/api-key.new.test.ts

@@ -0,0 +1,71 @@
+import handleNewApiKey from "@api/api-keys/new";
+import { createMocks } from "node-mocks-http";
+
+describe("POST /api/api-keys/new with a note", () => {
+  it("returns a 201, and the created api key", async () => {
+    const { req, res } = createMocks({
+      method: "POST", // This POST method is not allowed
+      body: {
+        note: "Updated note",
+      },
+    });
+    await handleNewApiKey(req, res);
+
+    expect(res._getStatusCode()).toBe(201);
+    expect(JSON.parse(res._getData()).data.note).toStrictEqual("Updated note");
+  });
+});
+
+describe("POST /api/api-keys/new with a slug param", () => {
+  it("returns error 400, and the details about invalid slug body param", async () => {
+    const { req, res } = createMocks({
+      method: "POST", // This POST method is not allowed
+      body: {
+        note: "Updated note",
+        slug: "slug",
+      },
+    });
+    await handleNewApiKey(req, res);
+
+    expect(res._getStatusCode()).toBe(400);
+    expect(JSON.parse(res._getData())).toStrictEqual(
+ [{"code": "unrecognized_keys", "keys": ["slug"], "message": "Unrecognized key(s) in object: 'slug'", "path": []}]
+    );
+  });
+});
+
+
+describe("GET /api/api-keys/new fails, only POST allowed", () => {
+  it("returns a message with the specified apiKeys", async () => {
+    const { req, res } = createMocks({
+      method: "GET", // This POST method is not allowed
+    });
+    await handleNewApiKey(req, res);
+
+    expect(res._getStatusCode()).toBe(405);
+    expect(JSON.parse(res._getData())).toStrictEqual({ error: "Only POST Method allowed" });
+  });
+});
+
+
+// FIXME: test 405 when prisma fails look for how to test prisma errors
+describe("GET /api/api-keys/new fails, only POST allowed", () => {
+  it("returns a message with the specified apiKeys", async () => {
+    const { req, res } = createMocks({
+      method: "POST", // This POST method is not allowed
+      body: {
+        nonExistentParam: true
+        // note: '123',
+        // slug: 12,
+      },
+    });
+    await handleNewApiKey(req, res);
+
+    expect(res._getStatusCode()).toBe(400);
+    expect(JSON.parse(res._getData())).toStrictEqual([{
+      "code": "unrecognized_keys",
+      "keys": ["nonExistentParam"],
+      "message": "Unrecognized key(s) in object: 'nonExistentParam'", "path": []
+    }]);
+  });
+});

tests/event-types/[id]/event-type.id.edit.test.ts

@@ -0,0 +1,92 @@
+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" });
+  });
+});
+
+

tests/event-types/[id]/event-type.id.index.test.ts

@@ -0,0 +1,77 @@
+import handleEventType from "@api/event-types/[id]";
+import { createMocks } from "node-mocks-http";
+
+import prisma from "@calcom/prisma";
+
+describe("GET /api/event-types/[id] with valid id as string returns an event-type", () => {
+  it("returns a message with the specified events", async () => {
+    const { req, res } = createMocks({
+      method: "GET",
+      query: {
+        id: "1",
+      },
+    });
+    const event = await prisma.eventType.findUnique({ where: { id: 1 } });
+    await handleEventType(req, res);
+
+    expect(res._getStatusCode()).toBe(200);
+    expect(JSON.parse(res._getData())).toStrictEqual({ data: event });
+  });
+});
+
+// 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/event-types/[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 handleEventType(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/event-types/[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 event type with id 0
+      },
+    });
+    await handleEventType(req, res);
+
+    expect(res._getStatusCode()).toBe(404);
+    expect(JSON.parse(res._getData())).toStrictEqual({ message: "Event type not found" });
+  });
+});
+
+describe("POST /api/event-types/[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 handleEventType(req, res);
+
+    expect(res._getStatusCode()).toBe(405);
+    expect(JSON.parse(res._getData())).toStrictEqual({ message: "Only GET Method allowed" });
+  });
+});
+
+

tests/event-types/event-type.index.test.ts

@@ -0,0 +1,31 @@
+import handleApiKeys from "@api/event-types";
+import { createMocks } from "node-mocks-http";
+
+import prisma from "@calcom/prisma";
+// import {stringifyISODate} from "@lib/utils/stringifyISODate";
+
+describe("GET /api/event-types without any params", () => {
+  it("returns a message with the specified eventTypes", async () => {
+    const { req, res } = createMocks({
+      method: "GET",
+      query: {},
+    });
+    const eventTypes = await prisma.eventType.findMany();
+    await handleApiKeys(req, res);
+
+    expect(res._getStatusCode()).toBe(200);
+    // eventTypes = eventTypes.map(eventType => (eventType = {...eventType, createdAt: stringifyISODate(eventType?.createdAt), expiresAt: stringifyISODate(eventType?.expiresAt)}));
+    expect(JSON.parse(res._getData())).toStrictEqual(JSON.parse(JSON.stringify({ data: {...eventTypes} })));
+  });
+});
+
+describe("POST /api/event-types/ fails, only GET allowed", () => {
+  it("returns a message with the specified eventTypes", async () => {
+    const { req, res } = createMocks({
+      method: "POST", // This POST method is not allowed
+    });
+    await handleApiKeys(req, res);
+    expect(res._getStatusCode()).toBe(405);
+    expect(JSON.parse(res._getData())).toStrictEqual({ message: "Only GET Method allowed" });
+  });
+});

tests/event-types/event-type.new.test.ts

@@ -0,0 +1,68 @@
+import handleNewApiKey from "@api/api-keys/new";
+import { createMocks } from "node-mocks-http";
+
+describe("POST /api/api-keys/new with a note", () => {
+  it("returns a 201, and the created api key", async () => {
+    const { req, res } = createMocks({
+      method: "POST", // This POST method is not allowed
+      body: {
+        note: "Updated note",
+      },
+    });
+    await handleNewApiKey(req, res);
+
+    expect(res._getStatusCode()).toBe(201);
+    expect(JSON.parse(res._getData()).data.note).toStrictEqual("Updated note");
+  });
+});
+
+
+describe("POST /api/api-keys/new with a slug param", () => {
+  it("returns error 400, and the details about invalid slug body param", async () => {
+    const { req, res } = createMocks({
+      method: "POST", // This POST method is not allowed
+      body: {
+        note: "Updated note",
+        slug: "slug",
+      },
+    });
+    await handleNewApiKey(req, res);
+
+    expect(res._getStatusCode()).toBe(400);
+    expect(JSON.parse(res._getData())).toStrictEqual(
+ [{"code": "unrecognized_keys", "keys": ["slug"], "message": "Unrecognized key(s) in object: 'slug'", "path": []}]
+    );
+  });
+});
+
+
+describe("GET /api/api-keys/new fails, only POST allowed", () => {
+  it("returns a message with the specified apiKeys", async () => {
+    const { req, res } = createMocks({
+      method: "GET", // This POST method is not allowed
+    });
+    await handleNewApiKey(req, res);
+
+    expect(res._getStatusCode()).toBe(405);
+    expect(JSON.parse(res._getData())).toStrictEqual({ error: "Only POST Method allowed" });
+  });
+});
+
+
+// FIXME: test 405 when prisma fails look for how to test prisma errors
+// describe("GET /api/api-keys/new fails, only POST allowed", () => {
+//   it("returns a message with the specified apiKeys", async () => {
+//     const { req, res } = createMocks({
+//       method: "POST", // This POST method is not allowed
+//       body: {
+//         fail: true
+//         // note: '123',
+//         // slug: 12,
+//       },
+//     });
+//     await handleNewApiKey(req, res);
+
+//     expect(res._getStatusCode()).toBe(400);
+//     expect(JSON.parse(res._getData())).toStrictEqual({ error: "Only POST Method allowed" });
+//   });
+// });

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

@@ -0,0 +1,90 @@
+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" });
+  });
+});
+
+

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

@@ -0,0 +1,77 @@
+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" });
+  });
+});
+
+

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

@@ -0,0 +1,92 @@
+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" });
+  });
+});
+
+

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

@@ -0,0 +1,78 @@
+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" });
+  });
+});
+
+