smartling-api-sdk-nodejs 3.4.2 → 3.6.0

package/test/integration/estimates.spec.ts

@@ -0,0 +1,271 @@
+import dotenv from "dotenv";
+import assert from "assert";
+import { SmartlingApiClientBuilder } from "../../api/builder/index";
+import { SmartlingEstimatesApi } from "../../api/estimates/index";
+import { SmartlingJobsApi } from "../../api/jobs/index";
+import { SmartlingProjectsApi } from "../../api/projects/index";
+import { SmartlingFilesApi } from "../../api/files/index";
+import { CreateJobParameters } from "../../api/jobs/params/create-job-parameters";
+import { CancelJobParameters } from "../../api/jobs/params/cancel-job-parameters";
+import { AddFileParameters } from "../../api/jobs/params/add-file-parameters";
+import { AuthorizeJobParameters } from "../../api/jobs/params/authorize-job-parameters";
+import { UploadFileParameters } from "../../api/files/params/upload-file-parameters";
+import { FileType } from "../../api/files/params/file-type";
+import { GenerateJobEstimateReportParameters } from "../../api/estimates/params/generate-job-estimate-report-parameters";
+import { ListJobEstimateReportsParameters } from "../../api/estimates/params/list-job-estimate-reports-parameters";
+import { ModifyEstimateReportTagsParameters } from "../../api/estimates/params/modify-estimate-report-tags-parameters";
+import { JobContentType } from "../../api/estimates/params/job-content-type";
+import { EstimateReportStatus } from "../../api/estimates/params/estimate-report-status";
+import { logResponse } from "./helpers/log-response";
+
+dotenv.config();
+
+const baseSmartlingApiUrl = process.env.SMARTLING_API_BASE_URL || "https://api.smartling.com";
+const accountUid = process.env.SMARTLING_ACCOUNT_UID as string;
+const userId = process.env.SMARTLING_USER_ID as string;
+const userSecret = process.env.SMARTLING_USER_SECRET as string;
+const hasCredentials = Boolean(accountUid && userId && userSecret);
+
+const TERMINAL_REPORT_STATUSES = [
+    EstimateReportStatus.COMPLETED,
+    EstimateReportStatus.FAILED,
+    EstimateReportStatus.TIMEOUT,
+    EstimateReportStatus.CANCELED,
+    EstimateReportStatus.NOT_FOUND
+];
+
+function delay(milliseconds: number): Promise<void> {
+    return new Promise((resolve) => {
+        setTimeout(resolve, milliseconds);
+    });
+}
+
+describe("SmartlingEstimatesApi integration tests.", function integrationSuite() {
+    this.timeout(180000);
+
+    let estimatesApi: SmartlingEstimatesApi;
+    let jobsApi: SmartlingJobsApi;
+    let projectsApi: SmartlingProjectsApi;
+    let filesApi: SmartlingFilesApi;
+    let projectId: string;
+    let translationJobUid: string;
+    let fileUri: string;
+    let fuzzyReportUid: string | undefined;
+    let costReportUid: string | undefined;
+
+    before(function skipWithoutCredentials() {
+        if (!hasCredentials) {
+            // eslint-disable-next-line no-console
+            console.log("Skipping Estimates integration tests: set SMARTLING_ACCOUNT_UID, SMARTLING_USER_ID, SMARTLING_USER_SECRET in .env");
+            this.skip();
+        }
+
+        estimatesApi = new SmartlingApiClientBuilder()
+            .setBaseSmartlingApiUrl(baseSmartlingApiUrl)
+            .authWithUserIdAndUserSecret(userId, userSecret)
+            .build(SmartlingEstimatesApi);
+
+        jobsApi = new SmartlingApiClientBuilder()
+            .setBaseSmartlingApiUrl(baseSmartlingApiUrl)
+            .authWithUserIdAndUserSecret(userId, userSecret)
+            .build(SmartlingJobsApi);
+
+        projectsApi = new SmartlingApiClientBuilder()
+            .setBaseSmartlingApiUrl(baseSmartlingApiUrl)
+            .authWithUserIdAndUserSecret(userId, userSecret)
+            .build(SmartlingProjectsApi);
+
+        filesApi = new SmartlingApiClientBuilder()
+            .setBaseSmartlingApiUrl(baseSmartlingApiUrl)
+            .authWithUserIdAndUserSecret(userId, userSecret)
+            .build(SmartlingFilesApi);
+    });
+
+    before(async () => {
+        const projects = await projectsApi.listProjects(accountUid);
+
+        logResponse("listProjects", projects);
+        assert.ok(projects.items.length > 0, "Test account must have at least one project to run Estimates integration tests");
+
+        ({ projectId } = projects.items[0]);
+
+        const project = await projectsApi.getProjectDetails(projectId);
+
+        logResponse("getProjectDetails", project);
+
+        const targetLocaleIds = project.targetLocales.map((locale) => locale.localeId);
+
+        const job = await jobsApi.createJob(
+            projectId,
+            new CreateJobParameters()
+                .setName(`api-sdk-nodejs estimates integration test ${Date.now()}`)
+                .setTargetLocaleIds(targetLocaleIds)
+        );
+
+        logResponse("createJob", job);
+        ({ translationJobUid } = job);
+
+        // Real translatable content, so the generated reports have non-zero word counts and
+        // a populated locale/workflow/fuzzy-match breakdown to verify the nested DTOs against.
+        fileUri = `api-sdk-nodejs-estimates-integration-test-${Date.now()}.json`;
+
+        const uploaded = await filesApi.uploadFile(
+            projectId,
+            new UploadFileParameters()
+                .setFileUri(fileUri)
+                .setFileType(FileType.JSON)
+                .setFileContent(JSON.stringify({
+                    greeting: "Hello, welcome to our service!",
+                    farewell: "Thank you for using our application, we hope to see you again soon.",
+                    description: "This is a sample piece of content used to generate a translation estimate for integration testing purposes."
+                }))
+        );
+
+        logResponse("uploadFile", uploaded);
+
+        const addedFile = await jobsApi.addFileToJob(
+            projectId,
+            translationJobUid,
+            new AddFileParameters().setFileUri(fileUri).setTargetLocaleIds(targetLocaleIds)
+        );
+
+        logResponse("addFileToJob", addedFile);
+
+        // Assigns the project's default workflow per locale, so the estimate has a workflow
+        // to break the word counts down by.
+        const authorized = await jobsApi.authorizeJob(
+            projectId, translationJobUid, new AuthorizeJobParameters()
+        );
+
+        logResponse("authorizeJob", authorized);
+    });
+
+    after(async () => {
+        // Guards against a leaked report if an assertion in the `it` block below threw before
+        // reaching that test's own deleteEstimateReport call - each test clears its tracked uid
+        // once it deletes the report itself, so this is a no-op on the happy path.
+        if (fuzzyReportUid) {
+            await estimatesApi.deleteEstimateReport(projectId, fuzzyReportUid);
+        }
+
+        if (costReportUid) {
+            await estimatesApi.deleteEstimateReport(projectId, costReportUid);
+        }
+
+        if (translationJobUid) {
+            // A job can only be deleted once it's CANCELLED.
+            await jobsApi.cancelJob(
+                projectId,
+                translationJobUid,
+                new CancelJobParameters().setReason("api-sdk-nodejs integration test cleanup")
+            );
+            await jobsApi.deleteJob(projectId, translationJobUid);
+        }
+
+        if (fileUri) {
+            await filesApi.deleteFile(projectId, fileUri);
+        }
+    });
+
+    async function waitForReportCompletion(reportUid: string): Promise<void> {
+        for (let attempt = 0; attempt < 30; attempt += 1) {
+            /* eslint-disable-next-line no-await-in-loop */
+            const status = await estimatesApi.getEstimateReportStatus(projectId, reportUid);
+
+            logResponse("getEstimateReportStatus", status);
+
+            if (TERMINAL_REPORT_STATUSES.includes(status.reportStatus)) {
+                return;
+            }
+
+            /* eslint-disable-next-line no-await-in-loop */
+            await delay(3000);
+        }
+
+        throw new Error(`Timed out waiting for report ${reportUid} to complete`);
+    }
+
+    it("generates, reads, lists, tags, downloads and deletes a fuzzy estimate report", async () => {
+        const generated = await estimatesApi.generateJobFuzzyEstimateReport(
+            projectId,
+            translationJobUid,
+            new GenerateJobEstimateReportParameters().setContentType(JobContentType.ALL_CONTENT)
+        );
+
+        logResponse("generateJobFuzzyEstimateReport", generated);
+        assert.ok(generated.reportUid);
+
+        const { reportUid } = generated;
+
+        fuzzyReportUid = reportUid;
+
+        await waitForReportCompletion(reportUid);
+
+        const report = await estimatesApi.getEstimateReport(projectId, reportUid);
+
+        logResponse("getEstimateReport", report);
+        assert.equal(report.reportUid, reportUid);
+        assert.ok(report.totalStrings > 0, "expected non-zero totalStrings now the job has real content");
+
+        const list = await estimatesApi.getJobFuzzyEstimateReports(
+            projectId,
+            translationJobUid,
+            new ListJobEstimateReportsParameters().setLimit(10).setOffset(0)
+        );
+
+        logResponse("getJobFuzzyEstimateReports", list);
+        assert.ok(list.items.some((item) => item.reportUid === reportUid));
+
+        const tagged = await estimatesApi.modifyEstimateReportTags(
+            projectId,
+            reportUid,
+            new ModifyEstimateReportTagsParameters().setTags(["api-sdk-nodejs-integration"])
+        );
+
+        logResponse("modifyEstimateReportTags", tagged);
+        assert.deepEqual(tagged.tags, ["api-sdk-nodejs-integration"]);
+
+        const downloaded = await estimatesApi.downloadEstimateReport(projectId, reportUid);
+
+        logResponse("downloadEstimateReport", `<${downloaded.byteLength} bytes>`);
+        assert.ok(downloaded.byteLength > 0);
+
+        await estimatesApi.deleteEstimateReport(projectId, reportUid);
+        fuzzyReportUid = undefined;
+    });
+
+    it("generates and reads a cost estimate report", async () => {
+        const generated = await estimatesApi.generateJobCostEstimateReport(
+            projectId,
+            translationJobUid,
+            new GenerateJobEstimateReportParameters().setContentType(JobContentType.ALL_CONTENT)
+        );
+
+        logResponse("generateJobCostEstimateReport", generated);
+        assert.ok(generated.reportUid);
+
+        const { reportUid } = generated;
+
+        costReportUid = reportUid;
+
+        await waitForReportCompletion(reportUid);
+
+        const report = await estimatesApi.getEstimateReport(projectId, reportUid);
+
+        logResponse("getEstimateReport (cost)", report);
+        assert.equal(report.reportUid, reportUid);
+        assert.ok(report.totalStrings > 0, "expected non-zero totalStrings now the job has real content");
+
+        const list = await estimatesApi.getJobCostEstimateReports(
+            projectId,
+            translationJobUid,
+            new ListJobEstimateReportsParameters().setLimit(10).setOffset(0)
+        );
+
+        logResponse("getJobCostEstimateReports", list);
+        assert.ok(list.items.some((item) => item.reportUid === reportUid));
+
+        await estimatesApi.deleteEstimateReport(projectId, reportUid);
+        costReportUid = undefined;
+    });
+});

package/test/integration/helpers/log-response.ts

@@ -1,7 +1,9 @@
-const logResponsesEnabled = process.env.SMARTLING_LOG_RESPONSES === "true";
-
 export function logResponse(label: string, response: unknown): void {
-    if (!logResponsesEnabled) {
+    // Read fresh on every call rather than freezing into a module-level constant at import
+    // time: this module is `require`d (by each spec file's own imports) before that same
+    // spec file's `dotenv.config()` call runs, and the require is cached - so a constant
+    // computed once here would always see pre-dotenv env vars, regardless of .env's content.
+    if (process.env.SMARTLING_LOG_RESPONSES !== "true") {
         return;
     }
 

package/test/integration/translation-memory.spec.ts

@@ -7,6 +7,8 @@ import { CreateStringSearchFilterParameters } from "../../api/translation-memory
 import { BulkExportTmStringsParameters } from "../../api/translation-memory/params/bulk-export-tm-strings-parameters";
 import { CreateTmParameters } from "../../api/translation-memory/params/create-tm-parameters";
 import { UpdateTmParameters } from "../../api/translation-memory/params/update-tm-parameters";
+import { SearchTmsParameters } from "../../api/translation-memory/params/search-tms-parameters";
+import { TmSorting } from "../../api/translation-memory/params/tm-sorting";
 import { TranslationQualityType } from "../../api/translation-memory/params/translation-quality-type";
 import { logResponse } from "./helpers/log-response";
 
@@ -32,6 +34,7 @@ describe("SmartlingTranslationMemoryApi integration tests.", function integratio
 
     let api: SmartlingTranslationMemoryApi;
     let tmUid: string;
+    let tmName: string;
 
     before(function skipWithoutCredentials() {
         if (!hasCredentials) {
@@ -47,10 +50,12 @@ describe("SmartlingTranslationMemoryApi integration tests.", function integratio
     });
 
     before(async () => {
+        tmName = `api-sdk-nodejs integration test TM ${Date.now()}`;
+
         const created = await api.createTm(
             accountUid,
             new CreateTmParameters()
-                .setName(`api-sdk-nodejs integration test TM ${Date.now()}`)
+                .setName(tmName)
                 .setDescription("Created by the api-sdk-nodejs integration suite")
                 .setSourceLocaleId("en-US")
                 .setTranslationQuality(TranslationQualityType.TRANSLATION)
@@ -83,6 +88,11 @@ describe("SmartlingTranslationMemoryApi integration tests.", function integratio
 
         logResponse("updateTm", updated);
 
+        // Keep tmName in sync with the TM's current name before any assertion below can throw,
+        // so a later nameFilter-based searchTms lookup (see "Finds the TM via searchTms") still
+        // matches the renamed TM even if one of those assertions fails.
+        tmName = updatedName;
+
         assert.ok(updated, "updateTm returned null");
         assert.equal(updated.tmUid, tmUid);
         assert.equal(updated.name, updatedName);
@@ -91,6 +101,47 @@ describe("SmartlingTranslationMemoryApi integration tests.", function integratio
         assert.ok(updated.lastModified instanceof Date);
     });
 
+    it("Gets the TM by UID", async () => {
+        const fetched = await api.getTm(accountUid, tmUid);
+
+        logResponse("getTm", fetched);
+
+        assert.ok(fetched, "getTm returned null");
+        assert.equal(fetched.tmUid, tmUid);
+        assert.ok(fetched.created instanceof Date);
+        assert.ok(fetched.lastModified instanceof Date);
+    });
+
+    it("Finds the TM via searchTms", async () => {
+        // Captured as a const so the polling loop's closure below doesn't trip no-loop-func.
+        const expectedTmUid = tmUid;
+        const searchParams = (): SearchTmsParameters => new SearchTmsParameters()
+            .setSourceLocaleId("en-US")
+            .setNameFilter(tmName)
+            .setSortBy(TmSorting.BY_NAME_ASC)
+            .setFirst(50);
+
+        // A just-created TM can briefly miss nameFilter-based search before it's indexed,
+        // so retry until it shows up or the deadline passes.
+        let found = await api.searchTms(accountUid, searchParams());
+        const deadline = Date.now() + 30000;
+
+        while (
+            !found?.some((tm) => tm?.tmUid === expectedTmUid)
+            && Date.now() < deadline
+        ) {
+            /* eslint-disable-next-line no-await-in-loop */
+            await delay(2000);
+            /* eslint-disable-next-line no-await-in-loop */
+            found = await api.searchTms(accountUid, searchParams());
+        }
+
+        logResponse("searchTms", found);
+
+        assert.ok(found, "searchTms returned null");
+        assert.ok(found.some((tm) => tm?.tmUid === expectedTmUid), "searchTms did not return the TM created by this suite");
+    });
+
     it("Imports a TMX file", async () => {
         const result = await api.importTmxFile(
             accountUid,

package/test/translation-memory.spec.ts

@@ -11,6 +11,8 @@ import { BulkExportTmStringsParameters } from "../api/translation-memory/params/
 import { ExtendedExportMetadataType } from "../api/translation-memory/params/extended-export-metadata-type";
 import { CreateTmParameters } from "../api/translation-memory/params/create-tm-parameters";
 import { UpdateTmParameters } from "../api/translation-memory/params/update-tm-parameters";
+import { SearchTmsParameters } from "../api/translation-memory/params/search-tms-parameters";
+import { TmSorting } from "../api/translation-memory/params/tm-sorting";
 import { TranslationQualityType } from "../api/translation-memory/params/translation-quality-type";
 import { LeverageType } from "../api/translation-memory/params/leverage-type";
 import { SourceType } from "../api/translation-memory/params/source-type";
@@ -26,7 +28,9 @@ function formDataText(formData: { _streams: Array<unknown> }): string {
 
 const noRequestIdHeaders = { get: (): string | null => null };
 
-function tmGraphQlResponseMock(operationName: string, tm: Record<string, unknown>): {
+function tmGraphQlResponseMock(
+    operationName: string, tm: Record<string, unknown> | Array<Record<string, unknown>>
+): {
     status: number;
     headers: { get: (name: string) => string | null };
     text: () => Promise<string>;
@@ -758,6 +762,80 @@ describe("SmartlingTranslationMemoryApi class tests.", () => {
             assert.equal(result.tmUid, "j45v1uvsi3tx");
         });
 
+        it("Get TM", async () => {
+            fetchStub.returns(tmGraphQlResponseMock("tm", sampleTm));
+
+            const result = await translationMemoryApi.getTm(accountUid, "j45v1uvsi3tx");
+
+            const sentBody = JSON.parse(fetchStub.getCall(0).args[1].body);
+            assert.deepEqual(sentBody.variables, { tmUid: "j45v1uvsi3tx" });
+            assert.ok(sentBody.query.includes("tm(tmUid: $tmUid)"));
+
+            assert.ok(result);
+            assert.equal(result.tmUid, "j45v1uvsi3tx");
+            assert.ok(result.created instanceof Date);
+            assert.ok(result.lastModified instanceof Date);
+        });
+
+        it("Get TM: a null result is returned as null, not thrown", async () => {
+            fetchStub.returns({
+                status: 200,
+                headers: noRequestIdHeaders,
+                text: async (): Promise<string> => JSON.stringify({ data: { tm: null } })
+            });
+
+            const result = await translationMemoryApi.getTm(accountUid, "missingTmUid");
+
+            assert.equal(result, null);
+        });
+
+        it("Search TMs: exercises every SearchTmsParameters setter", async () => {
+            fetchStub.returns(tmGraphQlResponseMock("searchTms", [sampleTm]));
+
+            const params = new SearchTmsParameters()
+                .setFirst(25)
+                .setOffset(10)
+                .setSortBy(TmSorting.BY_NAME_DESC)
+                .setSourceLocaleId("en-US")
+                .setNameFilter("Marketing")
+                .setSourceLanguageId("en")
+                .setTranslationQuality(TranslationQualityType.TRANSLATION);
+
+            const result = await translationMemoryApi.searchTms(accountUid, params);
+
+            const sentBody = JSON.parse(fetchStub.getCall(0).args[1].body);
+            assert.deepEqual(sentBody.variables, {
+                searchTmFilter: {
+                    first: 25,
+                    offset: 10,
+                    sortBy: "BY_NAME_DESC",
+                    sourceLocaleId: "en-US",
+                    nameFilter: "Marketing",
+                    sourceLanguageId: "en",
+                    translationQuality: "TRANSLATION"
+                }
+            });
+            assert.ok(sentBody.query.includes("searchTms(searchTmFilter: $searchTmFilter)"));
+
+            assert.ok(result);
+            assert.equal(result.length, 1);
+            assert.equal(result?.[0]?.tmUid, "j45v1uvsi3tx");
+        });
+
+        it("Search TMs: a null result is returned as null, not thrown", async () => {
+            fetchStub.returns({
+                status: 200,
+                headers: noRequestIdHeaders,
+                text: async (): Promise<string> => JSON.stringify({ data: { searchTms: null } })
+            });
+
+            const result = await translationMemoryApi.searchTms(
+                accountUid, new SearchTmsParameters()
+            );
+
+            assert.equal(result, null);
+        });
+
         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");