@sendbird/sendbird-platform-sdk-typescript 2.1.5 → 2.1.7

package/tests/integration/helper.ts

@@ -1,8 +0,0 @@
-export function hasValidField<T extends object>(
-  obj: T | null | undefined,
-  field: keyof T
-): boolean {
-  return (
-    obj !== null && obj !== undefined && field in obj && obj[field] != null
-  );
-}

package/tests/integration/metadata.test.ts

@@ -1,22 +0,0 @@
-import { ServerConfiguration } from "../../servers";
-import { createConfiguration } from "../../configuration";
-import { MetadataApi, OpenChannelApi } from "../../index";
-
-describe("Metadata API", () => {
-  const APP_ID = process.env.APP_ID || "";
-  const API_TOKEN = process.env.API_TOKEN || "";
-  let metadataApi: MetadataApi;
-
-  beforeEach(() => {
-    const serverConfig = new ServerConfiguration(
-      `https://api-${APP_ID}.sendbird.com`,
-      { app_id: APP_ID }
-    );
-    const configuration = createConfiguration({
-      baseServer: serverConfig,
-    });
-    metadataApi = new MetadataApi(configuration);
-  });
-
-  it.todo("no need test case for now");
-});

package/tests/integration/moderation.test.ts

@@ -1,172 +0,0 @@
-import {
-  CreateAGroupChannelRequest,
-  CreateAnOpenChannelRequest,
-} from "../../models/ObjectSerializer";
-import { ServerConfiguration } from "../../servers";
-import { createConfiguration } from "../../configuration";
-import { ModerationApi, GroupChannelApi, OpenChannelApi } from "../../index";
-import {
-  GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
-  MASTER_USER_ID,
-  USERS,
-} from "./constants";
-
-describe("Moderation API", () => {
-  const APP_ID = process.env.APP_ID || "";
-  const API_TOKEN = process.env.API_TOKEN || "";
-  let moderationApi: ModerationApi;
-  let groupChannelApi: GroupChannelApi;
-  let openChannelApi: OpenChannelApi;
-
-  beforeEach(() => {
-    const serverConfig = new ServerConfiguration(
-      `https://api-${APP_ID}.sendbird.com`,
-      { app_id: APP_ID }
-    );
-    const configuration = createConfiguration({
-      baseServer: serverConfig,
-    });
-    groupChannelApi = new GroupChannelApi(configuration);
-    moderationApi = new ModerationApi(configuration);
-    openChannelApi = new OpenChannelApi(configuration);
-  });
-
-  it("call freezeAGroupChannel from new created group channel", async () => {
-    const CHANNEL_URL = "freeze-integration-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,
-      });
-
-    expect(createGroupChannelresponse).toHaveProperty("channelUrl");
-    expect(createGroupChannelresponse.channelUrl).toBe(CHANNEL_URL);
-    expect(typeof createGroupChannelresponse.channelUrl).toBe("string");
-
-    expect(createGroupChannelresponse).toHaveProperty("freeze");
-    expect(createGroupChannelresponse.freeze).toBe(false);
-
-    const freezeChannelResponse = await moderationApi.freezeAGroupChannel({
-      channelUrl: createGroupChannelresponse.channelUrl,
-      apiToken: API_TOKEN,
-      freezeAGroupChannelRequest: { freeze: true },
-    });
-
-    expect(freezeChannelResponse).toHaveProperty("channelUrl");
-    expect(freezeChannelResponse.channelUrl).toBe(CHANNEL_URL);
-    expect(typeof freezeChannelResponse.channelUrl).toBe("string");
-
-    expect(freezeChannelResponse).not.toEqual(createGroupChannelresponse);
-    expect(freezeChannelResponse).toHaveProperty("freeze");
-    expect(freezeChannelResponse.freeze).toBe(true);
-
-    // Cleanup last
-    try {
-      await groupChannelApi.deleteAGroupChannel({
-        channelUrl: createGroupChannelresponse.channelUrl,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      console.warn("ignore error in cleanup", e);
-    }
-  });
-
-  it("call freezeAGroupChannel from new created open channel", async () => {
-    const CHANNEL_URL = "freeze-open-channel-integration-test-channel-url";
-    // Cleanup first
-    try {
-      await openChannelApi.deleteAnOpenChannel({
-        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: CreateAnOpenChannelRequest = {
-      isDynamicPartitioned: true,
-      channelUrl: CHANNEL_URL,
-      coverUrl: "data",
-      customType: "data",
-      data: "data",
-      isEphemeral: true,
-      name: "test-open-channel",
-      operatorIds: [MASTER_USER_ID],
-    };
-
-    const createAnOpenChannelresponse =
-      await openChannelApi.createAnOpenChannel({
-        apiToken: API_TOKEN,
-        createAnOpenChannelRequest: request,
-      });
-
-    expect(createAnOpenChannelresponse).toHaveProperty("channelUrl");
-    expect(createAnOpenChannelresponse.channelUrl).toBe(CHANNEL_URL);
-    expect(typeof createAnOpenChannelresponse.channelUrl).toBe("string");
-
-    expect(createAnOpenChannelresponse).toHaveProperty("freeze");
-    expect(createAnOpenChannelresponse.freeze).toBe(false);
-
-    const freezeChannelResponse = await moderationApi.freezeAnOpenChannel({
-      channelUrl: createAnOpenChannelresponse.channelUrl,
-      apiToken: API_TOKEN,
-      freezeAnOpenChannelRequest: { freeze: true },
-    });
-
-    expect(freezeChannelResponse).toHaveProperty("channelUrl");
-    expect(freezeChannelResponse.channelUrl).toBe(CHANNEL_URL);
-    expect(typeof freezeChannelResponse.channelUrl).toBe("string");
-
-    expect(freezeChannelResponse).not.toEqual(createAnOpenChannelresponse);
-    expect(freezeChannelResponse).toHaveProperty("freeze");
-    expect(freezeChannelResponse.freeze).toBe(true);
-    // Cleanup last
-    try {
-      await openChannelApi.deleteAnOpenChannel({
-        apiToken: API_TOKEN,
-        channelUrl: createAnOpenChannelresponse.channelUrl,
-      });
-    } catch (e) {
-      //ignore
-      console.warn("ignore error in cleanup", e);
-    }
-  });
-});

package/tests/integration/openChannel.test.ts

@@ -1,239 +0,0 @@
-import { CreateAnOpenChannelRequest } from "./../../models/CreateAnOpenChannelRequest";
-import { ServerConfiguration } from "../../servers";
-import { createConfiguration } from "../../configuration";
-import { OpenChannelApi } from "../../index";
-import { hasValidField } from "./helper";
-
-describe("Open Channel API", () => {
-  const APP_ID = process.env.APP_ID || "";
-  const API_TOKEN = process.env.API_TOKEN || "";
-  let openChannelApi: OpenChannelApi;
-
-  beforeEach(() => {
-    const serverConfig = new ServerConfiguration(
-      `https://api-${APP_ID}.sendbird.com`,
-      { app_id: APP_ID }
-    );
-    const configuration = createConfiguration({
-      baseServer: serverConfig,
-    });
-    openChannelApi = new OpenChannelApi(configuration);
-  });
-
-  it("call createAnOpenChannel", async () => {
-    const CHANNEL_URL = "test-create-open-channel-url";
-    // Cleanup first
-    try {
-      await openChannelApi.deleteAnOpenChannel({
-        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: CreateAnOpenChannelRequest = {
-      isDynamicPartitioned: false,
-      channelUrl: CHANNEL_URL,
-      coverUrl: "string",
-      customType: "custom",
-      data: "data",
-      isEphemeral: false,
-      name: CHANNEL_URL,
-      operatorIds: [],
-    };
-
-    const createAnOpenChannelResponse =
-      await openChannelApi.createAnOpenChannel({
-        apiToken: API_TOKEN,
-        createAnOpenChannelRequest: request,
-      });
-
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    expect(createAnOpenChannelResponse).toHaveProperty("channelUrl");
-    expect(typeof createAnOpenChannelResponse.channelUrl).toBe("string");
-
-    if (hasValidField(createAnOpenChannelResponse, "coverUrl")) {
-      expect(typeof createAnOpenChannelResponse.coverUrl).toBe("string");
-    }
-
-    if (hasValidField(createAnOpenChannelResponse, "createdAt")) {
-      expect(typeof createAnOpenChannelResponse.createdAt).toBe("number");
-    }
-
-    if (hasValidField(createAnOpenChannelResponse, "customType")) {
-      expect(typeof createAnOpenChannelResponse.customType).toBe("string");
-    }
-
-    if (hasValidField(createAnOpenChannelResponse, "data")) {
-      expect(typeof createAnOpenChannelResponse.data).toBe("string");
-    }
-
-    if (hasValidField(createAnOpenChannelResponse, "freeze")) {
-      expect(typeof createAnOpenChannelResponse.freeze).toBe("boolean");
-    }
-
-    if (hasValidField(createAnOpenChannelResponse, "isDynamicPartitioned")) {
-      expect(typeof createAnOpenChannelResponse.isDynamicPartitioned).toBe(
-        "boolean"
-      );
-    }
-
-    if (hasValidField(createAnOpenChannelResponse, "isEphemeral")) {
-      expect(typeof createAnOpenChannelResponse.isEphemeral).toBe("boolean");
-    }
-
-    if (hasValidField(createAnOpenChannelResponse, "maxLengthMessage")) {
-      expect(typeof createAnOpenChannelResponse.maxLengthMessage).toBe(
-        "number"
-      );
-    }
-
-    if (hasValidField(createAnOpenChannelResponse, "name")) {
-      expect(typeof createAnOpenChannelResponse.name).toBe("string");
-    }
-
-    if (hasValidField(createAnOpenChannelResponse, "operators")) {
-      expect(Array.isArray(createAnOpenChannelResponse.operators)).toBe(true);
-      createAnOpenChannelResponse.operators?.forEach((op) => {
-        expect(op).toHaveProperty("userId");
-        expect(typeof op.userId).toBe("string");
-      });
-    }
-
-    if (hasValidField(createAnOpenChannelResponse, "participantCount")) {
-      expect(typeof createAnOpenChannelResponse.participantCount).toBe(
-        "number"
-      );
-    }
-
-    if (hasValidField(createAnOpenChannelResponse, "metadata")) {
-      expect(typeof createAnOpenChannelResponse.metadata).toBe("object");
-    }
-
-    // Cleanup last
-    try {
-      await openChannelApi.deleteAnOpenChannel({
-        channelUrl: CHANNEL_URL,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      //ignore
-      console.warn("ignore error in cleanup", e);
-    }
-  });
-
-  it("call listOpenChannels", async () => {
-    const CHANNEL_URL = "test-create-open-before-list-channels-channel-url";
-    // Cleanup first
-    try {
-      await openChannelApi.deleteAnOpenChannel({
-        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: CreateAnOpenChannelRequest = {
-      isDynamicPartitioned: false,
-      channelUrl: CHANNEL_URL,
-      coverUrl: "string",
-      customType: "custom",
-      data: "data",
-      isEphemeral: false,
-      name: CHANNEL_URL,
-      operatorIds: [],
-    };
-
-    const createAnOpenChannelResponse =
-      await openChannelApi.createAnOpenChannel({
-        apiToken: API_TOKEN,
-        createAnOpenChannelRequest: request,
-      });
-
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    expect(createAnOpenChannelResponse).toBeDefined();
-
-    const listOpenChannelsResponse = await openChannelApi.listOpenChannels({
-      apiToken: API_TOKEN,
-    });
-
-    expect(listOpenChannelsResponse).toHaveProperty("channels");
-    listOpenChannelsResponse.channels?.forEach((channel) => {
-      expect(channel).toHaveProperty("channelUrl");
-      expect(typeof channel.channelUrl).toBe("string");
-
-      if (hasValidField(channel, "coverUrl")) {
-        expect(typeof channel.coverUrl).toBe("string");
-      }
-
-      if (hasValidField(channel, "createdAt")) {
-        expect(typeof channel.createdAt).toBe("number");
-      }
-
-      if (hasValidField(channel, "customType")) {
-        expect(typeof channel.customType).toBe("string");
-      }
-
-      if (hasValidField(channel, "data")) {
-        expect(typeof channel.data).toBe("string");
-      }
-
-      if (hasValidField(channel, "freeze")) {
-        expect(typeof channel.freeze).toBe("boolean");
-      }
-
-      if (hasValidField(channel, "isDynamicPartitioned")) {
-        expect(typeof channel.isDynamicPartitioned).toBe("boolean");
-      }
-
-      if (hasValidField(channel, "isEphemeral")) {
-        expect(typeof channel.isEphemeral).toBe("boolean");
-      }
-
-      if (hasValidField(channel, "maxLengthMessage")) {
-        expect(typeof channel.maxLengthMessage).toBe("number");
-      }
-
-      if (hasValidField(channel, "name")) {
-        expect(typeof channel.name).toBe("string");
-      }
-
-      if (hasValidField(channel, "operators")) {
-        expect(Array.isArray(channel.operators)).toBe(true);
-        channel.operators?.forEach((op) => {
-          expect(op).toHaveProperty("userId");
-          expect(typeof op.userId).toBe("string");
-        });
-      }
-
-      if (hasValidField(channel, "participantCount")) {
-        expect(typeof channel.participantCount).toBe("number");
-      }
-
-      if (hasValidField(channel, "metadata")) {
-        expect(typeof channel.metadata).toBe("object");
-      }
-    });
-
-    // Cleanup last
-    try {
-      await openChannelApi.deleteAnOpenChannel({
-        channelUrl: CHANNEL_URL,
-        apiToken: API_TOKEN,
-      });
-    } catch (e) {
-      //ignore
-      console.warn("ignore error in cleanup", e);
-    }
-  });
-});

package/tests/integration/statistics.test.ts

@@ -1,44 +0,0 @@
-import { ServerConfiguration } from "../../servers";
-import { createConfiguration } from "../../configuration";
-import { StatisticsApi } from "../../index";
-
-describe("Statistics API", () => {
-  const APP_ID = process.env.APP_ID || "";
-  const API_TOKEN = process.env.API_TOKEN || "";
-  let statisticApi: StatisticsApi;
-
-  beforeEach(() => {
-    const serverConfig = new ServerConfiguration(
-      `https://api-${APP_ID}.sendbird.com`,
-      { app_id: APP_ID }
-    );
-    const configuration = createConfiguration({
-      baseServer: serverConfig,
-    });
-    statisticApi = new StatisticsApi(configuration);
-  });
-
-  it("call viewNumberOfDailyActiveUsers", async () => {
-    const response = await statisticApi.viewNumberOfDailyActiveUsers({
-      apiToken: API_TOKEN,
-    });
-
-    expect(Object.keys(response).length).toBe(1);
-
-    expect(response).toHaveProperty("dau");
-    expect(response.dau).toBeGreaterThanOrEqual(0);
-    expect(typeof response.dau).toBe("number");
-  });
-
-  it("call viewNumberOfMonthlyActiveUsers", async () => {
-    const response = await statisticApi.viewNumberOfMonthlyActiveUsers({
-      apiToken: API_TOKEN,
-    });
-
-    expect(Object.keys(response).length).toBe(1);
-
-    expect(response).toHaveProperty("mau");
-    expect(response.mau).toBeGreaterThanOrEqual(0);
-    expect(typeof response.mau).toBe("number");
-  });
-});