tests/utils/download.test.ts

import { join } from "path";
import stream from "stream";
import { afterEach, describe, expect, it, vi } from "vitest";
import { downloadFile } from "../../src/utils/download";

const axiosMocks = vi.hoisted(() => {
    return {
        request: vi.fn(() => {
            return {
                status: 200,
                data: {
                    pipe: vi.fn()
                }
            };
        })
    };
});

vi.mock("fs", () => {
    return {
        createWriteStream: vi.fn(() => {
            return {
                write: vi.fn(),
                close: vi.fn(callback => callback(null)),
                closed: false
            };
        })
    };
});

vi.mock("stream", () => {
    return {
        default: {
            finished: vi.fn((stream, callback) => callback(null))
        }
    };
});

vi.mock("axios", () => {
    return {
        default: {
            request: axiosMocks.request
        }
    };
});

describe("downloadFile", () => {
    afterEach(() => {
        vi.resetAllMocks();
    });

    it("should download a file", async () => {
        const url = "https://example.com/file.txt";
        const destinationDirectory = "path/to/dir";
        const name = "file.txt";
        const axiosOptions = { headers: { Authorization: "Bearer token" } };

        const result = await downloadFile({ url, path: destinationDirectory, name, axiosOptions });

        expect(result).toEqual({
            filePath: join(destinationDirectory, name),
            storagePath: destinationDirectory
        });

        expect(stream.finished).toHaveBeenCalledTimes(1);
    });

    it("should throw an error if the request fails", async () => {
        const url = "https://example.com/file.txt";
        const destinationDirectory = "path/to/dir";
        const name = "file.txt";
        const axiosOptions = { headers: { Authorization: "Bearer token" } };

        axiosMocks.request.mockReturnValue({
            status: 500,
            data: {
                pipe: vi.fn()
            }
        });

        expect(
            downloadFile({ url, path: destinationDirectory, name, axiosOptions })
        ).rejects.toThrow("HTTP error: Non 2xx response received: code 500");
        expect(stream.finished).toHaveBeenCalledTimes(0);
    });
});
1	rakinar2	577	import { join } from "path";
2			import stream from "stream";
3			import { afterEach, describe, expect, it, vi } from "vitest";
4			import { downloadFile } from "../../src/utils/download";
5
6			const axiosMocks = vi.hoisted(() => {
7			return {
8			request: vi.fn(() => {
9			return {
10			status: 200,
11			data: {
12			pipe: vi.fn()
13			}
14			};
15			})
16			};
17			});
18
19			vi.mock("fs", () => {
20			return {
21			createWriteStream: vi.fn(() => {
22			return {
23			write: vi.fn(),
24			close: vi.fn(callback => callback(null)),
25			closed: false
26			};
27			})
28			};
29			});
30
31			vi.mock("stream", () => {
32			return {
33			default: {
34			finished: vi.fn((stream, callback) => callback(null))
35			}
36			};
37			});
38
39			vi.mock("axios", () => {
40			return {
41			default: {
42			request: axiosMocks.request
43			}
44			};
45			});
46
47			describe("downloadFile", () => {
48			afterEach(() => {
49			vi.resetAllMocks();
50			});
51
52			it("should download a file", async () => {
53			const url = "https://example.com/file.txt";
54			const destinationDirectory = "path/to/dir";
55			const name = "file.txt";
56			const axiosOptions = { headers: { Authorization: "Bearer token" } };
57
58			const result = await downloadFile({ url, path: destinationDirectory, name, axiosOptions });
59
60			expect(result).toEqual({
61			filePath: join(destinationDirectory, name),
62			storagePath: destinationDirectory
63			});
64
65			expect(stream.finished).toHaveBeenCalledTimes(1);
66			});
67
68			it("should throw an error if the request fails", async () => {
69			const url = "https://example.com/file.txt";
70			const destinationDirectory = "path/to/dir";
71			const name = "file.txt";
72			const axiosOptions = { headers: { Authorization: "Bearer token" } };
73
74			axiosMocks.request.mockReturnValue({
75			status: 500,
76			data: {
77			pipe: vi.fn()
78			}
79			});
80
81			expect(
82			downloadFile({ url, path: destinationDirectory, name, axiosOptions })
83			).rejects.toThrow("HTTP error: Non 2xx response received: code 500");
84			expect(stream.finished).toHaveBeenCalledTimes(0);
85			});
86			});