@whereby.com/browser-sdk 2.0.0-alpha → 2.0.0-alpha10

package/src/lib/api/test/ApiClient.spec.ts

@@ -1,139 +0,0 @@
-import axios from "axios";
-import ApiClient from "../ApiClient";
-import Credentials from "../Credentials";
-import Response from "../Response";
-import { itShouldThrowIfInvalid } from "./helpers";
-
-jest.mock("axios");
-
-const mockedAxios = axios as jest.Mocked<typeof axios>;
-
-const baseUrl = "https://localhost:8090";
-const credentials = new Credentials("12345", "67890");
-
-describe("ApiClient", () => {
-    describe("constructor", () => {
-        it("should not throw an error if no constructor params are passed through", () => {
-            expect(() => new ApiClient()).not.toThrowError();
-        });
-
-        //@ts-expect-error
-        itShouldThrowIfInvalid("baseUrl", () => new ApiClient({ baseUrl: null }));
-        //@ts-expect-error
-        itShouldThrowIfInvalid("fetchDeviceCredentials", () => new ApiClient({ fetchDeviceCredentials: null }));
-    });
-
-    describe("request", () => {
-        let fetchDeviceCredentialsMock: jest.Mock;
-        let apiClient: ApiClient;
-
-        beforeEach(() => {
-            mockedAxios.request.mockResolvedValue(new Response());
-            fetchDeviceCredentialsMock = jest.fn().mockResolvedValueOnce(credentials);
-            apiClient = new ApiClient({
-                baseUrl,
-                fetchDeviceCredentials: fetchDeviceCredentialsMock,
-            });
-        });
-
-        afterEach(() => {
-            mockedAxios.request.mockClear();
-        });
-
-        //@ts-expect-error
-        itShouldThrowIfInvalid("url", () => apiClient.request(null, {}));
-
-        // `url` is required to begin with a `/`
-        it('should throw if `url` does not begin with a "/"', () => {
-            expect(() => apiClient.request("some-url", {})).toThrowError();
-        });
-
-        //@ts-expect-error
-        itShouldThrowIfInvalid("fetchDeviceCredentials", () => new ApiClient({ fetchDeviceCredentials: null }));
-
-        it("should run `this.fetchDeviceCredentials`", () => {
-            const url = "/some/path";
-            const fetchOptions = {};
-
-            apiClient.request(url, fetchOptions);
-
-            expect(fetchDeviceCredentialsMock).toBeCalledTimes(1);
-        });
-
-        it("should return the correct Response value with the correct data if fulfilled", async () => {
-            const responseBaseUrl = "www.website.com";
-            const url = "/some/path";
-            const method = "post";
-            const headers = {
-                type: "jif",
-            };
-            const data = { some: "data" };
-            const status = 200;
-            const statusText = "some status text";
-            const response = {
-                data,
-                headers,
-                method,
-                status,
-                statusText,
-                config: {
-                    url,
-                    baseURL: responseBaseUrl,
-                },
-            };
-            const expectedResponse = new Response({
-                data,
-                headers,
-                status: response.status,
-                statusText: response.statusText,
-                url: `${responseBaseUrl}${url}`,
-            });
-            mockedAxios.request.mockResolvedValueOnce(response);
-
-            const result = await apiClient.request(url, {});
-
-            expect(result).toEqual(expectedResponse);
-        });
-
-        it("should throw an error if rejected with no `response` object", async () => {
-            const url = "/some/path";
-            const data = {};
-            mockedAxios.request.mockRejectedValue(new Response({ status: 404, data }));
-
-            await expect(apiClient.request(url, {})).rejects.toThrow("Could not make the request.");
-        });
-
-        it("should return the correct Response value with the correct data if rejected", async () => {
-            const responseBaseUrl = "www.website.com";
-            const url = "/some/path";
-            const method = "post";
-            const headers = {
-                type: "jif",
-            };
-            const data = { some: "data" };
-            const status = 200;
-            const statusText = "some status text";
-            const response = {
-                data,
-                headers,
-                method,
-                status,
-                statusText,
-                config: {
-                    url,
-                    baseURL: responseBaseUrl,
-                },
-            };
-            const expectedResponse = new Response({
-                data,
-                headers,
-                status: response.status,
-                statusText: response.statusText,
-                url: `${responseBaseUrl}${url}`,
-            });
-            mockedAxios.request.mockRejectedValue({ response });
-
-            await expect(apiClient.request(url, {})).rejects.toEqual(expectedResponse);
-        });
-    });
-});

package/src/lib/api/test/HttpClient.spec.ts

@@ -1,120 +0,0 @@
-import axios from "axios";
-import HttpClient from "../HttpClient";
-import Response from "../Response";
-import { itShouldThrowIfInvalid } from "./helpers";
-
-jest.mock("axios");
-
-const mockedAxios = axios as jest.Mocked<typeof axios>;
-
-const baseUrl = "https://localhost:8090";
-
-describe("HttpClient", () => {
-    describe("constructor", () => {
-        it("should set `baseUrl` param as class properties", () => {
-            const httpClient = new HttpClient({
-                baseUrl,
-            });
-
-            expect(httpClient._baseUrl).toBe(baseUrl);
-        });
-
-        //@ts-expect-error
-        itShouldThrowIfInvalid("baseUrl", () => new HttpClient({ baseUrl: null }));
-    });
-
-    describe("request", () => {
-        let httpClient: HttpClient;
-
-        beforeEach(() => {
-            httpClient = new HttpClient({
-                baseUrl,
-            });
-            mockedAxios.request.mockClear();
-        });
-
-        //@ts-expect-error
-        itShouldThrowIfInvalid("url", () => httpClient.request(null, {}));
-
-        // `url` is required to begin with a `/`
-        it('should throw if `url` does not begin with a "/"', () => {
-            expect(() => httpClient.request("some-url", {})).toThrowError();
-        });
-
-        it("should return the correct Response value with the correct data if fulfilled", async () => {
-            const responseBaseUrl = "www.website.com";
-            const url = "/some/path";
-            const method = "post";
-            const headers = {
-                type: "jif",
-            };
-            const data = { some: "data" };
-            const status = 200;
-            const statusText = "some status text";
-            const response = {
-                data,
-                headers,
-                method,
-                status,
-                statusText,
-                config: {
-                    url,
-                    baseURL: responseBaseUrl,
-                },
-            };
-            const expectedResponse = new Response({
-                data,
-                headers,
-                status: response.status,
-                statusText: response.statusText,
-                url: `${responseBaseUrl}${url}`,
-            });
-            mockedAxios.request.mockResolvedValue(response);
-
-            const result = await httpClient.request(url, {});
-
-            expect(result).toEqual(expectedResponse);
-        });
-
-        it("should throw an error if rejected with no `response` object", async () => {
-            const url = "/some/path";
-            const data = {};
-            mockedAxios.request.mockRejectedValue(new Response({ status: 404, data }));
-
-            await expect(httpClient.request(url, {})).rejects.toThrow("Could not make the request.");
-        });
-
-        it("should return the correct Response value with the correct data if rejected", async () => {
-            const responseBaseUrl = "www.website.com";
-            const url = "/some/path";
-            const method = "post";
-            const headers = {
-                type: "jif",
-            };
-            const data = { some: "data" };
-            const status = 200;
-            const statusText = "some status text";
-            const response = {
-                data,
-                headers,
-                method,
-                status,
-                statusText,
-                config: {
-                    url,
-                    baseURL: responseBaseUrl,
-                },
-            };
-            const expectedResponse = new Response({
-                data,
-                headers,
-                status: response.status,
-                statusText: response.statusText,
-                url: `${responseBaseUrl}${url}`,
-            });
-            mockedAxios.request.mockRejectedValue({ response });
-
-            await expect(httpClient.request(url, {})).rejects.toEqual(expectedResponse);
-        });
-    });
-});

package/src/lib/api/test/MultipartHttpClient.spec.ts

@@ -1,145 +0,0 @@
-// @ts-nocheck
-import axios from "axios";
-import MultipartHttpClient from "../MultipartHttpClient";
-import Response from "../Response";
-import HttpClient from "../HttpClient";
-import { itShouldThrowIfInvalid } from "./helpers";
-
-jest.mock("axios");
-
-const mockedAxios = axios as jest.Mocked<typeof axios>;
-
-class FormData {
-    values: Record<string, string>;
-    constructor() {
-        this.values = {};
-    }
-    append(key, value) {
-        this.values[key] = value;
-    }
-}
-
-describe("MultipartHttpClient", () => {
-    describe("dataToFormData", () => {
-        let originalFormData;
-        beforeAll(() => {
-            originalFormData = global.FormData;
-            global.FormData = FormData;
-        });
-
-        afterAll(() => {
-            global.FormData = originalFormData;
-        });
-
-        itShouldThrowIfInvalid("data", () => {
-            MultipartHttpClient.dataToFormData(null);
-        });
-
-        it("should return empty FormData if provided object is empty", () => {
-            const formData = MultipartHttpClient.dataToFormData({});
-
-            expect(formData).toEqual(new FormData());
-        });
-
-        it("should return FormData where each key and value is added", () => {
-            const expectedFormData = new FormData();
-            expectedFormData.append("a", "some a");
-            expectedFormData.append("some other key", "some other key value");
-
-            const formData = MultipartHttpClient.dataToFormData({
-                a: "some a",
-                "some other key": "some other key value",
-            });
-
-            expect(formData).toEqual(expectedFormData);
-        });
-    });
-
-    describe("constructor", () => {
-        itShouldThrowIfInvalid("httpClient", () => new MultipartHttpClient({ httpClient: undefined }));
-    });
-
-    describe("request", () => {
-        let httpClient: HttpClient;
-        let multipartHttpClient: MultipartHttpClient;
-        const uri = "/api";
-        const baseUrl = "https://localhost:8090";
-
-        beforeEach(() => {
-            httpClient = new HttpClient({
-                baseUrl,
-            });
-            mockedAxios.request.mockClear();
-            multipartHttpClient = new MultipartHttpClient({ httpClient });
-        });
-
-        it("should reject with the response from httpClient if rejected", async () => {
-            const response = new Response({ status: 400 });
-            mockedAxios.request.mockRejectedValueOnce(response);
-
-            await expect(multipartHttpClient.request(uri, { method: "GET" })).rejects.toThrow(
-                "Could not make the request."
-            );
-        });
-
-        it("should resolve with the response from httpClient if resolved", async () => {
-            const response = new Response({ status: 204 });
-            mockedAxios.request.mockResolvedValueOnce(response);
-
-            const result = await multipartHttpClient.request(uri, { method: "GET" });
-
-            expect(result).toEqual(response);
-        });
-
-        it("should call httpClient with merged options object that handles form parameters", async () => {
-            const data = {
-                someField: "someValue",
-            };
-            const options = {
-                method: "POST",
-                data,
-                headers: {
-                    accept: "text/xml",
-                    "Content-Type": "text/xml",
-                },
-            };
-            const response = new Response({ status: 204 });
-            mockedAxios.request.mockResolvedValueOnce(response);
-
-            await multipartHttpClient.request(uri, options);
-
-            expect(mockedAxios.request).toBeCalledWith({
-                baseURL: baseUrl,
-                method: "POST",
-                data,
-                headers: {
-                    accept: "text/xml",
-                    "Content-Type": undefined,
-                },
-                transformRequest: MultipartHttpClient.dataToFormData,
-                url: uri,
-            });
-        });
-
-        it("should call httpClient with contentType undefined even if it is provided", async () => {
-            const contentType = "overridenValue";
-            const response = new Response({ status: 204 });
-            mockedAxios.request.mockResolvedValueOnce(response);
-
-            await multipartHttpClient.request(uri, {
-                headers: {
-                    "Content-Type": contentType,
-                },
-            });
-
-            expect(mockedAxios.request).toBeCalledWith({
-                baseURL: baseUrl,
-                headers: {
-                    "Content-Type": undefined,
-                },
-                transformRequest: MultipartHttpClient.dataToFormData,
-                url: uri,
-            });
-        });
-    });
-});

package/src/lib/api/test/OrganizationApiClient.spec.ts

@@ -1,132 +0,0 @@
-import ApiClient from "../ApiClient";
-import Response from "../Response";
-import OrganizationApiClient from "../OrganizationApiClient";
-import { itShouldThrowIfInvalid } from "./helpers";
-import { HttpClientRequestConfig } from "../HttpClient";
-
-jest.mock("../ApiClient");
-
-describe("OrganizationApiClient", () => {
-    let apiClient: jest.Mocked<ApiClient>;
-
-    beforeEach(() => {
-        apiClient = new ApiClient() as jest.Mocked<ApiClient>;
-    });
-
-    describe("constructor", () => {
-        //@ts-expect-error
-        itShouldThrowIfInvalid("apiClient", () => new OrganizationApiClient({ apiClient: null }));
-        itShouldThrowIfInvalid(
-            "fetchOrganization",
-            () =>
-                new OrganizationApiClient({
-                    apiClient,
-                    //@ts-expect-error
-                    fetchOrganization: null,
-                })
-        );
-    });
-
-    function testRequestMethod(requestMethodName: "request" | "requestMultipart") {
-        describe(requestMethodName, () => {
-            let fetchOrganization: jest.Mock;
-            let organizationApiClient: OrganizationApiClient;
-            let apiRequestMethod: jest.MockInstance<Promise<Response>, [url: string, options: HttpClientRequestConfig]>;
-            let organizationApiRequestMethod: (
-                url: string,
-                config: HttpClientRequestConfig
-            ) => Promise<Response>;
-
-            beforeEach(() => {
-                fetchOrganization = jest.fn();
-                organizationApiClient = new OrganizationApiClient({
-                    apiClient,
-                    fetchOrganization,
-                });
-
-                apiRequestMethod = apiClient[requestMethodName];
-
-                organizationApiRequestMethod = organizationApiClient[requestMethodName].bind(organizationApiClient);
-            });
-
-            //@ts-expect-error
-            itShouldThrowIfInvalid("url", () => organizationApiRequestMethod(null, {}));
-
-            // `url` is required to begin with a `/`
-            it('should throw if `url` does not begin with a "/"', () => {
-                expect(() => organizationApiRequestMethod("some-url", {})).toThrowError();
-            });
-
-            it("should run `this.fetchOrganization`", () => {
-                const url = "/some/path";
-                const fetchOptions = {};
-                fetchOrganization.mockResolvedValue(null);
-
-                organizationApiRequestMethod(url, fetchOptions);
-
-                expect(fetchOrganization).toBeCalledTimes(1);
-            });
-
-            describe("when no organization is returned", () => {
-                beforeEach(() => {
-                    fetchOrganization.mockResolvedValue(null);
-                });
-
-                it("should call the apiClient without organization prefix", () => {
-                    const url = "/some/path";
-                    const opts = { headers: { blah: "blah" } };
-                    apiRequestMethod.mockResolvedValue(new Response());
-
-                    const promise = organizationApiRequestMethod(url, opts);
-
-                    return promise.then(() => {
-                        expect(apiRequestMethod).toBeCalledWith(url, opts);
-                    });
-                });
-
-                it("should return the response from the apiClient", async () => {
-                    const url = "/some/path";
-                    const options = { headers: { blah: "blah" } };
-                    const response = new Response({ status: 204 });
-                    apiRequestMethod.mockResolvedValue(response);
-
-                    const result = await organizationApiRequestMethod(url, options);
-
-                    expect(result).toEqual(response);
-                });
-            });
-
-            describe("when an organization is returned", () => {
-                const organizationId = 707;
-                const options = { headers: { blah: "blah" } };
-                beforeEach(() => {
-                    fetchOrganization.mockResolvedValue({ organizationId });
-                });
-
-                it("should call the apiClient without organization prefix", () => {
-                    const url = "/some/path";
-                    apiRequestMethod.mockResolvedValue(new Response());
-
-                    const promise = organizationApiRequestMethod(url, options);
-
-                    return promise.then(() => {
-                        expect(apiRequestMethod).toBeCalledWith(`/organizations/${organizationId}` + url, options);
-                    });
-                });
-
-                it("should return the response from the apiClient", async () => {
-                    const url = "/some/path";
-                    const response = new Response({ status: 204 });
-                    apiRequestMethod.mockResolvedValue(response);
-
-                    const result = await organizationApiRequestMethod(url, options);
-
-                    expect(result).toEqual(response);
-                });
-            });
-        });
-    }
-
-    testRequestMethod("request");
-    testRequestMethod("requestMultipart");
-});