smartling-api-sdk-nodejs 3.3.0 → 3.4.0

package/built/test/translation-memory.spec.js

@@ -0,0 +1,712 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const sinon_1 = __importDefault(require("sinon"));
+const assert_1 = __importDefault(require("assert"));
+const mock_1 = require("./mock");
+const index_1 = require("../api/translation-memory/index");
+const import_tmx_file_parameters_1 = require("../api/translation-memory/params/import-tmx-file-parameters");
+const escape_smp_unicode_parser_directive_1 = require("../api/translation-memory/params/escape-smp-unicode-parser-directive");
+const create_string_search_filter_parameters_1 = require("../api/translation-memory/params/create-string-search-filter-parameters");
+const bulk_export_tm_strings_parameters_1 = require("../api/translation-memory/params/bulk-export-tm-strings-parameters");
+const extended_export_metadata_type_1 = require("../api/translation-memory/params/extended-export-metadata-type");
+const create_tm_parameters_1 = require("../api/translation-memory/params/create-tm-parameters");
+const update_tm_parameters_1 = require("../api/translation-memory/params/update-tm-parameters");
+const translation_quality_type_1 = require("../api/translation-memory/params/translation-quality-type");
+const leverage_type_1 = require("../api/translation-memory/params/leverage-type");
+const source_type_1 = require("../api/translation-memory/params/source-type");
+const tu_translation_quality_type_1 = require("../api/translation-memory/params/tu-translation-quality-type");
+const keyword_search_type_1 = require("../api/translation-memory/params/keyword-search-type");
+const index_2 = require("../api/exception/index");
+const stream_to_string_1 = require("./stream-to-string");
+function formDataText(formData) {
+    return formData._streams.filter((entry) => typeof entry === "string").join("");
+}
+const noRequestIdHeaders = { get: () => null };
+function tmGraphQlResponseMock(operationName, tm) {
+    return {
+        status: 200,
+        headers: noRequestIdHeaders,
+        text: () => __awaiter(this, void 0, void 0, function* () {
+            return JSON.stringify({
+                data: {
+                    [operationName]: tm
+                }
+            });
+        })
+    };
+}
+const sampleTm = {
+    tmUid: "j45v1uvsi3tx",
+    name: "Integration test TM",
+    description: "Created by the SDK test suite",
+    sourceLocaleId: "en-US",
+    sourceLocale: {
+        localeId: "en-US",
+        localeDescription: "English (United States)",
+        rtlLanguage: false,
+        wordSpacing: true
+    },
+    creator: { userUid: "creatorUid", name: "Creator Name" },
+    created: "2026-06-17T00:09:44Z",
+    lastModifier: { userUid: "modifierUid", name: "Modifier Name" },
+    lastModified: "2026-06-17T00:09:44Z",
+    localeSummary: [],
+    translationQuality: "TRANSLATION",
+    managedWordsEnabled: false
+};
+describe("SmartlingTranslationMemoryApi class tests.", () => {
+    const accountUid = "testAccountUid";
+    let translationMemoryApi;
+    let fetchStub;
+    let uaStub;
+    let responseMockJsonStub;
+    beforeEach(() => {
+        translationMemoryApi = new index_1.SmartlingTranslationMemoryApi("https://test.com", mock_1.authMock, mock_1.loggerMock);
+        fetchStub = sinon_1.default.stub(translationMemoryApi, "fetch");
+        uaStub = sinon_1.default.stub(translationMemoryApi, "ua");
+        responseMockJsonStub = sinon_1.default.stub(mock_1.responseMock, "json");
+        uaStub.returns("test_user_agent");
+        fetchStub.returns(mock_1.responseMock);
+        responseMockJsonStub.returns({ response: {} });
+    });
+    afterEach(() => {
+        fetchStub.restore();
+        responseMockJsonStub.restore();
+        uaStub.restore();
+    });
+    describe("Methods", () => {
+        it("Import TMX file", () => __awaiter(void 0, void 0, void 0, function* () {
+            const params = new import_tmx_file_parameters_1.ImportTmxFileParameters()
+                .setFileFromLocalFilePath("./test/data/file.xml")
+                .setFileUri("test/file.tmx")
+                .setTmUid("j45v1uvsi3tx")
+                .setDescription("Integration test import")
+                .setTranslatorNameLocation("@tu.changeid")
+                .setTranslationDateLocation("@tu.creationdate")
+                .setVariantLocation("@prop.type.x-SID:SingleString")
+                .setFileUriLocation("@prop.type.x-idiom-source-ipath")
+                .setEscapeSmpUnicodeParserDirective(escape_smp_unicode_parser_directive_1.EscapeSmpUnicodeParserDirective.ON);
+            yield translationMemoryApi.importTmxFile(accountUid, params);
+            sinon_1.default.assert.calledOnce(fetchStub);
+            assert_1.default.equal(fetchStub.getCall(0).args[0], `https://test.com/tm-tmx-api/v2/accounts/${accountUid}/tmx/file`);
+            assert_1.default.equal(fetchStub.getCall(0).args[1].method, "post");
+            assert_1.default.equal(fetchStub.getCall(0).args[1].headers.Authorization, "test_token_type test_access_token");
+            assert_1.default.equal(yield (0, stream_to_string_1.streamToString)(fetchStub.getCall(0).args[1].body._streams[1]), fs.readFileSync(fs.realpathSync("./test/data/file.xml"), "utf8"));
+            const fields = formDataText(fetchStub.getCall(0).args[1].body);
+            assert_1.default.ok(fields.includes("name=\"file\""));
+            assert_1.default.ok(fields.includes("name=\"fileUri\"") && fields.includes("test/file.tmx"));
+            assert_1.default.ok(fields.includes("name=\"tmUid\"") && fields.includes("j45v1uvsi3tx"));
+            assert_1.default.ok(fields.includes("name=\"description\"") && fields.includes("Integration test import"));
+            assert_1.default.ok(fields.includes("name=\"translatorNameLocation\"") && fields.includes("@tu.changeid"));
+            assert_1.default.ok(fields.includes("name=\"translationDateLocation\"") && fields.includes("@tu.creationdate"));
+            assert_1.default.ok(fields.includes("name=\"variantLocation\"") && fields.includes("@prop.type.x-SID:SingleString"));
+            assert_1.default.ok(fields.includes("name=\"fileUriLocation\"") && fields.includes("@prop.type.x-idiom-source-ipath"));
+            assert_1.default.ok(fields.includes("name=\"escapeSmpUnicodeParserDirective\"") && fields.includes("on"));
+        }));
+        it("Import TMX file: as string", () => __awaiter(void 0, void 0, void 0, function* () {
+            const params = new import_tmx_file_parameters_1.ImportTmxFileParameters()
+                .setFileContent(fs.readFileSync(fs.realpathSync("./test/data/file.xml"), "utf8"))
+                .setFileUri("test/file.tmx")
+                .setTmUid("j45v1uvsi3tx");
+            yield translationMemoryApi.importTmxFile(accountUid, params);
+            sinon_1.default.assert.calledOnce(fetchStub);
+            assert_1.default.equal(yield (0, stream_to_string_1.streamToString)(fetchStub.getCall(0).args[1].body._streams[1]), fs.readFileSync(fs.realpathSync("./test/data/file.xml"), "utf8"));
+        }));
+        it("Import TMX file: from buffer", () => __awaiter(void 0, void 0, void 0, function* () {
+            const fileBuffer = fs.readFileSync(fs.realpathSync("./test/data/file.xml"));
+            const params = new import_tmx_file_parameters_1.ImportTmxFileParameters()
+                .setFileContentFromBuffer(fileBuffer)
+                .setFileUri("test/file.tmx")
+                .setTmUid("j45v1uvsi3tx");
+            yield translationMemoryApi.importTmxFile(accountUid, params);
+            sinon_1.default.assert.calledOnce(fetchStub);
+            assert_1.default.ok(fetchStub.getCall(0).args[1].body._streams[1].equals(fileBuffer));
+        }));
+        it("Import TMX file: FormData body is not reconverted on a 401 retry", () => __awaiter(void 0, void 0, void 0, function* () {
+            const params = new import_tmx_file_parameters_1.ImportTmxFileParameters()
+                .setFileFromLocalFilePath("./test/data/file.xml")
+                .setFileUri("test/file.tmx")
+                .setTmUid("j45v1uvsi3tx");
+            fetchStub.onCall(0).returns({ status: 401 });
+            fetchStub.onCall(1).returns(mock_1.responseMock);
+            yield translationMemoryApi.importTmxFile(accountUid, params);
+            sinon_1.default.assert.calledTwice(fetchStub);
+            assert_1.default.strictEqual(fetchStub.getCall(0).args[1].body, fetchStub.getCall(1).args[1].body);
+            assert_1.default.equal(yield (0, stream_to_string_1.streamToString)(fetchStub.getCall(1).args[1].body._streams[1]), fs.readFileSync(fs.realpathSync("./test/data/file.xml"), "utf8"));
+        }));
+        it("Import TMX file: warns when the response has partial import errors", () => __awaiter(void 0, void 0, void 0, function* () {
+            const warnStub = sinon_1.default.stub(mock_1.loggerMock, "warn");
+            fetchStub.returns({
+                status: 200,
+                text: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return JSON.stringify({
+                        response: {
+                            data: {
+                                message: null,
+                                wordCount: 10,
+                                stringCount: 5,
+                                translationMemoryImportErrors: [
+                                    { messages: ["bad string"], line: 3, column: 1 }
+                                ],
+                                parsingErrors: null,
+                                jobUid: "job-1",
+                                tmxUid: "tmx-1"
+                            }
+                        }
+                    });
+                })
+            });
+            const params = new import_tmx_file_parameters_1.ImportTmxFileParameters()
+                .setFileContentFromBuffer(Buffer.from("<tmx/>"))
+                .setFileUri("test/file.tmx")
+                .setTmUid("j45v1uvsi3tx");
+            const result = yield translationMemoryApi.importTmxFile(accountUid, params);
+            assert_1.default.equal(result.jobUid, "job-1");
+            assert_1.default.equal(result.tmxUid, "tmx-1");
+            assert_1.default.equal(result.wordCount, 10);
+            assert_1.default.equal(result.stringCount, 5);
+            sinon_1.default.assert.calledOnce(warnStub);
+            assert_1.default.ok(warnStub.getCall(0).args[0].includes("bad string"));
+            warnStub.restore();
+        }));
+        it("Import TMX file: does not warn when error arrays are merely empty", () => __awaiter(void 0, void 0, void 0, function* () {
+            const warnStub = sinon_1.default.stub(mock_1.loggerMock, "warn");
+            fetchStub.returns({
+                status: 200,
+                text: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return JSON.stringify({
+                        response: {
+                            data: {
+                                message: null,
+                                wordCount: 10,
+                                stringCount: 5,
+                                translationMemoryImportErrors: [],
+                                parsingErrors: [],
+                                jobUid: "job-1",
+                                tmxUid: "tmx-1"
+                            }
+                        }
+                    });
+                })
+            });
+            const params = new import_tmx_file_parameters_1.ImportTmxFileParameters()
+                .setFileContentFromBuffer(Buffer.from("<tmx/>"))
+                .setFileUri("test/file.tmx")
+                .setTmUid("j45v1uvsi3tx");
+            yield translationMemoryApi.importTmxFile(accountUid, params);
+            sinon_1.default.assert.notCalled(warnStub);
+            warnStub.restore();
+        }));
+        it("Download TMX file", () => __awaiter(void 0, void 0, void 0, function* () {
+            const downloadResponseMock = {
+                status: 200,
+                headers: {
+                    get: (name) => {
+                        if (name === "content-type") {
+                            return "application/xml";
+                        }
+                        if (name === "content-disposition") {
+                            return "attachment; filename=\"export.tmx\"";
+                        }
+                        return null;
+                    }
+                },
+                arrayBuffer: () => __awaiter(void 0, void 0, void 0, function* () { return new ArrayBuffer(8); })
+            };
+            fetchStub.returns(downloadResponseMock);
+            const result = yield translationMemoryApi.downloadTmxFile(accountUid, "a+b/c==");
+            sinon_1.default.assert.calledOnceWithExactly(fetchStub, `https://test.com/tm-tmx-api/v2/accounts/${accountUid}/tmx/file/a%2Bb%2Fc%3D%3D`, {
+                method: "get",
+                headers: {
+                    Authorization: "test_token_type test_access_token",
+                    "Content-Type": "application/json",
+                    "User-Agent": "test_user_agent"
+                }
+            });
+            assert_1.default.equal(result.fileName, "export.tmx");
+            assert_1.default.equal(result.contentType, "application/xml");
+        }));
+        it("Create string search", () => __awaiter(void 0, void 0, void 0, function* () {
+            const graphQlResponseMock = {
+                status: 200,
+                headers: noRequestIdHeaders,
+                text: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return JSON.stringify({
+                        data: {
+                            createStringSearch: {
+                                searchUid: "2z68632hdvw2",
+                                stringCount: 10,
+                                wordCount: 20,
+                                duplicateStrings: [],
+                                duplicateSearch: false,
+                                actionUid: "d23eb702-7358-11ea-bc55-0242ac130003",
+                                offlineReportUid: "6a2f41a3-c54c-fce8-32d2-0324e1c32e22"
+                            }
+                        }
+                    });
+                })
+            };
+            fetchStub.returns(graphQlResponseMock);
+            const filter = new create_string_search_filter_parameters_1.CreateStringSearchFilterParameters()
+                .setTmUids(["j45v1uvsi3tx"])
+                .setSourceLocaleIds(["en-US"]);
+            const result = yield translationMemoryApi.createStringSearch(accountUid, filter);
+            sinon_1.default.assert.calledOnce(fetchStub);
+            assert_1.default.equal(fetchStub.getCall(0).args[0], `https://test.com/tm-graphql-api/v2/accounts/${accountUid}/graphql`);
+            const sentBody = JSON.parse(fetchStub.getCall(0).args[1].body);
+            assert_1.default.deepEqual(sentBody.variables, {
+                createStringSearchFilter: {
+                    tmUids: ["j45v1uvsi3tx"],
+                    sourceLocaleIds: ["en-US"]
+                }
+            });
+            assert_1.default.ok(sentBody.query.includes("createStringSearch"));
+            [
+                "searchUid", "stringCount", "wordCount", "duplicateStrings", "duplicateKey",
+                "count", "srcText", "srcLocale", "translationLocale", "duplicateSearch",
+                "actionUid", "offlineReportUid"
+            ].forEach((field) => {
+                assert_1.default.ok(sentBody.query.includes(field), `query is missing field "${field}"`);
+            });
+            assert_1.default.equal(result.searchUid, "2z68632hdvw2");
+            assert_1.default.equal(result.stringCount, 10);
+        }));
+        it("Create string search: GraphQL error is thrown", () => __awaiter(void 0, void 0, void 0, function* () {
+            const graphQlResponseMock = {
+                status: 200,
+                headers: noRequestIdHeaders,
+                text: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return JSON.stringify({
+                        errors: [{ message: "tmUids is required" }]
+                    });
+                })
+            };
+            fetchStub.returns(graphQlResponseMock);
+            yield assert_1.default.rejects(translationMemoryApi.createStringSearch(accountUid, new create_string_search_filter_parameters_1.CreateStringSearchFilterParameters()), (e) => {
+                assert_1.default.ok(e instanceof index_2.SmartlingException);
+                assert_1.default.ok(e.message.includes("tmUids is required"));
+                assert_1.default.deepEqual(e.getPayload().errors, [{ message: "tmUids is required" }]);
+                return true;
+            });
+        }));
+        it("Create string search: an empty errors array does not throw", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.returns({
+                status: 200,
+                headers: noRequestIdHeaders,
+                text: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return JSON.stringify({
+                        errors: [],
+                        data: { createStringSearch: { searchUid: "2z68632hdvw2" } }
+                    });
+                })
+            });
+            const result = yield translationMemoryApi.createStringSearch(accountUid, new create_string_search_filter_parameters_1.CreateStringSearchFilterParameters());
+            assert_1.default.equal(result.searchUid, "2z68632hdvw2");
+        }));
+        it("Create string search: a null result is returned as null, not thrown", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.returns({
+                status: 200,
+                headers: noRequestIdHeaders,
+                text: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return JSON.stringify({
+                        data: { createStringSearch: null }
+                    });
+                })
+            });
+            const result = yield translationMemoryApi.createStringSearch(accountUid, new create_string_search_filter_parameters_1.CreateStringSearchFilterParameters());
+            assert_1.default.equal(result, null);
+        }));
+        it("Create string search: requestId is propagated into the thrown exception", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.returns({
+                status: 200,
+                headers: { get: (name) => (name === "x-sl-requestid" ? "test-request-id" : null) },
+                text: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return JSON.stringify({
+                        errors: [{ message: "tmUids is required" }]
+                    });
+                })
+            });
+            yield assert_1.default.rejects(translationMemoryApi.createStringSearch(accountUid, new create_string_search_filter_parameters_1.CreateStringSearchFilterParameters()), (e) => {
+                assert_1.default.equal(e.getPayload().requestId, "test-request-id");
+                return true;
+            });
+        }));
+        it("Create string search: malformed JSON response throws", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.returns({
+                status: 200,
+                headers: noRequestIdHeaders,
+                text: () => __awaiter(void 0, void 0, void 0, function* () { return "not json"; })
+            });
+            yield assert_1.default.rejects(translationMemoryApi.createStringSearch(accountUid, new create_string_search_filter_parameters_1.CreateStringSearchFilterParameters()), (e) => {
+                assert_1.default.ok(e instanceof index_2.SmartlingException);
+                assert_1.default.ok(e.message.includes("Couldn't parse GraphQL response json"));
+                assert_1.default.ok(e.getNestedException() instanceof Error);
+                return true;
+            });
+        }));
+        it("Create string search: response missing data entirely throws", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.returns({
+                status: 200,
+                headers: noRequestIdHeaders,
+                text: () => __awaiter(void 0, void 0, void 0, function* () { return JSON.stringify({}); })
+            });
+            yield assert_1.default.rejects(translationMemoryApi.createStringSearch(accountUid, new create_string_search_filter_parameters_1.CreateStringSearchFilterParameters()), (e) => {
+                assert_1.default.ok(e instanceof index_2.SmartlingException);
+                assert_1.default.ok(e.message.includes("is missing the expected field"));
+                return true;
+            });
+        }));
+        it("Create string search: data present but missing the operation's own key throws", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.returns({
+                status: 200,
+                headers: noRequestIdHeaders,
+                text: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return JSON.stringify({
+                        data: { someOtherOperation: { searchUid: "abc" } }
+                    });
+                })
+            });
+            yield assert_1.default.rejects(translationMemoryApi.createStringSearch(accountUid, new create_string_search_filter_parameters_1.CreateStringSearchFilterParameters()), (e) => {
+                assert_1.default.ok(e instanceof index_2.SmartlingException);
+                assert_1.default.ok(e.message.includes("is missing the expected field"));
+                return true;
+            });
+        }));
+        it("Create string search: a non-array errors field logs a warning and does not throw", () => __awaiter(void 0, void 0, void 0, function* () {
+            const warnStub = sinon_1.default.stub(mock_1.loggerMock, "warn");
+            fetchStub.returns({
+                status: 200,
+                headers: noRequestIdHeaders,
+                text: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return JSON.stringify({
+                        errors: { message: "unexpected shape" },
+                        data: { createStringSearch: { searchUid: "2z68632hdvw2" } }
+                    });
+                })
+            });
+            const result = yield translationMemoryApi.createStringSearch(accountUid, new create_string_search_filter_parameters_1.CreateStringSearchFilterParameters());
+            assert_1.default.ok(result);
+            assert_1.default.equal(result.searchUid, "2z68632hdvw2");
+            sinon_1.default.assert.calledOnce(warnStub);
+            assert_1.default.ok(warnStub.getCall(0).args[0].includes("unexpected"));
+            warnStub.restore();
+        }));
+        it("Bulk export TM strings", () => __awaiter(void 0, void 0, void 0, function* () {
+            const graphQlResponseMock = {
+                status: 200,
+                headers: noRequestIdHeaders,
+                text: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return JSON.stringify({
+                        data: {
+                            bulkExportTmStrings: {
+                                actionUid: "d23eb702-7358-11ea-bc55-0242ac130003",
+                                totalCount: 123,
+                                processedCount: 0,
+                                errorCount: 0,
+                                executionComplete: false,
+                                actionStatus: "QUEUEING"
+                            }
+                        }
+                    });
+                })
+            };
+            fetchStub.returns(graphQlResponseMock);
+            const params = new bulk_export_tm_strings_parameters_1.BulkExportTmStringsParameters()
+                .setSearchUid("2z68632hdvw2")
+                .setExtendedMetadata(true)
+                .setExtendedMetadataType(extended_export_metadata_type_1.ExtendedExportMetadataType.FIRST_TRANSLATED_STRINGS)
+                .setIncludeAllVariants(true);
+            const result = yield translationMemoryApi.bulkExportTmStrings(accountUid, params);
+            const sentBody = JSON.parse(fetchStub.getCall(0).args[1].body);
+            assert_1.default.deepEqual(sentBody.variables, {
+                bulkExportTmStrings: {
+                    searchUid: "2z68632hdvw2",
+                    extendedMetadata: true,
+                    extendedMetadataType: "FIRST_TRANSLATED_STRINGS",
+                    includeAllVariants: true
+                }
+            });
+            assert_1.default.ok(sentBody.query.includes("bulkExportTmStrings"));
+            assert_1.default.ok(sentBody.query.includes("executionComplete"));
+            assert_1.default.ok(sentBody.query.includes("actionStatus"));
+            assert_1.default.ok(result);
+            assert_1.default.equal(result.actionUid, "d23eb702-7358-11ea-bc55-0242ac130003");
+            assert_1.default.equal(result.actionStatus, "QUEUEING");
+        }));
+        it("Get bulk export TM strings status", () => __awaiter(void 0, void 0, void 0, function* () {
+            const debugStub = sinon_1.default.stub(mock_1.loggerMock, "debug");
+            const graphQlResponseMock = {
+                status: 200,
+                headers: noRequestIdHeaders,
+                text: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return JSON.stringify({
+                        data: {
+                            bulkExportTmStringsStatus: {
+                                actionUid: "d23eb702-7358-11ea-bc55-0242ac130003",
+                                totalCount: 123,
+                                processedCount: 123,
+                                errorCount: 0,
+                                executionComplete: true,
+                                tmxDownloadKey: "ZGpoaDczaGRqc2o6MA==",
+                                expired: false,
+                                actionStatus: "SUCCESS"
+                            }
+                        }
+                    });
+                })
+            };
+            fetchStub.returns(graphQlResponseMock);
+            const result = yield translationMemoryApi.getBulkExportTmStringsStatus(accountUid, "d23eb702-7358-11ea-bc55-0242ac130003");
+            const sentBody = JSON.parse(fetchStub.getCall(0).args[1].body);
+            assert_1.default.deepEqual(sentBody.variables, {
+                actionUid: "d23eb702-7358-11ea-bc55-0242ac130003"
+            });
+            assert_1.default.ok(sentBody.query.includes("bulkExportTmStringsStatus"));
+            assert_1.default.ok(sentBody.query.includes("tmxDownloadKey"));
+            assert_1.default.ok(sentBody.query.includes("expired"));
+            assert_1.default.ok(result);
+            assert_1.default.equal(result.tmxDownloadKey, "ZGpoaDczaGRqc2o6MA==");
+            assert_1.default.equal(result.executionComplete, true);
+            sinon_1.default.assert.calledOnce(debugStub);
+            const loggedText = debugStub.getCall(0).args[0];
+            assert_1.default.ok(loggedText.includes("[REDACTED]"));
+            assert_1.default.ok(!loggedText.includes("ZGpoaDczaGRqc2o6MA=="));
+            debugStub.restore();
+        }));
+        it("Get bulk export TM strings status: tmxDownloadKey is redacted in a thrown exception's payload too", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.returns({
+                status: 200,
+                headers: noRequestIdHeaders,
+                text: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return JSON.stringify({
+                        errors: [{ message: "partial failure" }],
+                        data: {
+                            bulkExportTmStringsStatus: {
+                                actionUid: "d23eb702-7358-11ea-bc55-0242ac130003",
+                                tmxDownloadKey: "ZGpoaDczaGRqc2o6MA=="
+                            }
+                        }
+                    });
+                })
+            });
+            yield assert_1.default.rejects(translationMemoryApi.getBulkExportTmStringsStatus(accountUid, "d23eb702-7358-11ea-bc55-0242ac130003"), (e) => {
+                const payloadText = JSON.stringify(e.getPayload());
+                assert_1.default.ok(payloadText.includes("[REDACTED]"));
+                assert_1.default.ok(!payloadText.includes("ZGpoaDczaGRqc2o6MA=="));
+                return true;
+            });
+        }));
+        it("Create TM", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.returns(tmGraphQlResponseMock("createTm", sampleTm));
+            const params = new create_tm_parameters_1.CreateTmParameters()
+                .setName("Integration test TM")
+                .setDescription("Created by the SDK test suite")
+                .setSourceLocaleId("en-US")
+                .setTranslationQuality(translation_quality_type_1.TranslationQualityType.TRANSLATION);
+            const result = yield translationMemoryApi.createTm(accountUid, params);
+            sinon_1.default.assert.calledOnce(fetchStub);
+            assert_1.default.equal(fetchStub.getCall(0).args[0], `https://test.com/tm-graphql-api/v2/accounts/${accountUid}/graphql`);
+            const sentBody = JSON.parse(fetchStub.getCall(0).args[1].body);
+            assert_1.default.deepEqual(sentBody.variables, {
+                createTm: {
+                    name: "Integration test TM",
+                    description: "Created by the SDK test suite",
+                    sourceLocaleId: "en-US",
+                    translationQuality: "TRANSLATION"
+                }
+            });
+            assert_1.default.ok(sentBody.query.includes("createTm"));
+            [
+                "tmUid", "name", "description", "sourceLocaleId", "sourceLocale", "localeId",
+                "localeDescription", "rtlLanguage", "wordSpacing", "creator", "userUid", "created",
+                "lastModifier", "lastModified", "localeSummary", "translationLocaleId",
+                "translationLocale", "stringCount", "wordCount", "translationQuality",
+                "managedWordsEnabled"
+            ].forEach((field) => {
+                assert_1.default.ok(sentBody.query.includes(field), `query is missing field "${field}"`);
+            });
+            assert_1.default.ok(result);
+            assert_1.default.equal(result.tmUid, "j45v1uvsi3tx");
+            assert_1.default.ok(result.created instanceof Date);
+            assert_1.default.ok(result.lastModified instanceof Date);
+        }));
+        it("Create TM: a null result is returned as null, not thrown", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.returns({
+                status: 200,
+                headers: noRequestIdHeaders,
+                text: () => __awaiter(void 0, void 0, void 0, function* () { return JSON.stringify({ data: { createTm: null } }); })
+            });
+            const result = yield translationMemoryApi.createTm(accountUid, new create_tm_parameters_1.CreateTmParameters());
+            assert_1.default.equal(result, null);
+        }));
+        it("Update TM", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.returns(tmGraphQlResponseMock("updateTm", sampleTm));
+            const params = new update_tm_parameters_1.UpdateTmParameters()
+                .setTmUid("j45v1uvsi3tx")
+                .setName("Renamed TM")
+                .setDescription("Updated description");
+            const result = yield translationMemoryApi.updateTm(accountUid, params);
+            const sentBody = JSON.parse(fetchStub.getCall(0).args[1].body);
+            assert_1.default.deepEqual(sentBody.variables, {
+                updateTm: {
+                    tmUid: "j45v1uvsi3tx",
+                    name: "Renamed TM",
+                    description: "Updated description"
+                }
+            });
+            assert_1.default.ok(result);
+            assert_1.default.equal(result.tmUid, "j45v1uvsi3tx");
+        }));
+        it("Delete TM", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.returns(tmGraphQlResponseMock("deleteTm", sampleTm));
+            const result = yield translationMemoryApi.deleteTm(accountUid, "j45v1uvsi3tx");
+            const sentBody = JSON.parse(fetchStub.getCall(0).args[1].body);
+            assert_1.default.deepEqual(sentBody.variables, {
+                deleteTm: { tmUid: "j45v1uvsi3tx" }
+            });
+            assert_1.default.ok(result);
+            assert_1.default.equal(result.tmUid, "j45v1uvsi3tx");
+        }));
+        it("Create string search: exercises every CreateStringSearchFilterParameters setter", () => {
+            const translationDateRangeStart = new Date("2026-01-01T00:00:00Z");
+            const translationDateRangeEnd = new Date("2026-02-01T00:00:00Z");
+            const editDateRangeStart = new Date("2026-01-02T00:00:00Z");
+            const editDateRangeEnd = new Date("2026-02-02T00:00:00Z");
+            const reviewDateRangeStart = new Date("2026-01-03T00:00:00Z");
+            const reviewDateRangeEnd = new Date("2026-02-03T00:00:00Z");
+            const authorizationDateRangeStart = new Date("2026-01-04T00:00:00Z");
+            const authorizationDateRangeEnd = new Date("2026-02-04T00:00:00Z");
+            const ingestedDateRangeStart = new Date("2026-01-05T00:00:00Z");
+            const ingestedDateRangeEnd = new Date("2026-02-05T00:00:00Z");
+            const lastTranslatedAfter = new Date("2026-01-06T00:00:00Z");
+            const lastTranslatedBefore = new Date("2026-02-06T00:00:00Z");
+            const firstTranslatedAfter = new Date("2026-01-07T00:00:00Z");
+            const firstTranslatedBefore = new Date("2026-02-07T00:00:00Z");
+            const keyword = { searchText: "year", caseSensitive: true, entireStringMatch: false, searchType: keyword_search_type_1.KeywordSearchType.BASIC };
+            const sourceKeyword = { searchText: "src", searchType: keyword_search_type_1.KeywordSearchType.EXACT_MATCH };
+            const translationKeyword = { searchText: "tgt", searchType: keyword_search_type_1.KeywordSearchType.REGEX };
+            const tags = { tags: ["tag1"], matchAllTags: true, noTags: false };
+            const searchOptions = {
+                highlightMatches: false,
+                searchDuplicates: true,
+                translationEqSource: false,
+                requestedResultsCount: 500
+            };
+            const filter = new create_string_search_filter_parameters_1.CreateStringSearchFilterParameters()
+                .setTmUids(["tm1"])
+                .setSourceLocaleIds(["en-US"])
+                .setTranslationLocaleIds(["fr-FR"])
+                .setKeyword(keyword)
+                .setSourceKeyword(sourceKeyword)
+                .setTranslationKeyword(translationKeyword)
+                .setLeverageType(leverage_type_1.LeverageType.PUBLISHED)
+                .setHashcodes(["hash1"])
+                .setSmtHashcodes(["smt1"])
+                .setTranslatorUids(["translator1"])
+                .setTranslationDateRange(translationDateRangeStart, translationDateRangeEnd)
+                .setEditorUids(["editor1"])
+                .setEditDateRange(editDateRangeStart, editDateRangeEnd)
+                .setReviewerUids(["reviewer1"])
+                .setReviewDateRange(reviewDateRangeStart, reviewDateRangeEnd)
+                .setAuthorizerUids(["authorizer1"])
+                .setAuthorizationDateRange(authorizationDateRangeStart, authorizationDateRangeEnd)
+                .setIngestedDateRange(ingestedDateRangeStart, ingestedDateRangeEnd)
+                .setVariants(["variant1"])
+                .setProjectUids(["project1"])
+                .setExternalStep(true)
+                .setUrls(["https://example.com"])
+                .setFileNames(["file1.xml"])
+                .setKeys(["key1"])
+                .setDomains(["domain1"])
+                .setTmxFileNames(["tmx1.tmx"])
+                .setSources([source_type_1.SourceType.TMX])
+                .setTranslationQualities([tu_translation_quality_type_1.TuTranslationQualityType.HUMAN])
+                .setFirstTranslatorUids(["firstTranslator1"])
+                .setLastTranslatedRange(lastTranslatedAfter, lastTranslatedBefore)
+                .setFirstTranslatedRange(firstTranslatedAfter, firstTranslatedBefore)
+                .setTags(tags)
+                .setOfflineReportUids(["offlineReport1"])
+                .setSearchOptions(searchOptions);
+            assert_1.default.deepEqual(filter.export(), {
+                tmUids: ["tm1"],
+                sourceLocaleIds: ["en-US"],
+                translationLocaleIds: ["fr-FR"],
+                keyword,
+                sourceKeyword,
+                translationKeyword,
+                leverageType: "PUBLISHED",
+                hashcodes: ["hash1"],
+                smtHashcodes: ["smt1"],
+                translatorUids: ["translator1"],
+                translationDateRangeStart,
+                translationDateRangeEnd,
+                editorUids: ["editor1"],
+                editDateRangeStart,
+                editDateRangeEnd,
+                reviewerUids: ["reviewer1"],
+                reviewDateRangeStart,
+                reviewDateRangeEnd,
+                authorizerUids: ["authorizer1"],
+                authorizationDateRangeStart,
+                authorizationDateRangeEnd,
+                ingestedDateRangeStart,
+                ingestedDateRangeEnd,
+                variants: ["variant1"],
+                projectUids: ["project1"],
+                externalStep: true,
+                urls: ["https://example.com"],
+                fileNames: ["file1.xml"],
+                keys: ["key1"],
+                domains: ["domain1"],
+                tmxFileNames: ["tmx1.tmx"],
+                sources: ["TMX"],
+                translationQualities: ["HUMAN"],
+                firstTranslatorUids: ["firstTranslator1"],
+                lastTranslatedAfter,
+                lastTranslatedBefore,
+                firstTranslatedAfter,
+                firstTranslatedBefore,
+                tags,
+                offlineReportUids: ["offlineReport1"],
+                searchOptions
+            });
+        });
+    });
+});
+//# sourceMappingURL=translation-memory.spec.js.map