public-offering
/
cal.pub0.org
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

remove old tests for now, add new tests later

pull/9078/head
Agusti Fernandez Pardo 2022-04-21 01:31:36 +02:00
parent ccd8637ae6
commit 00bd2ed6e1
12 changed files with 0 additions and 990 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

116
tests/bookings/[id]/booking.id.edit.test.ts
View File

@ -1,116 +0,0 @@
import handleBookingEdit from "@api/bookings/[id]/edit";
import { createMocks } from "node-mocks-http";
import prisma from "@calcom/prisma";
describe("PATCH /api/bookings/[id]/edit with valid id and body updates an booking", () => {
it("returns a message with the specified bookings", async () => {
const { req, res } = createMocks({
method: "PATCH",
query: {
id: "2",
},
body: {
title: "Updated title",
slug: "updated-slug",
length: 1,
},
});
const booking = await prisma.booking.findUnique({ where: { id: parseInt(req.query.id) } });
await handleBookingEdit(req, res);
expect(res._getStatusCode()).toBe(200);
if (booking) booking.title = "Updated title";
expect(JSON.parse(res._getData())).toStrictEqual({ data: booking });
});
});
describe("PATCH /api/bookings/[id]/edit with invalid id returns 404", () => {
it("returns a message with the specified bookings", async () => {
const { req, res } = createMocks({
method: "PATCH",
query: {
id: "0",
},
body: {
title: "Updated title",
slug: "updated-slug",
length: 1,
},
});
const booking = await prisma.booking.findUnique({ where: { id: parseInt(req.query.id) } });
await handleBookingEdit(req, res);
expect(res._getStatusCode()).toBe(404);
if (booking) booking.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/bookings/[id]/edit with valid id and no body returns 400 error and zod validation errors", () => {
it("returns a message with the specified bookings", async () => {
const { req, res } = createMocks({
method: "PATCH",
query: {
id: "2",
},
});
await handleBookingEdit(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/bookings/[id]/edit fails, only PATCH allowed", () => {
it("returns a message with the specified bookings", 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 handleBookingEdit(req, res);
expect(res._getStatusCode()).toBe(405);
expect(JSON.parse(res._getData())).toStrictEqual({
message: "Only PATCH Method allowed for updating bookings",
});
});
});

84
tests/bookings/[id]/booking.id.index.test.ts
View File

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

39
tests/bookings/booking.index.test.ts
View File

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

77
tests/bookings/booking.new.test.ts
View File

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

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

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

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

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

32
tests/event-types/event-type.index.test.ts
View File

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

70
tests/event-types/event-type.new.test.ts
View File

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

107
tests/teams/[id]/team.id.edit.test.ts
View File

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

75
tests/teams/[id]/team.id.index.test.ts
View File

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

116
tests/users/[id]/user.id.edit.test.ts
View File

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

83
tests/users/[id]/user.id.index.test.ts
View File

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