@uxf/scripts 11.122.5 → 11.124.0

package/src/google-chat.test.js

@@ -0,0 +1,95 @@
+const GoogleChat = require("./google-chat");
+
+const originalFetch = globalThis.fetch;
+const { GOOGLE_WEBHOOK_URL } = process.env;
+
+function stubFetch({ status = 200, payload = {} } = {}) {
+    const calls = [];
+    globalThis.fetch = async (url, init) => {
+        calls.push({ url, init });
+        return {
+            ok: status >= 200 && status < 300,
+            status,
+            headers: { get: () => "application/json" },
+            text: async () => JSON.stringify(payload),
+        };
+    };
+    return calls;
+}
+
+beforeEach(() => {
+    process.env.GOOGLE_WEBHOOK_URL = "https://chat.test/hook";
+    jest.spyOn(process.stdout, "write").mockImplementation(() => true);
+    jest.spyOn(process.stderr, "write").mockImplementation(() => true);
+    jest.spyOn(console, "error").mockImplementation(() => {});
+});
+
+afterEach(() => {
+    globalThis.fetch = originalFetch;
+    process.env.GOOGLE_WEBHOOK_URL = GOOGLE_WEBHOOK_URL;
+    jest.restoreAllMocks();
+});
+
+describe("chatPostMessage", () => {
+    it("posts the payload to the webhook from the environment", async () => {
+        const calls = stubFetch();
+
+        await GoogleChat.chatPostMessage({ text: "ahoj" });
+
+        expect(calls[0].url).toBe("https://chat.test/hook");
+        expect(calls[0].init.method).toBe("POST");
+        expect(JSON.parse(calls[0].init.body)).toEqual({ text: "ahoj" });
+    });
+
+    it("prefers an explicitly configured webhook url", async () => {
+        const calls = stubFetch();
+
+        await GoogleChat.chatPostMessage({ text: "ahoj" }, { webhookUrl: "https://other.test/hook" });
+
+        expect(calls[0].url).toBe("https://other.test/hook");
+    });
+
+    it("skips in dry run mode", async () => {
+        const calls = stubFetch();
+
+        await GoogleChat.chatPostMessage({ text: "ahoj" }, { dryRun: true });
+
+        expect(calls).toHaveLength(0);
+        expect(process.stdout.write).toHaveBeenCalledWith("GOOGLE CHAT: chat.postMessage - skipped");
+    });
+
+    it("skips when no webhook url is configured", async () => {
+        delete process.env.GOOGLE_WEBHOOK_URL;
+        const calls = stubFetch();
+
+        await GoogleChat.chatPostMessage({ text: "ahoj" });
+
+        expect(calls).toHaveLength(0);
+    });
+
+    // Notifiery posílají desítky zpráv za sebou; jedna neúspěšná nesmí shodit celý běh.
+    it("swallows a failed request instead of rejecting", async () => {
+        stubFetch({ status: 500 });
+
+        await expect(GoogleChat.chatPostMessage({ text: "ahoj" })).resolves.toBeUndefined();
+        expect(process.stderr.write).toHaveBeenCalledWith("GOOGLE CHAT: chat.postMessage - error");
+    });
+});
+
+describe("messageCardsV2", () => {
+    it("wraps the cards and sends the charset content type", async () => {
+        const calls = stubFetch();
+
+        await GoogleChat.messageCardsV2([{ cardId: "mr-1" }]);
+
+        expect(JSON.parse(calls[0].init.body)).toEqual({ cardsV2: [{ cardId: "mr-1" }] });
+        expect(calls[0].init.headers["Content-Type"]).toBe("application/json; charset=UTF-8");
+    });
+
+    // Na rozdíl od chatPostMessage tady chyba probublá — volající ji má řešit.
+    it("rejects on a failed request", async () => {
+        stubFetch({ status: 500 });
+
+        await expect(GoogleChat.messageCardsV2([])).rejects.toThrow("Request failed with status code 500");
+    });
+});

package/src/http.js

@@ -0,0 +1,86 @@
+/**
+ * Minimalistická náhrada axiosu nad globálním `fetch` (Node >= 18).
+ *
+ * Existuje proto, aby notifiery běžely v CI bez `npm install` — viz
+ * `docs/decisions/package-manager.md`. Drží se chování axiosu ve třech věcech,
+ * na kterých volající stojí: vyhazuje na non-2xx, parsuje JSON odpověď
+ * a zahazuje `undefined` query parametry.
+ */
+
+/**
+ * Chyba HTTP požadavku. `message` má stejný tvar jako u axiosu, protože
+ * `GitLab.findMigrationFiles` ho loguje.
+ */
+class HttpError extends Error {
+    /**
+     * @param {number} status
+     * @param {string} url
+     * @param {any} body
+     */
+    constructor(status, url, body) {
+        super(`Request failed with status code ${status}`);
+        this.name = "HttpError";
+        this.status = status;
+        this.url = url;
+        this.body = body;
+    }
+}
+
+/**
+ * Poskládá query string a zahodí `undefined`/`null` hodnoty — axios se choval stejně.
+ *
+ * @param {string} url
+ * @param {Record<string, any> | undefined} params
+ */
+function withQuery(url, params) {
+    const search = new URLSearchParams();
+
+    for (const [key, value] of Object.entries(params ?? {})) {
+        if (value !== undefined && value !== null) {
+            search.append(key, String(value));
+        }
+    }
+
+    const query = search.toString();
+
+    if (!query) {
+        return url;
+    }
+
+    return `${url}${url.includes("?") ? "&" : "?"}${query}`;
+}
+
+/**
+ * @param {string} url
+ * @param {{baseUrl?: string, method?: string, headers?: Record<string, string>, params?: Record<string, any>, body?: any}} options
+ * @returns {Promise<{data: any, headers: Headers, status: number}>}
+ */
+async function request(url, options = {}) {
+    const { baseUrl = "", method = "GET", headers = {}, params, body } = options;
+    const target = withQuery(`${baseUrl}${url}`, params);
+
+    /** @type {RequestInit} */
+    const init = { method, headers: { ...headers } };
+
+    if (body !== undefined) {
+        init.body = JSON.stringify(body);
+        init.headers["Content-Type"] = init.headers["Content-Type"] ?? "application/json";
+    }
+
+    const response = await fetch(target, init);
+    const text = await response.text();
+    const isJson = (response.headers.get("content-type") ?? "").includes("application/json");
+    const data = isJson && text ? JSON.parse(text) : text;
+
+    if (!response.ok) {
+        throw new HttpError(response.status, target, data);
+    }
+
+    return { data, headers: response.headers, status: response.status };
+}
+
+module.exports = {
+    HttpError,
+    request,
+    withQuery,
+};

package/src/http.test.js

@@ -0,0 +1,155 @@
+const { request, withQuery, HttpError } = require("./http");
+
+/**
+ * Minimální náhrada `Response` — testy nesmí záviset na tom, jestli ji testovací
+ * prostředí (jsdom) vystavuje.
+ */
+function fakeResponse({ status = 200, body = "", contentType = "application/json" } = {}) {
+    return {
+        ok: status >= 200 && status < 300,
+        status,
+        headers: { get: (name) => (name.toLowerCase() === "content-type" ? contentType : null) },
+        text: async () => body,
+    };
+}
+
+function stubFetch(response) {
+    const calls = [];
+    globalThis.fetch = async (url, init) => {
+        calls.push({ url, init });
+        return typeof response === "function" ? response(url, init) : response;
+    };
+    return calls;
+}
+
+const originalFetch = globalThis.fetch;
+
+afterEach(() => {
+    globalThis.fetch = originalFetch;
+});
+
+describe("withQuery", () => {
+    it("returns the url untouched when there are no params", () => {
+        expect(withQuery("/projects", undefined)).toBe("/projects");
+        expect(withQuery("/projects", {})).toBe("/projects");
+    });
+
+    it("drops undefined and null values", () => {
+        expect(withQuery("/mr", { a: "1", b: undefined, c: null, d: "2" })).toBe("/mr?a=1&d=2");
+    });
+
+    it("keeps falsy values that are not undefined or null", () => {
+        expect(withQuery("/mr", { page: 0, simple: false, empty: "" })).toBe("/mr?page=0&simple=false&empty=");
+    });
+
+    it("appends with & when the url already has a query string", () => {
+        expect(withQuery("/mr?state=open", { page: "2" })).toBe("/mr?state=open&page=2");
+    });
+
+    it("encodes values", () => {
+        expect(withQuery("/tags", { search: "^release-" })).toBe("/tags?search=%5Erelease-");
+    });
+});
+
+describe("request", () => {
+    it("joins baseUrl, path and params", async () => {
+        const calls = stubFetch(fakeResponse({ body: "{}" }));
+
+        await request("/projects", { baseUrl: "https://git.test/api/v4", params: { per_page: "100" } });
+
+        expect(calls[0].url).toBe("https://git.test/api/v4/projects?per_page=100");
+    });
+
+    it("defaults to GET and sends no body", async () => {
+        const calls = stubFetch(fakeResponse({ body: "{}" }));
+
+        await request("/x");
+
+        expect(calls[0].init.method).toBe("GET");
+        expect(calls[0].init.body).toBeUndefined();
+    });
+
+    it("serializes the body as JSON and sets the content type", async () => {
+        const calls = stubFetch(fakeResponse({ body: "{}" }));
+
+        await request("/x", { method: "POST", body: { text: "ahoj" } });
+
+        expect(calls[0].init.body).toBe('{"text":"ahoj"}');
+        expect(calls[0].init.headers["Content-Type"]).toBe("application/json");
+    });
+
+    it("does not override an explicitly provided content type", async () => {
+        const calls = stubFetch(fakeResponse({ body: "{}" }));
+
+        await request("/x", {
+            method: "POST",
+            headers: { "Content-Type": "application/json; charset=UTF-8" },
+            body: { a: 1 },
+        });
+
+        expect(calls[0].init.headers["Content-Type"]).toBe("application/json; charset=UTF-8");
+    });
+
+    it("passes custom headers through", async () => {
+        const calls = stubFetch(fakeResponse({ body: "{}" }));
+
+        await request("/x", { headers: { Authorization: "Bearer t" } });
+
+        expect(calls[0].init.headers.Authorization).toBe("Bearer t");
+    });
+
+    it("parses a JSON response", async () => {
+        stubFetch(fakeResponse({ body: '{"id":1}' }));
+
+        const response = await request("/x");
+
+        expect(response.data).toEqual({ id: 1 });
+        expect(response.status).toBe(200);
+    });
+
+    it("returns raw text when the response is not JSON", async () => {
+        stubFetch(fakeResponse({ body: "<html></html>", contentType: "text/html" }));
+
+        const response = await request("/x");
+
+        expect(response.data).toBe("<html></html>");
+    });
+
+    it("returns an empty string for an empty JSON response instead of throwing", async () => {
+        stubFetch(fakeResponse({ body: "" }));
+
+        const response = await request("/x");
+
+        expect(response.data).toBe("");
+    });
+
+    it("exposes response headers so callers can paginate", async () => {
+        globalThis.fetch = async () => ({
+            ok: true,
+            status: 200,
+            headers: { get: (name) => (name === "x-next-page" ? "2" : "application/json") },
+            text: async () => "[]",
+        });
+
+        const response = await request("/x");
+
+        expect(response.headers.get("x-next-page")).toBe("2");
+    });
+
+    it("throws on a non-2xx status, the way axios did", async () => {
+        stubFetch(fakeResponse({ status: 404, body: '{"message":"404 Not found"}' }));
+
+        await expect(request("/missing")).rejects.toThrow("Request failed with status code 404");
+    });
+
+    it("carries status, url and parsed body on the error", async () => {
+        stubFetch(fakeResponse({ status: 500, body: '{"message":"boom"}' }));
+
+        const error = await request("/x", { baseUrl: "https://git.test" }).catch((e) => e);
+
+        expect(error).toBeInstanceOf(HttpError);
+        expect(error.status).toBe(500);
+        expect(error.url).toBe("https://git.test/x");
+        expect(error.body).toEqual({ message: "boom" });
+    });
+});

package/src/sitemap.js

@@ -0,0 +1,80 @@
+const cheerio = require("cheerio");
+
+const { HTTP_USERNAME, HTTP_PASSWORD } = process.env;
+
+// got v15 je ESM-only, proto dynamický import — stejný vzorec jako v uxf-sitemap-check.
+const got = (url, init) => import("got").then((mod) => mod.default(url, init));
+
+const REQUEST_TIMEOUT_MS = 20_000;
+
+const HEADERS = {
+    "User-Agent":
+        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36",
+    Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+    "Accept-Language": "en-US,en;q=0.9,cs-CZ;q=0.8,cs;q=0.7,de;q=0.6",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+    Pragma: "no-cache",
+    "Sec-Ch-Ua": '"Google Chrome";v="111", "Not(A:Brand";v="8", "Chromium";v="111"',
+    "Sec-Ch-Ua-Arch": '"x86"',
+    "Sec-Ch-Ua-Mobile": "?0",
+    "Sec-Ch-Ua-Platform": '"Windows"',
+    "Sec-Fetch-Dest": "document",
+    "Sec-Fetch-Mode": "navigate",
+    "Sec-Fetch-Site": "cross-site",
+    "Sec-Fetch-User": "?1",
+    "Sec-Fetch-User-Agent": "?1",
+};
+
+/**
+ * Stáhne stránku se stejnou konfigurací, jakou měla původní axios instance:
+ * basic auth z env, žádné následování redirectů, 20s timeout a vypnuté ověřování
+ * TLS certifikátu (kvůli staging webům se self-signed certy).
+ *
+ * `https.rejectUnauthorized` je důvod, proč tenhle modul jede na `got` a ne na
+ * globálním `fetch` — undici žádnou per-request TLS volbu nenabízí.
+ *
+ * @param {string} url
+ * @returns {Promise<string>} tělo odpovědi
+ */
+async function fetchPage(url) {
+    const response = await got(url, {
+        headers: HEADERS,
+        username: HTTP_USERNAME || undefined,
+        password: HTTP_PASSWORD || undefined,
+        followRedirect: false,
+        // BEZPEČNOST: vypnuté ověřování TLS certifikátu. Zděděno z axios verze
+        // (`httpsAgent` s `rejectUnauthorized: false`), zachováno kvůli staging webům
+        // se self-signed certy. Platí to ale na VŠECHNY URL, včetně produkčních —
+        // takže crawler nepozná podvržený certifikát a je náchylný na MITM.
+        // Čistší by bylo podmínit to env proměnnou nebo přidat CA do trust storu.
+        https: { rejectUnauthorized: false },
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    });
+
+    // got s `followRedirect: false` vrací 3xx jako úspěch s prázdným tělem, kdežto
+    // axios s `maxRedirects: 0` na něj vyhazoval. Bez tohohle by přesměrované URL
+    // tiše propadly do exportu jako řádek s prázdným titulkem.
+    if (response.statusCode >= 300) {
+        throw new Error(`Request failed with status code ${response.statusCode}`);
+    }
+
+    return response.body;
+}
+
+async function getSitemap(xml) {
+    const $ = cheerio.load(await fetchPage(xml), { xmlMode: true });
+
+    const urls = [];
+
+    $("loc").each(function () {
+        urls.push($(this).text());
+    });
+
+    return urls;
+}
+
+module.exports = {
+    getSitemap,
+    fetchPage,
+};

package/src/sitemap.test.js

@@ -0,0 +1,64 @@
+const mockGot = jest.fn();
+
+jest.mock("got", () => ({ __esModule: true, default: (...args) => mockGot(...args) }));
+// cheerio je ESM-only a jest ho neprochází (viz transformIgnorePatterns v jest.config.js),
+// proto je mockované — stejně jako v uxf-sitemap-check/index.test.js. Parsování sitemapy
+// v `getSitemap` tím pádem testovat nejde; testy tu pokrývají `fetchPage`, tedy to,
+// co se převodem z axiosu na got mohlo rozejít.
+jest.mock("cheerio", () => ({ load: jest.fn() }));
+
+const Sitemap = require("./sitemap");
+
+function response({ statusCode = 200, body = "" } = {}) {
+    return { statusCode, body, headers: {} };
+}
+
+afterEach(() => {
+    mockGot.mockReset();
+});
+
+describe("fetchPage", () => {
+    it("returns the response body", async () => {
+        mockGot.mockResolvedValue(response({ body: "<html>ok</html>" }));
+
+        await expect(Sitemap.fetchPage("https://x.test/a")).resolves.toBe("<html>ok</html>");
+    });
+
+    it("does not follow redirects and skips TLS verification", async () => {
+        mockGot.mockResolvedValue(response({ body: "" }));
+
+        await Sitemap.fetchPage("https://x.test/a");
+
+        const [, options] = mockGot.mock.calls[0];
+        expect(options.followRedirect).toBe(false);
+        expect(options.https).toEqual({ rejectUnauthorized: false });
+        expect(options.signal).toBeInstanceOf(AbortSignal);
+    });
+
+    // got s `followRedirect: false` vrací 3xx jako úspěch s prázdným tělem, zatímco
+    // axios s `maxRedirects: 0` vyhazoval. Bez tohohle by přesměrované URL propadly
+    // do meta exportu jako řádek s prázdným titulkem.
+    it("throws on a redirect instead of returning an empty body", async () => {
+        mockGot.mockResolvedValue(response({ statusCode: 302, body: "" }));
+
+        await expect(Sitemap.fetchPage("https://x.test/redirect")).rejects.toThrow(
+            "Request failed with status code 302",
+        );
+    });
+
+    it("passes the requested url through", async () => {
+        mockGot.mockResolvedValue(response());
+
+        await Sitemap.fetchPage("https://x.test/a");
+
+        expect(mockGot.mock.calls[0][0]).toBe("https://x.test/a");
+    });
+
+    it("sends a browser-like user agent", async () => {
+        mockGot.mockResolvedValue(response());
+
+        await Sitemap.fetchPage("https://x.test/a");
+
+        expect(mockGot.mock.calls[0][1].headers["User-Agent"]).toContain("Mozilla/5.0");
+    });
+});

package/src/{Slack.js → slack.js}

@@ -1,12 +1,7 @@
 const { env } = require("process");
-const { create } = require("axios");
+const { request } = require("./http");
 
-const axios = create({
-    baseURL: "https://slack.com/api",
-    headers: {
-        Authorization: `Bearer ${env.SLACK_TOKEN}`,
-    },
-});
+const BASE_URL = "https://slack.com/api";
 
 /**
  * @see https://api.slack.com/methods/chat.postMessage
@@ -14,7 +9,13 @@ const axios = create({
  */
 async function chatPostMessage(channel, data, dryRun = false) {
     if (env.SLACK_TOKEN && !dryRun) {
-        const res = await axios.post("/chat.postMessage", { ...data, channel });
+        // Slack vrací HTTP 200 i pro chyby API, rozlišuje je až polem `ok`.
+        const res = await request("/chat.postMessage", {
+            baseUrl: BASE_URL,
+            method: "POST",
+            headers: { Authorization: `Bearer ${env.SLACK_TOKEN}` },
+            body: { ...data, channel },
+        });
         if (res.data.ok === false) {
             process.stdout.write("SLACK: chat.postMessage error - " + JSON.stringify(res.data));
             return;

package/src/slack.test.js

@@ -0,0 +1,81 @@
+const Slack = require("./slack");
+
+const originalFetch = globalThis.fetch;
+const { SLACK_TOKEN } = process.env;
+
+function stubFetch(payload = { ok: true }) {
+    const calls = [];
+    globalThis.fetch = async (url, init) => {
+        calls.push({ url, init });
+        return {
+            ok: true,
+            status: 200,
+            headers: { get: () => "application/json" },
+            text: async () => JSON.stringify(payload),
+        };
+    };
+    return calls;
+}
+
+beforeEach(() => {
+    process.env.SLACK_TOKEN = "xoxb-test";
+    jest.spyOn(process.stdout, "write").mockImplementation(() => true);
+});
+
+afterEach(() => {
+    globalThis.fetch = originalFetch;
+    process.env.SLACK_TOKEN = SLACK_TOKEN;
+    jest.restoreAllMocks();
+});
+
+describe("chatPostMessage", () => {
+    it("posts to the Slack API with the bearer token and the channel merged in", async () => {
+        const calls = stubFetch();
+
+        await Slack.chatPostMessage("#releases", { text: "ahoj" });
+
+        expect(calls[0].url).toBe("https://slack.com/api/chat.postMessage");
+        expect(calls[0].init.method).toBe("POST");
+        expect(calls[0].init.headers.Authorization).toBe("Bearer xoxb-test");
+        expect(JSON.parse(calls[0].init.body)).toEqual({ text: "ahoj", channel: "#releases" });
+    });
+
+    it("reports a done message on success", async () => {
+        stubFetch({ ok: true });
+
+        await Slack.chatPostMessage("#releases", { text: "ahoj" });
+
+        expect(process.stdout.write).toHaveBeenCalledWith("SLACK: chat.postMessage - done\n");
+    });
+
+    // Slack vrací HTTP 200 i pro chyby API, rozlišuje je až polem `ok` — proto se
+    // na to nedá spolehnout na status kód.
+    it("reports an error when Slack answers ok:false despite HTTP 200", async () => {
+        stubFetch({ ok: false, error: "channel_not_found" });
+
+        await Slack.chatPostMessage("#nope", { text: "ahoj" });
+
+        expect(process.stdout.write).toHaveBeenCalledWith(
+            'SLACK: chat.postMessage error - {"ok":false,"error":"channel_not_found"}',
+        );
+    });
+
+    it("skips when there is no token", async () => {
+        delete process.env.SLACK_TOKEN;
+        const calls = stubFetch();
+
+        await Slack.chatPostMessage("#releases", { text: "ahoj" });
+
+        expect(calls).toHaveLength(0);
+        expect(process.stdout.write).toHaveBeenCalledWith("SLACK: chat.postMessage - skipped\n");
+    });
+
+    it("skips in dry run mode", async () => {
+        const calls = stubFetch();
+
+        await Slack.chatPostMessage("#releases", { text: "ahoj" }, true);
+
+        expect(calls).toHaveLength(0);
+        expect(process.stdout.write).toHaveBeenCalledWith("SLACK: chat.postMessage - skipped\n");
+    });
+});