Lecture 07 - Testing

posted over 1 year ago ⋄ 13 min read

Lecture 7 - Testing#

Lecture 7 - Testing

Check-in 2 will be optional, and can be used to replace a missing attendance or the initial check-in. You already get 2 free absences, but if you have more than that this is one way to make that up. If you’re pivoting or need some advice, I’m happy to help out with that.

Feedback and Q&A Forms#

Here is a form for the Q&A session; if I see responses here that are relevant to the next lecture or are frequently asked for, I will do my best to include them in that lecture.
Here is a form for feedback; I will do my best to apply what I can from here to my next lectures. I know I’m getting a biased response talking to people after class, so please help me be less biased!

Lecture 6 Follow-up#

There’s a repo here that talks about getting tRPC set up within the app router that is worth looking at if you’re making that switch or want to start with both tRPC and the app router. tRPC isn’t super compatible with server side rendering in the app router, but on the server side you should have access to the things that tRPC would be querying, anyways.

Webhooks for Users#

Last time I mentioned that one way you might get users locally was to use webhooks. This is how I would do that:

apps/web/app/api/webhooks/user.ts

1
import { prisma } from "@my-app/db/lib/prisma";
2
import { HttpStatusCode } from "@my-app/status-codes";
3
import type { NextRequest } from "next/server";
4
import { NextResponse } from "next/server";
5
import { Webhook } from "svix";
6
import * as z from "zod";
7

8
const UserWebhookUpdateSchema = z.object({
9
  data: z.object({
10
    id: z.string(),
11
    email_addresses: z.array(
12
      z.object({
13
        email_address: z.string(),
14
      })
15
    ),
16
    first_name: z.string().nullable().optional(),
17
    last_name: z.string().nullable().optional(),
18
  }),
19
});
20

21
// Create a schema for the webhooks, choosing a different
22
// type based on the "type" field.
23
const UserWebhookSchema = z.discriminatedUnion("type", [
24
  UserWebhookUpdateSchema.extend({
25
    type: z.literal("user.created"),
26
  }),
27
  UserWebhookUpdateSchema.extend({
28
    type: z.literal("user.updated"),
29
  }),
30
  z.object({
31
    type: z.literal("user.deleted"),
32
    data: z.object({ id: z.string() }),
33
  }),
34
]);
35

36
// Deal with the POST request
37
export async function POST(request: NextRequest): Promise<NextResponse> {
38
  try {
39
    // Make sure that the webhook has the expected parameters
40
    const body = UserWebhookSchema.parse(await request.json());
41

42
    if (body.type === "user.deleted") {
43
      // Remove the user.
44
      await prisma.user.delete({
45
        where: {
46
          id: body.data.id,
47
        },
48
      });
49
    } else {
50
      // Update the user with the given info (or create it,
51
      // if it doesn't exist).
52
      await prisma.user.upsert({
53
        where: {
54
          id: body.data.id,
55
        },
56
        update: {
57
          email: body.data.email_addresses[0]?.email_address,
58
          name: `${body.data.first_name} ${body.data.last_name ?? ""}`.trim(),
59
        },
60
        create: {
61
          id: body.data.id,
62
          email: body.data.email_addresses[0]?.email_address,
63
          name: `${body.data.first_name} ${body.data.last_name ?? ""}`.trim(),
64
        },
65
      });
66
    }
67
    return new NextResponse(undefined, {
68
      status: HttpStatusCode.OK,
69
    });
70
  } catch (e) {
71
    // If we got something in an invalid format, return the
72
    // format error with a 400 error.
73
    if (e instanceof z.ZodError) {
74
      return new NextResponse(JSON.stringify(e), {
75
        status: HttpStatusCode.BAD_REQUEST,
76
      });
77
    }
78

79
    // Prisma "not found" error; pass it on
80
    else if (e.code === "P2025") {
81
      return new NextResponse(undefined, {
82
        status: HttpStatusCode.NOT_FOUND,
83
      });
84
    }
85

86
    // Otherwise, this is probably an us problem.
87
    return new NextResponse(undefined, {
88
      status: HttpStatusCode.INTERNAL_SERVER_ERROR,
89
    });
90
  }
91
}

Now, this isn’t very secure. I can make post requests to this endpoint and create users on my site without needing any authorization or signing or anything. Instead, we should make sure that we verify that the request is sent by Clerk using their signing tokens:

1
import { prisma } from "@my-app/db/lib/prisma";
2
import { HttpStatusCode } from "@my-app/status-codes";
3
import type { NextRequest } from "next/server";
4
import { NextResponse } from "next/server";
5
import { Webhook } from "svix";
6
import * as z from "zod";
7

8
const UserWebhookUpdateSchema = z.object({
9
  data: z.object({
10
    id: z.string(),
11
    email_addresses: z.array(
12
      z.object({
13
        email_address: z.string(),
14
      })
15
    ),
16
    first_name: z.string().nullable().optional(),
17
    last_name: z.string().nullable().optional(),
18
  }),
19
});
20

21
// Create a schema for the webhooks, choosing a different
22
// type based on the "type" field.
23
const UserWebhookSchema = z.discriminatedUnion("type", [
24
  UserWebhookUpdateSchema.extend({
25
    type: z.literal("user.created"),
26
  }),
27
  UserWebhookUpdateSchema.extend({
28
    type: z.literal("user.updated"),
29
  }),
30
  z.object({
31
    type: z.literal("user.deleted"),
32
    data: z.object({ id: z.string() }),
33
  }),
34
]);
35

36
// Get the signing key to prevent spoofing webhooks
37
const { CLERK_USER_WEBHOOK_SECRET_KEY } = process.env;
38

39
// Deal with the POST request
40
export async function POST(request: NextRequest): Promise<NextResponse> {
41
  try {
42
    const payload: unknown = await request.json();
43

44
    if (!CLERK_USER_WEBHOOK_SECRET_KEY) {
45
      throw new Error("Missing CLERK_WEBHOOK_SECRET_KEY");
46
    }
47

48
    // Decode the webhook
49
    const wh = new Webhook(CLERK_USER_WEBHOOK_SECRET_KEY);
50
    const evt = wh.verify(
51
      JSON.stringify(payload),
52
      Object.fromEntries(request.headers.entries())
53
    );
54

55
    // Make sure that the webhook has the expected parameters
56
    const body = UserWebhookSchema.parse(await request.json());
57
    if (body.type === "user.deleted") {
58
      // Remove the user.
59
      await prisma.user.delete({
60
        where: {
61
          id: body.data.id,
62
        },
63
      });
64
    } else {
65
      // Update the user with the given info (or create it,
66
      // if it doesn't exist).
67
      await prisma.user.upsert({
68
        where: {
69
          id: body.data.id,
70
        },
71
        update: {
72
          email: body.data.email_addresses[0]?.email_address,
73
          name: `${body.data.first_name} ${body.data.last_name ?? ""}`.trim(),
74
        },
75
        create: {
76
          id: body.data.id,
77
          email: body.data.email_addresses[0]?.email_address,
78
          name: `${body.data.first_name} ${body.data.last_name ?? ""}`.trim(),
79
        },
80
      });
81
    }
82
    return new NextResponse(undefined, {
83
      status: HttpStatusCode.OK,
84
    });
85
  } catch (e) {
86
    // If we got something in an invalid format, return the
87
    // format error with a 400 error.
88
    if (e instanceof z.ZodError) {
89
      return new NextResponse(JSON.stringify(e), {
90
        status: HttpStatusCode.BAD_REQUEST,
91
      });
92
    }
93

94
    // Deal with requests that aren't signed properly
95
    else if (e instanceof WebhookVerificationError) {
96
      return new NextResponse(undefined, {
97
        status: HttpStatusCode.UNAUTHORIZED,
98
      });
99
    }
100

101
    // Prisma "not found" error; pass it on
102
    else if (e.code === "P2025") {
103
      return new NextResponse(undefined, {
104
        status: HttpStatusCode.NOT_FOUND,
105
      });
106
    }
107

108
    // Otherwise, this is probably an us problem.
109
    return new NextResponse(undefined, {
110
      status: HttpStatusCode.INTERNAL_SERVER_ERROR,
111
    });
112
  }
113
}

Testing an API Route#

Testing is a very important part of any application, in my opinion. Having a fast turnaround time on if new changes have affected critical parts of your application code is a very useful tool when you’re trying to move fast.

I’m going to add the faker package so that I don’t need to come up with test data (and vitest and friends for those who don’t have them already, although I already had that from Lecture 5):

1
cd apps/web
2
pnpm i -D @faker-js/faker vitest @vitejs/plugin-react @testing-library/jest-dom @testing-library/react jsdom
3
cd -

And here’s my config, as a reminder:

apps/web/vitest.config.ts

1
import react from "@vitejs/plugin-react";
2
import { defineConfig } from "vitest/config";
3

4
// https://vitejs.dev/config/
5
export default defineConfig({
6
  plugins: [react()],
7
  test: {
8
    environment: "jsdom",
9
    exclude: ["**/node_modules/**", "e2e/**", "*.test.ts"],
10
  },
11
});

For this instance, I’m testing a webhook route, but the principle holds for other types of API routes. I’m going to start with a small refactor to the above webhook route. Because I’m not interested in signing my test requests, I’m not going to validate them, either. This is accomplished via dependency injection, using serverContainer to create an authorizer. This means extracting the functionality into a service:

apps/web/api/webhooks/user/userwebhookhandler.ts

1
import { prisma } from "@pointcontrol/db/lib/prisma";
2
import { HttpStatusCode } from "@pointcontrol/status-codes";
3
import { NextResponse } from "next/server";
4
import * as z from "zod";
5
import { inject, injectable } from "tsyringe";
6
import type { UserWebhookAuthorizer } from "./userwebhookauthorizer";
7

8
@injectable()
9
export class UserWebhookHandler {
10
  private static UpdateSchema = z.object({
11
    data: z.object({
12
      id: z.string(),
13
      email_addresses: z.array(
14
        z.object({
15
          email_address: z.string(),
16
        })
17
      ),
18
      first_name: z.string().nullable().optional(),
19
      last_name: z.string().nullable().optional(),
20
    }),
21
  });
22

23
  private static Schema = z.discriminatedUnion("type", [
24
    UserWebhookHandler.UpdateSchema.extend({
25
      type: z.literal("user.created"),
26
    }),
27
    UserWebhookHandler.UpdateSchema.extend({
28
      type: z.literal("user.updated"),
29
    }),
30
    z.object({
31
      type: z.literal("user.deleted"),
32
      data: z.object({ id: z.string() }),
33
    }),
34
  ]);
35
  constructor(
36
    @inject("UserWebhookAuthorizer")
37
    private readonly webhookAuthorizer: UserWebhookAuthorizer
38
  ) {}
39

40
  public readonly POST: (
41
    request: Request
42
  ) => ReturnType<UserWebhookHandler["_POST"]> = this._POST.bind(this);
43

44
  private async _POST(request: Request): Promise<NextResponse> {
45
    try {
46
      const json: unknown = await request.json();
47
      if (!(await this.webhookAuthorizer.isAuthorized(request, json))) {
48
        return new NextResponse(null, {
49
          status: HttpStatusCode.UNAUTHORIZED,
50
        });
51
      }
52
      const body = UserWebhookHandler.Schema.parse(json);
53
      if (body.type === "user.deleted") {
54
        await prisma.user.delete({
55
          where: {
56
            id: body.data.id,
57
          },
58
        });
59
      } else {
60
        await prisma.user.upsert({
61
          where: {
62
            id: body.data.id,
63
          },
64
          update: {
65
            email: body.data.email_addresses[0]?.email_address,
66
            name: `${body.data.first_name} ${body.data.last_name ?? ""}`.trim(),
67
          },
68
          create: {
69
            id: body.data.id,
70
            email: body.data.email_addresses[0]?.email_address,
71
            name: `${body.data.first_name} ${body.data.last_name ?? ""}`.trim(),
72
          },
73
        });
74
      }
75
      return new NextResponse(undefined, {
76
        status: HttpStatusCode.OK,
77
      });
78
    } catch (e) {
79
      if (e instanceof z.ZodError) {
80
        return new NextResponse(JSON.stringify(e), {
81
          status: HttpStatusCode.BAD_REQUEST,
82
        });
83
      }
84
      // Prisma "not found" error
85
      else if (e.code === "P2025") {
86
        return new NextResponse(undefined, {
87
          status: HttpStatusCode.NOT_FOUND,
88
        });
89
      }
90
      return new NextResponse(undefined, {
91
        status: HttpStatusCode.INTERNAL_SERVER_ERROR,
92
      });
93
    }
94
  }
95
}

And then the route.ts is just a super thin interface to that handler:

apps/web/api/webhooks/user/route.ts

1
import { serverContainer } from "../../../../util/server-container";
2
import { UserWebhookHandler } from "./userwebhookhandler";
3

4
const handler = serverContainer.resolve(UserWebhookHandler);
5

6
export const POST = handler.POST;

First I’ll create an interface to represent my authorizers in general:

apps/web/app/api/webhooks/user/userwebhookauthorizer.ts

1
export interface UserWebhookAuthorizer {
2
  isAuthorized: (request: Request, body: unknown) => Promise<boolean>;
3
}

Now I’ll create both authorizers. First, the one for svix, and the one we want to use in dev and production modes:

apps/web/app/api/webhooks/user/svixuserwebhookauthorizer.ts

1
import type { NextRequest } from "next/server";
2
import { injectable } from "tsyringe";
3
import { Webhook } from "svix";
4

5
const { CLERK_USER_WEBHOOK_SECRET_KEY } = process.env;
6

7
@injectable()
8
export class SvixUserWebhookAuthorizer {
9
  private readonly key: string;
10

11
  constructor() {
12
    if (!CLERK_USER_WEBHOOK_SECRET_KEY) {
13
      throw new Error("Missing CLERK_USER_WEBHOOK_SECRET_KEY");
14
    }
15
    this.key = CLERK_USER_WEBHOOK_SECRET_KEY;
16
  }
17

18
  isAuthorized(request: NextRequest, body: unknown): Promise<boolean> {
19
    try {
20
      const wh = new Webhook(this.key);
21
      const _ = wh.verify(
22
        JSON.stringify(body),
23
        Object.fromEntries(request.headers.entries())
24
      );
25
      return Promise.resolve(true);
26
    } catch (_) {
27
      return Promise.resolve(false);
28
    }
29
  }
30
}

And the null one that just lets every request through, for test mode:

apps/web/app/api/webhooks/user/nulluserwebhookauthorizer.ts

1
import type { NextRequest } from "next/server";
2
import { injectable } from "tsyringe";
3
import type { UserWebhookAuthorizer } from "./userwebhookauthorizer";
4

5
@injectable()
6
export class NullUserWebhookAuthorizer implements UserWebhookAuthorizer {
7
  isAuthorized(_request: NextRequest, _body: unknown): Promise<boolean> {
8
    return Promise.resolve(true);
9
  }
10
}

Now I’ll create a server injector, and inject the Svix authorizer by default:

apps/web/util/server-container.ts

1
import { container } from "tsyringe";
2
import { SvixUserWebhookAuthorizer } from "../app/api/webhooks/user/svixuserwebhookauthorizer";
3
import "reflect-metadata";
4

5
export const serverContainer = container.createChildContainer();
6

7
serverContainer.registerSingleton(
8
  "UserWebhookAuthorizer",
9
  SvixUserWebhookAuthorizer
10
);

And update my run scripts for tests (and the other ones to allow for running with injection):

apps/web/package.json

1
{
2
  "scripts": {
3
    "withenv": "dotenv -e ../../.env --",
4
    "dev": "cross-env NODE_OPTIONS=\"--require reflect-metadata\" pnpm withenv next dev",
5
    "build": "cross-env NODE_OPTIONS=\"--require reflect-metadata\" next build",
6
    "start": "cross-env NODE_OPTIONS=\"--require reflect-metadata\" next start",
7
    "lint": "next lint",
8
    "format": "prettier --check \"**/*.{js,jsx,cjs,mjs,prisma,ts,tsx,md,json}\"",
9
    "test:e2e": "cross-env NODE_OPTIONS=\"--require reflect-metadata\" NODE_ENV=test pnpm withenv playwright test",
10
    "test": "cross-env NODE_OPTIONS=\"--require reflect-metadata\" NODE_ENV=test pnpm withenv vitest"
11
  }
12
}

I’m not super happy with this approach since it requires stacking a bunch of required info into a couple scripts, but the Next team has been pretty quiet on this issue.

Now for my test:

apps/web/api/webhooks/user/route.spec.ts

1
import { describe, it, expect, beforeAll } from "vitest";
2
import { faker } from "@faker-js/faker";
3
import { UserWebhookHandler } from "./route";
4
import { container } from "tsyringe";
5
import { NullUserWebhookAuthorizer } from "./nulluserwebhookauthorizer";
6

7
// @vitest-environment node
8
describe(module.id, () => {
9
  let POST: Pick<UserWebhookHandler, "POST">["POST"];
10

11
  beforeAll(() => {
12
    POST = container
13
      .createChildContainer()
14
      .register("UserWebhookAuthorizer", NullUserWebhookAuthorizer)
15
      .resolve(UserWebhookHandler).POST;
16
  });
17

18
  describe("create and delete a user", () => {
19
    const userId = `user_${faker.string.fromCharacters(
20
      "abcdefghijklmnopqrstuvwxyz0123456789",
21
      27
22
    )}`;
23

24
    it("should create a user", async () => {
25
      const first = faker.person.firstName();
26
      const last = faker.person.lastName();
27
      const createReq = new Request("localhost:3000/api/webhooks/user", {
28
        body: JSON.stringify({
29
          type: "user.created",
30
          data: {
31
            id: userId,
32
            email_addresses: [
33
              {
34
                email_address: faker.internet.email({
35
                  firstName: first,
36
                  lastName: last,
37
                  provider: "example.com",
38
                }),
39
              },
40
            ],
41
            first_name: first,
42
            last_name: last,
43
          },
44
        }),
45
        method: "POST",
46
      });
47

48
      const createRes = await POST(createReq);
49
      expect(createRes.status).toBe(200);
50
    });
51

52
    it("should 400 on mangled bodies", async () => {
53
      const first = faker.person.firstName();
54
      const last = faker.person.lastName();
55
      const createReq = new Request("localhost:3000/api/webhooks/user", {
56
        body: JSON.stringify({
57
          type: "user.created",
58
          data: {
59
            email_addresses: [
60
              {
61
                email_address: faker.internet.email({
62
                  firstName: first,
63
                  lastName: last,
64
                  provider: "example.com",
65
                }),
66
              },
67
            ],
68
          },
69
        }),
70
        method: "POST",
71
      });
72

73
      const createRes = await POST(createReq);
74
      expect(createRes.status).toBe(400);
75
    });
76

77
    it("should 400 on invalid 'type's", async () => {
78
      const first = faker.person.firstName();
79
      const last = faker.person.lastName();
80
      const createReq = new Request("localhost:3000/api/webhooks/user", {
81
        body: JSON.stringify({
82
          type: "user.other",
83
          data: {
84
            id: userId,
85
            email_addresses: [
86
              {
87
                email_address: faker.internet.email({
88
                  firstName: first,
89
                  lastName: last,
90
                  provider: "example.com",
91
                }),
92
              },
93
            ],
94
            first_name: first,
95
            last_name: last,
96
          },
97
        }),
98
        method: "POST",
99
      });
100

101
      const createRes = await POST(createReq);
102
      expect(createRes.status).toBe(400);
103
    });
104

105
    it("should delete a user", async () => {
106
      const body = {
107
        type: "user.deleted",
108
        data: {
109
          id: userId,
110
        },
111
      };
112

113
      const deleteReq = new Request("localhost:3000/api/webhooks/user", {
114
        body: JSON.stringify(body),
115
        method: "POST",
116
      });
117

118
      // Should be fine the first time we ask for it
119
      const deleteRes = await POST(deleteReq);
120
      expect(deleteRes.status).toBe(200);
121

122
      const deleteReq2 = new Request("localhost:3000/api/webhooks/user", {
123
        body: JSON.stringify(body),
124
        method: "POST",
125
      });
126
      // Shouldn't find anything the next time and error
127
      const deleteRes2 = await POST(deleteReq2);
128
      expect(deleteRes2.status).toBe(404);
129
    });
130
  });
131
});

I use three names for my test files:

[name].spec.ts for the actual tests
[name].test.ts for any test-related code for that class that are not the actual tests
[name].mock.ts for any mock versions of that class

Testing a tRPC Mutation#

Testing tRPC queries and mutations is much simpler. I’m still going to do that with a database, but by constructing your context the right way you can get away with just in-memory tests as well.

First, I’m going to add vitest to my api package:

1
cd packages/api
2
pnpm i -D vitest @faker-js/faker

First, I need some utilities to create authentication contexts. I’m going to write them, (but probably copy them in class because they’re really long):

packages/api/src/context.test.ts

1
import { SignedInAuthObject, SignedOutAuthObject, User } from "@clerk/backend";
2
import { prisma } from "@pointcontrol/db/lib/prisma";
3
import { faker } from "@faker-js/faker";
4

5
export function withAnonContext<R extends void | Promise<void>>(
6
  run: (params: {
7
    ctx: { prisma: typeof prisma; auth: SignedOutAuthObject };
8
  }) => R
9
): R {
10
  return run({
11
    ctx: {
12
      prisma,
13
      auth: {
14
        sessionClaims: null,
15
        sessionId: null,
16
        session: null,
17
        actor: null,
18
        userId: null,
19
        user: null,
20
        orgId: null,
21
        orgRole: null,
22
        orgSlug: null,
23
        organization: null,
24
      },
25
    } as {
26
      prisma: typeof prisma;
27
      auth: SignedOutAuthObject;
28
    },
29
  });
30
}
31

32
export async function withAuthContext<R>(
33
  run: (params: {
34
    userId: string;
35
    ctx: {
36
      prisma: typeof prisma;
37
      auth: SignedInAuthObject;
38
    };
39
  }) => R,
40
  authPartial?: Partial<Exclude<SignedInAuthObject, "userId">>,
41
  userPartial?: Partial<Exclude<Exclude<User, "id">, "email_addresses">>
42
): R {
43
  const userId = `user_${faker.string.fromCharacters(
44
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
45
    27
46
  )}`;
47

48
  const firstName = faker.person.firstName();
49
  const lastName = faker.person.lastName();
50

51
  const email = faker.internet.email({
52
    firstName,
53
    lastName,
54
    provider: "example.com",
55
  });
56

57
  const data = {
58
    ...authPartial,
59
    userId,
60
  };
61

62
  await prisma.user.create({
63
    data: {
64
      id: userId,
65
      email,
66
      name: `${firstName} ${lastName}`,
67
    },
68
  });
69

70
  const params = {
71
    userId,
72
    ctx: {
73
      prisma,
74
      auth: {
75
        sessionClaims: null,
76
        sessionId: null,
77
        session: null,
78
        actor: null,
79
        user: {
80
          id: data.userId,
81
          passwordEnabled: false,
82
          totpEnabled: false,
83
          backupCodeEnabled: false,
84
          twoFactorEnabled: false,
85
          banned: false,
86
          createdAt: Date.now(),
87
          updatedAt: Date.now(),
88
          profileImageUrl: "",
89
          imageUrl: "",
90
          hasImage: false,
91
          gender: "",
92
          birthday: "",
93
          primaryEmailAddressId: null,
94
          primaryPhoneNumberId: null,
95
          primaryWeb3WalletId: null,
96
          lastSignInAt: null,
97
          externalId: null,
98
          username: null,
99
          firstName,
100
          lastName,
101
          emailAddresses: [
102
            {
103
              email,
104
            },
105
          ],
106
          ...userPartial,
107
        },
108
        orgId: null,
109
        orgRole: null,
110
        orgSlug: null,
111
        organization: null,
112
        ...data,
113
      },
114
    } as {
115
      prisma: typeof prisma;
116
      auth: SignedInAuthObject;
117
    },
118
  };
119

120
  const res = run(params);
121
  if (res instanceof Promise) {
122
    await res;
123
  }
124

125
  await prisma.user.delete({
126
    where: {
127
      id: userId,
128
    },
129
  });
130
}

And now for my tests:

packages/api/src/index.spec.ts

1
import { describe, expect, it } from "vitest";
2
import { appRouter } from "./index";
3
import { withAnonContext, withAuthContext } from "./context.test";
4

5
describe(module.id, () => {
6
  describe("createGame", () => {
7
    it("should create a game when authenticated", async () => {
8
      return withAuthContext(async ({ ctx }) => {
9
        const caller = appRouter.createCaller(ctx);
10

11
        const { slug } = await caller.createGame({
12
          title: "Test Game",
13
          description: "This is a test game.",
14
          location: "Test Location",
15
          public: true,
16
          approval: true,
17
        });
18

19
        expect(slug).toBeDefined();
20

21
        // Clean up afterwards
22
        await ctx.prisma.game.delete({
23
          where: {
24
            slug,
25
          },
26
        });
27
      });
28
    });
29

30
    it("should not create a game when unauthenticated", async () => {
31
      return withAnonContext(async ({ ctx }) => {
32
        const caller = appRouter.createCaller(ctx);
33

34
        const promise = caller.createGame({
35
          title: "Test Game",
36
          description: "This is a test game.",
37
          location: "Test Location",
38
          public: true,
39
          approval: true,
40
        });
41
        await expect(promise).rejects.toThrowError();
42
      });
43
    });
44
  });
45
});