@appcircle/codepush-cli 0.0.1-alpha.1

package/bin/test/hash-utils.js

@@ -0,0 +1,149 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = require("assert");
+const crypto = require("crypto");
+const fs = require("fs");
+const hashUtils = require("../script/hash-utils");
+var mkdirp = require("mkdirp");
+const os = require("os");
+const path = require("path");
+const q = require("q");
+var yauzl = require("yauzl");
+function randomString() {
+    var stringLength = 10;
+    return crypto
+        .randomBytes(Math.ceil(stringLength / 2))
+        .toString("hex") // convert to hexadecimal format
+        .slice(0, stringLength); // return required number of characters
+}
+function unzipToDirectory(zipPath, directoryPath) {
+    var deferred = q.defer();
+    var originalCwd = process.cwd();
+    mkdirp(directoryPath, (err) => {
+        if (err)
+            throw err;
+        process.chdir(directoryPath);
+        yauzl.open(zipPath, { lazyEntries: true }, function (err, zipfile) {
+            if (err)
+                throw err;
+            zipfile.readEntry();
+            zipfile.on("entry", function (entry) {
+                if (/\/$/.test(entry.fileName)) {
+                    // directory file names end with '/'
+                    mkdirp(entry.fileName, function (err) {
+                        if (err)
+                            throw err;
+                        zipfile.readEntry();
+                    });
+                }
+                else {
+                    // file entry
+                    zipfile.openReadStream(entry, function (err, readStream) {
+                        if (err)
+                            throw err;
+                        // ensure parent directory exists
+                        mkdirp(path.dirname(entry.fileName), function (err) {
+                            if (err)
+                                throw err;
+                            readStream.pipe(fs.createWriteStream(entry.fileName));
+                            readStream.on("end", function () {
+                                zipfile.readEntry();
+                            });
+                        });
+                    });
+                }
+            });
+            zipfile.on("end", function (err) {
+                if (err)
+                    deferred.reject(err);
+                else
+                    deferred.resolve(null);
+            });
+        });
+    });
+    return deferred.promise.finally(() => {
+        process.chdir(originalCwd);
+    });
+}
+describe("Hashing utility", () => {
+    const TEST_DIRECTORY = path.join(os.tmpdir(), "codepushtests", randomString());
+    const TEST_ARCHIVE_FILE_PATH = path.join(__dirname, "resources", "test.zip");
+    const TEST_ZIP_HASH = "540fed8df3553079e81d1353c5cc4e3cac7db9aea647a85d550f646e8620c317";
+    const TEST_ZIP_MANIFEST_HASH = "9e0499ce7df5c04cb304c9deed684dc137fc603cb484a5b027478143c595d80b";
+    const HASH_B = "3e23e8160039594a33894f6564e1b1348bbd7a0088d42c4acb73eeaed59c009d";
+    const HASH_C = "2e7d2c03a9507ae265ecf5b5356885a53393a2029d241394997265a1a25aefc6";
+    const HASH_D = "18ac3e7343f016890c510e93f935261169d9e3f565436429830faf0934f4f8e4";
+    const IGNORED_METADATA_ARCHIVE_FILE_PATH = path.join(__dirname, "resources", "ignoredMetadata.zip");
+    const INDEX_HASH = "b0693dc92f76e08bf1485b3dd9b514a2e31dfd6f39422a6b60edb722671dc98f";
+    it("generates a package hash from file", (done) => {
+        hashUtils.hashFile(TEST_ARCHIVE_FILE_PATH).done((packageHash) => {
+            assert.equal(packageHash, TEST_ZIP_HASH);
+            done();
+        });
+    });
+    it("generates a package manifest for an archive", (done) => {
+        hashUtils.generatePackageManifestFromZip(TEST_ARCHIVE_FILE_PATH).done((manifest) => {
+            var fileHashesMap = manifest.toMap();
+            assert.equal(fileHashesMap.size, 3);
+            var hash = fileHashesMap.get("b.txt");
+            assert.equal(hash, HASH_B);
+            hash = fileHashesMap.get("c.txt");
+            assert.equal(hash, HASH_C);
+            hash = fileHashesMap.get("d.txt");
+            assert.equal(hash, HASH_D);
+            done();
+        });
+    });
+    it("generates a package manifest for a directory", (done) => {
+        var directory = path.join(TEST_DIRECTORY, "testZip");
+        unzipToDirectory(TEST_ARCHIVE_FILE_PATH, directory)
+            .then(() => {
+            return hashUtils.generatePackageManifestFromDirectory(/*directoryPath*/ directory, /*basePath*/ directory);
+        })
+            .done((manifest) => {
+            var fileHashesMap = manifest.toMap();
+            assert.equal(fileHashesMap.size, 3);
+            var hash = fileHashesMap.get("b.txt");
+            assert.equal(hash, HASH_B);
+            hash = fileHashesMap.get("c.txt");
+            assert.equal(hash, HASH_C);
+            hash = fileHashesMap.get("d.txt");
+            assert.equal(hash, HASH_D);
+            done();
+        });
+    });
+    it("generates a package hash from manifest", (done) => {
+        hashUtils
+            .generatePackageManifestFromZip(TEST_ARCHIVE_FILE_PATH)
+            .then((manifest) => {
+            return manifest.computePackageHash();
+        })
+            .done((packageHash) => {
+            assert.equal(packageHash, TEST_ZIP_MANIFEST_HASH);
+            done();
+        });
+    });
+    it("generates a package manifest for an archive with ignorable metadata", (done) => {
+        hashUtils.generatePackageManifestFromZip(IGNORED_METADATA_ARCHIVE_FILE_PATH).done((manifest) => {
+            assert.equal(manifest.toMap().size, 1);
+            var hash = manifest.toMap().get("www/index.html");
+            assert.equal(hash, INDEX_HASH);
+            done();
+        });
+    });
+    it("generates a package manifest for a directory with ignorable metadata", (done) => {
+        var directory = path.join(TEST_DIRECTORY, "ignorableMetadata");
+        unzipToDirectory(IGNORED_METADATA_ARCHIVE_FILE_PATH, directory)
+            .then(() => {
+            return hashUtils.generatePackageManifestFromDirectory(/*directoryPath*/ directory, /*basePath*/ directory);
+        })
+            .done((manifest) => {
+            assert.equal(manifest.toMap().size, 1);
+            var hash = manifest.toMap().get("www/index.html");
+            assert.equal(hash, INDEX_HASH);
+            done();
+        });
+    });
+});

package/bin/test/management-sdk.js

@@ -0,0 +1,338 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = require("assert");
+const Q = require("q");
+const AccountManager = require("../script/management-sdk");
+var request = require("superagent");
+var manager;
+describe("Management SDK", () => {
+    beforeEach(() => {
+        manager = new AccountManager(/*accessKey=*/ "dummyAccessKey", "dummyPat", /*customHeaders=*/ null, /*serverUrl=*/ "http://localhost");
+    });
+    after(() => {
+        // Prevent an exception that occurs due to how superagent-mock overwrites methods
+        request.Request.prototype._callback = function () { };
+    });
+    it("methods reject the promise with status code info when an error occurs", (done) => {
+        mockReturn("Text", 404);
+        var methodsWithErrorHandling = [
+            manager.addApp.bind(manager, "appName"),
+            manager.getApp.bind(manager, "appName"),
+            manager.renameApp.bind(manager, "appName", {}),
+            manager.removeApp.bind(manager, "appName"),
+            manager.transferApp.bind(manager, "appName", "email1"),
+            manager.addDeployment.bind(manager, "appName", "deploymentName"),
+            manager.getDeployment.bind(manager, "appName", "deploymentName"),
+            manager.getDeployments.bind(manager, "appName"),
+            manager.renameDeployment.bind(manager, "appName", "deploymentName", {
+                name: "newDeploymentName",
+            }),
+            manager.removeDeployment.bind(manager, "appName", "deploymentName"),
+            manager.addCollaborator.bind(manager, "appName", "email1"),
+            manager.getCollaborators.bind(manager, "appName"),
+            manager.removeCollaborator.bind(manager, "appName", "email1"),
+            manager.patchRelease.bind(manager, "appName", "deploymentName", "label", {
+                description: "newDescription",
+            }),
+            manager.promote.bind(manager, "appName", "deploymentName", "newDeploymentName", { description: "newDescription" }),
+            manager.rollback.bind(manager, "appName", "deploymentName", "targetReleaseLabel"),
+        ];
+        var result = Q(null);
+        methodsWithErrorHandling.forEach(function (f) {
+            result = result.then(() => {
+                return testErrors(f);
+            });
+        });
+        result.done(() => {
+            done();
+        });
+        // Test that the proper error code and text is passed through on a server error
+        function testErrors(method) {
+            return Q.Promise((resolve, reject, notify) => {
+                method().done(() => {
+                    assert.fail("Should have thrown an error");
+                    reject();
+                }, (error) => {
+                    assert.equal(error.message, "Text");
+                    assert(error.statusCode);
+                    resolve();
+                });
+            });
+        }
+    });
+    it("isAuthenticated handles successful auth", (done) => {
+        mockReturn(JSON.stringify({ authenticated: true }), 200, {});
+        manager.isAuthenticated().done((authenticated) => {
+            assert(authenticated, "Should be authenticated");
+            done();
+        });
+    });
+    it("isAuthenticated handles unsuccessful auth", (done) => {
+        mockReturn("Unauthorized", 401, {});
+        manager.isAuthenticated().done((authenticated) => {
+            assert(!authenticated, "Should not be authenticated");
+            done();
+        });
+    });
+    it("isAuthenticated handles unsuccessful auth with promise rejection", (done) => {
+        mockReturn("Unauthorized", 401, {});
+        // use optional parameter to ask for rejection of the promise if not authenticated
+        manager.isAuthenticated(true).done((authenticated) => {
+            assert.fail("isAuthenticated should have rejected the promise");
+            done();
+        }, (err) => {
+            assert.equal(err.message, "Unauthorized", "Error message should be 'Unauthorized'");
+            done();
+        });
+    });
+    it("isAuthenticated handles unexpected status codes", (done) => {
+        mockReturn("Not Found", 404, {});
+        manager.isAuthenticated().done((authenticated) => {
+            assert.fail("isAuthenticated should have rejected the promise");
+            done();
+        }, (err) => {
+            assert.equal(err.message, "Not Found", "Error message should be 'Not Found'");
+            done();
+        });
+    });
+    it("addApp handles successful response", (done) => {
+        mockReturn(JSON.stringify({ success: true }), 201, {
+            location: "/appName",
+        });
+        manager.addApp("appName").done((obj) => {
+            assert.ok(obj);
+            done();
+        }, rejectHandler);
+    });
+    it("addApp handles error response", (done) => {
+        mockReturn(JSON.stringify({ success: false }), 404, {});
+        manager.addApp("appName").done((obj) => {
+            throw new Error("Call should not complete successfully");
+        }, (error) => done());
+    });
+    it("getApp handles JSON response", (done) => {
+        mockReturn(JSON.stringify({ app: {} }), 200, {});
+        manager.getApp("appName").done((obj) => {
+            assert.ok(obj);
+            done();
+        }, rejectHandler);
+    });
+    it("updateApp handles success response", (done) => {
+        mockReturn(JSON.stringify({ apps: [] }), 200, {});
+        manager.renameApp("appName", "newAppName").done((obj) => {
+            assert.ok(!obj);
+            done();
+        }, rejectHandler);
+    });
+    it("removeApp handles success response", (done) => {
+        mockReturn("", 200, {});
+        manager.removeApp("appName").done((obj) => {
+            assert.ok(!obj);
+            done();
+        }, rejectHandler);
+    });
+    it("transferApp handles successful response", (done) => {
+        mockReturn("", 201);
+        manager.transferApp("appName", "email1").done((obj) => {
+            assert.ok(!obj);
+            done();
+        }, rejectHandler);
+    });
+    it("addDeployment handles success response", (done) => {
+        mockReturn(JSON.stringify({ deployment: { name: "name", key: "key" } }), 201, { location: "/deploymentName" });
+        manager.addDeployment("appName", "deploymentName").done((obj) => {
+            assert.ok(obj);
+            done();
+        }, rejectHandler);
+    });
+    it("getDeployment handles JSON response", (done) => {
+        mockReturn(JSON.stringify({ deployment: {} }), 200, {});
+        manager.getDeployment("appName", "deploymentName").done((obj) => {
+            assert.ok(obj);
+            done();
+        }, rejectHandler);
+    });
+    it("getDeployments handles JSON response", (done) => {
+        mockReturn(JSON.stringify({ deployments: [] }), 200, {});
+        manager.getDeployments("appName").done((obj) => {
+            assert.ok(obj);
+            done();
+        }, rejectHandler);
+    });
+    it("renameDeployment handles success response", (done) => {
+        mockReturn(JSON.stringify({ apps: [] }), 200, {});
+        manager.renameDeployment("appName", "deploymentName", "newDeploymentName").done((obj) => {
+            assert.ok(!obj);
+            done();
+        }, rejectHandler);
+    });
+    it("removeDeployment handles success response", (done) => {
+        mockReturn("", 200, {});
+        manager.removeDeployment("appName", "deploymentName").done((obj) => {
+            assert.ok(!obj);
+            done();
+        }, rejectHandler);
+    });
+    it("getDeploymentHistory handles success response with no packages", (done) => {
+        mockReturn(JSON.stringify({ history: [] }), 200);
+        manager.getDeploymentHistory("appName", "deploymentName").done((obj) => {
+            assert.ok(obj);
+            assert.equal(obj.length, 0);
+            done();
+        }, rejectHandler);
+    });
+    it("getDeploymentHistory handles success response with two packages", (done) => {
+        mockReturn(JSON.stringify({ history: [{ label: "v1" }, { label: "v2" }] }), 200);
+        manager.getDeploymentHistory("appName", "deploymentName").done((obj) => {
+            assert.ok(obj);
+            assert.equal(obj.length, 2);
+            assert.equal(obj[0].label, "v1");
+            assert.equal(obj[1].label, "v2");
+            done();
+        }, rejectHandler);
+    });
+    it("getDeploymentHistory handles error response", (done) => {
+        mockReturn("", 404);
+        manager.getDeploymentHistory("appName", "deploymentName").done((obj) => {
+            throw new Error("Call should not complete successfully");
+        }, (error) => done());
+    });
+    it("clearDeploymentHistory handles success response", (done) => {
+        mockReturn("", 204);
+        manager.clearDeploymentHistory("appName", "deploymentName").done((obj) => {
+            assert.ok(!obj);
+            done();
+        }, rejectHandler);
+    });
+    it("clearDeploymentHistory handles error response", (done) => {
+        mockReturn("", 404);
+        manager.clearDeploymentHistory("appName", "deploymentName").done((obj) => {
+            throw new Error("Call should not complete successfully");
+        }, (error) => done());
+    });
+    it("addCollaborator handles successful response", (done) => {
+        mockReturn("", 201, { location: "/collaborators" });
+        manager.addCollaborator("appName", "email1").done((obj) => {
+            assert.ok(!obj);
+            done();
+        }, rejectHandler);
+    });
+    it("addCollaborator handles error response", (done) => {
+        mockReturn("", 404, {});
+        manager.addCollaborator("appName", "email1").done((obj) => {
+            throw new Error("Call should not complete successfully");
+        }, (error) => done());
+    });
+    it("getCollaborators handles success response with no collaborators", (done) => {
+        mockReturn(JSON.stringify({ collaborators: {} }), 200);
+        manager.getCollaborators("appName").done((obj) => {
+            assert.ok(obj);
+            assert.equal(Object.keys(obj).length, 0);
+            done();
+        }, rejectHandler);
+    });
+    it("getCollaborators handles success response with multiple collaborators", (done) => {
+        mockReturn(JSON.stringify({
+            collaborators: {
+                email1: { permission: "Owner", isCurrentAccount: true },
+                email2: { permission: "Collaborator", isCurrentAccount: false },
+            },
+        }), 200);
+        manager.getCollaborators("appName").done((obj) => {
+            assert.ok(obj);
+            assert.equal(obj["email1"].permission, "Owner");
+            assert.equal(obj["email2"].permission, "Collaborator");
+            done();
+        }, rejectHandler);
+    });
+    it("removeCollaborator handles success response", (done) => {
+        mockReturn("", 200, {});
+        manager.removeCollaborator("appName", "email1").done((obj) => {
+            assert.ok(!obj);
+            done();
+        }, rejectHandler);
+    });
+    it("patchRelease handles success response", (done) => {
+        mockReturn(JSON.stringify({ package: { description: "newDescription" } }), 200);
+        manager
+            .patchRelease("appName", "deploymentName", "label", {
+            description: "newDescription",
+        })
+            .done((obj) => {
+            assert.ok(!obj);
+            done();
+        }, rejectHandler);
+    });
+    it("patchRelease handles error response", (done) => {
+        mockReturn("", 400);
+        manager.patchRelease("appName", "deploymentName", "label", {}).done((obj) => {
+            throw new Error("Call should not complete successfully");
+        }, (error) => done());
+    });
+    it("promote handles success response", (done) => {
+        mockReturn(JSON.stringify({ package: { description: "newDescription" } }), 200);
+        manager
+            .promote("appName", "deploymentName", "newDeploymentName", {
+            description: "newDescription",
+        })
+            .done((obj) => {
+            assert.ok(!obj);
+            done();
+        }, rejectHandler);
+    });
+    it("promote handles error response", (done) => {
+        mockReturn("", 400);
+        manager
+            .promote("appName", "deploymentName", "newDeploymentName", {
+            rollout: 123,
+        })
+            .done((obj) => {
+            throw new Error("Call should not complete successfully");
+        }, (error) => done());
+    });
+    it("rollback handles success response", (done) => {
+        mockReturn(JSON.stringify({ package: { label: "v1" } }), 200);
+        manager.rollback("appName", "deploymentName", "v1").done((obj) => {
+            assert.ok(!obj);
+            done();
+        }, rejectHandler);
+    });
+    it("rollback handles error response", (done) => {
+        mockReturn("", 400);
+        manager.rollback("appName", "deploymentName", "v1").done((obj) => {
+            throw new Error("Call should not complete successfully");
+        }, (error) => done());
+    });
+});
+// Helper method that is used everywhere that an assert.fail() is needed in a promise handler
+function rejectHandler(val) {
+    assert.fail();
+}
+// Wrapper for superagent-mock that abstracts away information not needed for SDK tests
+function mockReturn(bodyText, statusCode, header = {}) {
+    require("superagent-mock")(request, [
+        {
+            pattern: "http://localhost/(\\w+)/?",
+            fixtures: function (match, params) {
+                var isOk = statusCode >= 200 && statusCode < 300;
+                if (!isOk) {
+                    var err = new Error(bodyText);
+                    err.status = statusCode;
+                    throw err;
+                }
+                return {
+                    text: bodyText,
+                    status: statusCode,
+                    ok: isOk,
+                    header: header,
+                    headers: {},
+                };
+            },
+            callback: function (match, data) {
+                return data;
+            },
+        },
+    ]);
+}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@appcircle/codepush-cli",
+  "version": "0.0.1-alpha.1",
+  "description": "Management CLI for the CodePush service",
+  "main": "./script/cli.js",
+  "scripts": {
+    "start": "node ./bin/script/cli.js",
+    "build": "tsc",
+    "prettier": "prettier --write \"./**/*.ts\"",
+    "lint": "npx eslint ./script/**/*.ts",
+    "lint:fix": "npx eslint ./script/**/*.ts --fix",
+    "check:package": "zx ./script/utils/check-package.mjs"
+  },
+  "bin": {
+    "appcircle-code-push": "./bin/script/cli.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/appcircleio/ac-codepush-cli"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Appcircle",
+  "license": "MIT",
+  "dependencies": {
+    "backslash": "^0.2.0",
+    "chalk": "^4.1.2",
+    "cli-table": "^0.3.11",
+    "email-validator": "^2.0.4",
+    "gradle-to-js": "2.0.1",
+    "jsonwebtoken": "^9.0.2",
+    "moment": "^2.29.4",
+    "opener": "^1.5.2",
+    "parse-duration": "1.1.0",
+    "plist": "^3.0.6",
+    "progress": "^2.0.3",
+    "prompt": "^1.3.0",
+    "properties": "^1.2.1",
+    "q": "~1.5.1",
+    "recursive-fs": "2.1.0",
+    "rimraf": "^2.5.1",
+    "semver": "^7.5.3",
+    "simctl": "^2.0.3",
+    "slash": "1.0.0",
+    "superagent": "^8.0.9",
+    "temp": "^0.9.4",
+    "which": "^1.2.7",
+    "wordwrap": "1.0.0",
+    "xcode": "^3.0.1",
+    "xml2js": "^0.6.0",
+    "yargs": "^17.7.2",
+    "yazl": "^2.5.1"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.17",
+    "@types/jest": "^29.5.2",
+    "@types/mocha": "^10.0.1",
+    "@types/node": "^20.3.1",
+    "@types/q": "^1.5.5",
+    "@types/sinon": "^10.0.15",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.45.0",
+    "express": "^4.19.2",
+    "mkdirp": "^3.0.1",
+    "prettier": "^2.8.8",
+    "sinon": "15.1.2",
+    "superagent-mock": "^4.0.0",
+    "typescript": "^5.1.3",
+    "which": "^3.0.1",
+    "zx": "^5.2.3"
+  }
+}

package/prettier.config.js

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+module.exports = {
+  printWidth: 135,
+  endOfLine: "auto",
+};