@sendbird/sendbird-platform-sdk-typescript 2.1.2 → 2.1.6

package/tests/integration/groupChannel.test.ts

@@ -1,1624 +0,0 @@
-import { ListOperatorsResponse } from "./../../models/ListOperatorsResponse";
-import {
-  CreateAGroupChannelRequest,
-  SendbirdBasicUserInfo,
-  SendbirdDisappearingMessage,
-  SendbirdGroupChannelCountPreferenceEnum,
-  SendbirdGroupChannelHiddenStateEnum,
-  SendbirdGroupChannelMemberStateEnum,
-  SendbirdGroupChannelMyRoleEnum,
-  SendbirdMessageResponse,
-  SendbirdSmsFallback,
-  SendbirdUser,
-  SendbirdMemberRoleEnum,
-  SendbirdMemberStateEnum,
-  SendbirdGroupChannelDetailChannel,
-} from "../../models/ObjectSerializer";
-import { hasValidField } from "./helper";
-import { ServerConfiguration } from "../../servers";
-import { createConfiguration } from "../../configuration";
-import { GroupChannelApi } from "../../index";
-import {
-  GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
-  MASTER_USER_ID,
-  SECOND_USER_ID,
-  USERS,
-} from "./constants";
-
-describe("Group Channel API", () => {
-  const APP_ID = process.env.APP_ID || "";
-  const API_TOKEN = process.env.API_TOKEN || "";
-  let groupChannelApi: GroupChannelApi;
-  const validSendbirdGroupChannelCountPreferenceEnum: (
-    | SendbirdGroupChannelCountPreferenceEnum
-    | undefined
-  )[] = [
-    "false",
-    "all",
-    "unread_message_count_only",
-    "unread_mentioned_count_only",
-  ];
-
-  const validSendbirdGroupChannelMemberStateEnum: (
-    | SendbirdGroupChannelMemberStateEnum
-    | undefined
-  )[] = ["invited", "joined", "none"];
-
-  const validSendbirdGroupChannelHiddenStateEnum: (
-    | SendbirdGroupChannelHiddenStateEnum
-    | undefined
-  )[] = ["hidden_allow_auto_unhide", "hidden_prevent_auto_unhide", "unhidden"];
-
-  const validSendbirdGroupChannelMyRoleEnum: (
-    | SendbirdGroupChannelMyRoleEnum
-    | undefined
-  )[] = ["none", "operator", ""];
-
-  const validSendbirdMemberRoleEnum: (SendbirdMemberRoleEnum | undefined)[] = [
-    "",
-    "none",
-    "operator",
-  ];
-
-  const validSendbirdMemberStateEnum: (SendbirdMemberStateEnum | undefined)[] =
-    ["", "invited", "joined"];
-
-  beforeEach(() => {
-    const serverConfig = new ServerConfiguration(
-      `https://api-${APP_ID}.sendbird.com`,
-      { app_id: APP_ID }
-    );
-    const configuration = createConfiguration({
-      baseServer: serverConfig,
-    });
-    groupChannelApi = new GroupChannelApi(configuration);
-  });
-
-  it("call listChannels with positive query params", async () => {
-    const CHANNEL_URL =
-      "create-group-channel-before-call-list-channels-with-positive-params-test-channel-url";
-    // Cleanup first
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: CHANNEL_URL,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, 500));
-
-    const request: CreateAGroupChannelRequest = {
-      accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
-      blockSdkUserChannelJoin: true,
-      channelUrl: CHANNEL_URL,
-      coverUrl: "empty",
-      customType: "data",
-      data: "data",
-      /**
-       * Specifies one or more key-value pair items which set the invitation status of each user invited to the channel. The key should be a user_id and the value should be their joining status. Acceptable values are joined, invited_by_friend, and invited_by_non_friend. (Default: joined)
-       */
-      invitationStatus: Object.fromEntries(USERS.map((id) => [id, "joined"])),
-      inviterId: MASTER_USER_ID,
-      isDistinct: false,
-      isEphemeral: true,
-      isPublic: true,
-      isSuper: true,
-      name: "test",
-      operatorIds: [],
-      strict: true,
-      users: USERS.map((id) => ({ userId: id })),
-    };
-
-    const createGroupChannelresponse =
-      await groupChannelApi.createAGroupChannel({
-        apiToken: API_TOKEN,
-        createAGroupChannelRequest: request,
-      });
-
-    expect(createGroupChannelresponse).toBeDefined();
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    const response = await groupChannelApi.listChannels({
-      apiToken: API_TOKEN,
-      limit: 10,
-      distinctMode: "all",
-      publicMode: "all",
-      superMode: "all",
-      showEmpty: true,
-      showMember: true,
-      showDeliveryReceipt: true,
-      showReadReceipt: true,
-      showMetadata: true,
-      showFrozen: true,
-    });
-    expect(response).toHaveProperty("channels");
-    expect(Array.isArray(response.channels)).toBe(true);
-
-    response.channels?.forEach((channel) => {
-      expect(channel).toHaveProperty("channelUrl");
-      expect(typeof channel.channelUrl).toBe("string");
-      if ("countPreference" in channel) {
-        expect(typeof channel.countPreference).toBe("string");
-        expect(
-          validSendbirdGroupChannelCountPreferenceEnum.includes(
-            channel.countPreference
-          )
-        ).toBe(true);
-      }
-      expect(channel).toHaveProperty("name");
-      expect(typeof channel.name).toBe("string");
-      expect(channel).toHaveProperty("coverUrl");
-      expect(typeof channel.coverUrl).toBe("string");
-
-      expect(channel).toHaveProperty("createdAt");
-      expect(typeof channel.createdAt).toBe("number");
-
-      if (hasValidField(channel, "createdBy")) {
-        expect(channel.createdBy).toBeInstanceOf(SendbirdBasicUserInfo);
-      }
-
-      expect(channel).toHaveProperty("customType");
-      expect(typeof channel.customType).toBe("string");
-
-      expect(channel).toHaveProperty("data");
-      expect(typeof channel.data).toBe("string");
-
-      expect(channel).toHaveProperty("deliveryReceipt");
-      expect(typeof channel.deliveryReceipt).toBe("object");
-
-      expect(channel).toHaveProperty("disappearingMessage");
-      expect(channel.disappearingMessage).toBeInstanceOf(
-        SendbirdDisappearingMessage
-      );
-
-      expect(channel).toHaveProperty("freeze");
-      expect(typeof channel.freeze).toBe("boolean");
-
-      expect(channel).toHaveProperty("hasAiBot");
-      expect(typeof channel.hasAiBot).toBe("boolean");
-
-      expect(channel).toHaveProperty("hasBot");
-      expect(typeof channel.hasBot).toBe("boolean");
-
-      if ("hiddenState" in channel) {
-        expect(
-          validSendbirdGroupChannelHiddenStateEnum.includes(channel.hiddenState)
-        ).toBe(true);
-        expect(typeof channel.hiddenState).toBe("string");
-      }
-
-      expect(channel).toHaveProperty("ignoreProfanityFilter");
-      expect(typeof channel.ignoreProfanityFilter).toBe("boolean");
-
-      expect(channel).toHaveProperty("invitedAt");
-      expect(typeof channel.invitedAt).toBe("number");
-
-      if (hasValidField(channel, "inviter")) {
-        expect(channel.inviter).toBeInstanceOf(SendbirdUser);
-      }
-
-      expect(channel).toHaveProperty("isAccessCodeRequired");
-      expect(typeof channel.isAccessCodeRequired).toBe("boolean");
-
-      expect(channel).toHaveProperty("isBroadcast");
-      expect(typeof channel.isBroadcast).toBe("boolean");
-
-      expect(channel).toHaveProperty("isDiscoverable");
-      expect(typeof channel.isDiscoverable).toBe("boolean");
-
-      expect(channel).toHaveProperty("isDistinct");
-      expect(typeof channel.isDistinct).toBe("boolean");
-
-      expect(channel).toHaveProperty("isEphemeral");
-      expect(typeof channel.isEphemeral).toBe("boolean");
-
-      expect(channel).toHaveProperty("isExclusive");
-      expect(typeof channel.isExclusive).toBe("boolean");
-
-      if ("isHidden" in channel) {
-        expect(typeof channel.isHidden).toBe("boolean");
-      }
-
-      // Object(channel).hasProe;
-      if ("isMuted" in channel) {
-        expect(typeof channel.isMuted).toBe("boolean");
-      }
-
-      if ("isPublic" in channel) {
-        expect(typeof channel.isPublic).toBe("boolean");
-      }
-
-      if ("isPushEnabled" in channel) {
-        expect(typeof channel.isPushEnabled).toBe("boolean");
-      }
-
-      expect(channel).toHaveProperty("isSuper");
-      expect(typeof channel.isSuper).toBe("boolean");
-
-      expect(channel).toHaveProperty("joinedMemberCount");
-      expect(typeof channel.joinedMemberCount).toBe("number");
-
-      if (hasValidField(channel, "joinedTs")) {
-        expect(typeof channel.joinedTs).toBe("number");
-      }
-
-      if (hasValidField(channel, "lastMessage")) {
-        expect(channel.lastMessage).toBeInstanceOf(SendbirdMessageResponse);
-      }
-
-      expect(channel).toHaveProperty("maxLengthMessage");
-      expect(typeof channel.maxLengthMessage).toBe("number");
-
-      expect(channel).toHaveProperty("memberCount");
-      expect(typeof channel.memberCount).toBe("number");
-
-      if (hasValidField(channel, "memberState")) {
-        expect(
-          validSendbirdGroupChannelMemberStateEnum.includes(channel.memberState)
-        ).toBe(true);
-        expect(typeof channel.memberState).toBe("string");
-      }
-
-      expect(channel).toHaveProperty("members");
-      expect(Array.isArray(channel.members)).toBe(true);
-
-      expect(channel).toHaveProperty("messageSurvivalSeconds");
-      expect(typeof channel.messageSurvivalSeconds).toBe("number");
-
-      expect(channel).toHaveProperty("metadata");
-      expect(typeof channel.metadata).toBe("object");
-
-      if (hasValidField(channel, "myRole")) {
-        expect(
-          validSendbirdGroupChannelMyRoleEnum.includes(channel.myRole)
-        ).toBe(true);
-        expect(typeof channel.myRole).toBe("string");
-      }
-
-      expect(channel).toHaveProperty("name");
-      expect(typeof channel.name).toBe("string");
-
-      expect(channel).toHaveProperty("readReceipt");
-      expect(typeof channel.readReceipt).toBe("object");
-
-      expect(channel).toHaveProperty("smsFallback");
-      expect(channel.smsFallback).toBeInstanceOf(SendbirdSmsFallback);
-
-      if (hasValidField(channel, "tsMessageOffset")) {
-        expect(typeof channel.tsMessageOffset).toBe("number");
-      }
-
-      expect(channel).toHaveProperty("unreadMentionCount");
-      expect(typeof channel.unreadMentionCount).toBe("number");
-
-      expect(channel).toHaveProperty("unreadMessageCount");
-      expect(typeof channel.unreadMessageCount).toBe("number");
-
-      if (hasValidField(channel, "userLastRead")) {
-        expect(typeof channel.userLastRead).toBe("number");
-      }
-    });
-
-    expect(response).toHaveProperty("next");
-    expect(typeof response.next).toBe("string");
-
-    // Cleanup last
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: CHANNEL_URL,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-  });
-
-  it("call listChannels with negative query params", async () => {
-    const CHANNEL_URL =
-      "create-group-channel-before-call-list-channels-with-negative-params-test-channel-url";
-    // Cleanup first
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: CHANNEL_URL,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, 500));
-
-    const request: CreateAGroupChannelRequest = {
-      accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
-      blockSdkUserChannelJoin: true,
-      channelUrl: CHANNEL_URL,
-      coverUrl: "empty",
-      customType: "data",
-      data: "data",
-      /**
-       * Specifies one or more key-value pair items which set the invitation status of each user invited to the channel. The key should be a user_id and the value should be their joining status. Acceptable values are joined, invited_by_friend, and invited_by_non_friend. (Default: joined)
-       */
-      invitationStatus: Object.fromEntries(USERS.map((id) => [id, "joined"])),
-      inviterId: MASTER_USER_ID,
-      isDistinct: false,
-      isEphemeral: true,
-      isPublic: true,
-      isSuper: true,
-      name: "test",
-      operatorIds: [],
-      strict: true,
-      users: USERS.map((id) => ({ userId: id })),
-    };
-
-    const createGroupChannelresponse =
-      await groupChannelApi.createAGroupChannel({
-        apiToken: API_TOKEN,
-        createAGroupChannelRequest: request,
-      });
-
-    expect(createGroupChannelresponse).toBeDefined();
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    const response = await groupChannelApi.listChannels({
-      apiToken: API_TOKEN,
-      limit: 10,
-      distinctMode: "all",
-      publicMode: "all",
-      superMode: "all",
-      showEmpty: false,
-      showMember: false,
-      showDeliveryReceipt: false,
-      showReadReceipt: false,
-      showMetadata: false,
-      showFrozen: false,
-    });
-    expect(response).toHaveProperty("channels");
-    expect(Array.isArray(response.channels)).toBe(true);
-
-    response.channels?.forEach((channel) => {
-      expect(channel).toHaveProperty("channelUrl");
-      expect(typeof channel.channelUrl).toBe("string");
-
-      expect(channel).not.toHaveProperty("deliveryReceipt");
-      expect(channel).not.toHaveProperty("members");
-      expect(channel).not.toHaveProperty("metadata");
-      expect(channel).not.toHaveProperty("readReceipt");
-
-      expect(channel).toHaveProperty("name");
-      expect(typeof channel.name).toBe("string");
-
-      expect(channel).toHaveProperty("coverUrl");
-      expect(typeof channel.coverUrl).toBe("string");
-
-      expect(channel).toHaveProperty("createdAt");
-      expect(typeof channel.createdAt).toBe("number");
-    });
-
-    expect(response).toHaveProperty("next");
-    expect(typeof response.next).toBe("string");
-
-    // Cleanup last
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: CHANNEL_URL,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-  });
-
-  it("call createAGroupChannel with Error", async () => {
-    const CHANNEL_URL = "create-group-channel-with-error-test-channel-url";
-    // Cleanup first
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: CHANNEL_URL,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    const request: CreateAGroupChannelRequest = {
-      accessCode: "integration",
-      blockSdkUserChannelJoin: true,
-      channelUrl: CHANNEL_URL,
-      coverUrl: "empty",
-      customType: "data",
-      data: "data",
-      /**
-       * Specifies one or more key-value pair items which set the invitation status of each user invited to the channel. The key should be a user_id and the value should be their joining status. Acceptable values are joined, invited_by_friend, and invited_by_non_friend. (Default: joined)
-       */
-      invitationStatus: Object.fromEntries(USERS.map((id) => [id, "joined"])),
-      inviterId: MASTER_USER_ID,
-      isDistinct: true,
-      isEphemeral: true,
-      isPublic: true,
-      isSuper: true,
-      name: "test",
-      operatorIds: [],
-      strict: true,
-      users: USERS.map((id) => ({ userId: id })),
-    };
-
-    try {
-      await groupChannelApi.createAGroupChannel({
-        apiToken: API_TOKEN,
-        createAGroupChannelRequest: request,
-      });
-    } catch (error) {
-      expect(JSON.parse((error as any).body).code).toBe(400111);
-    }
-  });
-
-  it("call createAGroupChannel and deleteAGroupChannel", async () => {
-    const CHANNEL_URL = "create-then-delete-group-channel-test-channel-url";
-    // Cleanup first
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: CHANNEL_URL,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, 500));
-
-    const request: CreateAGroupChannelRequest = {
-      accessCode: "integration",
-      blockSdkUserChannelJoin: true,
-      channelUrl: CHANNEL_URL,
-      coverUrl: "empty",
-      customType: "data",
-      data: "data",
-      /**
-       * Specifies one or more key-value pair items which set the invitation status of each user invited to the channel. The key should be a user_id and the value should be their joining status. Acceptable values are joined, invited_by_friend, and invited_by_non_friend. (Default: joined)
-       */
-      invitationStatus: Object.fromEntries(USERS.map((id) => [id, "joined"])),
-      inviterId: MASTER_USER_ID,
-      isDistinct: false,
-      isEphemeral: true,
-      isPublic: true,
-      isSuper: true,
-      name: "test",
-      operatorIds: [],
-      strict: true,
-      users: USERS.map((id) => ({ userId: id })),
-    };
-
-    const response = await groupChannelApi.createAGroupChannel({
-      apiToken: API_TOKEN,
-      createAGroupChannelRequest: request,
-    });
-
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    expect(response).toHaveProperty("channelUrl");
-    expect(response.channelUrl).toBe(CHANNEL_URL);
-    expect(typeof response.channelUrl).toBe("string");
-
-    expect(response).toHaveProperty("coverUrl");
-    expect(response.coverUrl).toBe("empty");
-    expect(typeof response.coverUrl).toBe("string");
-
-    expect(response).toHaveProperty("customType");
-    expect(response.customType).toBe("data");
-    expect(typeof response.customType).toBe("string");
-
-    // Cleanup last
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: response.channelUrl,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-  });
-
-  it("call getAGroupChannel", async () => {
-    const CHANNEL_URL = "get-group-channel-test-channel-url";
-    // Cleanup first
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: CHANNEL_URL,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, 500));
-
-    const request: CreateAGroupChannelRequest = {
-      accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
-      blockSdkUserChannelJoin: true,
-      channelUrl: CHANNEL_URL,
-      coverUrl: "empty",
-      customType: "data",
-      data: "data",
-      /**
-       * Specifies one or more key-value pair items which set the invitation status of each user invited to the channel. The key should be a user_id and the value should be their joining status. Acceptable values are joined, invited_by_friend, and invited_by_non_friend. (Default: joined)
-       */
-      invitationStatus: Object.fromEntries(USERS.map((id) => [id, "joined"])),
-      inviterId: MASTER_USER_ID,
-      isDistinct: false,
-      isEphemeral: true,
-      isPublic: true,
-      isSuper: true,
-      name: "test",
-      operatorIds: [],
-      strict: true,
-      users: USERS.map((id) => ({ userId: id })),
-    };
-
-    const createGroupChannelresponse =
-      await groupChannelApi.createAGroupChannel({
-        apiToken: API_TOKEN,
-        createAGroupChannelRequest: request,
-      });
-
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    expect(createGroupChannelresponse).toHaveProperty("channelUrl");
-    expect(createGroupChannelresponse.channelUrl).toBe(CHANNEL_URL);
-    expect(typeof createGroupChannelresponse.channelUrl).toBe("string");
-
-    const groupChannelResponse = await groupChannelApi.getAGroupChannel({
-      channelUrl: createGroupChannelresponse.channelUrl,
-      apiToken: API_TOKEN,
-      showDeliveryReceipt: true,
-      showReadReceipt: true,
-      showMember: true,
-      memberActiveMode: "all",
-    });
-
-    const channel = groupChannelResponse;
-    expect(channel).toHaveProperty("channelUrl");
-    expect(channel.channelUrl).toBe(CHANNEL_URL);
-
-    expect(channel).toHaveProperty("channel");
-    expect(channel.channel).toBeInstanceOf(SendbirdGroupChannelDetailChannel);
-
-    expect(channel.channel).toHaveProperty("channelUrl");
-    expect(typeof channel.channel?.channelUrl).toBe("string");
-
-    expect(channel.channel).toHaveProperty("coverUrl");
-    expect(typeof channel.channel?.coverUrl).toBe("string");
-
-    expect(channel.channel).toHaveProperty("createdAt");
-    expect(typeof channel.channel?.createdAt).toBe("number");
-
-    expect(channel.channel).toHaveProperty("customType");
-    expect(typeof channel.channel?.customType).toBe("string");
-
-    expect(channel.channel).toHaveProperty("data");
-    expect(typeof channel.channel?.data).toBe("string");
-
-    expect(channel.channel).toHaveProperty("maxLengthMessage");
-    expect(typeof channel.channel?.maxLengthMessage).toBe("number");
-
-    expect(channel.channel).toHaveProperty("memberCount");
-    expect(typeof channel.channel?.memberCount).toBe("number");
-
-    expect(channel.channel).toHaveProperty("name");
-    expect(typeof channel.channel?.name).toBe("string");
-
-    expect(channel).toHaveProperty("name");
-    expect(typeof channel.name).toBe("string");
-
-    expect(channel).toHaveProperty("coverUrl");
-    expect(typeof channel.coverUrl).toBe("string");
-
-    expect(channel).toHaveProperty("createdAt");
-    expect(typeof channel.createdAt).toBe("number");
-
-    if (hasValidField(channel, "createdBy")) {
-      expect(channel.createdBy).toBeInstanceOf(SendbirdBasicUserInfo);
-    }
-
-    expect(channel).toHaveProperty("customType");
-    expect(typeof channel.customType).toBe("string");
-
-    expect(channel).toHaveProperty("data");
-    expect(typeof channel.data).toBe("string");
-
-    expect(channel).toHaveProperty("deliveryReceipt");
-    expect(typeof channel.deliveryReceipt).toBe("object");
-
-    expect(channel).toHaveProperty("disappearingMessage");
-    expect(channel.disappearingMessage).toBeInstanceOf(
-      SendbirdDisappearingMessage
-    );
-
-    expect(channel).toHaveProperty("freeze");
-    expect(typeof channel.freeze).toBe("boolean");
-
-    expect(channel).toHaveProperty("hasAiBot");
-    expect(typeof channel.hasAiBot).toBe("boolean");
-
-    expect(channel).toHaveProperty("hasBot");
-    expect(typeof channel.hasBot).toBe("boolean");
-
-    expect(channel).toHaveProperty("ignoreProfanityFilter");
-    expect(typeof channel.ignoreProfanityFilter).toBe("boolean");
-
-    expect(channel).toHaveProperty("isAccessCodeRequired");
-    expect(typeof channel.isAccessCodeRequired).toBe("boolean");
-
-    expect(channel).toHaveProperty("isBroadcast");
-    expect(typeof channel.isBroadcast).toBe("boolean");
-
-    expect(channel).toHaveProperty("isDiscoverable");
-    expect(typeof channel.isDiscoverable).toBe("boolean");
-
-    expect(channel).toHaveProperty("isDistinct");
-    expect(typeof channel.isDistinct).toBe("boolean");
-
-    expect(channel).toHaveProperty("isEphemeral");
-    expect(typeof channel.isEphemeral).toBe("boolean");
-
-    if ("isHidden" in channel) {
-      expect(typeof channel.isHidden).toBe("boolean");
-    }
-
-    if ("isMuted" in channel) {
-      expect(typeof channel.isMuted).toBe("boolean");
-    }
-
-    if ("isPublic" in channel) {
-      expect(typeof channel.isPublic).toBe("boolean");
-    }
-
-    if ("isPushEnabled" in channel) {
-      expect(typeof channel.isPushEnabled).toBe("boolean");
-    }
-
-    expect(channel).toHaveProperty("isSuper");
-    expect(typeof channel.isSuper).toBe("boolean");
-
-    expect(channel).toHaveProperty("joinedMemberCount");
-    expect(typeof channel.joinedMemberCount).toBe("number");
-
-    if (hasValidField(channel, "lastMessage")) {
-      expect(channel.lastMessage).toBeInstanceOf(SendbirdMessageResponse);
-    }
-
-    expect(channel).toHaveProperty("maxLengthMessage");
-    expect(typeof channel.maxLengthMessage).toBe("number");
-
-    expect(channel).toHaveProperty("memberCount");
-    expect(typeof channel.memberCount).toBe("number");
-
-    expect(channel).toHaveProperty("members");
-    expect(Array.isArray(channel.members)).toBe(true);
-
-    expect(channel).toHaveProperty("messageSurvivalSeconds");
-    expect(typeof channel.messageSurvivalSeconds).toBe("number");
-
-    expect(channel).toHaveProperty("name");
-    expect(typeof channel.name).toBe("string");
-
-    expect(channel).toHaveProperty("readReceipt");
-    expect(typeof channel.readReceipt).toBe("object");
-
-    expect(channel).toHaveProperty("smsFallback");
-    expect(channel.smsFallback).toBeInstanceOf(SendbirdSmsFallback);
-
-    expect(channel).toHaveProperty("unreadMentionCount");
-    expect(typeof channel.unreadMentionCount).toBe("number");
-
-    expect(channel).toHaveProperty("unreadMessageCount");
-    expect(typeof channel.unreadMessageCount).toBe("number");
-
-    // Cleanup last
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: createGroupChannelresponse.channelUrl,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-  });
-
-  it("call listMembers", async () => {
-    const CHANNEL_URL =
-      "create-group-channel-before-call-list-channels-with-then-list-members-test-channel-url";
-    // Cleanup first
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: CHANNEL_URL,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, 500));
-
-    const request: CreateAGroupChannelRequest = {
-      accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
-      blockSdkUserChannelJoin: true,
-      channelUrl: CHANNEL_URL,
-      coverUrl: "empty",
-      customType: "data",
-      data: "data",
-      /**
-       * Specifies one or more key-value pair items which set the invitation status of each user invited to the channel. The key should be a user_id and the value should be their joining status. Acceptable values are joined, invited_by_friend, and invited_by_non_friend. (Default: joined)
-       */
-      invitationStatus: Object.fromEntries(USERS.map((id) => [id, "joined"])),
-      inviterId: MASTER_USER_ID,
-      isDistinct: false,
-      isEphemeral: true,
-      isPublic: true,
-      isSuper: true,
-      name: "test",
-      operatorIds: [],
-      strict: true,
-      users: USERS.map((id) => ({ userId: id })),
-    };
-
-    const createGroupChannelresponse =
-      await groupChannelApi.createAGroupChannel({
-        apiToken: API_TOKEN,
-        createAGroupChannelRequest: request,
-      });
-
-    expect(createGroupChannelresponse).toBeDefined();
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    const listResponse = await groupChannelApi.listChannels({
-      apiToken: API_TOKEN,
-      limit: 1,
-      distinctMode: "all",
-      publicMode: "all",
-      superMode: "all",
-      showEmpty: true,
-      showMember: true,
-      showDeliveryReceipt: true,
-      showReadReceipt: true,
-      showMetadata: true,
-      showFrozen: true,
-    });
-    expect(listResponse).toHaveProperty("channels");
-    expect(Array.isArray(listResponse.channels)).toBe(true);
-    expect(listResponse.channels?.length).toBe(1);
-
-    const channel = listResponse.channels?.[0];
-    expect(channel).toBeDefined();
-
-    if (channel) {
-      const listMembersResponse = await groupChannelApi.listMembers({
-        apiToken: API_TOKEN,
-        channelUrl: channel.channelUrl,
-      });
-
-      expect(listMembersResponse).toHaveProperty("members");
-      expect(Array.isArray(listMembersResponse.members)).toBe(true);
-      listMembersResponse.members.forEach((member) => {
-        expect(member).toHaveProperty("userId");
-        expect(typeof member.userId).toBe("string");
-
-        if (hasValidField(member, "deliveredTs")) {
-          expect(typeof member.deliveredTs).toBe("number");
-        }
-
-        if (hasValidField(member, "doNotDisturb")) {
-          expect(typeof member.doNotDisturb).toBe("boolean");
-        }
-
-        if (hasValidField(member, "friendDiscoveryKey")) {
-          expect(Array.isArray(member.friendDiscoveryKey)).toBe(true);
-        }
-
-        if (hasValidField(member, "friendName")) {
-          expect(typeof member.friendName).toBe("string");
-        }
-
-        if (hasValidField(member, "isActive")) {
-          expect(typeof member.isActive).toBe("boolean");
-        }
-
-        if (hasValidField(member, "isBlockedByMe")) {
-          expect(typeof member.isBlockedByMe).toBe("boolean");
-        }
-
-        if (hasValidField(member, "isBlockingMe")) {
-          expect(typeof member.isBlockingMe).toBe("boolean");
-        }
-
-        if (hasValidField(member, "isMuted")) {
-          expect(typeof member.isMuted).toBe("boolean");
-        }
-
-        if (hasValidField(member, "isOnline")) {
-          expect(typeof member.isOnline).toBe("boolean");
-        }
-
-        if (hasValidField(member, "lastSeenAt")) {
-          expect(typeof member.lastSeenAt).toBe("number");
-        }
-
-        if (hasValidField(member, "metadata")) {
-          expect(typeof member.metadata).toBe("object");
-        }
-
-        if (hasValidField(member, "mutedDescription")) {
-          expect(typeof member.mutedDescription).toBe("string");
-        }
-
-        if (hasValidField(member, "mutedEndAt")) {
-          expect(typeof member.mutedEndAt).toBe("number");
-        }
-
-        if (hasValidField(member, "nickname")) {
-          expect(typeof member.nickname).toBe("string");
-        }
-
-        if (hasValidField(member, "pushEnabled")) {
-          expect(typeof member.pushEnabled).toBe("boolean");
-        }
-
-        if (hasValidField(member, "pushTriggerOption")) {
-          expect(typeof member.pushTriggerOption).toBe("string");
-        }
-
-        if (hasValidField(member, "profileUrl")) {
-          expect(typeof member.profileUrl).toBe("string");
-        }
-
-        if (hasValidField(member, "requireAuthForProfileImage")) {
-          expect(typeof member.requireAuthForProfileImage).toBe("boolean");
-        }
-
-        if (hasValidField(member, "readTs")) {
-          expect(typeof member.readTs).toBe("number");
-        }
-
-        if (hasValidField(member, "role")) {
-          expect(typeof member.role).toBe("string");
-          expect(validSendbirdMemberRoleEnum.includes(member.role)).toBe(true);
-        }
-
-        if (hasValidField(member, "state")) {
-          expect(typeof member.state).toBe("string");
-          expect(validSendbirdMemberStateEnum.includes(member.state)).toBe(
-            true
-          );
-        }
-      });
-    }
-
-    // Cleanup last
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: CHANNEL_URL,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-  });
-
-  it("call registerOperatorsToAGroupChannel, listOperators then cancelTheRegistrationOfOperators", async () => {
-    const CHANNEL_URL = "list-operator-test-channel-url";
-    // Cleanup first
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: CHANNEL_URL,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, 500));
-
-    const request: CreateAGroupChannelRequest = {
-      accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
-      blockSdkUserChannelJoin: true,
-      channelUrl: CHANNEL_URL,
-      coverUrl: "empty",
-      customType: "data",
-      data: "data",
-      /**
-       * Specifies one or more key-value pair items which set the invitation status of each user invited to the channel. The key should be a user_id and the value should be their joining status. Acceptable values are joined, invited_by_friend, and invited_by_non_friend. (Default: joined)
-       */
-      invitationStatus: Object.fromEntries(USERS.map((id) => [id, "joined"])),
-      inviterId: MASTER_USER_ID,
-      isDistinct: false,
-      isEphemeral: true,
-      isPublic: true,
-      isSuper: true,
-      name: "test",
-      operatorIds: [],
-      strict: true,
-      users: USERS.map((id) => ({ userId: id })),
-    };
-
-    const createGroupChannelresponse =
-      await groupChannelApi.createAGroupChannel({
-        apiToken: API_TOKEN,
-        createAGroupChannelRequest: request,
-      });
-
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    expect(createGroupChannelresponse).toHaveProperty("channelUrl");
-    expect(createGroupChannelresponse.channelUrl).toBe(CHANNEL_URL);
-    expect(typeof createGroupChannelresponse.channelUrl).toBe("string");
-
-    expect(createGroupChannelresponse).toHaveProperty("operators");
-    expect(createGroupChannelresponse.operators?.length || 0).toBe(0);
-
-    const registerOperatorResponse =
-      await groupChannelApi.registerOperatorsToAGroupChannel({
-        channelUrl: createGroupChannelresponse.channelUrl,
-        apiToken: API_TOKEN,
-        registerOperatorsToAGroupChannelRequest: {
-          operatorIds: [MASTER_USER_ID],
-        },
-      });
-
-    expect(registerOperatorResponse).toBeDefined();
-
-    const listOperatorsResponse = await groupChannelApi.listOperators({
-      channelUrl: createGroupChannelresponse.channelUrl,
-      apiToken: API_TOKEN,
-    });
-
-    expect(listOperatorsResponse).toHaveProperty("operators");
-    expect(Object.keys(listOperatorsResponse).length).toBe(2);
-
-    expect(listOperatorsResponse.operators?.length || 0).toBe(1);
-
-    listOperatorsResponse.operators?.map((operator) => {
-      expect(operator.userId).toEqual(MASTER_USER_ID);
-      expect(operator).toHaveProperty("nickname");
-      expect(typeof operator.nickname).toBe("string");
-      expect(operator).toHaveProperty("profileUrl");
-      expect(typeof operator.profileUrl).toBe("string");
-      expect(operator).toHaveProperty("metadata");
-      expect(typeof operator.metadata).toBe("object");
-      expect(operator).toHaveProperty("requireAuthForProfileImage");
-      expect(typeof operator.requireAuthForProfileImage).toBe("boolean");
-    });
-
-    const cancelTheRegistrationOfOperatorsResponse =
-      await groupChannelApi.cancelTheRegistrationOfOperators({
-        channelUrl: createGroupChannelresponse.channelUrl,
-        apiToken: API_TOKEN,
-        operatorIds: MASTER_USER_ID,
-      });
-
-    expect(cancelTheRegistrationOfOperatorsResponse).toBeDefined();
-
-    const listOperatorsAfterCancelRegistrationResponse =
-      await groupChannelApi.listOperators({
-        channelUrl: createGroupChannelresponse.channelUrl,
-        apiToken: API_TOKEN,
-      });
-
-    expect(listOperatorsAfterCancelRegistrationResponse).toHaveProperty(
-      "operators"
-    );
-    expect(
-      Object.keys(listOperatorsAfterCancelRegistrationResponse).length
-    ).toBe(2);
-
-    expect(
-      listOperatorsAfterCancelRegistrationResponse.operators?.length || 0
-    ).toBe(0);
-
-    // Cleanup last
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: createGroupChannelresponse.channelUrl,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-  });
-
-  it("call startTypingIndicators and stopTypingIndicators", async () => {
-    const CHANNEL_URL = "group-channel-typing-indicators-test-channel-url";
-    // Cleanup first
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: CHANNEL_URL,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, 500));
-
-    const request: CreateAGroupChannelRequest = {
-      accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
-      blockSdkUserChannelJoin: true,
-      channelUrl: CHANNEL_URL,
-      coverUrl: "empty",
-      customType: "data",
-      data: "data",
-      /**
-       * Specifies one or more key-value pair items which set the invitation status of each user invited to the channel. The key should be a user_id and the value should be their joining status. Acceptable values are joined, invited_by_friend, and invited_by_non_friend. (Default: joined)
-       */
-      invitationStatus: Object.fromEntries(USERS.map((id) => [id, "joined"])),
-      inviterId: MASTER_USER_ID,
-      isDistinct: false,
-      isEphemeral: true,
-      isPublic: true,
-      isSuper: true,
-      name: "test",
-      operatorIds: [],
-      strict: true,
-      users: USERS.map((id) => ({ userId: id })),
-    };
-
-    const createGroupChannelresponse =
-      await groupChannelApi.createAGroupChannel({
-        apiToken: API_TOKEN,
-        createAGroupChannelRequest: request,
-      });
-
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    expect(createGroupChannelresponse).toHaveProperty("channelUrl");
-    expect(createGroupChannelresponse.channelUrl).toBe(CHANNEL_URL);
-
-    const startTypingResponse = await groupChannelApi.startTypingIndicators({
-      channelUrl: createGroupChannelresponse.channelUrl,
-      apiToken: API_TOKEN,
-      startTypingIndicatorsRequest: {
-        userIds: [MASTER_USER_ID],
-      },
-    });
-
-    const stopTypingResponse = await groupChannelApi.startTypingIndicators({
-      channelUrl: createGroupChannelresponse.channelUrl,
-      apiToken: API_TOKEN,
-      startTypingIndicatorsRequest: {
-        userIds: [MASTER_USER_ID],
-      },
-    });
-
-    expect(startTypingResponse).toBeDefined();
-    expect(stopTypingResponse).toBeDefined();
-
-    // Cleanup last
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: createGroupChannelresponse.channelUrl,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-  });
-
-  it("call hideAChannel then unhideAChannel", async () => {
-    const CHANNEL_URL = "group-channel-hide-test-channel-url";
-    // Cleanup first
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: CHANNEL_URL,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, 500));
-
-    const request: CreateAGroupChannelRequest = {
-      accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
-      blockSdkUserChannelJoin: true,
-      channelUrl: CHANNEL_URL,
-      coverUrl: "empty",
-      customType: "data",
-      data: "data",
-      /**
-       * Specifies one or more key-value pair items which set the invitation status of each user invited to the channel. The key should be a user_id and the value should be their joining status. Acceptable values are joined, invited_by_friend, and invited_by_non_friend. (Default: joined)
-       */
-      invitationStatus: {
-        MASTER_USER_ID: "joined",
-      },
-      inviterId: MASTER_USER_ID,
-      isDistinct: false,
-      isEphemeral: true,
-      isPublic: true,
-      isSuper: true,
-      name: "test",
-      operatorIds: [],
-      strict: true,
-      users: USERS.map((id) => ({ userId: id })),
-    };
-
-    const createGroupChannelresponse =
-      await groupChannelApi.createAGroupChannel({
-        apiToken: API_TOKEN,
-        createAGroupChannelRequest: request,
-      });
-
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    expect(createGroupChannelresponse).toHaveProperty("channelUrl");
-    expect(createGroupChannelresponse.channelUrl).toBe(CHANNEL_URL);
-
-    const hideAChannelResponse = await groupChannelApi.hideAChannel({
-      channelUrl: createGroupChannelresponse.channelUrl,
-      apiToken: API_TOKEN,
-      hideAChannelRequest: {
-        userId: SECOND_USER_ID,
-        allowAutoUnhide: true,
-        shouldHideAll: false,
-      },
-    });
-
-    const groupChannelAfterHideResponse =
-      await groupChannelApi.getAGroupChannel({
-        channelUrl: createGroupChannelresponse.channelUrl,
-        apiToken: API_TOKEN,
-        showDeliveryReceipt: true,
-        showReadReceipt: true,
-        showMember: true,
-        memberActiveMode: "all",
-        userId: SECOND_USER_ID,
-      });
-
-    const unhideAChannelResponse = await groupChannelApi.unhideAChannel({
-      channelUrl: createGroupChannelresponse.channelUrl,
-      apiToken: API_TOKEN,
-      shouldUnhideAll: false,
-      userId: SECOND_USER_ID,
-    });
-
-    const groupChannelAfterUnHideResponse =
-      await groupChannelApi.getAGroupChannel({
-        channelUrl: createGroupChannelresponse.channelUrl,
-        apiToken: API_TOKEN,
-        showDeliveryReceipt: true,
-        showReadReceipt: true,
-        showMember: true,
-        memberActiveMode: "all",
-        userId: SECOND_USER_ID,
-      });
-
-    expect(groupChannelAfterHideResponse.channelUrl).toBe(CHANNEL_URL);
-    expect(groupChannelAfterHideResponse).toHaveProperty("hiddenState");
-    expect(groupChannelAfterHideResponse.isHidden).toBeTruthy();
-
-    expect(groupChannelAfterHideResponse).toHaveProperty("hiddenState");
-    expect(groupChannelAfterHideResponse.hiddenState).toBe(
-      "hidden_allow_auto_unhide"
-    );
-    expect(
-      validSendbirdGroupChannelHiddenStateEnum.includes(
-        groupChannelAfterHideResponse.hiddenState
-      )
-    ).toBeTruthy();
-
-    expect(groupChannelAfterUnHideResponse).toHaveProperty("hiddenState");
-    expect(groupChannelAfterUnHideResponse.isHidden).toBeFalsy();
-    expect(groupChannelAfterUnHideResponse).toHaveProperty("hiddenState");
-    expect(groupChannelAfterUnHideResponse.hiddenState).toBe("unhidden");
-    expect(
-      validSendbirdGroupChannelHiddenStateEnum.includes(
-        groupChannelAfterUnHideResponse.hiddenState
-      )
-    ).toBeTruthy();
-
-    expect(hideAChannelResponse).toBeDefined();
-    expect(unhideAChannelResponse).toBeDefined();
-
-    // Cleanup last
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: createGroupChannelresponse.channelUrl,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-  });
-
-  it("call inviteAsMembers then acceptAnInvitation and checkIfMember", async () => {
-    const CHANNEL_URL = "group-channel-member-invitation-test-channel-url";
-    // Cleanup first
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: CHANNEL_URL,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, 500));
-
-    const request: CreateAGroupChannelRequest = {
-      accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
-      blockSdkUserChannelJoin: true,
-      channelUrl: CHANNEL_URL,
-      coverUrl: "empty",
-      customType: "data",
-      data: "data",
-      /**
-       * Specifies one or more key-value pair items which set the invitation status of each user invited to the channel. The key should be a user_id and the value should be their joining status. Acceptable values are joined, invited_by_friend, and invited_by_non_friend. (Default: joined)
-       */
-      invitationStatus: {
-        MASTER_USER_ID: "joined",
-      },
-      inviterId: MASTER_USER_ID,
-      isDistinct: false,
-      isEphemeral: true,
-      isPublic: true,
-      isSuper: true,
-      name: "test",
-      operatorIds: [],
-      strict: true,
-      users: USERS.map((id) => ({ userId: id })),
-    };
-
-    const createGroupChannelresponse =
-      await groupChannelApi.createAGroupChannel({
-        apiToken: API_TOKEN,
-        createAGroupChannelRequest: request,
-      });
-
-    expect(createGroupChannelresponse).toHaveProperty("channelUrl");
-    expect(createGroupChannelresponse.channelUrl).toBe(CHANNEL_URL);
-
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    const inviteAsMembersResponse = await groupChannelApi.inviteAsMembers({
-      channelUrl: CHANNEL_URL,
-      apiToken: API_TOKEN,
-      inviteAsMembersRequest: {
-        inviterId: MASTER_USER_ID,
-        userIds: [SECOND_USER_ID],
-      },
-    });
-
-    const groupChannelAfterInviteResponse =
-      await groupChannelApi.getAGroupChannel({
-        channelUrl: createGroupChannelresponse.channelUrl,
-        apiToken: API_TOKEN,
-        showDeliveryReceipt: true,
-        showReadReceipt: true,
-        showMember: true,
-        memberActiveMode: "all",
-        userId: SECOND_USER_ID,
-      });
-
-    const acceptAnInvitationResponse = await groupChannelApi.acceptAnInvitation(
-      {
-        channelUrl: createGroupChannelresponse.channelUrl,
-        apiToken: API_TOKEN,
-        acceptAnInvitationRequest: {
-          userId: SECOND_USER_ID,
-          accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
-        },
-      }
-    );
-
-    const checkIfMemberResponse = await groupChannelApi.checkIfMember({
-      channelUrl: createGroupChannelresponse.channelUrl,
-      apiToken: API_TOKEN,
-      userId: SECOND_USER_ID,
-    });
-
-    const groupChannelAfterJoinedResponse =
-      await groupChannelApi.getAGroupChannel({
-        channelUrl: createGroupChannelresponse.channelUrl,
-        apiToken: API_TOKEN,
-        showDeliveryReceipt: true,
-        showReadReceipt: true,
-        showMember: true,
-        memberActiveMode: "all",
-        userId: SECOND_USER_ID,
-      });
-
-    expect(inviteAsMembersResponse).toHaveProperty("invitedAt");
-    expect(inviteAsMembersResponse).toHaveProperty("inviter");
-    expect(inviteAsMembersResponse.inviter?.userId).toBe(MASTER_USER_ID);
-    expect(inviteAsMembersResponse.inviter).toBeInstanceOf(
-      SendbirdBasicUserInfo
-    );
-
-    expect(groupChannelAfterInviteResponse).toHaveProperty("memberState");
-    expect(groupChannelAfterInviteResponse.memberState).toBe("invited");
-    expect(groupChannelAfterInviteResponse.memberCount).toBe(2);
-    expect(groupChannelAfterInviteResponse.joinedMemberCount).toBe(1);
-
-    expect(acceptAnInvitationResponse.joinedMemberCount).toBe(2);
-    expect(
-      acceptAnInvitationResponse.members?.find(
-        (member) => (member.state = "joined")
-      )?.userId
-    ).toBe(SECOND_USER_ID);
-
-    expect(groupChannelAfterJoinedResponse).toHaveProperty("memberState");
-    expect(groupChannelAfterJoinedResponse).toHaveProperty("joinedTs");
-    expect(groupChannelAfterJoinedResponse.joinedTs?.toString().length).toBe(
-      10
-    );
-    expect(groupChannelAfterJoinedResponse.memberState).toBe("joined");
-    expect(groupChannelAfterJoinedResponse.memberCount).toBe(2);
-    expect(groupChannelAfterJoinedResponse.joinedMemberCount).toBe(2);
-
-    expect(checkIfMemberResponse).toHaveProperty("isMember");
-    expect(checkIfMemberResponse.isMember).toBeTruthy();
-    expect(typeof checkIfMemberResponse.isMember).toBe("boolean");
-
-    expect(checkIfMemberResponse).toHaveProperty("state");
-    expect(checkIfMemberResponse.state).toBeTruthy();
-    expect(typeof checkIfMemberResponse.state).toBe("string");
-    expect(
-      validSendbirdGroupChannelMemberStateEnum.includes(
-        checkIfMemberResponse.state
-      )
-    ).toBeTruthy();
-
-    // Cleanup last
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: createGroupChannelresponse.channelUrl,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-  });
-
-  it("call joinAChannel then leaveAChannel", async () => {
-    const CHANNEL_URL = "group-channel-join-leave-channel-test-channel-url";
-    // Cleanup first
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: CHANNEL_URL,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, 500));
-
-    const request: CreateAGroupChannelRequest = {
-      accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
-      blockSdkUserChannelJoin: true,
-      channelUrl: CHANNEL_URL,
-      coverUrl: "empty",
-      customType: "data",
-      data: "data",
-      /**
-       * Specifies one or more key-value pair items which set the invitation status of each user invited to the channel. The key should be a user_id and the value should be their joining status. Acceptable values are joined, invited_by_friend, and invited_by_non_friend. (Default: joined)
-       */
-      invitationStatus: {
-        MASTER_USER_ID: "joined",
-      },
-      inviterId: MASTER_USER_ID,
-      isDistinct: false,
-      isEphemeral: true,
-      isPublic: true,
-      isSuper: true,
-      name: "test",
-      operatorIds: [],
-      strict: true,
-      users: USERS.map((id) => ({ userId: id })),
-    };
-
-    const createGroupChannelresponse =
-      await groupChannelApi.createAGroupChannel({
-        apiToken: API_TOKEN,
-        createAGroupChannelRequest: request,
-      });
-
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    expect(createGroupChannelresponse).toHaveProperty("channelUrl");
-    expect(createGroupChannelresponse.channelUrl).toBe(CHANNEL_URL);
-
-    const joinAChannelResponse = await groupChannelApi.joinAChannel({
-      channelUrl: CHANNEL_URL,
-      apiToken: API_TOKEN,
-      joinAChannelRequest: {
-        userId: SECOND_USER_ID,
-        accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
-      },
-    });
-
-    const leaveAChannelResponse = await groupChannelApi.leaveAChannel({
-      channelUrl: createGroupChannelresponse.channelUrl,
-      apiToken: API_TOKEN,
-      leaveAChannelRequest: {
-        shouldLeaveAll: false,
-        userIds: [SECOND_USER_ID],
-      },
-    });
-
-    const getAGroupChannelResponse = await groupChannelApi.getAGroupChannel({
-      channelUrl: createGroupChannelresponse.channelUrl,
-      apiToken: API_TOKEN,
-      showDeliveryReceipt: true,
-      showReadReceipt: true,
-      showMember: true,
-      memberActiveMode: "all",
-      userId: MASTER_USER_ID,
-    });
-
-    expect(joinAChannelResponse.memberCount).toBe(2);
-    expect(joinAChannelResponse.joinedMemberCount).toBe(2);
-
-    expect(leaveAChannelResponse).toBeDefined();
-
-    expect(getAGroupChannelResponse.memberCount).toBe(1);
-    expect(getAGroupChannelResponse.joinedMemberCount).toBe(1);
-
-    // Cleanup last
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: createGroupChannelresponse.channelUrl,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-  });
-
-  it("call updateAGroupChannel", async () => {
-    const CHANNEL_URL = "group-channel-update-channel-test-channel-url";
-    // Cleanup first
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: CHANNEL_URL,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      //ignore
-      console.warn("ignore error in cleanup", e);
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, 500));
-
-    const request: CreateAGroupChannelRequest = {
-      accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
-      blockSdkUserChannelJoin: true,
-      channelUrl: CHANNEL_URL,
-      coverUrl: "empty",
-      customType: "data",
-      data: "data",
-      /**
-       * Specifies one or more key-value pair items which set the invitation status of each user invited to the channel. The key should be a user_id and the value should be their joining status. Acceptable values are joined, invited_by_friend, and invited_by_non_friend. (Default: joined)
-       */
-      invitationStatus: {
-        MASTER_USER_ID: "joined",
-      },
-      inviterId: MASTER_USER_ID,
-      isDistinct: false,
-      isEphemeral: true,
-      isPublic: true,
-      isSuper: true,
-      name: "test",
-      operatorIds: [],
-      strict: true,
-      users: USERS.map((id) => ({ userId: id })),
-    };
-
-    const createGroupChannelResponse =
-      await groupChannelApi.createAGroupChannel({
-        apiToken: API_TOKEN,
-        createAGroupChannelRequest: request,
-      });
-
-    expect(createGroupChannelResponse).toHaveProperty("channelUrl");
-    expect(createGroupChannelResponse.channelUrl).toBe(CHANNEL_URL);
-
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    const updateAGroupChannelResponse =
-      await groupChannelApi.updateAGroupChannel({
-        channelUrl: CHANNEL_URL,
-        apiToken: API_TOKEN,
-        updateAGroupChannelRequest: {
-          name: "test2",
-          data: "data2",
-        },
-      });
-
-    expect(updateAGroupChannelResponse.name).toBe("test2");
-    expect(updateAGroupChannelResponse.data).toBe("data2");
-
-    // Cleanup last
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: CHANNEL_URL,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-  });
-
-  it("call resetChatHistory", async () => {
-    const CHANNEL_URL = "group-channel-reset-chat-history-test-channel-url";
-    // Cleanup first
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: CHANNEL_URL,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      //ignore
-      console.warn("ignore error in cleanup", e);
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, 500));
-
-    const request: CreateAGroupChannelRequest = {
-      accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
-      blockSdkUserChannelJoin: true,
-      channelUrl: CHANNEL_URL,
-      coverUrl: "empty",
-      customType: "data",
-      data: "data",
-      /**
-       * Specifies one or more key-value pair items which set the invitation status of each user invited to the channel. The key should be a user_id and the value should be their joining status. Acceptable values are joined, invited_by_friend, and invited_by_non_friend. (Default: joined)
-       */
-      invitationStatus: Object.fromEntries(USERS.map((id) => [id, "joined"])),
-      inviterId: MASTER_USER_ID,
-      isDistinct: false,
-      isEphemeral: true,
-      isPublic: true,
-      isSuper: true,
-      name: "test",
-      operatorIds: [],
-      strict: true,
-      users: USERS.map((id) => ({ userId: id })),
-    };
-    const createGroupChannelresponse =
-      await groupChannelApi.createAGroupChannel({
-        apiToken: API_TOKEN,
-        createAGroupChannelRequest: request,
-      });
-
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    expect(createGroupChannelresponse).toHaveProperty("channelUrl");
-    expect(createGroupChannelresponse.channelUrl).toBe(CHANNEL_URL);
-
-    const resetChatHistoryresponse = await groupChannelApi.resetChatHistory({
-      apiToken: API_TOKEN,
-      channelUrl: createGroupChannelresponse.channelUrl,
-      resetChatHistoryRequest: {
-        userId: MASTER_USER_ID,
-        resetAll: true,
-      },
-    });
-
-    expect(resetChatHistoryresponse).toHaveProperty("tsMessageOffset");
-    expect(typeof resetChatHistoryresponse.tsMessageOffset).toBe("number");
-    expect(resetChatHistoryresponse.tsMessageOffset?.toString().length).toBe(
-      13
-    );
-
-    // Cleanup last
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: createGroupChannelresponse.channelUrl,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-  });
-});