yt-grabber 1.8.7 → 1.8.9

package/.eslintrc.json

@@ -1,29 +1,29 @@
-{
-  "env": {
-    "browser": true,
-    "es2021": true
-  },
-  "extends": ["eslint:recommended", "plugin:react/recommended", "plugin:@typescript-eslint/recommended", "prettier"],
-  "parser": "@typescript-eslint/parser",
-  "parserOptions": {
-    "ecmaVersion": "latest",
-    "sourceType": "module"
-  },
-  "settings": {
-    "react": {
-        "version": "detect"
-    }
-  },
-  "plugins": ["react", "@typescript-eslint"],
-  "rules": {
-    "indent": ["error", 4],
-    "linebreak-style": ["error", "windows"],
-    "quotes": ["error", "double"],
-    "semi": ["error", "always"],
-    "@typescript-eslint/no-var-requires": 0,
-    "@typescript-eslint/no-explicit-any": 0,
-    "@typescript-eslint/no-empty-interface": 0,
-    "react/prop-types": 0,
-    "react/display-name": 0
-  }
-}
+// {
+//   "env": {
+//     "browser": true,
+//     "es2021": true
+//   },
+//   "extends": ["eslint:recommended", "plugin:react/recommended", "plugin:@typescript-eslint/recommended", "prettier"],
+//   "parser": "@typescript-eslint/parser",
+//   "parserOptions": {
+//     "ecmaVersion": "latest",
+//     "sourceType": "module"
+//   },
+//   "settings": {
+//     "react": {
+//         "version": "detect"
+//     }
+//   },
+//   "plugins": ["react", "@typescript-eslint"],
+//   "rules": {
+//     "indent": ["error", 4],
+//     "linebreak-style": ["error", "windows"],
+//     "quotes": ["error", "double"],
+//     "semi": ["error", "always"],
+//     "@typescript-eslint/no-var-requires": 0,
+//     "@typescript-eslint/no-explicit-any": 0,
+//     "@typescript-eslint/no-empty-interface": 0,
+//     "react/prop-types": 0,
+//     "react/display-name": 0
+//   }
+// }

package/.github/workflows/tests.yml

@@ -0,0 +1,50 @@
+name: Run Unit Tests
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Enable Corepack (Yarn 4.x support)
+        run: corepack enable
+
+      - name: Prepare Yarn version
+        run: corepack prepare yarn@4.4.1 --activate
+
+      - name: Cache Yarn PnP
+        uses: actions/cache@v4
+        with:
+          path: .yarn/cache
+          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-yarn-
+
+      - name: Install dependencies (Yarn PnP)
+        run: yarn install --immutable
+
+      - name: Run unit tests
+        run: yarn test --ci --coverage
+
+      - name: Upload coverage artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage
+          path: coverage
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          token: 6353cc14-1536-4b0c-bf9c-a0aad51ceff5
+          files: ./coverage/lcov.info

package/.vscode/tasks.json

@@ -0,0 +1,13 @@
+{
+	"version": "2.0.0",
+	"tasks": [
+        {
+            "type": "npm",
+            "script": "build",
+            "group": "build",
+            "problemMatcher": [],
+            "label": "npm: build",
+            "detail": "yarn clean && \"cross-env NODE_ENV=development yarn webpack-tsx\""
+        }
+    ]
+}

package/README.md

@@ -2,6 +2,9 @@
 
 ---
 
+![Tests](https://github.com/karenpommeroy/yt-grabber/actions/workflows/tests.yml/badge.svg)
+[![Coverage](https://codecov.io/gh/karenpommeroy/yt-grabber/branch/main/graph/badge.svg)](https://codecov.io/gh/karenpommeroy/yt-grabber)
+
 **YT Grabber** is a robust desktop application designed to retrieve multimedia from YouTube and YouTube Music services.
 
 It provides responsive UI to manage your downloads and automation features improve and accelerate download process.

package/eslint.config.ts

@@ -1,5 +1,5 @@
 import react from "eslint-plugin-react";
-import {defineConfig} from "eslint/config";
+import {Config, defineConfig} from "eslint/config";
 import globals from "globals";
 import path from "node:path";
 import {fileURLToPath} from "node:url";
@@ -9,6 +9,10 @@ import js from "@eslint/js";
 import typescriptEslint from "@typescript-eslint/eslint-plugin";
 import tsParser from "@typescript-eslint/parser";
 
+type EslintConfig = Config & {
+    extends?: any[];
+};
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const compat = new FlatCompat({
@@ -17,7 +21,49 @@ const compat = new FlatCompat({
     allConfig: js.configs.all
 });
 
-export default defineConfig([{
+const TestConfig: EslintConfig  = {
+    extends: compat.extends(
+        // "eslint:recommended",
+        "plugin:react/recommended",
+        // "plugin:@typescript-eslint/recommended",
+        "prettier",
+    ),
+    plugins: {
+        react,
+        "@typescript-eslint": typescriptEslint as any,
+    },
+    languageOptions: {
+        globals: {
+            ...globals.browser,
+        },
+
+        parser: tsParser,
+        ecmaVersion: "latest",
+        sourceType: "module",
+    },
+    settings: {
+        react: {
+            version: "detect",
+        },
+    },
+    files: ["**/*.test.{ts,tsx,js,jsx}"],
+    rules: {
+        indent: ["warn", 4],
+        "linebreak-style": ["warn", "windows"],
+        quotes: ["warn", "double"],
+        semi: ["warn", "always"],
+        "@typescript-eslint/no-unused-vars": ["warn"],
+        "@typescript-eslint/no-var-requires": 0,
+        "@typescript-eslint/no-explicit-any": 0,
+        "@typescript-eslint/no-empty-interface": 0,
+        "react/prop-types": 0,
+        "react/display-name": 0,
+        "react/react-in-jsx-scope": 0,
+        "import/no-commonjs": "off",
+    },
+};
+
+const BaseConfig: EslintConfig = {
     extends: compat.extends(
         "eslint:recommended",
         "plugin:react/recommended",
@@ -46,6 +92,10 @@ export default defineConfig([{
         },
     },
 
+    files: [
+        "**/!(*.test).{ts,tsx,js,jsx}",
+    ],
+
     rules: {
         indent: ["warn", 4],
         "linebreak-style": ["warn", "windows"],
@@ -59,4 +109,9 @@ export default defineConfig([{
         "react/display-name": 0,
         "react/react-in-jsx-scope": 0,
     },
-}]);
+};
+
+export default defineConfig([
+    BaseConfig,
+    TestConfig
+]);

package/jest.config.ts

@@ -11,14 +11,30 @@ const config: Config = {
     ],
     moduleNameMapper: {
         "\\.(css|less|scss|sass|styl)$": "identity-obj-proxy",
-        "\\.(jpg|jpeg|png|gif|svg)$": "<rootDir>/tests/FileMock.ts",
-        "^@tests/(.*)$": "<rootDir>/tests/$1"
+        "\\.(jpg|jpeg|png|gif|svg)$": "<rootDir>/tests/mocks/FileMock.ts",
+        "^@tests/(.*)$": "<rootDir>/tests/$1",
+        "^@app/(.*)$": "<rootDir>/src/$1",
     },
     setupFilesAfterEnv: [
         "@testing-library/jest-dom",
         "<rootDir>/jest.setup.ts",
     ],
     testPathIgnorePatterns: ["/node_modules/", "/dist/", "/out/", "/e2e/"],
+    reporters: [
+        "default",
+    ],
+    collectCoverage: true,
+    collectCoverageFrom: [
+        "src/**/*.{ts,tsx}",
+        "!src/**/*.d.ts",
+        "!src/**/index.ts",
+    ],
+    coverageDirectory: "<rootDir>/coverage",
+    coverageProvider: "v8",
+    coverageReporters: [
+        "json",
+        "lcov",
+    ],
 };
 
 export default config;

package/jest.setup.ts

@@ -1,33 +1,19 @@
 import {TextDecoder, TextEncoder} from "util";
 
-global.TextEncoder = TextEncoder;
-global.TextDecoder = TextDecoder as typeof global.TextDecoder;
+import electronMock from "@tests/mocks/electron";
+import storeMock from "@tests/mocks/electron-store";
+import reactI18nMock from "@tests/mocks/react-i18next";
 
-const mockStore = {
-    get: jest.fn().mockReturnValue({language: "en"}),
-    set: jest.fn(),
-    delete: jest.fn(),
-    clear: jest.fn(),
-    has: jest.fn().mockReturnValue(true),
-    onDidAnyChange: jest.fn().mockReturnValue(jest.fn()),
-    onDidChange: jest.fn().mockReturnValue(jest.fn())
-};
+global.TextEncoder = TextEncoder as typeof global.TextEncoder;
+global.TextDecoder = TextDecoder as typeof global.TextDecoder;
 
 Object.defineProperty(process, "resourcesPath", {
-    value: "/mocked/resources/path",
+    value: "./src/resources",
     writable: false,
 });
 
-jest.mock("electron", () => ({
-    ipcRenderer: {
-        send: jest.fn(),
-        on: jest.fn(),
-        off: jest.fn(),
-    },
-}));
-
-jest.mock("electron-store", () => {
-    return jest.fn(() => mockStore);
-});
+jest.mock("react-i18next", () => reactI18nMock);
+jest.mock("electron", () => electronMock);
+jest.mock("electron-store", () => storeMock);
 
-(global as any).store = mockStore;
+(global as any).store = storeMock();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yt-grabber",
-  "version": "1.8.7",
+  "version": "1.8.9",
   "description": "Youtube Grabber - robust desktop application designed to retrieve multimedia from YouTube and YouTube Music services",
   "keywords": [
     "youtube",
@@ -171,6 +171,7 @@
     "identity-obj-proxy": "^3.0.0",
     "jest": "^30.2.0",
     "jest-environment-jsdom": "^30.2.0",
+    "jest-html-reporter": "^4.3.0",
     "jiti": "^2.6.1",
     "mini-css-extract-plugin": "^2.9.4",
     "prettier": "^3.6.2",

package/src/automations/Helpers.test.ts

@@ -0,0 +1,65 @@
+import fs from "fs-extra";
+
+import {getProfilePath} from "../common/FileSystem";
+import {waitFor} from "../common/Helpers";
+import {createInput, createPage} from "../common/TestHelpers";
+import {clearInput, navigateToPage, setCookies} from "./Helpers";
+
+jest.mock("fs-extra", () => require("@tests/mocks/fs-extra"));
+jest.mock("../common/FileSystem", () => require("@tests/mocks/common/FileSystem"));
+jest.mock("../common/Helpers", () => require("@tests/mocks/common/Helpers"));
+
+describe("automation helpers", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        (getProfilePath as jest.Mock).mockReturnValue("/profile");
+    });
+
+    test("navigateToPage forwards url and timeout options", async () => {
+        const page = createPage();
+
+        await navigateToPage("https://example.com", page);
+
+        expect(page.goto).toHaveBeenCalledWith("https://example.com", {
+            waitUntil: ["networkidle0", "domcontentloaded", "load"],
+            timeout: 15000,
+        });
+    });
+
+    test("clearInput selects content and presses backspace", async () => {
+        const page = createPage();
+        const input = createInput();
+
+        await clearInput(input, page);
+
+        expect((input as any).click).toHaveBeenCalledWith({clickCount: 3});
+        expect(page.keyboard.press).toHaveBeenCalledWith("Backspace");
+    });
+
+    test("setCookies caches fresh cookies when cache empty", async () => {
+        (fs.readJSONSync as jest.Mock).mockReturnValue(undefined);
+        const pageCookies = [{name: "session", value: "abc"}];
+        const page = createPage();
+        page.cookies.mockResolvedValue(pageCookies);
+
+        await setCookies(page);
+
+        expect(waitFor).toHaveBeenCalledWith(3000);
+        expect(page.cookies).toHaveBeenCalled();
+        expect(fs.writeJSONSync).toHaveBeenCalledWith("/profile/cookies.json", pageCookies, {spaces: 2});
+        expect(page.setCookie).toHaveBeenCalledWith(...pageCookies);
+    });
+
+    test("setCookies reuses cached cookies when available", async () => {
+        const cachedCookies = [{name: "session", value: "cached"}];
+        (fs.readJSONSync as jest.Mock).mockReturnValue(cachedCookies);
+        const page = createPage();
+
+        await setCookies(page);
+
+        expect(waitFor).not.toHaveBeenCalled();
+        expect(page.cookies).not.toHaveBeenCalled();
+        expect(page.setCookie).toHaveBeenCalledWith(...cachedCookies);
+        expect(fs.writeJSONSync).not.toHaveBeenCalled();
+    });
+});

package/src/automations/Youtube.test.ts

@@ -0,0 +1,232 @@
+import {TimeoutError} from "puppeteer-core";
+import puppeteer from "puppeteer-extra";
+
+import {UserAgent} from "../common/PuppeteerOptions";
+import {Reporter} from "../common/Reporter";
+import {
+    createBrowserMock, createElements, createI18n, createPageMock, createYoutubeParams
+} from "../common/TestHelpers";
+import {navigateToPage, setCookies} from "./Helpers";
+import {
+    AlbumFilterSelector, AlbumLinkSelector, AlbumsDirectLinkSelector, AlbumsHrefSelector
+} from "./Selectors";
+import execute from "./Youtube";
+
+jest.mock("./Helpers", () => require("@tests/mocks/automations/Helpers"));
+jest.mock("puppeteer-core", () => require("@tests/mocks/puppeteer-core"));
+jest.mock("puppeteer-extra", () => require("@tests/mocks/puppeteer-extra"));
+jest.mock("puppeteer-extra-plugin-stealth", () => require("@tests/mocks/puppeteer-extra-plugin-stealth"));
+jest.mock("../common/Reporter", () => require("@tests/mocks/common/Reporter"));
+
+const navigateToPageMock = navigateToPage as jest.Mock;
+const setCookiesMock = setCookies as jest.Mock;
+const launchMock = puppeteer.launch as jest.Mock;
+const ReporterMock = new Reporter(() => {});
+const reporterFinishMock = ReporterMock.finish as jest.Mock;
+
+describe("Youtube automation", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    test("collects album links via filtered listing", async () => {
+        const page = createPageMock();
+        page.waitForSelector.mockImplementation((selector: string) => {
+            if (selector.includes(AlbumsHrefSelector)) {
+                return Promise.resolve({evaluate: jest.fn().mockResolvedValue("channel/albums")});
+            }
+
+            if (selector.includes(AlbumFilterSelector)) {
+                return Promise.resolve({click: jest.fn()});
+            }
+
+            return Promise.reject(new Error(`Unexpected selector: ${selector}`));
+        });
+
+        page.$$eval.mockImplementation((selector: string, callback: (elements: Array<{getAttribute: () => string;}>) => string[]) => {
+            if (selector === "xpath/" + AlbumLinkSelector) {
+                return Promise.resolve(callback(createElements(["album/one", "album/two"])));
+            }
+
+            if (selector === "xpath/" + AlbumsDirectLinkSelector) {
+                return Promise.resolve(callback(createElements([])));
+            }
+            return Promise.reject(new Error(`Unexpected selector: ${selector}`));
+        });
+
+        const browser = createBrowserMock(page);
+        launchMock.mockResolvedValue(browser);
+        navigateToPageMock.mockResolvedValue(undefined);
+        setCookiesMock.mockResolvedValue(undefined);
+
+        await execute({
+            params: createYoutubeParams(),
+            options: {},
+            i18n: createI18n(),
+            onUpdate: jest.fn(),
+            signal: new AbortController().signal
+        });
+
+        expect(page.setUserAgent).toHaveBeenCalledWith(UserAgent);
+        expect(navigateToPageMock).toHaveBeenCalledWith("https://music.youtube.com", page);
+        expect(reporterFinishMock).toHaveBeenCalledWith("done", expect.objectContaining({
+            errors: [],
+            warnings: [],
+            values: [
+                "https://music.youtube.com/album/one",
+                "https://music.youtube.com/album/two",
+            ],
+            sources: ["https://music.youtube.com/channel/UC123"],
+        }));
+        expect(page.close).toHaveBeenCalledTimes(1);
+        expect(browser.close).toHaveBeenCalledTimes(1);
+    });
+
+    test("falls back to direct album links when filters fail", async () => {
+        const page = createPageMock();
+        page.waitForSelector.mockRejectedValue(new Error("Not available"));
+        page.$$eval.mockImplementation((selector: string, callback: (elements: Array<{getAttribute: () => string;}>) => string[]) => {
+            if (selector === "xpath/" + AlbumsDirectLinkSelector) {
+                return Promise.resolve(callback(createElements(["direct/one"])));
+            }
+
+            return Promise.reject(new Error(`Unexpected selector ${selector}`));
+        });
+
+        const browser = createBrowserMock(page);
+        launchMock.mockResolvedValue(browser);
+        navigateToPageMock.mockResolvedValue(undefined);
+        setCookiesMock.mockResolvedValue(undefined);
+
+        await execute({
+            params: createYoutubeParams(),
+            options: {},
+            i18n: createI18n(),
+            onUpdate: jest.fn(),
+            signal: new AbortController().signal,
+        });
+
+        expect(page.$$eval).toHaveBeenCalledWith("xpath/" + AlbumsDirectLinkSelector, expect.any(Function));
+        expect(reporterFinishMock).toHaveBeenCalledWith("done", expect.objectContaining({
+            values: ["https://music.youtube.com/direct/one"],
+            errors: [],
+            warnings: [],
+        }));
+    });
+
+    test("reports timeout errors", async () => {
+        const page = createPageMock();
+        const browser = createBrowserMock(page);
+        launchMock.mockResolvedValue(browser);
+        setCookiesMock.mockResolvedValue(undefined);
+        navigateToPageMock.mockRejectedValue(new TimeoutError("timeout"));
+
+        const consoleErrorSpy = jest.spyOn(console, "error").mockImplementation(() => undefined);
+
+        await execute({
+            params: createYoutubeParams(),
+            options: {},
+            i18n: createI18n(),
+            onUpdate: jest.fn(),
+            signal: new AbortController().signal,
+        });
+
+        const [, result] = reporterFinishMock.mock.calls[0];
+
+        expect(result.errors).toEqual([
+            {
+                title: "exceptionTimeout",
+                description: "exceptionTimeoutText",
+            },
+        ]);
+        expect(result.warnings ?? []).toEqual([]);
+        expect(result.values ?? []).toEqual([]);
+        expect(page.close).toHaveBeenCalledTimes(1);
+        expect(browser.close).toHaveBeenCalledTimes(1);
+        consoleErrorSpy.mockRestore();
+    });
+
+    test("reports navigation detach as warning", async () => {
+        const page = createPageMock();
+        const browser = createBrowserMock(page);
+        const consoleErrorSpy = jest.spyOn(console, "error").mockImplementation(() => undefined);
+
+        launchMock.mockResolvedValue(browser);
+        setCookiesMock.mockResolvedValue(undefined);
+        navigateToPageMock.mockRejectedValue(new Error("Navigating frame was detached"));
+
+        await execute({
+            params: createYoutubeParams(),
+            options: {},
+            i18n: createI18n(),
+            onUpdate: jest.fn(),
+            signal: new AbortController().signal,
+        });
+
+        const [, result] = reporterFinishMock.mock.calls[0];
+
+        expect(result.errors ?? []).toEqual([]);
+        expect(result.warnings).toEqual([
+            {
+                title: "exceptionGetYoutubeUrls",
+                description: "exceptionGetYoutubeUrlsText",
+            },
+        ]);
+        expect(page.close).toHaveBeenCalledTimes(1);
+        expect(browser.close).toHaveBeenCalledTimes(1);
+        consoleErrorSpy.mockRestore();
+    });
+
+    test("reports generic errors", async () => {
+        const page = createPageMock();
+        const browser = createBrowserMock(page);
+        const consoleErrorSpy = jest.spyOn(console, "error").mockImplementation(() => undefined);
+
+        launchMock.mockResolvedValue(browser);
+        setCookiesMock.mockResolvedValue(undefined);
+        navigateToPageMock.mockRejectedValue(new Error("boom"));
+
+        await execute({
+            params: createYoutubeParams(),
+            options: {},
+            i18n: createI18n(),
+            onUpdate: jest.fn(),
+            signal: new AbortController().signal,
+        });
+
+        const [, result] = reporterFinishMock.mock.calls[0];
+
+        expect(result.errors).toEqual([
+            {
+                title: "exceptionGetYoutubeUrls",
+                description: "exceptionGetYoutubeUrlsText",
+            },
+        ]);
+        expect(result.warnings ?? []).toEqual([]);
+        expect(page.close).toHaveBeenCalledTimes(1);
+        expect(browser.close).toHaveBeenCalledTimes(1);
+        consoleErrorSpy.mockRestore();
+    });
+
+    test("cancels operation properly", async () => {
+        const page = createPageMock();
+        const abortController = new AbortController();
+
+        page.waitForSelector.mockImplementation(() => {
+            abortController.abort();
+        });
+
+        const browser = createBrowserMock(page);
+        launchMock.mockResolvedValue(browser);
+        navigateToPageMock.mockResolvedValue(undefined);
+        setCookiesMock.mockResolvedValue(undefined);
+
+        expect(execute({
+            params: createYoutubeParams(),
+            options: {},
+            i18n: createI18n(),
+            onUpdate: jest.fn(),
+            signal: abortController.signal,
+        })).rejects.toThrow("aborted");
+    });
+});

package/src/automations/Youtube.ts

@@ -1,5 +1,5 @@
 import {i18n as i18next} from "i18next";
-import {map, merge} from "lodash-es";
+import {merge} from "lodash-es";
 import {Browser, LaunchOptions, Page, TimeoutError} from "puppeteer-core";
 import puppeteer from "puppeteer-extra";
 import StealthPlugin from "puppeteer-extra-plugin-stealth";
@@ -32,7 +32,7 @@ export const execute = async (parameters: MessageHandlerParams) => {
             abortPromise,
         ]);
     } catch (error: any) {
-        const result: GetYoutubeResult = {errors: [], sources: params.values};
+        const result: GetYoutubeResult = {warnings: [], errors: [], sources: params.values};
         if (error.message === "aborted") {
             throw error;
         }
@@ -55,7 +55,6 @@ export const execute = async (parameters: MessageHandlerParams) => {
 
 const run = async (params: GetYoutubeParams, options: LaunchOptions, i18n: i18next, onUpdate: (data: ProgressInfo<GetYoutubeResult>) => void) => {
     const result: GetYoutubeResult = {warnings: [], errors: [], values: [], sources: params.values};
-    
     await i18n.changeLanguage(params.lang);
 
     reporter = new Reporter(onUpdate);
@@ -81,8 +80,7 @@ const run = async (params: GetYoutubeParams, options: LaunchOptions, i18n: i18ne
 
             albumFilterButton.click();
             await page.waitForNetworkIdle();
-
-            const items = await page.$$eval(`xpath/${AlbumLinkSelector}`, (elements: Element[]) => map(elements, (el) => el.getAttribute("href")));
+            const items = await page.$$eval(`xpath/${AlbumLinkSelector}`, (elements: Element[]) => elements.map((el) => el.getAttribute("href")));
 
             for (const item of items) {
                 results.push(`${params.url}/${item}`);
@@ -90,7 +88,7 @@ const run = async (params: GetYoutubeParams, options: LaunchOptions, i18n: i18ne
 
             return results;
         } catch (error) {
-            const items = await page.$$eval(`xpath/${AlbumsDirectLinkSelector}`, (elements: Element[]) => map(elements, (el) => el.getAttribute("href")));
+            const items = await page.$$eval(`xpath/${AlbumsDirectLinkSelector}`, (elements: Element[]) => elements.map((el) => el.getAttribute("href")));
 
             for (const item of items) {
                 results.push(`${params.url}/${item}`);