@revopush/code-push-cli 0.0.1

package/test/hash-utils.ts

@@ -0,0 +1,170 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import * as assert from "assert";
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as hashUtils from "../script/hash-utils";
+var mkdirp = require("mkdirp");
+import * as os from "os";
+import * as path from "path";
+import * as q from "q";
+var yauzl = require("yauzl");
+
+import PackageManifest = hashUtils.PackageManifest;
+import Promise = q.Promise;
+
+function randomString(): string {
+  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: string, directoryPath: string): Promise<void> {
+  var deferred: q.Deferred<void> = q.defer<void>();
+  var originalCwd: string = process.cwd();
+
+  mkdirp(directoryPath, (err: Error) => {
+    if (err) throw err;
+    process.chdir(directoryPath);
+
+    yauzl.open(zipPath, { lazyEntries: true }, function (err: Error, zipfile: any) {
+      if (err) throw err;
+      zipfile.readEntry();
+      zipfile.on("entry", function (entry: any) {
+        if (/\/$/.test(entry.fileName)) {
+          // directory file names end with '/'
+          mkdirp(entry.fileName, function (err: Error) {
+            if (err) throw err;
+            zipfile.readEntry();
+          });
+        } else {
+          // file entry
+          zipfile.openReadStream(entry, function (err: Error, readStream: any) {
+            if (err) throw err;
+            // ensure parent directory exists
+            mkdirp(path.dirname(entry.fileName), function (err: Error) {
+              if (err) throw err;
+              readStream.pipe(fs.createWriteStream(entry.fileName));
+              readStream.on("end", function () {
+                zipfile.readEntry();
+              });
+            });
+          });
+        }
+      });
+
+      zipfile.on("end", function (err: Error) {
+        if (err) deferred.reject(err);
+        else deferred.resolve(<void>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: string): void => {
+      assert.equal(packageHash, TEST_ZIP_HASH);
+
+      done();
+    });
+  });
+
+  it("generates a package manifest for an archive", (done) => {
+    hashUtils.generatePackageManifestFromZip(TEST_ARCHIVE_FILE_PATH).done((manifest: PackageManifest): void => {
+      var fileHashesMap = manifest.toMap();
+      assert.equal(fileHashesMap.size, 3);
+
+      var hash: string = 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: PackageManifest): void => {
+        var fileHashesMap = manifest.toMap();
+        assert.equal(fileHashesMap.size, 3);
+
+        var hash: string = 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: PackageManifest) => {
+        return manifest.computePackageHash();
+      })
+      .done((packageHash: string): void => {
+        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: PackageManifest): void => {
+      assert.equal(manifest.toMap().size, 1);
+      var hash: string = 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: PackageManifest): void => {
+        assert.equal(manifest.toMap().size, 1);
+        var hash: string = manifest.toMap().get("www/index.html");
+        assert.equal(hash, INDEX_HASH);
+        done();
+      });
+  });
+});

package/test/management-sdk.ts

@@ -0,0 +1,438 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import * as assert from "assert";
+import * as Q from "q";
+
+import AccountManager = require("../script/management-sdk");
+
+var request = require("superagent");
+
+var manager: AccountManager;
+describe("Management SDK", () => {
+  beforeEach(() => {
+    manager = new AccountManager(/*accessKey=*/ "dummyAccessKey", /*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: Mocha.Done) => {
+    mockReturn("Text", 404);
+
+    var methodsWithErrorHandling: any[] = [
+      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<void>(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: any): Q.Promise<void> {
+      return Q.Promise<void>((resolve: any, reject: any, notify: any) => {
+        method().done(
+          () => {
+            assert.fail("Should have thrown an error");
+            reject();
+          },
+          (error: any) => {
+            assert.equal(error.message, "Text");
+            assert(error.statusCode);
+            resolve();
+          }
+        );
+      });
+    }
+  });
+
+  it("isAuthenticated handles successful auth", (done: Mocha.Done) => {
+    mockReturn(JSON.stringify({ authenticated: true }), 200, {});
+    manager.isAuthenticated().done((authenticated: boolean) => {
+      assert(authenticated, "Should be authenticated");
+      done();
+    });
+  });
+
+  it("isAuthenticated handles unsuccessful auth", (done: Mocha.Done) => {
+    mockReturn("Unauthorized", 401, {});
+    manager.isAuthenticated().done((authenticated: boolean) => {
+      assert(!authenticated, "Should not be authenticated");
+      done();
+    });
+  });
+
+  it("isAuthenticated handles unsuccessful auth with promise rejection", (done: Mocha.Done) => {
+    mockReturn("Unauthorized", 401, {});
+
+    // use optional parameter to ask for rejection of the promise if not authenticated
+    manager.isAuthenticated(true).done(
+      (authenticated: boolean) => {
+        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: Mocha.Done) => {
+    mockReturn("Not Found", 404, {});
+    manager.isAuthenticated().done(
+      (authenticated: boolean) => {
+        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: Mocha.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: Mocha.Done) => {
+    mockReturn(JSON.stringify({ success: false }), 404, {});
+    manager.addApp("appName").done(
+      (obj) => {
+        throw new Error("Call should not complete successfully");
+      },
+      (error: Error) => done()
+    );
+  });
+
+  it("getApp handles JSON response", (done: Mocha.Done) => {
+    mockReturn(JSON.stringify({ app: {} }), 200, {});
+
+    manager.getApp("appName").done((obj: any) => {
+      assert.ok(obj);
+      done();
+    }, rejectHandler);
+  });
+
+  it("updateApp handles success response", (done: Mocha.Done) => {
+    mockReturn(JSON.stringify({ apps: [] }), 200, {});
+
+    manager.renameApp("appName", "newAppName").done((obj: any) => {
+      assert.ok(!obj);
+      done();
+    }, rejectHandler);
+  });
+
+  it("removeApp handles success response", (done: Mocha.Done) => {
+    mockReturn("", 200, {});
+
+    manager.removeApp("appName").done((obj: any) => {
+      assert.ok(!obj);
+      done();
+    }, rejectHandler);
+  });
+
+  it("transferApp handles successful response", (done: Mocha.Done) => {
+    mockReturn("", 201);
+    manager.transferApp("appName", "email1").done((obj: any) => {
+      assert.ok(!obj);
+      done();
+    }, rejectHandler);
+  });
+
+  it("addDeployment handles success response", (done: Mocha.Done) => {
+    mockReturn(JSON.stringify({ deployment: { name: "name", key: "key" } }), 201, { location: "/deploymentName" });
+
+    manager.addDeployment("appName", "deploymentName").done((obj: any) => {
+      assert.ok(obj);
+      done();
+    }, rejectHandler);
+  });
+
+  it("getDeployment handles JSON response", (done: Mocha.Done) => {
+    mockReturn(JSON.stringify({ deployment: {} }), 200, {});
+
+    manager.getDeployment("appName", "deploymentName").done((obj: any) => {
+      assert.ok(obj);
+      done();
+    }, rejectHandler);
+  });
+
+  it("getDeployments handles JSON response", (done: Mocha.Done) => {
+    mockReturn(JSON.stringify({ deployments: [] }), 200, {});
+
+    manager.getDeployments("appName").done((obj: any) => {
+      assert.ok(obj);
+      done();
+    }, rejectHandler);
+  });
+
+  it("renameDeployment handles success response", (done: Mocha.Done) => {
+    mockReturn(JSON.stringify({ apps: [] }), 200, {});
+
+    manager.renameDeployment("appName", "deploymentName", "newDeploymentName").done((obj: any) => {
+      assert.ok(!obj);
+      done();
+    }, rejectHandler);
+  });
+
+  it("removeDeployment handles success response", (done: Mocha.Done) => {
+    mockReturn("", 200, {});
+
+    manager.removeDeployment("appName", "deploymentName").done((obj: any) => {
+      assert.ok(!obj);
+      done();
+    }, rejectHandler);
+  });
+
+  it("getDeploymentHistory handles success response with no packages", (done: Mocha.Done) => {
+    mockReturn(JSON.stringify({ history: [] }), 200);
+
+    manager.getDeploymentHistory("appName", "deploymentName").done((obj: any) => {
+      assert.ok(obj);
+      assert.equal(obj.length, 0);
+      done();
+    }, rejectHandler);
+  });
+
+  it("getDeploymentHistory handles success response with two packages", (done: Mocha.Done) => {
+    mockReturn(JSON.stringify({ history: [{ label: "v1" }, { label: "v2" }] }), 200);
+
+    manager.getDeploymentHistory("appName", "deploymentName").done((obj: any) => {
+      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: Mocha.Done) => {
+    mockReturn("", 404);
+
+    manager.getDeploymentHistory("appName", "deploymentName").done(
+      (obj: any) => {
+        throw new Error("Call should not complete successfully");
+      },
+      (error: Error) => done()
+    );
+  });
+
+  it("clearDeploymentHistory handles success response", (done: Mocha.Done) => {
+    mockReturn("", 204);
+
+    manager.clearDeploymentHistory("appName", "deploymentName").done((obj: any) => {
+      assert.ok(!obj);
+      done();
+    }, rejectHandler);
+  });
+
+  it("clearDeploymentHistory handles error response", (done: Mocha.Done) => {
+    mockReturn("", 404);
+
+    manager.clearDeploymentHistory("appName", "deploymentName").done(
+      (obj: any) => {
+        throw new Error("Call should not complete successfully");
+      },
+      (error: Error) => done()
+    );
+  });
+
+  it("addCollaborator handles successful response", (done: Mocha.Done) => {
+    mockReturn("", 201, { location: "/collaborators" });
+    manager.addCollaborator("appName", "email1").done((obj: any) => {
+      assert.ok(!obj);
+      done();
+    }, rejectHandler);
+  });
+
+  it("addCollaborator handles error response", (done: Mocha.Done) => {
+    mockReturn("", 404, {});
+    manager.addCollaborator("appName", "email1").done(
+      (obj) => {
+        throw new Error("Call should not complete successfully");
+      },
+      (error: Error) => done()
+    );
+  });
+
+  it("getCollaborators handles success response with no collaborators", (done: Mocha.Done) => {
+    mockReturn(JSON.stringify({ collaborators: {} }), 200);
+
+    manager.getCollaborators("appName").done((obj: any) => {
+      assert.ok(obj);
+      assert.equal(Object.keys(obj).length, 0);
+      done();
+    }, rejectHandler);
+  });
+
+  it("getCollaborators handles success response with multiple collaborators", (done: Mocha.Done) => {
+    mockReturn(
+      JSON.stringify({
+        collaborators: {
+          email1: { permission: "Owner", isCurrentAccount: true },
+          email2: { permission: "Collaborator", isCurrentAccount: false },
+        },
+      }),
+      200
+    );
+
+    manager.getCollaborators("appName").done((obj: any) => {
+      assert.ok(obj);
+      assert.equal(obj["email1"].permission, "Owner");
+      assert.equal(obj["email2"].permission, "Collaborator");
+      done();
+    }, rejectHandler);
+  });
+
+  it("removeCollaborator handles success response", (done: Mocha.Done) => {
+    mockReturn("", 200, {});
+
+    manager.removeCollaborator("appName", "email1").done((obj: any) => {
+      assert.ok(!obj);
+      done();
+    }, rejectHandler);
+  });
+
+  it("patchRelease handles success response", (done: Mocha.Done) => {
+    mockReturn(JSON.stringify({ package: { description: "newDescription" } }), 200);
+
+    manager
+      .patchRelease("appName", "deploymentName", "label", {
+        description: "newDescription",
+      })
+      .done((obj: any) => {
+        assert.ok(!obj);
+        done();
+      }, rejectHandler);
+  });
+
+  it("patchRelease handles error response", (done: Mocha.Done) => {
+    mockReturn("", 400);
+
+    manager.patchRelease("appName", "deploymentName", "label", {}).done(
+      (obj: any) => {
+        throw new Error("Call should not complete successfully");
+      },
+      (error: Error) => done()
+    );
+  });
+
+  it("promote handles success response", (done: Mocha.Done) => {
+    mockReturn(JSON.stringify({ package: { description: "newDescription" } }), 200);
+
+    manager
+      .promote("appName", "deploymentName", "newDeploymentName", {
+        description: "newDescription",
+      })
+      .done((obj: any) => {
+        assert.ok(!obj);
+        done();
+      }, rejectHandler);
+  });
+
+  it("promote handles error response", (done: Mocha.Done) => {
+    mockReturn("", 400);
+
+    manager
+      .promote("appName", "deploymentName", "newDeploymentName", {
+        rollout: 123,
+      })
+      .done(
+        (obj: any) => {
+          throw new Error("Call should not complete successfully");
+        },
+        (error: Error) => done()
+      );
+  });
+
+  it("rollback handles success response", (done: Mocha.Done) => {
+    mockReturn(JSON.stringify({ package: { label: "v1" } }), 200);
+
+    manager.rollback("appName", "deploymentName", "v1").done((obj: any) => {
+      assert.ok(!obj);
+      done();
+    }, rejectHandler);
+  });
+
+  it("rollback handles error response", (done: Mocha.Done) => {
+    mockReturn("", 400);
+
+    manager.rollback("appName", "deploymentName", "v1").done(
+      (obj: any) => {
+        throw new Error("Call should not complete successfully");
+      },
+      (error: Error) => done()
+    );
+  });
+});
+
+// Helper method that is used everywhere that an assert.fail() is needed in a promise handler
+function rejectHandler(val: any): void {
+  assert.fail();
+}
+
+// Wrapper for superagent-mock that abstracts away information not needed for SDK tests
+function mockReturn(bodyText: string, statusCode: number, header = {}): void {
+  require("superagent-mock")(request, [
+    {
+      pattern: "http://localhost/(\\w+)/?",
+      fixtures: function (match: any, params: any): any {
+        var isOk = statusCode >= 200 && statusCode < 300;
+        if (!isOk) {
+          var err: any = new Error(bodyText);
+          err.status = statusCode;
+          throw err;
+        }
+        return {
+          text: bodyText,
+          status: statusCode,
+          ok: isOk,
+          header: header,
+          headers: {},
+        };
+      },
+      callback: function (match: any, data: any): any {
+        return data;
+      },
+    },
+  ]);
+}

package/test/resources/TestApp/android/app/build.gradle

@@ -0,0 +1,56 @@
+apply plugin: "com.android.application"
+
+import com.android.build.OutputFile
+
+apply from: "react.gradle"
+
+def enableSeparateBuildPerCPUArchitecture = false
+def enableProguardInReleaseBuilds = true
+
+android {
+    compileSdkVersion 23
+    buildToolsVersion "23.0.1"
+
+    defaultConfig {
+        applicationId "com.microsoft.testapp"
+        minSdkVersion 16
+        targetSdkVersion 22
+        versionCode 1
+        versionName "1.0.0"
+        ndk {
+            abiFilters "armeabi-v7a", "x86"
+        }
+    }
+    splits {
+        abi {
+            enable enableSeparateBuildPerCPUArchitecture
+            universalApk true
+            reset()
+            include "armeabi-v7a", "x86"
+        }
+    }
+    buildTypes {
+        release {
+            minifyEnabled enableProguardInReleaseBuilds
+            proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"
+        }
+    }
+    
+    applicationVariants.all { variant ->
+        variant.outputs.each { output ->
+            def versionCodes = ["armeabi-v7a":1, "x86":2]
+            def abi = output.getFilter(OutputFile.ABI)
+            if (abi != null) {
+                output.versionCodeOverride =
+                        versionCodes.get(abi) * 1048576 + defaultConfig.versionCode
+            }
+        }
+    }
+}
+
+dependencies {
+    compile fileTree(dir: "libs", include: ["*.jar"])
+    compile "com.android.support:appcompat-v7:23.0.1"
+    compile "com.facebook.react:react-native:0.19.+"
+    compile project(":react-native-code-push")
+}