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

package/tests/integration/user.test.ts

@@ -396,10 +396,6 @@ describe("User API", () => {
     expect(createAUserResponse.accessToken).toBe("");
     expect(typeof createAUserResponse.accessToken).toBe("string");
 
-    expect(createAUserResponse).toHaveProperty("sessionTokens");
-    expect(createAUserResponse.sessionTokens).toStrictEqual([]);
-    expect(Array.isArray(createAUserResponse.sessionTokens)).toBeTruthy();
-
     expect(createAUserResponse).toHaveProperty("isOnline");
     expect(createAUserResponse.isOnline).toBe(false);
     expect(typeof createAUserResponse.isOnline).toBe("boolean");
@@ -465,10 +461,6 @@ describe("User API", () => {
     expect(viewAUserResponse.isShadowBlocked).toBe(false);
     expect(typeof viewAUserResponse.isShadowBlocked).toBe("boolean");
 
-    expect(viewAUserResponse).toHaveProperty("sessionTokens");
-    expect(viewAUserResponse.sessionTokens).toStrictEqual([]);
-    expect(Array.isArray(viewAUserResponse.sessionTokens)).toBeTruthy();
-
     expect(viewAUserResponse).toHaveProperty("isOnline");
     expect(viewAUserResponse.isOnline).toBe(false);
     expect(typeof viewAUserResponse.isOnline).toBe("boolean");
@@ -547,10 +539,6 @@ describe("User API", () => {
     expect(updateAUserResponse.isShadowBlocked).toBe(false);
     expect(typeof updateAUserResponse.isShadowBlocked).toBe("boolean");
 
-    expect(updateAUserResponse).toHaveProperty("sessionTokens");
-    expect(updateAUserResponse.sessionTokens).toStrictEqual([]);
-    expect(Array.isArray(updateAUserResponse.sessionTokens)).toBeTruthy();
-
     expect(updateAUserResponse).toHaveProperty("isOnline");
     expect(updateAUserResponse.isOnline).toBe(false);
     expect(typeof updateAUserResponse.isOnline).toBe("boolean");
@@ -582,4 +570,239 @@ describe("User API", () => {
 
     expect(deleteAUserResponse).toBeDefined();
   });
+
+  it("call createUserMetadata", async () => {
+    const TEST_METADATA_KEY = "create_metadata_key";
+    const TEST_METADATA_VALUE = "test_value";
+
+    try {
+      await userApi.deleteUserAllMetadata({
+        userId: MASTER_USER_ID,
+        apiToken: API_TOKEN,
+      });
+    } catch (e) {
+      console.warn("ignoring error deleting metadata:", e);
+    }
+
+    const createMetadataResponse = await userApi.createUserMetadata({
+      userId: MASTER_USER_ID,
+      apiToken: API_TOKEN,
+      createUserMetadataRequest: {
+        metadata: {
+          [TEST_METADATA_KEY]: TEST_METADATA_VALUE,
+        },
+      },
+    });
+
+    expect(createMetadataResponse).toBeDefined();
+    expect(typeof createMetadataResponse).toBe("object");
+    expect(createMetadataResponse).toHaveProperty(TEST_METADATA_KEY);
+    expect(createMetadataResponse[TEST_METADATA_KEY]).toBe(
+      TEST_METADATA_VALUE
+    );
+  });
+  it("call deleteUserMetadata", async () => {
+    const TEST_METADATA_KEY = "create_metadata_key";
+    const TEST_METADATA_VALUE = "test_value";
+
+    try {
+      await userApi.deleteUserAllMetadata({
+        userId: MASTER_USER_ID,
+        apiToken: API_TOKEN,
+      });
+    } catch (e) {
+      console.warn("ignoring error deleting metadata:", e);
+    }
+
+    await userApi.createUserMetadata({
+      userId: MASTER_USER_ID,
+      apiToken: API_TOKEN,
+      createUserMetadataRequest: {
+        metadata: {
+          [TEST_METADATA_KEY]: TEST_METADATA_VALUE,
+        },
+      },
+    });
+
+    try {
+      await userApi.deleteUserAllMetadata({
+        userId: MASTER_USER_ID,
+        apiToken: API_TOKEN,
+      });
+    } catch (e) {
+      fail(`error deleting metadata: ${e}`);
+    }
+  });
+  it("call updateUserMetadata", async () => {
+    const TEST_METADATA_KEY = "create_metadata_key";
+    const TEST_METADATA_VALUE = "test_value";
+
+    try {
+      await userApi.deleteUserAllMetadata({
+        userId: MASTER_USER_ID,
+        apiToken: API_TOKEN,
+      });
+    } catch (e) {
+      console.warn("ignoring error deleting metadata:", e);
+    }
+
+    await userApi.createUserMetadata({
+      userId: MASTER_USER_ID,
+      apiToken: API_TOKEN,
+      createUserMetadataRequest: {
+        metadata: {
+          [TEST_METADATA_KEY]: TEST_METADATA_VALUE,
+        },
+      },
+    });
+
+    const UPDATED_METADATA_VALUE = "updated_test_value";
+
+    const updateMetadataResponse = await userApi.updateUserMetadata({
+      userId: MASTER_USER_ID,
+      apiToken: API_TOKEN,
+      updateUserMetadataRequest: {
+        metadata: {
+          [TEST_METADATA_KEY]: UPDATED_METADATA_VALUE,
+        },
+      },
+    });
+
+    expect(updateMetadataResponse).toBeDefined();
+    expect(typeof updateMetadataResponse).toBe("object");
+    expect(updateMetadataResponse).toHaveProperty(TEST_METADATA_KEY);
+    expect(updateMetadataResponse[TEST_METADATA_KEY]).toBe(
+      UPDATED_METADATA_VALUE
+    );
+  });
+  it("call Get Specific UserMetadata", async () => {
+    const TEST_METADATA_KEY = "create_metadata_key";
+    const TEST_METADATA_VALUE = "test_value";
+    const TEST_METADATA_KEY_1 = "create_metadata_key_1";
+    const TEST_METADATA_VALUE_1 = "test_value_1";
+
+    try {
+      await userApi.deleteUserAllMetadata({
+        userId: MASTER_USER_ID,
+        apiToken: API_TOKEN,
+      });
+    } catch (e) {
+      console.warn("ignoring error deleting metadata:", e);
+    }
+
+    await userApi.createUserMetadata({
+      userId: MASTER_USER_ID,
+      apiToken: API_TOKEN,
+      createUserMetadataRequest: {
+        metadata: {
+          [TEST_METADATA_KEY]: TEST_METADATA_VALUE,
+          [TEST_METADATA_KEY_1]: TEST_METADATA_VALUE_1,
+        },
+      },
+    });
+
+    const getSpecificMetadataResponse = await userApi.viewSpecificUserMetadata({
+      userId: MASTER_USER_ID,
+      apiToken: API_TOKEN,
+      key: TEST_METADATA_KEY_1,
+    });
+
+    expect(getSpecificMetadataResponse).toBeDefined();
+    expect(typeof getSpecificMetadataResponse).toBe("object");
+    expect(getSpecificMetadataResponse).toHaveProperty(TEST_METADATA_KEY_1);
+    expect(getSpecificMetadataResponse[TEST_METADATA_KEY_1]).toBe(
+      TEST_METADATA_VALUE_1
+    );
+  });
+  it("call Update Specific UserMetadata", async () => {
+    const TEST_METADATA_KEY = "create_metadata_key";
+    const TEST_METADATA_VALUE = "test_value";
+    const TEST_METADATA_KEY_1 = "create_metadata_key_1";
+    const TEST_METADATA_VALUE_1 = "test_value_1";
+
+    try {
+      await userApi.deleteUserAllMetadata({
+        userId: MASTER_USER_ID,
+        apiToken: API_TOKEN,
+      });
+    } catch (e) {
+      console.warn("ignoring error deleting metadata:", e);
+    }
+
+    await userApi.createUserMetadata({
+      userId: MASTER_USER_ID,
+      apiToken: API_TOKEN,
+      createUserMetadataRequest: {
+        metadata: {
+          [TEST_METADATA_KEY]: TEST_METADATA_VALUE,
+          [TEST_METADATA_KEY_1]: TEST_METADATA_VALUE_1,
+        },
+      },
+    });
+
+    const UPDATED_METADATA_VALUE_1 = "updated_test_value_1";
+    const updateSpecificMetadataResponse = await userApi.updateSpecificUserMetadata({
+      userId: MASTER_USER_ID,
+      apiToken: API_TOKEN,
+      key: TEST_METADATA_KEY_1,
+      updateSpecificUserMetadataRequest: {
+        value: UPDATED_METADATA_VALUE_1,
+      },
+    });
+
+    expect(updateSpecificMetadataResponse).toBeDefined();
+    expect(typeof updateSpecificMetadataResponse).toBe("object");
+    expect(updateSpecificMetadataResponse).toHaveProperty(TEST_METADATA_KEY_1);
+    expect(updateSpecificMetadataResponse[TEST_METADATA_KEY_1]).toBe(
+      UPDATED_METADATA_VALUE_1
+    );
+  });
+  it("call Delete Specific UserMetadata", async () => {
+    const TEST_METADATA_KEY = "create_metadata_key";
+    const TEST_METADATA_VALUE = "test_value";
+    const TEST_METADATA_KEY_1 = "create_metadata_key_1";
+    const TEST_METADATA_VALUE_1 = "test_value_1";
+
+    try {
+      await userApi.deleteUserAllMetadata({
+        userId: MASTER_USER_ID,
+        apiToken: API_TOKEN,
+      });
+    } catch (e) {
+      console.warn("ignoring error deleting metadata:", e);
+    }
+
+    await userApi.createUserMetadata({
+      userId: MASTER_USER_ID,
+      apiToken: API_TOKEN,
+      createUserMetadataRequest: {
+        metadata: {
+          [TEST_METADATA_KEY]: TEST_METADATA_VALUE,
+          [TEST_METADATA_KEY_1]: TEST_METADATA_VALUE_1,
+        },
+      },
+    });
+
+    try {
+      await userApi.deleteSpecificUserMetadata({
+        userId: MASTER_USER_ID,
+        apiToken: API_TOKEN,
+        key: TEST_METADATA_KEY_1,
+      });
+    } catch (e) {
+      fail(`error deleting specific metadata: ${e}`);
+    }
+
+    try {
+      await userApi.viewSpecificUserMetadata({
+        userId: MASTER_USER_ID,
+        apiToken: API_TOKEN,
+        key: TEST_METADATA_KEY_1,
+      });
+    } catch (e) {
+      const errorBody = JSON.parse((e as any).body);
+      expect(errorBody).toBeDefined();
+      expect(errorBody['code']).toBe(400201);
+    }
+  });
 });

package/tests/utils/fileLoader.ts

@@ -0,0 +1,46 @@
+import { readFileSync } from 'fs';
+const mimeTypes = require('mime-types');
+
+export enum FileAsset {
+  IMAGE_20kb = 'image/test_20kb.jpg',
+  IMAGE_75kb = 'image/test_75kb.jpg',
+  IMAGE_5MB = 'image/test_5mb.jpg',
+  IMAGE_25MB = 'image/test_25mb.bmp',
+}
+
+const base64toBlob = (base64Data: string, name: string, contentType: string = '') => {
+  const sliceSize = 1024;
+  const byteCharacters = atob(base64Data);
+  const bytesLength = byteCharacters.length;
+  const slicesCount = Math.ceil(bytesLength / sliceSize);
+  const byteArrays = new Array(slicesCount);
+  for (let sliceIndex = 0; sliceIndex < slicesCount; ++sliceIndex) {
+    const begin = sliceIndex * sliceSize;
+    const end = Math.min(begin + sliceSize, bytesLength);
+    const bytes = new Array(end - begin);
+    for (let offset = begin, i = 0; offset < end; ++i, ++offset) {
+      bytes[i] = byteCharacters[offset].charCodeAt(0);
+    }
+    byteArrays[sliceIndex] = new Uint8Array(bytes);
+  }
+  return new File(byteArrays, name, { type: contentType });
+};
+
+interface FileLoaderProperties {
+  name: FileAsset;
+}
+
+export default class FileLoader {
+  private _asset: FileAsset;
+
+  constructor({ name }: FileLoaderProperties) {
+    this._asset = name;
+  }
+  async load(): Promise<File> {
+    const path = `${__dirname}/../asset/${this._asset}`;
+    const buffer = readFileSync(path);
+    const type = mimeTypes.lookup(path);
+    const base64 = buffer.toString('base64');
+    return base64toBlob(base64, this._asset, typeof type === 'string' ? type : undefined);
+  }
+}