fix: add error message

Author: kuhe

lib/lib-storage/src/byteLength.spec.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { BYTE_LENGTH_SOURCE, byteLengthSource } from "./byteLengthSource";
+import { runtimeConfig } from "./runtimeConfig";
+
+vi.mock("./runtimeConfig", () => ({
+  runtimeConfig: {
+    lstatSync: vi.fn(),
+  },
+}));
+
+describe("byteLengthSource", () => {
+  it("should return CONTENT_LENGTH when override is provided", () => {
+    expect(byteLengthSource({}, 100)).toBe(BYTE_LENGTH_SOURCE.CONTENT_LENGTH);
+  });
+
+  it("should return EMPTY_INPUT for null input", () => {
+    expect(byteLengthSource(null)).toBe(BYTE_LENGTH_SOURCE.EMPTY_INPUT);
+  });
+
+  it("should return EMPTY_INPUT for undefined input", () => {
+    expect(byteLengthSource(undefined)).toBe(BYTE_LENGTH_SOURCE.EMPTY_INPUT);
+  });
+
+  it("should return STRING_LENGTH for string input", () => {
+    expect(byteLengthSource("test")).toBe(BYTE_LENGTH_SOURCE.STRING_LENGTH);
+  });
+
+  it("should return TYPED_ARRAY for input with byteLength", () => {
+    const input = new Uint8Array(10);
+    expect(byteLengthSource(input)).toBe(BYTE_LENGTH_SOURCE.TYPED_ARRAY);
+  });
+
+  it("should return LENGTH for input with length property", () => {
+    const input = { length: 10 };
+    expect(byteLengthSource(input)).toBe(BYTE_LENGTH_SOURCE.LENGTH);
+  });
+
+  it("should return SIZE for input with size property", () => {
+    const input = { size: 10 };
+    expect(byteLengthSource(input)).toBe(BYTE_LENGTH_SOURCE.SIZE);
+  });
+
+  it("should return START_END_DIFF for input with start and end properties", () => {
+    const input = { start: 0, end: 10 };
+    expect(byteLengthSource(input)).toBe(BYTE_LENGTH_SOURCE.START_END_DIFF);
+  });
+
+  it("should return LSTAT for input with path that exists", () => {
+    const input = { path: "/test/path" };
+    vi.mocked(runtimeConfig.lstatSync).mockReturnValue({ size: 100 } as any);
+
+    expect(byteLengthSource(input)).toBe(BYTE_LENGTH_SOURCE.LSTAT);
+    expect(runtimeConfig.lstatSync).toHaveBeenCalledWith("/test/path");
+  });
+
+  it("should return undefined for input with path that throws error", () => {
+    const input = { path: "/test/path" };
+    vi.mocked(runtimeConfig.lstatSync).mockImplementation(() => {
+      throw new Error("File not found");
+    });
+
+    expect(byteLengthSource(input)).toBeUndefined();
+  });
+
+  it("should return undefined for input with no matching properties", () => {
+    const input = { foo: "bar" };
+    expect(byteLengthSource(input)).toBeUndefined();
+  });
+});

lib/lib-storage/src/chunks/getChunkUint8Array.spec.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test as it } from "vitest";
 
-import { byteLength } from "../bytelength";
+import { byteLength } from "../byteLength";
+import { BYTE_LENGTH_SOURCE, byteLengthSource } from "../byteLengthSource";
 import { RawDataPart } from "../Upload";
 import { getChunkUint8Array } from "./getChunkUint8Array";
 
@@ -21,6 +22,7 @@ describe(getChunkUint8Array.name, () => {
         for await (const chunk of chunker) {
           chunkNum += 1;
           expect(byteLength(chunk.data)).toEqual(chunklength);
+          expect(byteLengthSource(chunk.data)).toEqual(BYTE_LENGTH_SOURCE.TYPED_ARRAY);
           expect(chunk.partNumber).toEqual(chunkNum);
           if (chunkNum < expectedNumberOfChunks) {
             expect(chunk.lastPart).toBe(undefined);
@@ -45,10 +47,13 @@ describe(getChunkUint8Array.name, () => {
 
         expect(chunks.length).toEqual(3);
         expect(byteLength(chunks[0].data)).toBe(chunklength);
+        expect(byteLengthSource(chunks[0].data)).toEqual(BYTE_LENGTH_SOURCE.TYPED_ARRAY);
         expect(chunks[0].lastPart).toBe(undefined);
         expect(byteLength(chunks[1].data)).toBe(chunklength);
+        expect(byteLengthSource(chunks[1].data)).toEqual(BYTE_LENGTH_SOURCE.TYPED_ARRAY);
         expect(chunks[1].lastPart).toBe(undefined);
         expect(byteLength(chunks[2].data)).toBe(totalLength % chunklength);
+        expect(byteLengthSource(chunks[2].data)).toEqual(BYTE_LENGTH_SOURCE.TYPED_ARRAY);
         expect(chunks[2].lastPart).toBe(true);
       });
 
@@ -65,6 +70,7 @@ describe(getChunkUint8Array.name, () => {
 
         expect(chunks.length).toEqual(1);
         expect(byteLength(chunks[0].data)).toBe(totalLength % chunklength);
+        expect(byteLengthSource(chunks[0].data)).toEqual(BYTE_LENGTH_SOURCE.TYPED_ARRAY);
         expect(chunks[0].lastPart).toBe(true);
       });
     });

lib/lib-storage/src/chunks/getDataReadable.spec.ts

@@ -1,7 +1,7 @@
 import { Readable } from "stream";
 import { describe, expect, test as it } from "vitest";
 
-import { byteLength } from "../bytelength";
+import { byteLength } from "../byteLength";
 import { RawDataPart as DataPart } from "../Upload";
 import { getChunkStream as chunkFromReadable } from "./getChunkStream";
 import { getDataReadable } from "./getDataReadable";

lib/lib-storage/src/chunks/getDataReadableStream.spec.ts

@@ -2,7 +2,7 @@ import { describe, expect, test as it } from "vitest";
 // polyfill exposes the same ReadableStream API as web, allowing easy testing
 import { ReadableStream } from "web-streams-polyfill";
 
-import { byteLength } from "../bytelength";
+import { byteLength } from "../byteLength";
 import { RawDataPart as DataPart } from "../Upload";
 import { getChunkStream as chunkFromReadable } from "./getChunkStream";
 import { getDataReadableStream } from "./getDataReadableStream";