@compassdigital/sdk.typescript 3.0.0-beta.20 → 3.0.0-beta.3

package/test/client.test.ts

@@ -1,192 +0,0 @@
-
-import { ServiceClient, ResponseData, ServiceError, RequestData, InterceptFn } from "../src";
-import { Task } from "../src/interface/task";
-
-describe("ServiceClient", () => {
-
-  function response(status: number, body?: any, err?: any): ResponseData {
-    const res = { ok: status === 200, status: status, body: "", err: undefined };
-    if (body) {
-      res.body = JSON.stringify(body);
-    }
-    if (err) {
-      res.err = err;
-    }
-    return res;
-  }
-
-  function interceptor(status: number, body?: any, err?: any): InterceptFn {
-    return (req: RequestData) => Promise.resolve(response(status, body, err));
-  }
-
-  test("makes basic request", async () => {
-    const fake: Task = { id: "some_id" };
-    const intercept = jest.fn(interceptor(200, fake));
-    const api = new ServiceClient({ intercept });
-    const task = await api.get_task("some_id");
-    expect(task).toEqual(fake);
-    const req = intercept.mock.calls[0][0];
-    expect(req).toEqual({
-      name: "get_task",
-      service: "task",
-      url: "https://api.compassdigital.org/dev/task/some_id",
-      method: "get",
-      headers: {
-        "User-Agent": "CDL/ServiceClient",
-      },
-    })
-  });
-
-  test("token gets passed", async () => {
-    const token = "this is a token";
-    const intercept = jest.fn(interceptor(200));
-    const api = new ServiceClient({ intercept });
-    await api.get_task("", { token });
-    const req = intercept.mock.calls[0][0];
-    expect(req.headers).toHaveProperty("Authorization", `Bearer ${token}`);
-  });
-
-  test("headers get merged", async () => {
-    const intercept = jest.fn(interceptor(200));
-    const api = new ServiceClient({
-      intercept,
-      headers: {
-        "a": "a from constructor",
-        "b": "b from constructor",
-      },
-    });
-    await api.get_task("", {
-      headers: {
-        "b": "b from method",
-        "c": "c from method",
-      },
-    });
-    const req = intercept.mock.calls[0][0];
-    expect(req.headers).toEqual({
-      "User-Agent": "CDL/ServiceClient",
-      "a": "a from constructor",
-      "b": "b from method",
-      "c": "c from method",
-    });
-  });
-
-  test("client retries on bad status codes", async () => {
-    const intercept = jest.fn(async (req: RequestData) => {
-      if (intercept.mock.calls.length === 3) {
-        return response(200, "{}");
-      }
-      return response(500, "something went wrong");
-    });
-    const api = new ServiceClient({ intercept });
-    const task = await api.get_task("", { retry: 2 });
-    expect(intercept.mock.calls.length).toBe(3);
-  });
-
-  test("client retries on network error", async () => {
-    const intercept = jest.fn(async (req: RequestData) => {
-      if (intercept.mock.calls.length === 3) {
-        return response(200, "{}");
-      }
-      return response(0, "", new Error("network error"));
-    });
-    const api = new ServiceClient({ intercept });
-    const task = await api.get_task("", { retry: 2 });
-    expect(intercept.mock.calls.length).toBe(3);
-  });
-
-  test("client gives up after retry limit", async () => {
-    const intercept = jest.fn(interceptor(500));
-    const api = new ServiceClient({ intercept });
-    const promise = api.get_task("", { retry: 5 });
-    await expect(promise).rejects.toBeInstanceOf(ServiceError);
-    expect(intercept.mock.calls.length).toEqual(6);
-  });
-
-  describe("ServiceError", () => {
-
-    // see: https://github.com/microsoft/TypeScript/issues/13965
-    test("is instance of itself", async () => {
-      const err = new ServiceError(0, 0, "");
-      expect(err).toBeInstanceOf(ServiceError);
-    });
-
-    test("returns null for ignored http status", async () => {
-      const api = new ServiceClient({
-        intercept: interceptor(501),
-      });
-      const task = await api.get_task("").ignore(501);
-      expect(task).toBeNull();
-    });
-
-    test("returns null for ignored service error code", async () => {
-      const api = new ServiceClient({
-        intercept: interceptor(500, { code: 500.4, message: "uh oh" }),
-      });
-      const task = await api.get_task("").ignore(500.4);
-      expect(task).toBeNull();
-    });
-
-    test("throws ServiceError for non-ignored errors", async () => {
-      const api = new ServiceClient({
-        intercept: interceptor(500, { code: 500.4, message: "hello world"}),
-      });
-      try {
-        await api.get_task("");
-      } catch (err) {
-        expect(err).toBeInstanceOf(ServiceError);
-        expect(ServiceError.status(err)).toBe(500);
-        expect(ServiceError.code(err)).toBe(500.4);
-      }
-    });
-
-    test("throws ServiceError for network errors", async () => {
-      const api = new ServiceClient({
-        intercept: interceptor(0, null, new Error("Network Error")),
-      });
-      try {
-        await api.get_task("");
-      } catch (err) {
-        expect(err).toBeInstanceOf(ServiceError);
-        expect(ServiceError.status(err)).toBe(0);
-        expect(ServiceError.code(err)).toBe(0);
-      }
-    });
-
-    test("either should be true with 200 response", async () => {
-      const api = new ServiceClient({
-        intercept: interceptor(200, "{}"),
-      });
-      const res = await api.get_task("{}").combine();
-      expect(res.ok).toBe(true);
-      expect(res.data).toBeTruthy();
-      expect(res.err).toBeNull();
-    });
-
-    test("either should be false with non-200 response", async () => {
-      const api = new ServiceClient({
-        intercept: interceptor(400, "{}"),
-      });
-      const res = await api.get_task("{}").combine();
-      expect(res.ok).toBe(false);
-      expect(res.data).toBeNull();
-      expect(res.err).toBeInstanceOf(ServiceError);
-    });
-
-    test("either should be false with matching code", async () => {
-      const api = new ServiceClient({
-        intercept: interceptor(400, "{}"),
-      });
-      const res = await api.get_task("{}").combine(400);
-      expect(res.ok).toBe(false);
-      expect(res.err).toBeInstanceOf(ServiceError);
-    });
-
-    test("method should throw if code is not specified", async () => {
-      const api = new ServiceClient({
-        intercept: interceptor(400, "{}"),
-      });
-      const promise = api.get_task("").combine(500);
-      expect(promise).rejects.toThrow();
-    });
-  });
-});

package/test/gen.test.ts

@@ -1,22 +0,0 @@
-
-import { OperationObject, OperationParams, Schema } from "@icholy/openapi-ts";
-import { CodeGenerator } from "../gen";
-
-describe("CodeGenerator", () => {
-    describe("inferName", () => {
-        const gen = new CodeGenerator();
-        test("/order/location/brand/{id}", () => {
-            const op: OperationObject = {
-                operationId: "get_brand_orders",
-            }
-            const name = gen.inferName({
-                method: "get",
-                params: new OperationParams(op),
-                path: "/order/location/brand/{id}",
-                obj: op,
-            }, { name: "order", swagger: "" });
-            expect(name.pascal).toBe("GetOrderLocationBrand");
-            expect(name.snake).toBe("get_order_location_brand");
-        });
-    });
-});