bdy 1.18.31-dev → 1.18.31-dev-commands-changes-869c3r8yn

package/distTs/src/command/tests/visual/upload.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../../utils");
+const texts_1 = require("../../../texts");
+const output_1 = __importDefault(require("../../../output"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_zlib_1 = require("node:zlib");
+const commandVisualUpload = (0, utils_1.newCommand)('upload', texts_1.DESC_COMMAND_VISUAL_UPLOAD);
+commandVisualUpload.action(async () => {
+    const { getCiAndGitInfo, formattedCiInfo } = require('@buddy-works/ci-info');
+    const { getDefaultSettings, sendStorybook } = require('../../../visualTest/requests');
+    const { setDefaultSettings } = require('../../../visualTest/snapshots');
+    const { createVtContext, applyToken, applyCiAndCommitInfo } = require('../../../visualTest/context');
+    const Input = require('../../../input').default;
+    const ctx = createVtContext();
+    const token = await Input.vtSuiteToken();
+    if (!token) {
+        output_1.default.exitError(texts_1.ERR_MISSING_VT_TOKEN);
+    }
+    applyToken(ctx, token);
+    const currentDirectoryFiles = getCurrentDirectoryFiles();
+    if (!isStorybookDirectory(currentDirectoryFiles)) {
+        output_1.default.exitError(texts_1.ERR_WRONG_STORYBOOK_DIRECTORY);
+    }
+    const storybookStoriesIndex = getStorybookStoriesIndex(currentDirectoryFiles);
+    const storiesList = getStoriesList(storybookStoriesIndex);
+    const storybookSnapshots = getStorybookSnapshots(storiesList);
+    const defaultSettings = await getDefaultSettings(ctx);
+    setDefaultSettings(defaultSettings);
+    const ciAndGitInfo = await getCiAndGitInfo({
+        baseBranch: defaultSettings.baseBranch,
+        logger: output_1.default.warning,
+    });
+    applyCiAndCommitInfo(ctx, ciAndGitInfo);
+    output_1.default.normal(formattedCiInfo(ciAndGitInfo));
+    try {
+        const compressedStorybookDirectory = await createCompressedStorybookDirectory(currentDirectoryFiles);
+        const { message } = await sendStorybook(ctx, storybookSnapshots, compressedStorybookDirectory);
+        output_1.default.exitSuccess(message);
+    }
+    catch (error) {
+        output_1.default.exitError(`${error}`);
+    }
+});
+function getCurrentDirectoryFiles() {
+    const cwd = process.cwd();
+    const filesAndDirectories = (0, node_fs_1.readdirSync)(cwd, {
+        encoding: 'utf8',
+        recursive: true,
+    });
+    return filesAndDirectories.filter((file) => {
+        const elementPath = node_path_1.default.join(cwd, file);
+        const stats = (0, node_fs_1.statSync)(elementPath);
+        return stats.isFile();
+    });
+}
+async function createCompressedStorybookDirectory(files) {
+    const tar = require('tar-stream');
+    const cwd = process.cwd();
+    const chunks = [];
+    return new Promise((resolve, reject) => {
+        const compressStream = (0, node_zlib_1.createBrotliCompress)({
+            params: {
+                [node_zlib_1.constants.BROTLI_PARAM_QUALITY]: 6,
+            },
+        });
+        compressStream.on('data', (chunk) => {
+            chunks.push(chunk);
+        });
+        compressStream.on('end', () => {
+            resolve(Buffer.concat(chunks));
+        });
+        compressStream.on('error', reject);
+        const packStream = tar.pack();
+        packStream.pipe(compressStream);
+        let filesProcessed = 0;
+        for (const file of files) {
+            const filePath = node_path_1.default.join(cwd, file);
+            const stats = (0, node_fs_1.statSync)(filePath);
+            const entry = packStream.entry({
+                name: file,
+                size: stats.size,
+            }, (error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    filesProcessed += 1;
+                    if (filesProcessed === files.length) {
+                        packStream.finalize();
+                    }
+                }
+            });
+            const fileStream = (0, node_fs_1.createReadStream)(filePath);
+            fileStream.pipe(entry);
+            fileStream.on('error', reject);
+        }
+    });
+}
+function isStorybookDirectory(files) {
+    return (files.length > 0 &&
+        files.includes('index.html') &&
+        files.includes('iframe.html'));
+}
+function getStorybookStoriesIndex(files) {
+    const indexFiles = files.find((file) => file === 'index.json');
+    if (indexFiles) {
+        return indexFiles;
+    }
+    else {
+        return output_1.default.exitError(texts_1.ERR_MISSING_STORYBOOK_INDEX_FILE);
+    }
+}
+function getStoriesList(storybookStoriesIndex) {
+    const storiesListFile = (0, node_fs_1.readFileSync)(storybookStoriesIndex);
+    try {
+        const json = JSON.parse(storiesListFile.toString());
+        if (![4, 5].includes(json.v)) {
+            output_1.default.exitError(texts_1.ERR_UNSUPPORTED_STORYBOOK);
+        }
+        return json;
+    }
+    catch {
+        output_1.default.exitError(texts_1.ERR_PARSING_STORIES);
+    }
+}
+function getStorybookSnapshots(storiesList) {
+    const stories = Object.entries(storiesList.entries)
+        .filter(([, value]) => value.type === 'story')
+        .map(([key, value]) => ({
+        id: key,
+        name: `${value.title}/${value.name}`,
+    }));
+    output_1.default.normal((0, texts_1.TXT_STORIES_AMOUNT)(stories.length));
+    return stories;
+}
+exports.default = commandVisualUpload;

package/distTs/src/command/tests/visual.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+const texts_1 = require("../../texts");
+const setup_1 = __importDefault(require("./visual/setup"));
+const upload_1 = __importDefault(require("./visual/upload"));
+const session_1 = __importDefault(require("./visual/session"));
+const link_1 = __importDefault(require("./visual/link"));
+const commandVisual = (0, utils_1.newCommand)('visual', texts_1.DESC_COMMAND_VISUAL);
+commandVisual.addCommand(setup_1.default);
+commandVisual.addCommand(upload_1.default);
+commandVisual.addCommand(session_1.default);
+commandVisual.addCommand(link_1.default);
+exports.default = commandVisual;

package/distTs/src/command/tests.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const texts_1 = require("../texts");
+const unit_1 = __importDefault(require("./tests/unit"));
+const visual_1 = __importDefault(require("./tests/visual"));
+const capture_1 = __importDefault(require("./tests/capture"));
+const commandTests = (0, utils_1.newCommand)('tests', texts_1.DESC_COMMAND_TESTS);
+commandTests.addCommand(unit_1.default);
+commandTests.addCommand(visual_1.default);
+commandTests.addCommand(capture_1.default);
+exports.default = commandTests;

package/distTs/src/command/whoami.js

@@ -30,6 +30,18 @@ commandWhoami.action(async () => {
     if (localProject) {
         output_1.default.normal(`Project: ${localProject}`);
     }
+    const vtSuite = cfg_2.default.getVtSuite();
+    const utSuite = cfg_2.default.getUtSuite();
+    const crawlSuite = cfg_2.default.getCrawlSuite();
+    if (vtSuite) {
+        output_1.default.normal(`Visual test suite: ${vtSuite}`);
+    }
+    if (utSuite) {
+        output_1.default.normal(`Unit test suite: ${utSuite}`);
+    }
+    if (crawlSuite) {
+        output_1.default.normal(`Crawl suite: ${crawlSuite}`);
+    }
     output_1.default.exitNormal();
 });
 exports.default = commandWhoami;

package/distTs/src/crawl/requests.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendCrawl = sendCrawl;
+exports.downloadCrawlPackage = downloadCrawlPackage;
+exports.connectToCrawlSession = connectToCrawlSession;
+const context_1 = require("../visualTest/context");
+const undici_1 = require("undici");
+const output_1 = __importDefault(require("../output"));
+const texts_1 = require("../texts");
+const eventsource_1 = require("eventsource");
+const customServiceUrl = process.env.BUDDY_CRAWL_SERVICE_URL;
+function checkIfIsDevToken(token) {
+    const tokenParts = token.split('_');
+    return tokenParts.length === 5;
+}
+function getServiceUrl(token) {
+    if (customServiceUrl) {
+        return customServiceUrl;
+    }
+    const tokenParts = token.split('_');
+    const isDevToken = checkIfIsDevToken(token);
+    const devServiceUrl = Buffer.from(tokenParts[3], 'base64url').toString('utf-8');
+    if (isDevToken) {
+        if (devServiceUrl.includes('local.io')) {
+            throw new Error('Use BUDDY_CRAWL_SERVICE_URL to set the service URL in this environment');
+        }
+        return devServiceUrl;
+    }
+    if (token.startsWith('bud_crawl_eu')) {
+        return 'https://vt.eu.buddy.works';
+    }
+    if (token.startsWith('bud_crawl_asia')) {
+        return 'https://vt.asia.buddy.works';
+    }
+    return 'https://vt.buddy.works';
+}
+async function sendCrawl(ctx, url, follow, respectRobots, outputTypes, colorScheme, browsers, devices, cookies, requestHeaders, delays, waitForSelectors, localStorage) {
+    const payload = {
+        url,
+        follow,
+        respectRobots,
+        outputTypes,
+        colorScheme,
+        browsers,
+        devices,
+        cookies,
+        requestHeaders,
+        delays,
+        waitForSelectors,
+        localStorage,
+        pipelineId: ctx.pipelineId,
+        pipelineName: ctx.pipelineName,
+        executionId: ctx.executionId,
+        actionId: ctx.actionId,
+        invokerId: ctx.invokerId,
+        ci: ctx.ci,
+        executionUrl: ctx.executionUrl,
+    };
+    const [message, response] = await sendRequest({
+        path: '/crawl',
+        token: ctx.token,
+        payload,
+    });
+    if (message) {
+        throw new Error(message);
+    }
+    if (!response) {
+        throw new Error(texts_1.ERR_INVALID_CRAWL_RESPONSE);
+    }
+    return response;
+}
+async function downloadCrawlPackage(ctx, buildId) {
+    const [message, response] = await sendRequest({
+        path: '/download',
+        token: ctx.token,
+        payload: { token: ctx.token, buildId },
+    });
+    if (message) {
+        throw new Error(message);
+    }
+    if (!response) {
+        throw new Error(texts_1.ERR_INVALID_DOWNLOAD_RESPONSE);
+    }
+    return response;
+}
+function connectToCrawlSession(ctx, buildId) {
+    return new eventsource_1.EventSource(`${getServiceUrl(ctx.token)}/sse`, {
+        fetch: (url, options) => {
+            return (0, undici_1.fetch)(url, {
+                ...options,
+                headers: {
+                    ...options?.headers,
+                    'x-token': ctx.token,
+                    'x-cli-version': context_1.cliVersion,
+                    'x-build-id': buildId,
+                },
+            });
+        },
+    });
+}
+async function sendRequest({ path, token, payload, }) {
+    const fullUrl = new URL(path, getServiceUrl(token));
+    output_1.default.debug((0, texts_1.LOG_SENDING_REQUEST)(fullUrl.toString()));
+    const init = {
+        method: 'GET',
+        redirect: 'follow',
+        headers: {
+            'X-CLI-VERSION': context_1.cliVersion,
+            'X-TOKEN': token,
+        },
+    };
+    if (payload) {
+        init.method = 'POST';
+        init.headers = {
+            'Content-Type': 'application/json',
+            'X-TOKEN': token,
+            'X-CLI-VERSION': context_1.cliVersion,
+        };
+        init.body = JSON.stringify(payload);
+    }
+    const response = await (0, undici_1.fetch)(fullUrl, init);
+    const contentType = response.headers.get('content-type');
+    if (contentType && contentType.includes('application/json')) {
+        try {
+            const json = (await response.json());
+            return [undefined, json];
+        }
+        catch {
+            throw new Error(texts_1.ERR_INVALID_JSON);
+        }
+    }
+    if (contentType && contentType.includes('application/octet-stream')) {
+        const buffer = response.body;
+        return [undefined, buffer];
+    }
+    const text = await response.text();
+    return [text, undefined];
+}

package/distTs/src/index.js

@@ -11,9 +11,8 @@ const pre_1 = __importDefault(require("./command/pre"));
 const stream_1 = __importDefault(require("stream"));
 const utils_1 = require("./utils");
 const texts_1 = require("./texts");
-const vt_1 = __importDefault(require("./command/vt"));
-const scrape_1 = __importDefault(require("./command/scrape"));
-const ut_1 = __importDefault(require("./command/ut"));
+const crawl_1 = __importDefault(require("./command/crawl"));
+const tests_1 = __importDefault(require("./command/tests"));
 const tunnel_1 = __importDefault(require("./command/tunnel"));
 const pipeline_1 = __importDefault(require("./command/pipeline"));
 const sandbox_1 = __importDefault(require("./command/sandbox"));
@@ -41,9 +40,8 @@ program.addCommand(tunnel_1.default);
 if (!(0, utils_1.isDocker)())
     program.addCommand(agent_1.default);
 program.addCommand(version_1.default);
-program.addCommand(vt_1.default);
-program.addCommand(scrape_1.default);
-program.addCommand(ut_1.default);
+program.addCommand(crawl_1.default);
+program.addCommand(tests_1.default);
 program.addCommand(pipeline_1.default);
 program.addCommand(package_1.default);
 program.addCommand(sandbox_1.default);

package/distTs/src/input.js

@@ -743,6 +743,84 @@ class Input {
             host: d.host,
         };
     }
+    static async resolveSuiteId(client, workspace, project, identifier, type) {
+        const paramKey = type === 'vt' ? 'visual_test_suite'
+            : type === 'crawl' ? 'crawl_suite'
+                : 'unit_test_suite';
+        const responseKey = type === 'vt' ? 'visual_test_suite_id'
+            : type === 'crawl' ? 'crawl_suite_id'
+                : 'unit_test_suite_id';
+        try {
+            const result = await client.resolveIdentifiers(workspace, {
+                project,
+                [paramKey]: identifier,
+            });
+            return result?.[responseKey] ? String(result[responseKey]) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    static async vtSuiteToken() {
+        const envToken = process.env.BUDDY_VT_TOKEN;
+        if (envToken)
+            return envToken;
+        const ProjectCfg = require('./project/cfg').default;
+        const suiteIdentifier = ProjectCfg.getVtSuite();
+        if (suiteIdentifier && (cfg_1.default.getApiToken() || process.env.BUDDY_TOKEN)) {
+            const workspace = Input.restApiWorkspace('', true);
+            const project = Input.restApiProject('', true);
+            if (workspace && project) {
+                const client = Input.restApiTokenClient();
+                const suiteId = await Input.resolveSuiteId(client, workspace, project, suiteIdentifier, 'vt');
+                if (!suiteId)
+                    return '';
+                const result = await client.getVtSuiteToken(workspace, project, suiteId);
+                return String(result?.token || '');
+            }
+        }
+        return '';
+    }
+    static async crawlSuiteToken() {
+        const envToken = process.env.BUDDY_CRAWL_TOKEN;
+        if (envToken)
+            return envToken;
+        const ProjectCfg = require('./project/cfg').default;
+        const suiteIdentifier = ProjectCfg.getCrawlSuite();
+        if (suiteIdentifier && (cfg_1.default.getApiToken() || process.env.BUDDY_TOKEN)) {
+            const workspace = Input.restApiWorkspace('', true);
+            const project = Input.restApiProject('', true);
+            if (workspace && project) {
+                const client = Input.restApiTokenClient();
+                const suiteId = await Input.resolveSuiteId(client, workspace, project, suiteIdentifier, 'crawl');
+                if (!suiteId)
+                    return '';
+                const result = await client.getCrawlSuiteToken(workspace, project, suiteId);
+                return String(result?.token || '');
+            }
+        }
+        return '';
+    }
+    static async utSuiteToken() {
+        const envToken = process.env.BUDDY_UT_TOKEN;
+        if (envToken)
+            return envToken;
+        const ProjectCfg = require('./project/cfg').default;
+        const suiteIdentifier = ProjectCfg.getUtSuite();
+        if (suiteIdentifier && (cfg_1.default.getApiToken() || process.env.BUDDY_TOKEN)) {
+            const workspace = Input.restApiWorkspace('', true);
+            const project = Input.restApiProject('', true);
+            if (workspace && project) {
+                const client = Input.restApiTokenClient();
+                const suiteId = await Input.resolveSuiteId(client, workspace, project, suiteIdentifier, 'ut');
+                if (!suiteId)
+                    return '';
+                const result = await client.getUtSuiteToken(workspace, project, suiteId);
+                return String(result?.token || '');
+            }
+        }
+        return '';
+    }
     static keyCert(keyPath, certPath) {
         let key;
         let cert;