refactor

tests/http.test.ts

@@ -1,4 +1,4 @@
-import { http, } from "../src/http";
+import { http, http2From, } from "../src/http";
 
 describe("http", () => {
   const mockAxios = jest.fn();
@@ -11,6 +11,7 @@ describe("http", () => {
   describe.each([
     ["baseURL"],
     ["url"],
+    ["method"],
   ])('%s', (field) => {
     const getValue = (value: string) => {
       const thing = {} as any;
@@ -136,3 +137,141 @@ describe("http", () => {
     });
   })
 });
+
+describe("http2", () => {
+  const mockAxios = jest.fn();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.resetAllMocks();
+  });
+
+  describe.each([
+    ["baseURL"],
+    ["url"],
+    ["method"],
+  ])('%s', (field) => {
+    const fieldWithValue = (value: string) => {
+      const thing = {} as any;
+      thing[field] = value;
+      return thing;
+    };
+
+    const base = http2From(mockAxios).with(fieldWithValue('default'));
+
+    describe("using default", () => {
+      it("should use the default", () => {
+        base({})
+        expect(mockAxios).toHaveBeenCalledWith(fieldWithValue('default'));
+      });
+    });
+
+    describe("overriding", () => {
+      it("should use the override", () => {
+        base(fieldWithValue('override'))
+        expect(mockAxios).toHaveBeenCalledWith(fieldWithValue('override'));
+      });
+    });
+
+    describe("wrapping", () => {
+      const firstLayer = http2From(base).with(fieldWithValue('level1'));
+      const secondLayer = firstLayer.with(fieldWithValue('level2'));
+
+      describe("when the outter call provides a value", () => {
+        it("should apply it", () => {
+          secondLayer(fieldWithValue('outter'))
+          expect(mockAxios).toHaveBeenCalledWith(fieldWithValue('outter'));
+        });
+      });
+
+      describe("when the outter call does not provide a value", () => {
+        it("should use the second layer", () => {
+          secondLayer({ })
+          expect(mockAxios).toHaveBeenCalledWith(fieldWithValue('level2'));
+        });
+      });
+    });
+  });
+
+  describe("requestType", () => {
+    const base = http2From(mockAxios).with({ responseType: 'stream' });
+
+    describe("using default", () => {
+      it("should use the default", () => {
+        base({})
+        expect(mockAxios).toHaveBeenCalledWith({ responseType: 'stream' });
+      });
+    });
+
+    describe("overriding", () => {
+      it("should use the override", () => {
+        base({ responseType: 'arraybuffer' })
+        expect(mockAxios).toHaveBeenCalledWith({ responseType: 'arraybuffer' });
+      });
+    });
+
+    describe("wrapping", () => {
+      const firstLayer = base.with({ responseType: 'arraybuffer' });
+      const secondLayer = firstLayer.with({ responseType: 'blob' });
+
+      describe("when the outter call provides a value", () => {
+        it("should apply it", () => {
+          secondLayer({ responseType: 'text' })
+          expect(mockAxios).toHaveBeenCalledWith({ responseType: 'text' });
+        });
+      });
+
+      describe("when the outter call does not provide a value", () => {
+        it("should use the second layer", () => {
+          secondLayer({ })
+          expect(mockAxios).toHaveBeenCalledWith({ responseType: 'blob' });
+        });
+      });
+    });
+  });  
+
+  describe.each([
+    ["params"],
+    ["headers"],
+  ])('%s', (field) => {
+    const fieldWithValues = (values: any) => {
+      const thing = {} as any;
+      thing[field] = values;
+      return thing;
+    }
+    const base = http2From(mockAxios).with(fieldWithValues({ a: 1, b: 2, c: 3, d: 4 }));
+
+    describe("using default", () => {
+      it("should use the default", () => {
+        base({});
+        expect(mockAxios).toHaveBeenCalledWith(fieldWithValues({ a: 1, b: 2, c: 3, d: 4 }));
+      });
+    });
+
+    describe("overriding", () => {
+      it("should use the override", () => {
+        base(fieldWithValues({ b: 22, e: 5 }));
+        expect(mockAxios).toHaveBeenCalledWith(fieldWithValues({ a: 1, b: 22, c: 3, d: 4, e: 5 }));
+      });
+    });
+
+    describe("wrapping", () => {
+      const firstLayer = base.with(fieldWithValues({ b: 22 }));
+      const secondLayer = firstLayer.with(fieldWithValues({ c: 33 }));
+
+      describe("when the outter call provides a value", () => {
+        it("should apply it", () => {
+          secondLayer(fieldWithValues({ a: 11, e: 5 }));
+          expect(mockAxios).toHaveBeenCalledWith(fieldWithValues({ a: 11, b: 22, c: 33, d: 4, e: 5 }));
+        });
+      });
+
+      describe("when the outter call does not provide a value", () => {
+        it("should use the second layer", () => {
+          secondLayer({ });
+          expect(mockAxios).toHaveBeenCalledWith(fieldWithValues({ a: 1, b: 22, c: 33, d: 4 }));
+        });
+      });
+    });
+  })
+});

tests/subsonic/generic.test.ts

@@ -46,7 +46,7 @@ import {
 import { EMPTY, error, FAILURE, subsonicOK, ok } from "../subsonic.test";
 import { DODGY_IMAGE_NAME, t } from "../../src/subsonic";
 import { b64Encode } from "../../src/b64";
-import { http as http2 } from "../../src/http";
+import { http2From } from "../../src/http";
 
 const maybeIdFromCoverArtUrn = (coverArt: BUrn | undefined) =>
   pipe(
@@ -511,7 +511,7 @@ describe("SubsonicGenericMusicLibrary", () => {
   const generic = new SubsonicGenericMusicLibrary(
     streamClientApplication,
     // todo: all this stuff doesnt need to be defaulted in here.
-    http2(mockAxios, {
+    http2From(mockAxios).with({
       baseURL,
       params: authParams,
       headers

tests/utils.test.ts

@@ -1,4 +1,4 @@
-import { asURLSearchParams, takeWithRepeats } from "../src/utils";
+import { asURLSearchParams, mask, takeWithRepeats } from "../src/utils";
 
 describe("asURLSearchParams", () => {
   describe("empty q", () => {
@@ -46,8 +46,6 @@ describe("asURLSearchParams", () => {
   });
 });
 
-
-
 describe("takeWithRepeat", () => {
   describe("when there is nothing in the input", () => {
     it("should return an array of undefineds", () => {
@@ -77,7 +75,32 @@ describe("takeWithRepeat", () => {
   describe("when there more than the amount required", () => {
     it("should return the first n items", () => {
       expect(takeWithRepeats(["a", "b", "c"], 2)).toEqual(["a", "b"]);
-      expect(takeWithRepeats(["a", undefined, "c"], 2)).toEqual(["a", undefined]);
+      expect(takeWithRepeats(["a", undefined, "c"], 2)).toEqual([
+        "a",
+        undefined,
+      ]);
     });
   });
 });
+
+describe("mask", () => {
+  it.each([
+    [{}, ["a", "b"], {}],
+    [{ foo: "bar" }, ["a", "b"], { foo: "bar" }],
+    [{ a: 1 }, ["a", "b"], { a: "****" }],
+    [{ a: 1, b: "dog" }, ["a", "b"], { a: "****", b: "****" }],
+    [
+      { a: 1, b: "dog", foo: "bar" },
+      ["a", "b"],
+      { a: "****", b: "****", foo: "bar" },
+    ],
+  ])(
+    "masking of %s, keys = %s, should result in %s",
+    (original: any, keys: string[], expected: any) => {
+      const copyOfOrig = JSON.parse(JSON.stringify(original));
+      const masked = mask(original, keys);
+      expect(masked).toEqual(expected);
+      expect(original).toEqual(copyOfOrig);
+    }
+  );
+});