From e3beae244daee627805edc8502d9a55b68d0fb09 Mon Sep 17 00:00:00 2001 From: Andrew Bastin Date: Fri, 21 Aug 2020 23:11:45 -0400 Subject: [PATCH] Add test spec for helpers/strategies/AxiosStrategy.js --- .../__tests__/AxiosStrategy-NoProxy.spec.js | 59 ++++++ .../__tests__/AxiosStrategy-Proxy.spec.js | 184 ++++++++++++++++++ 2 files changed, 243 insertions(+) create mode 100644 helpers/strategies/__tests__/AxiosStrategy-NoProxy.spec.js create mode 100644 helpers/strategies/__tests__/AxiosStrategy-Proxy.spec.js diff --git a/helpers/strategies/__tests__/AxiosStrategy-NoProxy.spec.js b/helpers/strategies/__tests__/AxiosStrategy-NoProxy.spec.js new file mode 100644 index 000000000..3c06df48c --- /dev/null +++ b/helpers/strategies/__tests__/AxiosStrategy-NoProxy.spec.js @@ -0,0 +1,59 @@ +import axios from "axios" +import axiosStrategy from "../AxiosStrategy" + +jest.mock("axios") +axios.CancelToken.source.mockReturnValue({ token: "test" }) +axios.mockResolvedValue({}) + +describe("axiosStrategy", () => { + describe("No-Proxy Requests", () => { + const store = { + state: { + postwoman: { + settings: { + PROXY_ENABLED: false, + PROXY_URL: "test", + }, + }, + }, + } + + test("sends request to the actual sender if proxy disabled", async () => { + await axiosStrategy({ url: "test" }, store) + + expect(axios).toBeCalledWith( + expect.objectContaining({ + url: "test", + }) + ) + }) + + test("asks axios to return data as arraybuffer", async () => { + await axiosStrategy({ url: "test" }, store) + + expect(axios).toBeCalledWith( + expect.objectContaining({ + responseType: "arraybuffer", + }) + ) + }) + + test("resolves successful requests", async () => { + await expect(axiosStrategy({}, store)).resolves.toBeDefined() + }) + + test("rejects cancel errors with text 'cancellation'", async () => { + axios.isCancel.mockReturnValueOnce(true) + axios.mockRejectedValue("err") + + expect(axiosStrategy({}, store)).rejects.toBe("cancellation") + }) + + test("rejects non-cancellation errors as-is", async () => { + axios.isCancel.mockReturnValueOnce(false) + axios.mockRejectedValue("err") + + expect(axiosStrategy({}, store)).rejects.toBe("err") + }) + }) +}) diff --git a/helpers/strategies/__tests__/AxiosStrategy-Proxy.spec.js b/helpers/strategies/__tests__/AxiosStrategy-Proxy.spec.js new file mode 100644 index 000000000..b033c3cce --- /dev/null +++ b/helpers/strategies/__tests__/AxiosStrategy-Proxy.spec.js @@ -0,0 +1,184 @@ +import axios from "axios" +import axiosStrategy, { testables, cancelRunningAxiosRequest } from "../AxiosStrategy" + +jest.mock("../../utils/b64", () => { + return { + __esModule: true, + decodeB64StringToArrayBuffer: jest.fn((data) => data + "-converted"), + } +}) + +describe("cancelRunningAxiosRequest", () => { + test("cancels axios request and does that only 1 time", () => { + const cancelFunc = jest.spyOn(testables.cancelSource, "cancel") + + cancelRunningAxiosRequest() + expect(cancelFunc).toHaveBeenCalledTimes(1) + }) +}) + +describe("axiosStrategy", () => { + describe("Proxy Requests", () => { + const store = { + state: { + postwoman: { + settings: { + PROXY_ENABLED: true, + PROXY_URL: "test", + }, + }, + }, + } + + test("sends POST request to proxy if proxy is enabled", async () => { + let passedURL + + jest.spyOn(axios, "post").mockImplementation((url) => { + passedURL = url + return Promise.resolve({ data: { success: true, isBinary: false } }) + }) + + await axiosStrategy({}, store) + + expect(passedURL).toEqual("test") + }) + + test("passes request fields to axios properly", async () => { + const reqFields = { + testA: "testA", + testB: "testB", + testC: "testC", + } + + let passedFields + + jest.spyOn(axios, "post").mockImplementation((_url, req) => { + passedFields = req + return Promise.resolve({ data: { success: true, isBinary: false } }) + }) + + await axiosStrategy(reqFields, store) + + expect(passedFields).toMatchObject(reqFields) + }) + + test("passes wantsBinary field", async () => { + let passedFields + + jest.spyOn(axios, "post").mockImplementation((_url, req) => { + passedFields = req + return Promise.resolve({ data: { success: true, isBinary: false } }) + }) + + await axiosStrategy({}, store) + + expect(passedFields).toHaveProperty("wantsBinary") + }) + + test("checks for proxy response success field and throws error message for non-success", async () => { + jest.spyOn(axios, "post").mockResolvedValue({ + data: { + success: false, + data: { + message: "test message", + }, + }, + }) + + await expect(axiosStrategy({}, store)).rejects.toThrow("test message") + }) + + test("checks for proxy response success field and throws error 'Proxy Error' for non-success", async () => { + jest.spyOn(axios, "post").mockResolvedValue({ + data: { + success: false, + data: {}, + }, + }) + + await expect(axiosStrategy({}, store)).rejects.toThrow("Proxy Error") + }) + + test("checks for proxy response success and doesn't throw for success", async () => { + jest.spyOn(axios, "post").mockResolvedValue({ + data: { + success: true, + data: {}, + }, + }) + + await expect(axiosStrategy({}, store)).resolves.toBeDefined() + }) + + test("checks isBinary response field and resolve with the converted value if so", async () => { + jest.spyOn(axios, "post").mockResolvedValue({ + data: { + success: true, + isBinary: true, + data: "testdata", + }, + }) + + await expect(axiosStrategy({}, store)).resolves.toMatchObject({ + data: "testdata-converted", + }) + }) + + test("checks isBinary response field and resolve with the actual value if not so", async () => { + jest.spyOn(axios, "post").mockResolvedValue({ + data: { + success: true, + isBinary: false, + data: "testdata", + }, + }) + + await expect(axiosStrategy({}, store)).resolves.toMatchObject({ + data: "testdata", + }) + }) + + test("cancel errors are thrown with the string 'cancellation'", async () => { + jest.spyOn(axios, "post").mockRejectedValue("errr") + jest.spyOn(axios, "isCancel").mockReturnValueOnce(true) + + await expect(axiosStrategy({}, store)).rejects.toBe("cancellation") + }) + + test("non-cancellation errors are thrown", async () => { + jest.spyOn(axios, "post").mockRejectedValue("errr") + jest.spyOn(axios, "isCancel").mockReturnValueOnce(false) + + await expect(axiosStrategy({}, store)).rejects.toBe("errr") + }) + }) + + describe("No-Proxy Requests", () => { + const store = { + state: { + postwoman: { + settings: { + PROXY_ENABLED: false, + PROXY_URL: "test", + }, + }, + }, + } + + test("sends request to the actual sender if proxy disabled", async () => { + // jest.mock("axios") + // await axiosStrategy({ url: "test" }, store) + // expect(axiosFunc).toBeCalledWith(expect.objectContaining({ + // url: "test" + // })) + }) + + test("asks axios to return data as arraybuffer", () => {}) + + test("resolves successful requests", () => {}) + + test("rejects cancel errors with text 'cancellation'", () => {}) + + test("rejects non-cancellation errors as-is", () => {}) + }) +})