chore(server): move server tests folder (#9614)

packages/backend/server/src/__tests__/utils/blobs.ts

@@ -0,0 +1,97 @@
+import type { INestApplication } from '@nestjs/common';
+import request from 'supertest';
+
+import { gql } from './common';
+
+export async function listBlobs(
+  app: INestApplication,
+  token: string,
+  workspaceId: string
+): Promise<string[]> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            query {
+              listBlobs(workspaceId: "${workspaceId}")
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.data.listBlobs;
+}
+
+export async function getWorkspaceBlobsSize(
+  app: INestApplication,
+  token: string,
+  workspaceId: string
+): Promise<number> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .send({
+      query: `
+              query {
+                workspace(id: "${workspaceId}") {
+                  blobsSize
+                }
+              }
+            `,
+    })
+    .expect(200);
+  return res.body.data.workspace.blobsSize;
+}
+
+export async function collectAllBlobSizes(
+  app: INestApplication,
+  token: string
+): Promise<number> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .send({
+      query: `
+              query {
+                currentUser {
+                  quotaUsage {
+                    storageQuota
+                  }
+                }
+              }
+            `,
+    })
+    .expect(200);
+  return res.body.data.currentUser.quotaUsage.storageQuota;
+}
+
+export async function setBlob(
+  app: INestApplication,
+  token: string,
+  workspaceId: string,
+  buffer: Buffer
+): Promise<string> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .field(
+      'operations',
+      JSON.stringify({
+        name: 'setBlob',
+        query: `mutation setBlob($blob: Upload!) {
+              setBlob(workspaceId: "${workspaceId}", blob: $blob)
+            }`,
+        variables: { blob: null },
+      })
+    )
+    .field('map', JSON.stringify({ '0': ['variables.blob'] }))
+    .attach(
+      '0',
+      buffer,
+      `blob-${Math.random().toString(16).substring(2, 10)}.data`
+    )
+    .expect(200);
+  return res.body.data.setBlob;
+}

packages/backend/server/src/__tests__/utils/common.ts

@@ -0,0 +1 @@
+export const gql = '/graphql';

packages/backend/server/src/__tests__/utils/feature.ts

@@ -0,0 +1,27 @@
+import { Injectable } from '@nestjs/common';
+import { PrismaClient, WorkspaceMemberStatus } from '@prisma/client';
+
+import { Permission } from '../../core/permission';
+import { UserType } from '../../core/user/types';
+
+@Injectable()
+export class WorkspaceResolverMock {
+  constructor(private readonly prisma: PrismaClient) {}
+
+  async createWorkspace(user: UserType, _init: null) {
+    const workspace = await this.prisma.workspace.create({
+      data: {
+        public: false,
+        permissions: {
+          create: {
+            type: Permission.Owner,
+            userId: user.id,
+            accepted: true,
+            status: WorkspaceMemberStatus.Accepted,
+          },
+        },
+      },
+    });
+    return workspace;
+  }
+}

packages/backend/server/src/__tests__/utils/index.ts

@@ -0,0 +1,5 @@
+export * from './blobs';
+export * from './invite';
+export * from './user';
+export * from './utils';
+export * from './workspace';

packages/backend/server/src/__tests__/utils/invite.ts

@@ -0,0 +1,281 @@
+import type { INestApplication } from '@nestjs/common';
+import request from 'supertest';
+
+import type { InvitationType } from '../../core/workspaces';
+import { gql } from './common';
+
+export async function inviteUser(
+  app: INestApplication,
+  token: string,
+  workspaceId: string,
+  email: string,
+  sendInviteMail = false
+): Promise<string> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+              invite(workspaceId: "${workspaceId}", email: "${email}", sendInviteMail: ${sendInviteMail})
+            }
+          `,
+    })
+    .expect(200);
+  if (res.body.errors) {
+    throw new Error(res.body.errors[0].message);
+  }
+  return res.body.data.invite;
+}
+
+export async function inviteUsers(
+  app: INestApplication,
+  token: string,
+  workspaceId: string,
+  emails: string[],
+  sendInviteMail = false
+): Promise<Array<{ email: string; inviteId?: string; sentSuccess?: boolean }>> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+          mutation inviteBatch($workspaceId: String!, $emails: [String!]!, $sendInviteMail: Boolean) {
+            inviteBatch(
+              workspaceId: $workspaceId
+              emails: $emails
+              sendInviteMail: $sendInviteMail
+            ) {
+              email
+              inviteId
+              sentSuccess
+            }
+          }
+          `,
+      variables: { workspaceId, emails, sendInviteMail },
+    })
+    .expect(200);
+  if (res.body.errors) {
+    throw new Error(res.body.errors[0].message);
+  }
+  return res.body.data.inviteBatch;
+}
+
+export async function getInviteLink(
+  app: INestApplication,
+  token: string,
+  workspaceId: string
+): Promise<{ link: string; expireTime: string }> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+          query {
+            workspace(id: "${workspaceId}") {
+              inviteLink {
+                link
+                expireTime
+              }
+            }
+          }
+          `,
+    })
+    .expect(200);
+  if (res.body.errors) {
+    throw new Error(res.body.errors[0].message);
+  }
+  return res.body.data.workspace.inviteLink;
+}
+
+export async function createInviteLink(
+  app: INestApplication,
+  token: string,
+  workspaceId: string,
+  expireTime: 'OneDay' | 'ThreeDays' | 'OneWeek' | 'OneMonth'
+): Promise<{ link: string; expireTime: string }> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+              createInviteLink(workspaceId: "${workspaceId}", expireTime: ${expireTime}) {
+                link
+                expireTime
+              }
+            }
+          `,
+    })
+    .expect(200);
+  if (res.body.errors) {
+    throw new Error(res.body.errors[0].message);
+  }
+  return res.body.data.createInviteLink;
+}
+
+export async function revokeInviteLink(
+  app: INestApplication,
+  token: string,
+  workspaceId: string
+): Promise<boolean> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+              revokeInviteLink(workspaceId: "${workspaceId}")
+            }
+          `,
+    })
+    .expect(200);
+  if (res.body.errors) {
+    throw new Error(res.body.errors[0].message);
+  }
+  return res.body.data.revokeInviteLink;
+}
+
+export async function acceptInviteById(
+  app: INestApplication,
+  workspaceId: string,
+  inviteId: string,
+  sendAcceptMail = false,
+  token: string = ''
+): Promise<boolean> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .auth(token, { type: 'bearer' })
+    .send({
+      query: `
+            mutation {
+              acceptInviteById(workspaceId: "${workspaceId}", inviteId: "${inviteId}", sendAcceptMail: ${sendAcceptMail})
+            }
+          `,
+    })
+    .expect(200);
+  if (res.body.errors) {
+    throw new Error(res.body.errors[0].message, {
+      cause: res.body.errors[0].cause,
+    });
+  }
+  return res.body.data.acceptInviteById;
+}
+
+export async function approveMember(
+  app: INestApplication,
+  token: string,
+  workspaceId: string,
+  userId: string
+): Promise<string> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .auth(token, { type: 'bearer' })
+    .send({
+      query: `
+          mutation {
+            approveMember(workspaceId: "${workspaceId}", userId: "${userId}")
+          }
+          `,
+    })
+    .expect(200);
+  if (res.body.errors) {
+    throw new Error(res.body.errors[0].message, {
+      cause: res.body.errors[0].cause,
+    });
+  }
+  return res.body.data.approveMember;
+}
+
+export async function leaveWorkspace(
+  app: INestApplication,
+  token: string,
+  workspaceId: string,
+  sendLeaveMail = false
+): Promise<boolean> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+              leaveWorkspace(workspaceId: "${workspaceId}", sendLeaveMail: ${sendLeaveMail})
+            }
+          `,
+    })
+    .expect(200);
+  if (res.body.errors) {
+    throw new Error(res.body.errors[0].message);
+  }
+  return res.body.data.leaveWorkspace;
+}
+
+export async function revokeUser(
+  app: INestApplication,
+  token: string,
+  workspaceId: string,
+  userId: string
+): Promise<boolean> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+              revoke(workspaceId: "${workspaceId}", userId: "${userId}")
+            }
+          `,
+    })
+    .expect(200);
+  if (res.body.errors) {
+    throw new Error(res.body.errors[0].message, {
+      cause: res.body.errors[0].cause,
+    });
+  }
+  return res.body.data.revoke;
+}
+
+export async function getInviteInfo(
+  app: INestApplication,
+  token: string,
+  inviteId: string
+): Promise<InvitationType> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            query {
+              getInviteInfo(inviteId: "${inviteId}") {
+                workspace {
+                  id
+                  name
+                  avatar
+                }
+                user {
+                  id
+                  name
+                  avatarUrl
+                }
+              }
+            }
+          `,
+    })
+    .expect(200);
+  if (res.body.errors) {
+    throw new Error(res.body.errors[0].message, {
+      cause: res.body.errors[0].cause,
+    });
+  }
+  return res.body.data.getInviteInfo;
+}

packages/backend/server/src/__tests__/utils/user.ts

@@ -0,0 +1,200 @@
+import type { INestApplication } from '@nestjs/common';
+import request, { type Response } from 'supertest';
+
+import {
+  AuthService,
+  type ClientTokenType,
+  type CurrentUser,
+} from '../../core/auth';
+import { sessionUser } from '../../core/auth/service';
+import { UserService, type UserType } from '../../core/user';
+import { gql } from './common';
+
+export type UserAuthedType = UserType & { token: ClientTokenType };
+
+export async function internalSignIn(app: INestApplication, userId: string) {
+  const auth = app.get(AuthService);
+
+  const session = await auth.createUserSession(userId);
+
+  return `${AuthService.sessionCookieName}=${session.sessionId}`;
+}
+
+export function sessionCookie(headers: any): string {
+  const cookie = headers['set-cookie']?.find((c: string) =>
+    c.startsWith(`${AuthService.sessionCookieName}=`)
+  );
+
+  if (!cookie) {
+    return '';
+  }
+
+  return cookie.split(';')[0];
+}
+
+export async function getSession(
+  app: INestApplication,
+  signInRes: Response
+): Promise<{ user?: CurrentUser }> {
+  const cookie = sessionCookie(signInRes.headers);
+  const res = await request(app.getHttpServer())
+    .get('/api/auth/session')
+    .set('cookie', cookie!)
+    .expect(200);
+
+  return res.body;
+}
+
+export async function signUp(
+  app: INestApplication,
+  name: string,
+  email: string,
+  password: string,
+  autoVerifyEmail = true
+): Promise<UserAuthedType> {
+  const user = await app.get(UserService).createUser({
+    name,
+    email,
+    password,
+    emailVerifiedAt: autoVerifyEmail ? new Date() : null,
+  });
+  const { sessionId } = await app.get(AuthService).createUserSession(user.id);
+
+  return {
+    ...sessionUser(user),
+    token: { token: sessionId, refresh: '' },
+  };
+}
+
+export async function currentUser(app: INestApplication, token: string) {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            query {
+              currentUser {
+                id, name, email, emailVerified, avatarUrl, hasPassword,
+                token { token }
+              }
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.data.currentUser;
+}
+
+export async function sendChangeEmail(
+  app: INestApplication,
+  userToken: string,
+  email: string,
+  callbackUrl: string
+): Promise<boolean> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(userToken, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+              sendChangeEmail(email: "${email}", callbackUrl: "${callbackUrl}")
+            }
+          `,
+    })
+    .expect(200);
+
+  return res.body.data.sendChangeEmail;
+}
+
+export async function sendSetPasswordEmail(
+  app: INestApplication,
+  userToken: string,
+  email: string,
+  callbackUrl: string
+): Promise<boolean> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(userToken, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+              sendSetPasswordEmail(email: "${email}", callbackUrl: "${callbackUrl}")
+            }
+          `,
+    })
+    .expect(200);
+
+  return res.body.data.sendChangeEmail;
+}
+
+export async function changePassword(
+  app: INestApplication,
+  userId: string,
+  token: string,
+  password: string
+): Promise<string> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation changePassword($token: String!, $userId: String!, $password: String!) {
+              changePassword(token: $token, userId: $userId, newPassword: $password)
+            }
+          `,
+      variables: { token, password, userId },
+    })
+    .expect(200);
+  return res.body.data.changePassword;
+}
+
+export async function sendVerifyChangeEmail(
+  app: INestApplication,
+  userToken: string,
+  token: string,
+  email: string,
+  callbackUrl: string
+): Promise<boolean> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(userToken, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+              sendVerifyChangeEmail(token:"${token}", email: "${email}", callbackUrl: "${callbackUrl}")
+            }
+          `,
+    })
+    .expect(200);
+
+  return res.body.data.sendVerifyChangeEmail;
+}
+
+export async function changeEmail(
+  app: INestApplication,
+  userToken: string,
+  token: string,
+  email: string
+): Promise<UserAuthedType> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(userToken, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+               changeEmail(token: "${token}", email: "${email}") {
+                id
+                name
+                avatarUrl
+                email
+              }
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.data.changeEmail;
+}

packages/backend/server/src/__tests__/utils/utils.ts

@@ -0,0 +1,190 @@
+import { INestApplication, ModuleMetadata } from '@nestjs/common';
+import { APP_GUARD } from '@nestjs/core';
+import { Query, Resolver } from '@nestjs/graphql';
+import { Test, TestingModuleBuilder } from '@nestjs/testing';
+import { PrismaClient } from '@prisma/client';
+import cookieParser from 'cookie-parser';
+import graphqlUploadExpress from 'graphql-upload/graphqlUploadExpress.mjs';
+import type { Response } from 'supertest';
+import supertest from 'supertest';
+
+import { AppModule, FunctionalityModules } from '../../app.module';
+import { GlobalExceptionFilter, Runtime } from '../../base';
+import { GqlModule } from '../../base/graphql';
+import { AuthGuard, AuthModule } from '../../core/auth';
+import { UserFeaturesInit1698652531198 } from '../../data/migrations/1698652531198-user-features-init';
+import { ModelModules } from '../../models';
+
+export type PermissionEnum = 'Owner' | 'Admin' | 'Write' | 'Read';
+
+async function flushDB(client: PrismaClient) {
+  const result: { tablename: string }[] =
+    await client.$queryRaw`SELECT tablename
+                           FROM pg_catalog.pg_tables
+                           WHERE schemaname != 'pg_catalog'
+                             AND schemaname != 'information_schema'`;
+
+  // remove all table data
+  await client.$executeRawUnsafe(
+    `TRUNCATE TABLE ${result
+      .map(({ tablename }) => tablename)
+      .filter(name => !name.includes('migrations'))
+      .join(', ')}`
+  );
+}
+
+async function initFeatureConfigs(db: PrismaClient) {
+  await UserFeaturesInit1698652531198.up(db);
+}
+
+export async function initTestingDB(db: PrismaClient) {
+  await flushDB(db);
+  await initFeatureConfigs(db);
+}
+
+interface TestingModuleMeatdata extends ModuleMetadata {
+  tapModule?(m: TestingModuleBuilder): void;
+  tapApp?(app: INestApplication): void;
+}
+
+function dedupeModules(modules: NonNullable<ModuleMetadata['imports']>) {
+  const map = new Map();
+
+  modules.forEach(m => {
+    if ('module' in m) {
+      map.set(m.module, m);
+    } else {
+      map.set(m, m);
+    }
+  });
+
+  return Array.from(map.values());
+}
+
+@Resolver(() => String)
+class MockResolver {
+  @Query(() => String)
+  hello() {
+    return 'hello world';
+  }
+}
+
+export async function createTestingModule(
+  moduleDef: TestingModuleMeatdata = {},
+  init = true
+) {
+  // setting up
+  let imports = moduleDef.imports ?? [];
+  imports =
+    imports[0] === AppModule
+      ? [AppModule]
+      : dedupeModules([
+          ...FunctionalityModules,
+          ModelModules,
+          AuthModule,
+          GqlModule,
+          ...imports,
+        ]);
+
+  const builder = Test.createTestingModule({
+    imports,
+    providers: [
+      {
+        provide: APP_GUARD,
+        useClass: AuthGuard,
+      },
+      MockResolver,
+      ...(moduleDef.providers ?? []),
+    ],
+    controllers: moduleDef.controllers,
+  });
+
+  if (moduleDef.tapModule) {
+    moduleDef.tapModule(builder);
+  }
+
+  const m = await builder.compile();
+
+  const prisma = m.get(PrismaClient);
+  if (prisma instanceof PrismaClient) {
+    await initTestingDB(prisma);
+  }
+
+  if (init) {
+    await m.init();
+
+    const runtime = m.get(Runtime);
+    // by pass password min length validation
+    await runtime.set('auth/password.min', 1);
+  }
+
+  return m;
+}
+
+export async function createTestingApp(moduleDef: TestingModuleMeatdata = {}) {
+  const m = await createTestingModule(moduleDef, false);
+
+  const app = m.createNestApplication({
+    cors: true,
+    bodyParser: true,
+    rawBody: true,
+    logger: ['warn'],
+  });
+
+  app.useGlobalFilters(new GlobalExceptionFilter(app.getHttpAdapter()));
+  app.use(
+    graphqlUploadExpress({
+      maxFileSize: 10 * 1024 * 1024,
+      maxFiles: 5,
+    })
+  );
+
+  app.use(cookieParser());
+
+  if (moduleDef.tapApp) {
+    moduleDef.tapApp(app);
+  }
+
+  await app.init();
+
+  const runtime = app.get(Runtime);
+  // by pass password min length validation
+  await runtime.set('auth/password.min', 1);
+
+  return {
+    module: m,
+    app,
+  };
+}
+
+export function handleGraphQLError(resp: Response) {
+  const { errors } = resp.body;
+  if (errors) {
+    const cause = errors[0];
+    const stacktrace = cause.extensions?.stacktrace;
+    throw new Error(
+      stacktrace
+        ? Array.isArray(stacktrace)
+          ? stacktrace.join('\n')
+          : String(stacktrace)
+        : cause.message,
+      cause
+    );
+  }
+}
+
+export function gql(app: INestApplication, query?: string) {
+  const req = supertest(app.getHttpServer())
+    .post('/graphql')
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' });
+
+  if (query) {
+    return req.send({ query });
+  }
+
+  return req;
+}
+
+export async function sleep(ms: number) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}

packages/backend/server/src/__tests__/utils/workspace.ts

@@ -0,0 +1,182 @@
+import type { INestApplication } from '@nestjs/common';
+import request from 'supertest';
+
+import type { WorkspaceType } from '../../core/workspaces';
+import { gql } from './common';
+import { PermissionEnum } from './utils';
+
+export async function createWorkspace(
+  app: INestApplication,
+  token: string
+): Promise<WorkspaceType> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .field(
+      'operations',
+      JSON.stringify({
+        name: 'createWorkspace',
+        query: `mutation createWorkspace($init: Upload!) {
+              createWorkspace(init: $init) {
+                id
+              }
+            }`,
+        variables: { init: null },
+      })
+    )
+    .field('map', JSON.stringify({ '0': ['variables.init'] }))
+    .attach('0', Buffer.from([0, 0]), 'init.data')
+    .expect(200);
+  return res.body.data.createWorkspace;
+}
+
+export async function getWorkspacePublicPages(
+  app: INestApplication,
+  token: string,
+  workspaceId: string
+) {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            query {
+              workspace(id: "${workspaceId}") {
+                publicPages {
+                  id
+                  mode
+                }
+              }
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.data.workspace.publicPages;
+}
+
+export async function getWorkspace(
+  app: INestApplication,
+  token: string,
+  workspaceId: string,
+  skip = 0,
+  take = 8
+): Promise<WorkspaceType> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            query {
+              workspace(id: "${workspaceId}") {
+                id, members(skip: ${skip}, take: ${take}) { id, name, email, permission, inviteId, status }
+              }
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.data.workspace;
+}
+
+export async function updateWorkspace(
+  app: INestApplication,
+  token: string,
+  workspaceId: string,
+  isPublic: boolean
+): Promise<boolean> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+              updateWorkspace(input: { id: "${workspaceId}", public: ${isPublic} }) {
+                public
+              }
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.data.updateWorkspace.public;
+}
+
+export async function publishPage(
+  app: INestApplication,
+  token: string,
+  workspaceId: string,
+  pageId: string
+) {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+              publishPage(workspaceId: "${workspaceId}", pageId: "${pageId}") {
+                id
+                mode
+              }
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.errors?.[0]?.message || res.body.data?.publishPage;
+}
+
+export async function revokePublicPage(
+  app: INestApplication,
+  token: string,
+  workspaceId: string,
+  pageId: string
+) {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+              revokePublicPage(workspaceId: "${workspaceId}", pageId: "${pageId}") {
+                id
+                mode
+                public
+              }
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.errors?.[0]?.message || res.body.data?.revokePublicPage;
+}
+
+export async function grantMember(
+  app: INestApplication,
+  token: string,
+  workspaceId: string,
+  userId: string,
+  permission: PermissionEnum
+) {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+          mutation {
+            grantMember(
+              workspaceId: "${workspaceId}"
+              userId: "${userId}"
+              permission: ${permission}
+            )
+          }
+          `,
+    })
+    .expect(200);
+  if (res.body.errors) {
+    throw new Error(res.body.errors[0].message);
+  }
+  return res.body.data?.grantMember;
+}