@octopusdeploy/api-client - npm Package Compare versions

Comparing version 3.3.0 to 3.3.1

dist/features/packages/packageRepository.test.js

@@ -193,3 +193,3 @@ "use strict";
                     if (error_1 instanceof Error) {
-                        expect(error_1.message).toContain("A package with the same ID and version already exists");
+                        expect(error_1.message).toContain("A package with the same name and version already exists");
                     }
@@ -196,0 +196,0 @@ else {

dist/features/serverTasks/serverTaskWaiter.js

@@ -102,19 +102,20 @@ "use strict";
                         completedTasks = [];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 5, 6]);
                         _loop_1 = function () {
-                            var tasks_2, unknownTaskIds, nowCompletedTaskIds_1, tasks_1, tasks_1_1, task;
+                            var tasks, unknownTaskIds, nowCompletedTaskIds, tasks_1, tasks_1_1, task;
                             var e_1, _b;
                             return __generator(this, function (_c) {
                                 switch (_c.label) {
-                                    case 0:
-                                        _c.trys.push([0, , 2, 3]);
-                                        return [4 /*yield*/, spaceServerTaskRepository.getByIds(serverTaskIds)];
+                                    case 0: return [4 /*yield*/, spaceServerTaskRepository.getByIds(serverTaskIds)];
                                     case 1:
-                                        tasks_2 = _c.sent();
-                                        unknownTaskIds = serverTaskIds.filter(function (id) { return tasks_2.filter(function (t) { return t.Id === id; }).length == 0; });
+                                        tasks = _c.sent();
+                                        unknownTaskIds = serverTaskIds.filter(function (id) { return tasks.filter(function (t) { return t.Id === id; }).length == 0; });
                                         if (unknownTaskIds.length) {
                                             throw new Error("Unknown task Id(s) ".concat(unknownTaskIds.join(", ")));
                                         }
-                                        nowCompletedTaskIds_1 = [];
+                                        nowCompletedTaskIds = [];
                                         try {
-                                            for (tasks_1 = (e_1 = void 0, __values(tasks_2)), tasks_1_1 = tasks_1.next(); !tasks_1_1.done; tasks_1_1 = tasks_1.next()) {
+                                            for (tasks_1 = (e_1 = void 0, __values(tasks)), tasks_1_1 = tasks_1.next(); !tasks_1_1.done; tasks_1_1 = tasks_1.next()) {
                                                 task = tasks_1_1.value;
@@ -126,3 +127,3 @@ if (pollingCallback) {
                                                 if (task.IsCompleted) {
-                                                    nowCompletedTaskIds_1.push(task.Id);
+                                                    nowCompletedTaskIds.push(task.Id);
                                                     completedTasks.push(task);
@@ -140,13 +141,10 @@ }
                                         // filter down the ids to only those that haven't completed for the next time around the loop
-                                        serverTaskIds = serverTaskIds.filter(function (id) { return nowCompletedTaskIds_1.indexOf(id) < 0; });
+                                        serverTaskIds = serverTaskIds.filter(function (id) { return nowCompletedTaskIds.indexOf(id) < 0; });
                                         // once all tasks have completed we can stop the loop
-                                        if (serverTaskIds.length === 0 || tasks_2.length === 0) {
+                                        if (serverTaskIds.length === 0 || tasks.length === 0) {
                                             stop = true;
+                                            clearTimeout(t);
                                         }
-                                        return [3 /*break*/, 3];
+                                        return [4 /*yield*/, sleep(statusCheckSleepCycle)];
                                     case 2:
-                                        clearTimeout(t);
-                                        return [7 /*endfinally*/];
-                                    case 3: return [4 /*yield*/, sleep(statusCheckSleepCycle)];
-                                    case 4:
                                         _c.sent();
@@ -157,10 +155,14 @@ return [2 /*return*/];
                         };
-                        _a.label = 1;
-                    case 1:
-                        if (!!stop) return [3 /*break*/, 3];
+                        _a.label = 2;
+                    case 2:
+                        if (!!stop) return [3 /*break*/, 4];
                         return [5 /*yield**/, _loop_1()];
-                    case 2:
+                    case 3:
                         _a.sent();
-                        return [3 /*break*/, 1];
-                    case 3: return [2 /*return*/, completedTasks];
+                        return [3 /*break*/, 2];
+                    case 4: return [3 /*break*/, 6];
+                    case 5:
+                        clearTimeout(t);
+                        return [7 /*endfinally*/];
+                    case 6: return [2 /*return*/, completedTasks];
                 }
@@ -167,0 +169,0 @@ });

dist/features/serverTasks/serverTaskWaiter.test.js

@@ -39,28 +39,242 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/init-declarations */
+var crypto_1 = require("crypto");
+var __1 = require("../..");
 var client_1 = require("../../client");
 var clientConfiguration_test_1 = require("../../clientConfiguration.test");
 var serverTaskWaiter_1 = require("./serverTaskWaiter");
-describe("push build information", function () {
+describe("wait for server task", function () {
     jest.setTimeout(100000);
-    test("wait for non-existent task exits correctly", function () { return __awaiter(void 0, void 0, void 0, function () {
-        var client, serverTaskWaiter, startTime, endTime, timeDiff;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, client_1.Client.create((0, clientConfiguration_test_1.processConfiguration)())];
-                case 1:
-                    client = _a.sent();
-                    serverTaskWaiter = new serverTaskWaiter_1.ServerTaskWaiter(client, "Default");
-                    startTime = new Date();
-                    return [4 /*yield*/, expect(function () {
-                            return serverTaskWaiter.waitForServerTaskToComplete("ServerTasks-99999", 1000, 10000);
-                        }).rejects.toThrow("Unknown task Id(s) ServerTasks-99999")];
-                case 2:
-                    _a.sent();
-                    endTime = new Date();
-                    timeDiff = endTime.getTime() - startTime.getTime();
-                    expect(timeDiff).toBeLessThan(6000);
-                    return [2 /*return*/];
-            }
-        });
-    }); });
+    describe("non-existent task", function () {
+        test("wait exits correctly", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var client, serverTaskWaiter, startTime, endTime, timeDiff;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, client_1.Client.create((0, clientConfiguration_test_1.processConfiguration)())];
+                    case 1:
+                        client = _a.sent();
+                        serverTaskWaiter = new serverTaskWaiter_1.ServerTaskWaiter(client, "Default");
+                        startTime = new Date();
+                        return [4 /*yield*/, expect(function () {
+                                return serverTaskWaiter.waitForServerTaskToComplete("ServerTasks-99999", 1000, 10000);
+                            }).rejects.toThrow("Unknown task Id(s) ServerTasks-99999")];
+                    case 2:
+                        _a.sent();
+                        endTime = new Date();
+                        timeDiff = endTime.getTime() - startTime.getTime();
+                        expect(timeDiff).toBeLessThan(6000);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe("existing task", function () {
+        var client;
+        var environment;
+        var project;
+        var space;
+        var user;
+        jest.setTimeout(100000);
+        beforeAll(function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, client_1.Client.create((0, clientConfiguration_test_1.processConfiguration)())];
+                    case 1:
+                        client = _a.sent();
+                        console.log("Client connected to API endpoint successfully.");
+                        return [4 /*yield*/, (0, __1.userGetCurrent)(client)];
+                    case 2:
+                        user = _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        beforeEach(function () { return __awaiter(void 0, void 0, void 0, function () {
+            var spaceName, spaceRepository, projectGroup, lifecycle, projectName, deploymentProcessRepository, deploymentProcess, environmentName, envRepository;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        spaceName = (0, crypto_1.randomUUID)().substring(0, 20);
+                        console.log("Creating space, \"".concat(spaceName, "\"..."));
+                        spaceRepository = new __1.SpaceRepository(client);
+                        return [4 /*yield*/, spaceRepository.create({ Name: spaceName, SpaceManagersTeams: [], SpaceManagersTeamMembers: [user.Id], IsDefault: false })];
+                    case 1:
+                        space = _a.sent();
+                        console.log("Space \"".concat(spaceName, "\" created successfully."));
+                        return [4 /*yield*/, new __1.ProjectGroupRepository(client, spaceName).list({ take: 1 })];
+                    case 2:
+                        projectGroup = (_a.sent()).Items[0];
+                        return [4 /*yield*/, new __1.LifecycleRepository(client, spaceName).list({ take: 1 })];
+                    case 3:
+                        lifecycle = (_a.sent()).Items[0];
+                        projectName = (0, crypto_1.randomUUID)();
+                        console.log("Creating project, \"".concat(projectName, "\"..."));
+                        return [4 /*yield*/, new __1.ProjectRepository(client, spaceName).create((0, __1.NewProject)(projectName, projectGroup, lifecycle))];
+                    case 4:
+                        project = _a.sent();
+                        console.log("Project \"".concat(projectName, "\" created successfully."));
+                        deploymentProcessRepository = new __1.DeploymentProcessRepository(client, space.Name);
+                        return [4 /*yield*/, deploymentProcessRepository.get(project)];
+                    case 5:
+                        deploymentProcess = _a.sent();
+                        deploymentProcess.Steps = [
+                            {
+                                Condition: __1.RunCondition.Success,
+                                PackageRequirement: __1.PackageRequirement.LetOctopusDecide,
+                                StartTrigger: __1.StartTrigger.StartAfterPrevious,
+                                Id: "",
+                                Name: (0, crypto_1.randomUUID)(),
+                                Properties: {},
+                                Actions: [
+                                    {
+                                        Id: "",
+                                        Name: "Run a Script",
+                                        ActionType: "Octopus.Script",
+                                        Notes: null,
+                                        IsDisabled: false,
+                                        CanBeUsedForProjectVersioning: false,
+                                        IsRequired: false,
+                                        WorkerPoolId: null,
+                                        Container: {
+                                            Image: null,
+                                            FeedId: null,
+                                        },
+                                        WorkerPoolVariable: "",
+                                        Environments: [],
+                                        ExcludedEnvironments: [],
+                                        Channels: [],
+                                        TenantTags: [],
+                                        Packages: [],
+                                        Condition: __1.RunConditionForAction.Success,
+                                        Properties: {
+                                            "Octopus.Action.RunOnServer": "true",
+                                            "Octopus.Action.Script.ScriptSource": "Inline",
+                                            "Octopus.Action.Script.Syntax": "PowerShell",
+                                            "Octopus.Action.Script.ScriptBody": "Write-Host 'hello'; Start-Sleep -Seconds 10",
+                                        },
+                                    },
+                                ],
+                            },
+                        ];
+                        console.log("Updating deployment process, \"".concat(deploymentProcess.Id, "\"..."));
+                        return [4 /*yield*/, deploymentProcessRepository.update(project, deploymentProcess)];
+                    case 6:
+                        _a.sent();
+                        console.log("Deployment process, \"".concat(deploymentProcess.Id, "\" updated successfully."));
+                        environmentName = (0, crypto_1.randomUUID)();
+                        console.log("Creating environment, \"".concat(environmentName, "\"..."));
+                        envRepository = new __1.EnvironmentRepository(client, spaceName);
+                        return [4 /*yield*/, envRepository.create({ Name: environmentName })];
+                    case 7:
+                        environment = _a.sent();
+                        console.log("Environment \"".concat(environment.Name, "\" created successfully."));
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        test("deploy with default timeout exits correctly", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var releaseCommand, releaseRepository, releaseResponse, deployCommand, deploymentRepository, response, deployments, taskIds, e, completedTasks;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        releaseCommand = {
+                            spaceName: space.Name,
+                            ProjectName: project.Name,
+                        };
+                        releaseRepository = new __1.ReleaseRepository(client, space.Name);
+                        return [4 /*yield*/, releaseRepository.create(releaseCommand)];
+                    case 1:
+                        releaseResponse = _a.sent();
+                        deployCommand = {
+                            spaceName: space.Name,
+                            ProjectName: project.Name,
+                            ReleaseVersion: releaseResponse.ReleaseVersion,
+                            EnvironmentNames: [environment.Name],
+                        };
+                        deploymentRepository = new __1.DeploymentRepository(client, space.Name);
+                        return [4 /*yield*/, deploymentRepository.create(deployCommand)];
+                    case 2:
+                        response = _a.sent();
+                        return [4 /*yield*/, deploymentRepository.list({ ids: response.DeploymentServerTasks.map(function (t) { return t.DeploymentId; }) })];
+                    case 3:
+                        deployments = _a.sent();
+                        expect(deployments.Items.length).toBe(1);
+                        taskIds = response.DeploymentServerTasks.map(function (x) { return x.ServerTaskId; });
+                        e = new serverTaskWaiter_1.ServerTaskWaiter(client, space.Name);
+                        return [4 /*yield*/, e.waitForServerTasksToComplete(taskIds, 1000, 600000, function (serverTask) {
+                                console.log("Waiting for task ".concat(serverTask.Id, ". Current status: ").concat(serverTask.State));
+                            })];
+                    case 4:
+                        completedTasks = _a.sent();
+                        expect(completedTasks.length).toBe(1);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        test("deploy with short timeout exits correctly", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var releaseCommand, releaseRepository, releaseResponse, deployCommand, deploymentRepository, response, deployments, taskIds, e, completedTasks;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        releaseCommand = {
+                            spaceName: space.Name,
+                            ProjectName: project.Name,
+                        };
+                        releaseRepository = new __1.ReleaseRepository(client, space.Name);
+                        return [4 /*yield*/, releaseRepository.create(releaseCommand)];
+                    case 1:
+                        releaseResponse = _a.sent();
+                        deployCommand = {
+                            spaceName: space.Name,
+                            ProjectName: project.Name,
+                            ReleaseVersion: releaseResponse.ReleaseVersion,
+                            EnvironmentNames: [environment.Name],
+                        };
+                        deploymentRepository = new __1.DeploymentRepository(client, space.Name);
+                        return [4 /*yield*/, deploymentRepository.create(deployCommand)];
+                    case 2:
+                        response = _a.sent();
+                        return [4 /*yield*/, deploymentRepository.list({ ids: response.DeploymentServerTasks.map(function (t) { return t.DeploymentId; }) })];
+                    case 3:
+                        deployments = _a.sent();
+                        expect(deployments.Items.length).toBe(1);
+                        taskIds = response.DeploymentServerTasks.map(function (x) { return x.ServerTaskId; });
+                        e = new serverTaskWaiter_1.ServerTaskWaiter(client, space.Name);
+                        return [4 /*yield*/, e.waitForServerTasksToComplete(taskIds, 1000, 5000, function (serverTask) {
+                                console.log("Waiting for task ".concat(serverTask.Id, ". Current status: ").concat(serverTask.State));
+                            })];
+                    case 4:
+                        completedTasks = _a.sent();
+                        expect(completedTasks.length).toBe(0);
+                        return [4 /*yield*/, e.waitForServerTasksToComplete(taskIds, 1000, 600000, function (serverTask) {
+                                console.log("Waiting for task ".concat(serverTask.Id, ". Current status: ").concat(serverTask.State));
+                            })];
+                    case 5:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        afterEach(function () { return __awaiter(void 0, void 0, void 0, function () {
+            var spaceRepository;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (space === undefined || space === null)
+                            return [2 /*return*/];
+                        console.log("Deleting space, ".concat(space.Name, "..."));
+                        space.TaskQueueStopped = true;
+                        spaceRepository = new __1.SpaceRepository(client);
+                        return [4 /*yield*/, spaceRepository.modify(space)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, spaceRepository.del(space)];
+                    case 2:
+                        _a.sent();
+                        console.log("Space '".concat(space.Name, "' deleted successfully."));
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
 });

package.json

@@ -29,2 +29,3 @@ {
     "@typescript-eslint/parser": "^5.46.1",
+    "dotenv": "^16.4.5",
     "eslint": "^8.29.0",
@@ -79,3 +80,3 @@ "eslint-config-prettier": "^8.5.0",
   "types": "dist/index.d.ts",
-  "version": "3.3.0",
+  "version": "3.3.1",
   "jest-junit": {
@@ -82,0 +83,0 @@ "outputDirectory": "reports",

No alert changes

Improved metrics

Total package byte prevSize

426015

3.12%

Lines of code

8547

2.59%

Worsened metrics

Dev dependency count

33

3.13%

No dependency changes