chore(util-buffer-from): remove usage of deprecated Buffer constructor (#1568)

Author: trivikr

packages/util-buffer-from/src/index.spec.ts

@@ -1,145 +1,71 @@
-jest.mock("buffer", () => {
-  const Buffer = jest.fn().mockReturnValue(new Uint8Array(0));
-  (Buffer as any).from = jest.fn().mockReturnValue(new Uint8Array(0));
-
-  return { Buffer };
-});
 import { Buffer } from "buffer";
 
 import { fromArrayBuffer, fromString } from "./";
 
-describe("fromArrayBuffer", () => {
-  it("should throw if provided an argument that is not an ArrayBuffer", () => {
-    expect(() => fromArrayBuffer(255 as any)).toThrow();
-  });
+jest.mock("buffer");
 
-  describe("Buffer.from", () => {
-    beforeEach(() => {
-      (Buffer.from as any).mockClear();
-    });
-
-    it("should use Buffer.from if available", () => {
-      const underlyingBuffer = new ArrayBuffer(0);
-      const offsetArg = 12;
-      const lengthArg = 13;
-      fromArrayBuffer(underlyingBuffer, offsetArg, lengthArg);
-
-      const { calls } = (Buffer.from as any).mock;
-      expect(calls.length).toBe(1);
-      expect(calls[0].length).toBe(3);
+afterEach(() => {
+  jest.clearAllMocks();
+});
 
-      const [buffer, offset, length] = calls[0];
-      expect(buffer).toBe(underlyingBuffer);
-      expect(offset).toBe(offsetArg);
-      expect(length).toBe(lengthArg);
-    });
+describe("fromArrayBuffer", () => {
+  it("throws if argument is not an ArrayBuffer", () => {
+    const input = 255;
+    // @ts-expect-error is not assignable to parameter of type 'ArrayBuffer'
+    expect(() => fromArrayBuffer(input)).toThrow(
+      new TypeError(`The "input" argument must be ArrayBuffer. Received type ${typeof input} (${input})`)
+    );
   });
 
-  describe("new Buffer", () => {
-    const bufferDotFrom = Buffer.from;
-
-    beforeEach(() => {
-      (Buffer as any).mockClear();
-      // @ts-ignore TODO: remove support as v3 is going to support Node.js v10+
-      delete Buffer.from;
-    });
-
-    afterAll(() => {
-      Buffer.from = bufferDotFrom;
-    });
-
-    it("should use the Buffer constructor if Buffer.from is not defined", () => {
-      const underlyingBuffer = new ArrayBuffer(0);
-      fromArrayBuffer(underlyingBuffer);
-
-      const { calls } = (Buffer as any).mock;
-      expect(calls.length).toBe(1);
-      expect(calls[0].length).toBe(1);
-      expect(calls[0][0]).toBe(underlyingBuffer);
-    });
-
-    it("should use the Buffer constructor if Buffer.from is inherited from Uint8Array", () => {
-      Buffer.from = Uint8Array.from as any;
-      const underlyingBuffer = new ArrayBuffer(0);
-      fromArrayBuffer(underlyingBuffer);
+  describe("returns if argument is an ArrayBuffer", () => {
+    const buffer = new ArrayBuffer(16);
 
-      const { calls } = (Buffer as any).mock;
-      expect(calls.length).toBe(1);
-      expect(calls[0].length).toBe(1);
-      expect(calls[0][0]).toBe(underlyingBuffer);
+    it("with one arg", () => {
+      fromArrayBuffer(buffer);
+      expect(Buffer.from).toHaveBeenCalledTimes(1);
+      expect(Buffer.from).toHaveBeenCalledWith(buffer, 0, buffer.byteLength);
     });
 
-    it("should throw if Buffer.from is undefined and a non-zero offset is provided", () => {
-      expect(() => fromArrayBuffer(new ArrayBuffer(0), 1)).toThrow();
+    it("with two args", () => {
+      const offset = 12;
+      fromArrayBuffer(buffer, offset);
+      expect(Buffer.from).toHaveBeenCalledTimes(1);
+      expect(Buffer.from).toHaveBeenCalledWith(buffer, offset, buffer.byteLength - offset);
     });
 
-    it("should not throw if Buffer.from is undefined and an offset of 0 is provided", () => {
-      expect(() => fromArrayBuffer(new ArrayBuffer(0), 0)).not.toThrow();
-    });
-
-    it("should throw if Buffer.from is undefined and a length other than the length of the underlying buffer is provided", () => {
-      expect(() => fromArrayBuffer(new ArrayBuffer(10), 0, 9)).toThrow();
-    });
-
-    it("should not throw if Buffer.from is undefined and a length of the length of the underlying buffer is provided", () => {
-      expect(() => fromArrayBuffer(new ArrayBuffer(10), 0, 10)).not.toThrow();
+    it("with three args", () => {
+      const offset = 12;
+      const length = 13;
+      fromArrayBuffer(buffer, offset, length);
+      expect(Buffer.from).toHaveBeenCalledTimes(1);
+      expect(Buffer.from).toHaveBeenCalledWith(buffer, offset, length);
     });
   });
 });
 
 describe("fromString", () => {
-  it("should throw if provided an argument that is not an ArrayBuffer", () => {
-    expect(() => fromString(255 as any)).toThrow();
+  it("throws if argument is not an ArrayBuffer", () => {
+    const input = 255;
+    // @ts-expect-error is not assignable to parameter of type 'ArrayBuffer'
+    expect(() => fromString(input)).toThrow(
+      new TypeError(`The "input" argument must be of type string. Received type ${typeof input} (${input})`)
+    );
   });
 
-  describe("Buffer.from", () => {
-    beforeEach(() => {
-      (Buffer.from as any).mockClear();
-    });
+  describe("returns if argument is an ArrayBuffer", () => {
+    const input = "a string";
 
-    it("should use Buffer.from if available", () => {
-      const inputArg = "a string";
-      const encodingArg = "utf16le";
-      fromString(inputArg, encodingArg);
-
-      const { calls } = (Buffer.from as any).mock;
-      expect(calls.length).toBe(1);
-      expect(calls[0].length).toBe(2);
-
-      const [input, encoding] = calls[0];
-      expect(input).toBe(inputArg);
-      expect(encoding).toBe(encodingArg);
+    it("without explicit encoding", () => {
+      fromString(input);
+      expect(Buffer.from).toHaveBeenCalledTimes(1);
+      expect(Buffer.from).toHaveBeenCalledWith(input);
     });
-  });
-
-  describe("new Buffer", () => {
-    const bufferDotFrom = Buffer.from;
-
-    beforeEach(() => {
-      (Buffer as any).mockClear();
-      // @ts-ignore TODO: remove support as v3 is going to support Node.js v10+
-      delete Buffer.from;
-    });
-
-    afterAll(() => {
-      Buffer.from = bufferDotFrom;
-    });
-
-    it("should use the Buffer constructor if Buffer.from is not defined", () => {
-      fromString("string", "hex");
-
-      const { calls } = (Buffer as any).mock;
-      expect(calls.length).toBe(1);
-      expect(calls[0]).toEqual(["string", "hex"]);
-    });
-
-    it("should use the Buffer constructor if Buffer.from is inherited from Uint8Array", () => {
-      Buffer.from = Uint8Array.from as any;
-      fromString("string", "utf8");
 
-      const { calls } = (Buffer as any).mock;
-      expect(calls.length).toBe(1);
-      expect(calls[0]).toEqual(["string", "utf8"]);
+    it("with encoding", () => {
+      const encoding = "utf16le";
+      fromString(input, encoding);
+      expect(Buffer.from).toHaveBeenCalledTimes(1);
+      expect(Buffer.from).toHaveBeenCalledWith(input, encoding);
     });
   });
 });

packages/util-buffer-from/src/index.ts

@@ -1,33 +1,20 @@
 import { isArrayBuffer } from "@aws-sdk/is-array-buffer";
 import { Buffer } from "buffer";
 
-export function fromArrayBuffer(input: ArrayBuffer, offset = 0, length: number = input.byteLength - offset): Buffer {
+export const fromArrayBuffer = (input: ArrayBuffer, offset = 0, length: number = input.byteLength - offset): Buffer => {
   if (!isArrayBuffer(input)) {
-    throw new Error("argument passed to fromArrayBuffer was not an ArrayBuffer");
+    throw new TypeError(`The "input" argument must be ArrayBuffer. Received type ${typeof input} (${input})`);
   }
 
-  if (typeof Buffer.from === "function" && Buffer.from !== Uint8Array.from) {
-    return Buffer.from(input, offset, length);
-  }
+  return Buffer.from(input, offset, length);
+};
 
-  // Any version of node that supports the optional offset and length
-  // parameters, which were added in Node 6.0.0, will support Buffer.from and
-  // have already returned. Throw if offset is not 0 or if length differs from
-  // the underlying buffer's length.
-  if (offset !== 0 || length !== input.byteLength) {
-    throw new Error(`Unable to convert TypedArray to Buffer in Node ${process.version}`);
-  }
-  return new Buffer(input);
-}
 export type StringEncoding = "ascii" | "utf8" | "utf16le" | "ucs2" | "base64" | "latin1" | "binary" | "hex";
-export function fromString(input: string, encoding?: StringEncoding): Buffer {
-  if (typeof input !== "string") {
-    throw new Error("argument passed to fromString was not a string");
-  }
 
-  if (typeof Buffer.from === "function" && Buffer.from !== Uint8Array.from) {
-    return Buffer.from(input, encoding as any);
+export const fromString = (input: string, encoding?: StringEncoding): Buffer => {
+  if (typeof input !== "string") {
+    throw new TypeError(`The "input" argument must be of type string. Received type ${typeof input} (${input})`);
   }
 
-  return new Buffer(input, encoding as any);
-}
+  return encoding ? Buffer.from(input, encoding) : Buffer.from(input);
+};