smartling-api-sdk-nodejs 3.5.0 → 3.6.0

package/test/estimates.spec.ts

@@ -0,0 +1,242 @@
+import sinon from "sinon";
+import { loggerMock, authMock, responseMock } from "./mock";
+import { SmartlingEstimatesApi } from "../api/estimates/index";
+import { SmartlingAuthApi } from "../api/auth/index";
+import { ListJobEstimateReportsParameters } from "../api/estimates/params/list-job-estimate-reports-parameters";
+import { GenerateJobEstimateReportParameters } from "../api/estimates/params/generate-job-estimate-report-parameters";
+import { ModifyEstimateReportTagsParameters } from "../api/estimates/params/modify-estimate-report-tags-parameters";
+import { EstimateReportStatus } from "../api/estimates/params/estimate-report-status";
+import { EstimateReportContentCoverage } from "../api/estimates/params/estimate-report-content-coverage";
+import { JobContentType } from "../api/estimates/params/job-content-type";
+
+describe("SmartlingEstimatesApi class tests.", () => {
+    const projectId = "testProjectId";
+    const translationJobUid = "testJobUid";
+    const reportUid = "testReportUid";
+    let estimatesApi;
+    let estimatesApiFetchStub;
+    let estimatesApiUaStub;
+    let responseMockJsonStub;
+
+    beforeEach(() => {
+        estimatesApi = new SmartlingEstimatesApi(
+            "https://test.com", authMock as unknown as SmartlingAuthApi, loggerMock
+        );
+        estimatesApiFetchStub = sinon.stub(estimatesApi, "fetch");
+        estimatesApiUaStub = sinon.stub(estimatesApi, "ua");
+        responseMockJsonStub = sinon.stub(responseMock, "json");
+
+        estimatesApiUaStub.returns("test_user_agent");
+        estimatesApiFetchStub.returns(responseMock);
+        responseMockJsonStub.returns({
+            response: {}
+        });
+    });
+
+    afterEach(() => {
+        estimatesApiFetchStub.restore();
+        responseMockJsonStub.restore();
+        estimatesApiUaStub.restore();
+    });
+
+    describe("Methods", () => {
+        it("Get job fuzzy estimate reports", async () => {
+            const params = new ListJobEstimateReportsParameters()
+                .setReportStatus(EstimateReportStatus.COMPLETED)
+                .setContentCoverage(EstimateReportContentCoverage.FULL)
+                .setCreatorUserUids(["creatorUserUid1"])
+                .setTranslationJobSchemaContents([JobContentType.ALL_CONTENT])
+                .setTags(["tag1", "tag2"])
+                .setCreatedFrom(new Date("2020-01-01T00:00:00.000Z"))
+                .setCreatedTo(new Date("2020-02-01T00:00:00.000Z"))
+                .setLimit(100)
+                .setOffset(10);
+
+            await estimatesApi.getJobFuzzyEstimateReports(projectId, translationJobUid, params);
+
+            sinon.assert.calledOnce(estimatesApiFetchStub);
+            sinon.assert.calledWithExactly(
+                estimatesApiFetchStub,
+                `https://test.com/estimates-api/v2/projects/${projectId}/jobs/${translationJobUid}/reports/fuzzy?reportStatus=COMPLETED&contentCoverage=FULL&creatorUserUids=creatorUserUid1&translationJobSchemaContents=ALL_CONTENT&tags=tag1&tags=tag2&createdFrom=2020-01-01T00%3A00%3A00Z&createdTo=2020-02-01T00%3A00%3A00Z&limit=100&offset=10`,
+                {
+                    headers: {
+                        Authorization: "test_token_type test_access_token",
+                        "Content-Type": "application/json",
+                        "User-Agent": "test_user_agent"
+                    },
+                    method: "get"
+                }
+            );
+        });
+
+        it("Generate job fuzzy estimate report", async () => {
+            const params = new GenerateJobEstimateReportParameters()
+                .setContentType(JobContentType.ALL_CONTENT)
+                .setTags(["tag1"])
+                .setLocaleWorkflowStepsFilter([
+                    { targetLocaleId: "es-CR", workflowStepUid: "9358c9ed8748" }
+                ]);
+
+            await estimatesApi.generateJobFuzzyEstimateReport(projectId, translationJobUid, params);
+
+            sinon.assert.calledOnce(estimatesApiFetchStub);
+            sinon.assert.calledWithExactly(
+                estimatesApiFetchStub,
+                `https://test.com/estimates-api/v2/projects/${projectId}/jobs/${translationJobUid}/reports/fuzzy`,
+                {
+                    body: "{\"contentType\":\"ALL_CONTENT\",\"tags\":[\"tag1\"],\"localeWorkflowStepsFilter\":[{\"targetLocaleId\":\"es-CR\",\"workflowStepUid\":\"9358c9ed8748\"}]}",
+                    headers: {
+                        Authorization: "test_token_type test_access_token",
+                        "Content-Type": "application/json",
+                        "User-Agent": "test_user_agent"
+                    },
+                    method: "post"
+                }
+            );
+        });
+
+        it("Get job cost estimate reports", async () => {
+            const params = new ListJobEstimateReportsParameters()
+                .setLimit(50)
+                .setOffset(0);
+
+            await estimatesApi.getJobCostEstimateReports(projectId, translationJobUid, params);
+
+            sinon.assert.calledOnce(estimatesApiFetchStub);
+            sinon.assert.calledWithExactly(
+                estimatesApiFetchStub,
+                `https://test.com/estimates-api/v2/projects/${projectId}/jobs/${translationJobUid}/reports/cost?limit=50&offset=0`,
+                {
+                    headers: {
+                        Authorization: "test_token_type test_access_token",
+                        "Content-Type": "application/json",
+                        "User-Agent": "test_user_agent"
+                    },
+                    method: "get"
+                }
+            );
+        });
+
+        it("Generate job cost estimate report", async () => {
+            const params = new GenerateJobEstimateReportParameters()
+                .setContentType(JobContentType.UNAUTHORIZED)
+                .setTags(["tag1", "tag2"])
+                .setLocaleWorkflows([{ targetLocaleId: "en-FR", workflowUid: "783d9d255523" }])
+                .setFuzzyProfileUid("uid123456")
+                .setRushRequest(true)
+                .setLocaleWorkflowStepsFilter([
+                    { targetLocaleId: "es-CR", workflowStepUid: "9358c9ed8748" }
+                ]);
+
+            await estimatesApi.generateJobCostEstimateReport(projectId, translationJobUid, params);
+
+            sinon.assert.calledOnce(estimatesApiFetchStub);
+            sinon.assert.calledWithExactly(
+                estimatesApiFetchStub,
+                `https://test.com/estimates-api/v2/projects/${projectId}/jobs/${translationJobUid}/reports/cost`,
+                {
+                    body: "{\"contentType\":\"UNAUTHORIZED\",\"tags\":[\"tag1\",\"tag2\"],\"localeWorkflows\":[{\"targetLocaleId\":\"en-FR\",\"workflowUid\":\"783d9d255523\"}],\"fuzzyProfileUid\":\"uid123456\",\"rushRequest\":true,\"localeWorkflowStepsFilter\":[{\"targetLocaleId\":\"es-CR\",\"workflowStepUid\":\"9358c9ed8748\"}]}",
+                    headers: {
+                        Authorization: "test_token_type test_access_token",
+                        "Content-Type": "application/json",
+                        "User-Agent": "test_user_agent"
+                    },
+                    method: "post"
+                }
+            );
+        });
+
+        it("Get estimate report", async () => {
+            await estimatesApi.getEstimateReport(projectId, reportUid);
+
+            sinon.assert.calledOnce(estimatesApiFetchStub);
+            sinon.assert.calledWithExactly(
+                estimatesApiFetchStub,
+                `https://test.com/estimates-api/v2/projects/${projectId}/reports/${reportUid}`,
+                {
+                    headers: {
+                        Authorization: "test_token_type test_access_token",
+                        "Content-Type": "application/json",
+                        "User-Agent": "test_user_agent"
+                    },
+                    method: "get"
+                }
+            );
+        });
+
+        it("Delete estimate report", async () => {
+            await estimatesApi.deleteEstimateReport(projectId, reportUid);
+
+            sinon.assert.calledOnce(estimatesApiFetchStub);
+            sinon.assert.calledWithExactly(
+                estimatesApiFetchStub,
+                `https://test.com/estimates-api/v2/projects/${projectId}/reports/${reportUid}`,
+                {
+                    headers: {
+                        Authorization: "test_token_type test_access_token",
+                        "Content-Type": "application/json",
+                        "User-Agent": "test_user_agent"
+                    },
+                    method: "delete"
+                }
+            );
+        });
+
+        it("Get estimate report status", async () => {
+            await estimatesApi.getEstimateReportStatus(projectId, reportUid);
+
+            sinon.assert.calledOnce(estimatesApiFetchStub);
+            sinon.assert.calledWithExactly(
+                estimatesApiFetchStub,
+                `https://test.com/estimates-api/v2/projects/${projectId}/reports/${reportUid}/status`,
+                {
+                    headers: {
+                        Authorization: "test_token_type test_access_token",
+                        "Content-Type": "application/json",
+                        "User-Agent": "test_user_agent"
+                    },
+                    method: "get"
+                }
+            );
+        });
+
+        it("Modify estimate report tags", async () => {
+            const params = new ModifyEstimateReportTagsParameters().setTags(["AdminJob", "NEWTAG1"]);
+
+            await estimatesApi.modifyEstimateReportTags(projectId, reportUid, params);
+
+            sinon.assert.calledOnce(estimatesApiFetchStub);
+            sinon.assert.calledWithExactly(
+                estimatesApiFetchStub,
+                `https://test.com/estimates-api/v2/projects/${projectId}/reports/${reportUid}/tags`,
+                {
+                    body: "{\"tags\":[\"AdminJob\",\"NEWTAG1\"]}",
+                    headers: {
+                        Authorization: "test_token_type test_access_token",
+                        "Content-Type": "application/json",
+                        "User-Agent": "test_user_agent"
+                    },
+                    method: "put"
+                }
+            );
+        });
+
+        it("Download estimate report", async () => {
+            await estimatesApi.downloadEstimateReport(projectId, reportUid);
+
+            sinon.assert.calledOnce(estimatesApiFetchStub);
+            sinon.assert.calledWithExactly(
+                estimatesApiFetchStub,
+                `https://test.com/estimates-api/v2/projects/${projectId}/reports/${reportUid}/download?format=csv`,
+                {
+                    headers: {
+                        Authorization: "test_token_type test_access_token",
+                        "Content-Type": "application/json",
+                        "User-Agent": "test_user_agent"
+                    },
+                    method: "get"
+                }
+            );
+        });
+    });
+});

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;
     }