@crowdin/app-project-module 0.45.1 → 0.46.1

package/out/app-test/index.d.ts

@@ -0,0 +1,6 @@
+import { ClientConfig, Config } from '../types';
+import { TestSuiteConfig } from './types';
+export declare const runAllTests: ({ getAppConfig, testSuiteConfig, }: {
+    getAppConfig: () => Promise<Config | ClientConfig>;
+    testSuiteConfig: TestSuiteConfig;
+}) => void;

package/out/app-test/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAllTests = void 0;
+const integration_1 = require("./integration");
+const runAllTests = ({ getAppConfig, testSuiteConfig, }) => {
+    if (!testSuiteConfig) {
+        throw new Error('Please provide a valid tests configuration');
+    }
+    if (testSuiteConfig.projectIntegration) {
+        (0, integration_1.runProjectIntegrationTests)({ getAppConfig, integrationTestConfig: testSuiteConfig.projectIntegration });
+    }
+};
+exports.runAllTests = runAllTests;

package/out/app-test/integration/get-integration-files.d.ts

@@ -0,0 +1,6 @@
+import { ClientConfig, Config } from '../../types';
+import { IntegrationTestConfig } from './types';
+export declare const getIntegrationFilesTest: ({ appConfig, integrationTestConfig, }: {
+    appConfig: Config | ClientConfig;
+    integrationTestConfig: IntegrationTestConfig;
+}) => Promise<void>;

package/out/app-test/integration/get-integration-files.js

@@ -0,0 +1,70 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIntegrationFilesTest = void 0;
+const globals_1 = require("@jest/globals");
+const util_1 = require("../util");
+const getIntegrationFilesTest = ({ appConfig, integrationTestConfig, }) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!appConfig.projectIntegration) {
+        throw new Error('The app configuration is missing the projectIntegration module.');
+    }
+    const integration = appConfig.projectIntegration;
+    const { getIntegrationFiles } = integrationTestConfig;
+    const expectedTree = getIntegrationFiles.expected;
+    const allFiles = [];
+    const params = {
+        apiCredentials: {},
+        config: {},
+        parentId: '',
+        search: '',
+        page: '0',
+    };
+    const result = yield (0, util_1.assert)(() => integration.getIntegrationFiles(params.apiCredentials, params.config, params.parentId, params.search, params.page), `Fail to run method getIntegrationFiles(), with params ${JSON.stringify(params)}`);
+    if (integration.integrationOneLevelFetching) {
+        const rootLevel = result;
+        const rootLevelExpected = expectedTree.filter((node) => !node.parentId || node.parentId === '0');
+        yield (0, util_1.assert)(() => (0, globals_1.expect)(rootLevel).toHaveLength(rootLevelExpected.length), `Received root files length: ${rootLevel.length}, but expected root tree length: ${rootLevelExpected.length}`);
+        yield (0, util_1.assert)(() => (0, globals_1.expect)(rootLevel).toEqual(globals_1.expect.arrayContaining(rootLevelExpected.map((node) => globals_1.expect.objectContaining(node)))), 'Received root files properties do not match to the expected properties');
+        const isFolder = (node) => {
+            return !('type' in node) || !node.type;
+        };
+        const getAll = (node) => __awaiter(void 0, void 0, void 0, function* () {
+            params.parentId = node.id;
+            const data = (yield (0, util_1.assert)(() => integration.getIntegrationFiles(params.apiCredentials, params.config, params.parentId, params.search, params.page), `Fail to run method getIntegrationFiles(), with params ${JSON.stringify(params)}`));
+            for (const node of data) {
+                if (isFolder(node)) {
+                    yield getAll(node);
+                }
+                allFiles.push(node);
+            }
+        });
+        for (const node of rootLevel) {
+            if (isFolder(node)) {
+                yield getAll(node);
+            }
+            allFiles.push(node);
+        }
+    }
+    else if (integration.integrationPagination) {
+        // Todo. Should be implemented
+    }
+    else {
+        allFiles.push(...result);
+    }
+    yield (0, util_1.assert)(() => (0, globals_1.expect)(allFiles).toHaveLength(expectedTree.length), `Received files length: ${allFiles.length}, but expected tree length ${expectedTree.length}`);
+    yield (0, util_1.assert)(() => (0, globals_1.expect)(allFiles).toEqual(globals_1.expect.arrayContaining(expectedTree.map((node) => globals_1.expect.objectContaining(node)))), 'Received files properties do not match to the expected properties');
+    if (getIntegrationFiles === null || getIntegrationFiles === void 0 ? void 0 : getIntegrationFiles.extraChecks) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
+        // @ts-ignore
+        yield (0, util_1.assert)(() => getIntegrationFiles.extraChecks(), 'ExtraChecks for getIntegrationFiles() fails');
+    }
+});
+exports.getIntegrationFilesTest = getIntegrationFilesTest;

package/out/app-test/integration/index.d.ts

@@ -0,0 +1,15 @@
+import { ClientConfig, Config } from '../../types';
+import { IntegrationTestConfig } from './types';
+export declare const mockProjectId = 1;
+export declare const mockStoragesById: {
+    [key: string]: {
+        name: string;
+        data: unknown;
+    };
+};
+export declare const mockFiles: any[];
+export declare const mockDirectories: any[];
+export declare const runProjectIntegrationTests: ({ getAppConfig, integrationTestConfig, }: {
+    getAppConfig: () => Promise<Config | ClientConfig>;
+    integrationTestConfig: IntegrationTestConfig;
+}) => void;

package/out/app-test/integration/index.js

@@ -0,0 +1,73 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runProjectIntegrationTests = exports.mockDirectories = exports.mockFiles = exports.mockStoragesById = exports.mockProjectId = void 0;
+const globals_1 = require("@jest/globals");
+const mock_axios_1 = require("./mocks/mock-axios");
+const mock_crowdin_api_client_1 = require("./mocks/mock-crowdin-api-client");
+const get_integration_files_1 = require("./get-integration-files");
+const update_crowdin_1 = require("./update-crowdin");
+const update_integration_1 = require("./update-integration");
+// CommonData
+exports.mockProjectId = 1;
+exports.mockStoragesById = {};
+exports.mockFiles = [];
+exports.mockDirectories = [];
+jest.mock('axios', () => mock_axios_1.mockAxios);
+jest.mock('@crowdin/crowdin-api-client', () => jest.fn().mockImplementation(() => mock_crowdin_api_client_1.mockCrowdinApiClient));
+const runProjectIntegrationTests = ({ getAppConfig, integrationTestConfig, }) => {
+    (0, globals_1.describe)('Run integration module tests', () => {
+        var _a, _b, _c;
+        if (!((_a = integrationTestConfig.getIntegrationFiles) === null || _a === void 0 ? void 0 : _a.expected.length)) {
+            throw new Error('Please provide a valid expected files');
+        }
+        beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
+            if (integrationTestConfig === null || integrationTestConfig === void 0 ? void 0 : integrationTestConfig.beforeAll) {
+                yield integrationTestConfig.beforeAll();
+            }
+        }));
+        (0, globals_1.test)('getIntegrationFiles()', () => __awaiter(void 0, void 0, void 0, function* () {
+            var _d;
+            if ((_d = integrationTestConfig.getIntegrationFiles) === null || _d === void 0 ? void 0 : _d.setup) {
+                yield integrationTestConfig.getIntegrationFiles.setup();
+            }
+            const appConfig = yield getAppConfig();
+            yield (0, get_integration_files_1.getIntegrationFilesTest)({ appConfig, integrationTestConfig });
+        }));
+        if (!((_b = integrationTestConfig.updateCrowdin) === null || _b === void 0 ? void 0 : _b.disabled)) {
+            (0, globals_1.test)('updateCrowdin()', () => __awaiter(void 0, void 0, void 0, function* () {
+                var _e;
+                if ((_e = integrationTestConfig.updateCrowdin) === null || _e === void 0 ? void 0 : _e.setup) {
+                    yield integrationTestConfig.updateCrowdin.setup();
+                }
+                const appConfig = yield getAppConfig();
+                yield (0, update_crowdin_1.updateCrowdinTest)({
+                    appConfig,
+                    integrationTestConfig,
+                });
+            }));
+        }
+        if (!((_c = integrationTestConfig.updateIntegration) === null || _c === void 0 ? void 0 : _c.disabled)) {
+            (0, globals_1.test)('updateIntegration()', () => __awaiter(void 0, void 0, void 0, function* () {
+                var _f;
+                if ((_f = integrationTestConfig.updateIntegration) === null || _f === void 0 ? void 0 : _f.setup) {
+                    yield integrationTestConfig.updateIntegration.setup();
+                }
+                const appConfig = yield getAppConfig();
+                yield (0, update_integration_1.updateIntegrationTest)({
+                    appConfig,
+                    integrationTestConfig,
+                });
+            }));
+        }
+    });
+};
+exports.runProjectIntegrationTests = runProjectIntegrationTests;

package/out/app-test/integration/mocks/crowdin-storage.d.ts

@@ -0,0 +1,35 @@
+import { SourceFilesModel } from '@crowdin/crowdin-api-client';
+import { ClientConfig, Config } from '../../../types';
+export declare const crowdinFolders: {
+    create: (params: SourceFilesModel.CreateDirectoryRequest) => {
+        data: {
+            id: number;
+            path: string;
+            branchId?: number | undefined;
+            directoryId?: number | undefined;
+            name: string;
+            title?: string | undefined;
+            exportPattern?: string | undefined;
+            priority?: SourceFilesModel.Priority | undefined;
+        };
+    };
+};
+export declare const crowdinFiles: {
+    create: (params: SourceFilesModel.CreateFileRequest) => {
+        data: {
+            id: number;
+            path: string;
+            storageId: number;
+            name: string;
+            branchId?: number | undefined;
+            directoryId?: number | undefined;
+            title?: string | undefined;
+            type?: SourceFilesModel.FileType | undefined;
+            importOptions?: SourceFilesModel.SpreadsheetImportOptions | SourceFilesModel.XmlImportOptions | SourceFilesModel.OtherImportOptions | SourceFilesModel.DocxFileImportOptions | undefined;
+            exportOptions?: SourceFilesModel.GeneralExportOptions | SourceFilesModel.PropertyExportOptions | undefined;
+            attachLabelIds?: number[] | undefined;
+            excludedTargetLanguages?: string[] | undefined;
+        };
+    };
+};
+export declare const getRootFolder: (appConfig: Config | ClientConfig) => SourceFilesModel.Directory | undefined;

package/out/app-test/integration/mocks/crowdin-storage.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRootFolder = exports.crowdinFiles = exports.crowdinFolders = void 0;
+const index_1 = require("../index");
+const getNewFileOrFolderId = () => index_1.mockFiles.length + index_1.mockDirectories.length + 1;
+const getFullPath = (parentId) => {
+    const folder = index_1.mockDirectories.find(({ id }) => id === parentId);
+    return (folder === null || folder === void 0 ? void 0 : folder.path) ? folder.path : '';
+};
+exports.crowdinFolders = {
+    create: (params) => {
+        const parentPath = params.directoryId ? getFullPath(params.directoryId) : '';
+        const data = Object.assign(Object.assign({}, params), { id: getNewFileOrFolderId(), path: `${parentPath}/${params.name}` });
+        index_1.mockDirectories.push(data);
+        return {
+            data,
+        };
+    },
+};
+exports.crowdinFiles = {
+    create: (params) => {
+        const parentPath = params.directoryId ? getFullPath(params.directoryId) : '';
+        const data = Object.assign(Object.assign({}, params), { id: getNewFileOrFolderId(), path: `${parentPath}/${params.name}` });
+        index_1.mockFiles.push(data);
+        return {
+            data,
+        };
+    },
+};
+const getRootFolder = (appConfig) => {
+    var _a;
+    return ((_a = appConfig.projectIntegration) === null || _a === void 0 ? void 0 : _a.withRootFolder)
+        ? {
+            id: 1,
+            projectId: index_1.mockProjectId,
+            branchId: 1,
+            directoryId: 0,
+            name: appConfig.name,
+            title: '',
+            exportPattern: '',
+            priority: 'normal',
+            createdAt: '',
+            updatedAt: '',
+        }
+        : undefined;
+};
+exports.getRootFolder = getRootFolder;

package/out/app-test/integration/mocks/mock-axios.d.ts

@@ -0,0 +1 @@
+export declare const mockAxios: any;

package/out/app-test/integration/mocks/mock-axios.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockAxios = void 0;
+const index_1 = require("../index");
+const mockOriginalAxios = jest.requireActual('axios');
+const mock = Object.assign(Object.assign({}, mockOriginalAxios), { get: jest.fn((url) => {
+        expect(url).toMatch(/^file-id:(\d+)$/);
+        const fileId = Number(url.replace('file-id:', ''));
+        const file = index_1.mockFiles.find(({ id }) => id === fileId);
+        const storageId = file === null || file === void 0 ? void 0 : file.storageId;
+        expect(storageId).not.toBeUndefined();
+        return {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
+            // @ts-ignore
+            data: index_1.mockStoragesById[storageId].data,
+        };
+    }) });
+exports.mockAxios = Object.assign(Object.assign({}, mock), { default: Object.assign({ create: () => (Object.assign({}, mock)) }, mock) });

package/out/app-test/integration/mocks/mock-crowdin-api-client.d.ts

@@ -0,0 +1 @@
+export declare const mockCrowdinApiClient: any;

package/out/app-test/integration/mocks/mock-crowdin-api-client.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockCrowdinApiClient = void 0;
+const globals_1 = require("@jest/globals");
+const index_1 = require("../index");
+const listSupportedLanguagesResponse = __importStar(require("../../crowdin-responses/mock-list-supported-languages.json"));
+const getProjectResponse = __importStar(require("../../crowdin-responses/mock-get-project.json"));
+const crowdin_storage_1 = require("./crowdin-storage");
+const sleep = () => __awaiter(void 0, void 0, void 0, function* () {
+    const min = 10;
+    const max = 50;
+    return new Promise((resovle) => {
+        setTimeout(() => {
+            resovle();
+        }, Math.floor(Math.random() * (max - min) + min));
+    });
+});
+const mockBuildProjectFileTranslation = jest.fn((projectId, fileId) => __awaiter(void 0, void 0, void 0, function* () {
+    (0, globals_1.expect)(projectId).toBe(index_1.mockProjectId);
+    yield sleep();
+    return {
+        data: {
+            url: `file-id:${fileId}`,
+        },
+    };
+}));
+const mockTranslationsApi = {
+    buildProjectFileTranslation: mockBuildProjectFileTranslation,
+};
+const mockUploadStorageApi = {
+    addStorage: (fileName, request) => __awaiter(void 0, void 0, void 0, function* () {
+        const id = Object.keys(index_1.mockStoragesById).length + 1; // 1
+        index_1.mockStoragesById[id] = {
+            name: fileName,
+            data: request,
+        };
+        yield sleep();
+        return {
+            data: {
+                id,
+            },
+        };
+    }),
+};
+const mockLanguagesApi = {
+    withFetchAll: () => {
+        return {
+            listSupportedLanguages: () => {
+                return listSupportedLanguagesResponse;
+            },
+        };
+    },
+};
+const mockProjectsGroupsApi = {
+    getProject: function mockResponse() {
+        return getProjectResponse;
+    },
+};
+const mockCreateDirectory = jest.fn((projectId, params) => __awaiter(void 0, void 0, void 0, function* () {
+    (0, globals_1.expect)(projectId).toBe(index_1.mockProjectId);
+    yield sleep();
+    return crowdin_storage_1.crowdinFolders.create(params);
+}));
+const mockCreateFile = jest.fn((projectId, params) => __awaiter(void 0, void 0, void 0, function* () {
+    (0, globals_1.expect)(projectId).toBe(index_1.mockProjectId);
+    yield sleep();
+    return crowdin_storage_1.crowdinFiles.create(params);
+}));
+const mockListProjectDirectories = jest.fn((projectId) => __awaiter(void 0, void 0, void 0, function* () {
+    (0, globals_1.expect)(projectId).toBe(index_1.mockProjectId);
+    return {
+        // data: options ? [] : mockDirectories.map((d: SourceFilesModel.Directory) => ({ data: d })),
+        data: index_1.mockDirectories.map((d) => ({ data: d })),
+        pagination: {
+            offset: 0,
+            limit: 0,
+        },
+    };
+}));
+const mockListProjectFiles = jest.fn((projectId) => __awaiter(void 0, void 0, void 0, function* () {
+    (0, globals_1.expect)(projectId).toBe(index_1.mockProjectId);
+    return {
+        data: index_1.mockFiles.map((d) => ({ data: d })),
+        pagination: {
+            offset: 0,
+            limit: 0,
+        },
+    };
+}));
+const mockOriginalClient = jest.requireActual('@crowdin/crowdin-api-client');
+exports.mockCrowdinApiClient = Object.assign(Object.assign({}, mockOriginalClient), { sourceFilesApi: {
+        withFetchAll: () => {
+            return {
+                listProjectDirectories: mockListProjectDirectories,
+                listProjectFiles: mockListProjectFiles,
+            };
+        },
+        createDirectory: mockCreateDirectory,
+        createFile: mockCreateFile,
+    }, projectsGroupsApi: mockProjectsGroupsApi, languagesApi: mockLanguagesApi, translationsApi: mockTranslationsApi, uploadStorageApi: mockUploadStorageApi });

package/out/app-test/integration/types.d.ts

@@ -0,0 +1,41 @@
+import { IntegrationFile, TreeItem, UpdateIntegrationRequest } from '../../modules/integration/types';
+export interface ExpectedObject {
+    [key: string]: unknown;
+}
+export interface ExpectedUpdateCrowdin {
+    files?: ExpectedObject[];
+    folders?: ExpectedObject[];
+}
+export interface BaseMethodTestConfig {
+    disabled?: boolean;
+    setup?: () => Promise<void>;
+    extraChecks?: (params?: any) => Promise<void>;
+}
+export interface GetIntegrationFilesConfig extends Omit<BaseMethodTestConfig, 'disabled'> {
+    expected: TreeItem[];
+}
+export interface UpdateCrowdinConfig extends Partial<BaseMethodTestConfig> {
+    updateProgressDisabled?: boolean;
+    expected?: ExpectedUpdateCrowdin;
+    updateRequest?: IntegrationFile[];
+    extraChecks?: (params: {
+        request: IntegrationFile[];
+        result?: unknown;
+    }) => Promise<void>;
+}
+export interface UpdateIntegrationConfig extends BaseMethodTestConfig {
+    updateProgressDisabled?: boolean;
+    updateRequest?: UpdateIntegrationRequest;
+    extraChecks?: (params: {
+        request: UpdateIntegrationRequest;
+        result?: unknown;
+    }) => Promise<void>;
+}
+export interface IntegrationTestConfig {
+    getIntegrationFiles: GetIntegrationFilesConfig;
+    updateCrowdin?: UpdateCrowdinConfig;
+    updateIntegration?: UpdateIntegrationConfig;
+    appSettings?: object;
+    integrationCredentials?: object;
+    beforeAll?: () => Promise<void>;
+}

package/out/app-test/integration/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/out/app-test/integration/update-crowdin.d.ts

@@ -0,0 +1,6 @@
+import { ClientConfig, Config } from '../../types';
+import { IntegrationTestConfig } from './types';
+export declare const updateCrowdinTest: ({ appConfig, integrationTestConfig, }: {
+    appConfig: Config | ClientConfig;
+    integrationTestConfig: IntegrationTestConfig;
+}) => Promise<void>;

package/out/app-test/integration/update-crowdin.js

@@ -0,0 +1,137 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateCrowdinTest = void 0;
+const globals_1 = require("@jest/globals");
+const crowdin_api_client_1 = __importDefault(require("@crowdin/crowdin-api-client"));
+const types_1 = require("../../modules/integration/util/types");
+const index_1 = require("./index");
+const crowdin_storage_1 = require("./mocks/crowdin-storage");
+const util_1 = require("../util");
+const getParents = (node, expectedTree, parentNames = []) => {
+    if (node.parentId) {
+        const parent = expectedTree.find(({ id }) => id === node.parentId);
+        if (parent) {
+            parentNames.unshift(parent.name);
+            return getParents(parent, expectedTree, parentNames);
+        }
+    }
+    return parentNames;
+};
+const getExpectedFolders = ({ integrationTestConfig, expectedTree, updateRequest, }) => {
+    var _a, _b;
+    if ((_b = (_a = integrationTestConfig.updateCrowdin) === null || _a === void 0 ? void 0 : _a.expected) === null || _b === void 0 ? void 0 : _b.folders) {
+        return integrationTestConfig.updateCrowdin.expected.folders;
+    }
+    const expectedDirectoriesByPath = {};
+    updateRequest.forEach((node) => {
+        const parentNames = getParents(node, expectedTree);
+        if (parentNames.length) {
+            const fullPath = `/${parentNames.join('/')}`;
+            expectedDirectoriesByPath[fullPath] = { path: fullPath, name: parentNames.pop() || '' };
+        }
+    });
+    return Object.values(expectedDirectoriesByPath);
+};
+const getExpectedFiles = ({ integrationTestConfig, expectedTree, updateRequest, }) => {
+    var _a, _b;
+    if ((_b = (_a = integrationTestConfig.updateCrowdin) === null || _a === void 0 ? void 0 : _a.expected) === null || _b === void 0 ? void 0 : _b.files) {
+        return integrationTestConfig.updateCrowdin.expected.files;
+    }
+    const expectedFilesByPath = {};
+    updateRequest.forEach((node) => {
+        const parentNames = getParents(node, expectedTree);
+        parentNames.push(`${node.name}.${node.type}`);
+        const fullPath = `/${parentNames.join('/')}`;
+        expectedFilesByPath[fullPath] = { path: fullPath, name: parentNames.pop() || '' };
+    });
+    return Object.values(expectedFilesByPath);
+};
+const getFilesFromTree = (tree) => {
+    return tree
+        .filter((item) => 'type' in item)
+        .filter(({ type }) => type)
+        .map((file) => file);
+};
+const updateCrowdinTest = ({ appConfig, integrationTestConfig, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { updateCrowdin, appSettings, integrationCredentials: credentials } = integrationTestConfig;
+    const expectedTree = integrationTestConfig.getIntegrationFiles.expected;
+    if (!appConfig.projectIntegration) {
+        throw new Error('The app configuration is missing the projectIntegration module.');
+    }
+    const client = new crowdin_api_client_1.default({ token: 'fakeToken' });
+    const request = getFilesFromTree(expectedTree);
+    const updateProgressMock = jest.fn(() => __awaiter(void 0, void 0, void 0, function* () {
+        return { isCanceled: false };
+    }));
+    const rootFolder = (0, crowdin_storage_1.getRootFolder)(appConfig);
+    if (rootFolder) {
+        index_1.mockDirectories.push(rootFolder);
+    }
+    const result = yield (0, util_1.assert)(() => {
+        var _a;
+        return (_a = appConfig.projectIntegration) === null || _a === void 0 ? void 0 : _a.updateCrowdin({
+            projectId: index_1.mockProjectId,
+            client,
+            credentials,
+            request,
+            rootFolder,
+            appSettings,
+            uploadTranslations: false,
+            job: {
+                get: function getJob() {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        return {
+                            id: 'jobId1',
+                            integrationId: 'string',
+                            crowdinId: 'string',
+                            type: types_1.JobType.UPDATE_TO_CROWDIN,
+                            title: 'Sync files to Crowdin',
+                            progress: 0,
+                            status: types_1.JobStatus.CREATED,
+                            createdAt: 0,
+                        };
+                    });
+                },
+                update: updateProgressMock,
+            },
+        });
+    }, 'Fail to run method updateCrowdin()');
+    if (!(updateCrowdin === null || updateCrowdin === void 0 ? void 0 : updateCrowdin.updateProgressDisabled)) {
+        yield (0, util_1.assert)(() => (0, globals_1.expect)(updateProgressMock.mock.calls.length).toBeGreaterThanOrEqual(request.length), 'The sync progress should be updated at least once for each file in request');
+    }
+    const expectedFiles = getExpectedFiles({
+        integrationTestConfig,
+        expectedTree,
+        updateRequest: request,
+    });
+    yield (0, util_1.assert)(() => (0, globals_1.expect)(index_1.mockFiles).toHaveLength(expectedFiles.length), `Files created: ${index_1.mockFiles.length}, but expected: ${expectedFiles.length}`);
+    yield (0, util_1.assert)(() => (0, globals_1.expect)(index_1.mockFiles).toEqual(globals_1.expect.arrayContaining(expectedFiles.map((f) => globals_1.expect.objectContaining(f)))), 'The properties of the created files do not match to the expected');
+    const expectedDirectories = getExpectedFolders({
+        integrationTestConfig,
+        expectedTree,
+        updateRequest: request,
+    });
+    const createdDirectories = rootFolder
+        ? index_1.mockDirectories.filter(({ id }) => rootFolder && id !== rootFolder.id)
+        : index_1.mockDirectories;
+    yield (0, util_1.assert)(() => (0, globals_1.expect)(createdDirectories).toHaveLength(expectedDirectories.length), `Directories created: ${createdDirectories.length}, but expected: ${expectedDirectories.length}`);
+    yield (0, util_1.assert)(() => (0, globals_1.expect)(createdDirectories).toEqual(globals_1.expect.arrayContaining(expectedDirectories.map((f) => globals_1.expect.objectContaining(f)))), 'The properties of the created directories do not match to the expected');
+    if (updateCrowdin === null || updateCrowdin === void 0 ? void 0 : updateCrowdin.extraChecks) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
+        // @ts-ignore
+        yield (0, util_1.assert)(() => updateCrowdin.extraChecks({ request, result }), 'ExtraChecks for updateCrowdin() fails');
+    }
+});
+exports.updateCrowdinTest = updateCrowdinTest;

package/out/app-test/integration/update-integration.d.ts

@@ -0,0 +1,8 @@
+import { ClientConfig, Config } from '../../types';
+import { UpdateIntegrationRequest } from '../../modules/integration/types';
+import { IntegrationTestConfig } from './types';
+export declare const getUpdateIntegrationRequest: () => UpdateIntegrationRequest;
+export declare const updateIntegrationTest: ({ appConfig, integrationTestConfig, }: {
+    appConfig: Config | ClientConfig;
+    integrationTestConfig: IntegrationTestConfig;
+}) => Promise<void>;