@revopush/code-push-cli 0.0.1

package/script/types/rest-definitions.ts

@@ -0,0 +1,152 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+interface AccessKeyBase {
+  createdBy?: string;
+  /*legacy*/ description?: string;
+  /*key*/ friendlyName?: string;
+  /*generated key*/ name?: string;
+}
+
+/*out*/
+export interface AccessKey extends AccessKeyBase {
+  /*generated*/ createdTime?: number;
+  expires: number;
+  /*generated*/ isSession?: boolean;
+}
+
+/*in*/
+export interface AccessKeyRequest extends AccessKeyBase {
+  ttl?: number;
+}
+
+/*out*/
+export interface DeploymentMetrics {
+  [packageLabelOrAppVersion: string]: UpdateMetrics;
+}
+
+/*in*/
+export interface DeploymentStatusReport {
+  appVersion: string;
+  clientUniqueId?: string;
+  deploymentKey: string;
+  previousDeploymentKey?: string;
+  previousLabelOrAppVersion?: string;
+  label?: string;
+  status?: string;
+}
+
+/*in*/
+export interface DownloadReport {
+  clientUniqueId: string;
+  deploymentKey: string;
+  label: string;
+}
+
+/*inout*/
+export interface PackageInfo {
+  appVersion?: string;
+  description?: string;
+  isDisabled?: boolean;
+  isMandatory?: boolean;
+  /*generated*/ label?: string;
+  /*generated*/ packageHash?: string;
+  rollout?: number;
+}
+
+/*out*/
+export interface UpdateCheckResponse extends PackageInfo {
+  target_binary_range?: string;
+  downloadURL?: string;
+  isAvailable: boolean;
+  packageSize?: number;
+  shouldRunBinaryVersion?: boolean;
+  updateAppVersion?: boolean;
+}
+
+/*out*/
+export interface UpdateCheckCacheResponse {
+  originalPackage: UpdateCheckResponse;
+  rollout?: number;
+  rolloutPackage?: UpdateCheckResponse;
+}
+
+/*in*/
+export interface UpdateCheckRequest {
+  appVersion: string;
+  clientUniqueId?: string;
+  deploymentKey: string;
+  isCompanion?: boolean;
+  label?: string;
+  packageHash?: string;
+}
+
+/*out*/
+export interface UpdateMetrics {
+  active: number;
+  downloaded?: number;
+  failed?: number;
+  installed?: number;
+}
+
+/*out*/
+export interface Account {
+  /*key*/ email: string;
+  name: string;
+  linkedProviders: string[];
+}
+
+/*out*/
+export interface CollaboratorProperties {
+  isCurrentAccount?: boolean;
+  permission: string;
+}
+
+/*out*/
+export interface CollaboratorMap {
+  [email: string]: CollaboratorProperties;
+}
+
+/*inout*/
+export interface App {
+  /*generated*/ collaborators?: CollaboratorMap;
+  /*key*/ name: string;
+  /*generated*/ deployments?: string[];
+}
+
+/*in*/
+export interface AppCreationRequest extends App {
+  manuallyProvisionDeployments?: boolean;
+}
+
+/*inout*/
+export interface Deployment {
+  /*generated key*/ key?: string;
+  /*key*/ name: string;
+  /*generated*/ package?: Package;
+}
+
+/*out*/
+export interface BlobInfo {
+  size: number;
+  url: string;
+}
+
+/*out*/
+export interface PackageHashToBlobInfoMap {
+  [packageHash: string]: BlobInfo;
+}
+
+/*inout*/
+export interface Package extends PackageInfo {
+  /*generated*/ blobUrl: string;
+  /*generated*/ diffPackageMap?: PackageHashToBlobInfoMap;
+  /*generated*/ originalLabel?: string; // Set on "Promote" and "Rollback"
+  /*generated*/ originalDeployment?: string; // Set on "Promote"
+  /*generated*/ releasedBy?: string; // Set by commitPackage
+  /*generated*/ releaseMethod?: string; // "Upload", "Promote" or "Rollback". Unknown if unspecified
+  /*generated*/ size: number;
+  /*generated*/ uploadTime: number;
+}
+
+export * from "./rest-definitions";

package/script/types.ts

@@ -0,0 +1,35 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+export {
+  AccessKeyRequest,
+  Account,
+  App,
+  CollaboratorMap,
+  CollaboratorProperties,
+  Deployment,
+  DeploymentMetrics,
+  Package,
+  PackageInfo,
+  AccessKey as ServerAccessKey,
+  UpdateMetrics,
+} from "../script/types/rest-definitions";
+
+export interface CodePushError {
+  message: string;
+  statusCode: number;
+}
+
+export interface AccessKey {
+  createdTime: number;
+  expires: number;
+  name: string;
+  key?: string;
+}
+
+export interface Session {
+  loggedInTime: number;
+  machineName: string;
+}
+
+export type Headers = { [headerName: string]: string };

package/script/utils/file-utils.ts

@@ -0,0 +1,46 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as rimraf from "rimraf";
+import * as temp from "temp";
+
+export function isBinaryOrZip(path: string): boolean {
+  return path.search(/\.zip$/i) !== -1 || path.search(/\.apk$/i) !== -1 || path.search(/\.ipa$/i) !== -1;
+}
+
+export function isDirectory(path: string): boolean {
+  return fs.statSync(path).isDirectory();
+}
+
+export function fileExists(file: string): boolean {
+  try {
+    return fs.statSync(file).isFile();
+  } catch (e) {
+    return false;
+  }
+};
+
+export function copyFileToTmpDir(filePath: string): string {
+  if (!isDirectory(filePath)) {
+    const outputFolderPath: string = temp.mkdirSync("code-push");
+    rimraf.sync(outputFolderPath);
+    fs.mkdirSync(outputFolderPath);
+
+    const outputFilePath: string = path.join(outputFolderPath, path.basename(filePath));
+    fs.writeFileSync(outputFilePath, fs.readFileSync(filePath));
+
+    return outputFolderPath;
+  }
+}
+
+export function fileDoesNotExistOrIsDirectory(path: string): boolean {
+  try {
+    return isDirectory(path);
+  } catch (error) {
+    return true;
+  }
+}
+
+export function normalizePath(filePath: string): string {
+  //replace all backslashes coming from cli running on windows machines by slashes
+  return filePath.replace(/\\/g, "/");
+}

package/test/acquisition-rest-mock.ts

@@ -0,0 +1,125 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import * as express from "express";
+import * as querystring from "querystring";
+
+import * as acquisitionSdk from "../script/acquisition-sdk";
+import * as rest from "../script/types/rest-definitions";
+
+export var validDeploymentKey = "asdfasdfawerqw";
+export var latestPackage = <rest.UpdateCheckResponse>{
+  downloadURL: "http://www.windowsazure.com/blobs/awperoiuqpweru",
+  description: "Angry flappy birds",
+  appVersion: "1.5.0",
+  label: "2.4.0",
+  isMandatory: false,
+  isAvailable: true,
+  updateAppVersion: false,
+  packageHash: "hash240",
+  packageSize: 1024,
+};
+
+export var serverUrl = "http://myurl.com";
+var reportStatusDeployUrl = serverUrl + "/reportStatus/deploy";
+var reportStatusDownloadUrl = serverUrl + "/reportStatus/download";
+var updateCheckUrl = serverUrl + "/updateCheck?";
+
+export class HttpRequester implements acquisitionSdk.Http.Requester {
+  public request(
+    verb: acquisitionSdk.Http.Verb,
+    url: string,
+    requestBodyOrCallback: string | acquisitionSdk.Callback<acquisitionSdk.Http.Response>,
+    callback?: acquisitionSdk.Callback<acquisitionSdk.Http.Response>
+  ): void {
+    if (!callback && typeof requestBodyOrCallback === "function") {
+      callback = <acquisitionSdk.Callback<acquisitionSdk.Http.Response>>requestBodyOrCallback;
+    }
+
+    if (verb === acquisitionSdk.Http.Verb.GET && url.indexOf(updateCheckUrl) === 0) {
+      var params = querystring.parse(url.substring(updateCheckUrl.length));
+      Server.onUpdateCheck(params, callback);
+    } else if (verb === acquisitionSdk.Http.Verb.POST && url === reportStatusDeployUrl) {
+      Server.onReportStatus(callback);
+    } else if (verb === acquisitionSdk.Http.Verb.POST && url === reportStatusDownloadUrl) {
+      Server.onReportStatus(callback);
+    } else {
+      throw new Error("Unexpected call");
+    }
+  }
+}
+
+export class CustomResponseHttpRequester implements acquisitionSdk.Http.Requester {
+  response: acquisitionSdk.Http.Response;
+
+  constructor(response: acquisitionSdk.Http.Response) {
+    this.response = response;
+  }
+
+  public request(
+    verb: acquisitionSdk.Http.Verb,
+    url: string,
+    requestBodyOrCallback: string | acquisitionSdk.Callback<acquisitionSdk.Http.Response>,
+    callback?: acquisitionSdk.Callback<acquisitionSdk.Http.Response>
+  ): void {
+    if (typeof requestBodyOrCallback !== "function") {
+      throw new Error("Unexpected request body");
+    }
+
+    callback = <acquisitionSdk.Callback<acquisitionSdk.Http.Response>>requestBodyOrCallback;
+    callback(null, this.response);
+  }
+}
+
+class Server {
+  public static onAcquire(params: any, callback: acquisitionSdk.Callback<acquisitionSdk.Http.Response>): void {
+    if (params.deploymentKey !== validDeploymentKey) {
+      callback(/*error=*/ null, {
+        statusCode: 200,
+        body: JSON.stringify({ updateInfo: { isAvailable: false } }),
+      });
+    } else {
+      callback(/*error=*/ null, {
+        statusCode: 200,
+        body: JSON.stringify({ updateInfo: latestPackage }),
+      });
+    }
+  }
+
+  public static onUpdateCheck(params: any, callback: acquisitionSdk.Callback<acquisitionSdk.Http.Response>): void {
+    var updateRequest: rest.UpdateCheckRequest = {
+      deploymentKey: params.deploymentKey,
+      appVersion: params.appVersion,
+      packageHash: params.packageHash,
+      isCompanion: !!params.isCompanion,
+      label: params.label,
+    };
+
+    if (!updateRequest.deploymentKey || !updateRequest.appVersion) {
+      callback(/*error=*/ null, { statusCode: 400 });
+    } else {
+      var updateInfo = <rest.UpdateCheckResponse>{ isAvailable: false };
+      if (updateRequest.deploymentKey === validDeploymentKey) {
+        if (updateRequest.isCompanion || updateRequest.appVersion === latestPackage.appVersion) {
+          if (updateRequest.packageHash !== latestPackage.packageHash) {
+            updateInfo = latestPackage;
+          }
+        } else if (updateRequest.appVersion < latestPackage.appVersion) {
+          updateInfo = <rest.UpdateCheckResponse>(<any>{
+            updateAppVersion: true,
+            appVersion: latestPackage.appVersion,
+          });
+        }
+      }
+
+      callback(/*error=*/ null, {
+        statusCode: 200,
+        body: JSON.stringify({ updateInfo: updateInfo }),
+      });
+    }
+  }
+
+  public static onReportStatus(callback: acquisitionSdk.Callback<acquisitionSdk.Http.Response>): void {
+    callback(/*error*/ null, /*response*/ { statusCode: 200 });
+  }
+}

package/test/acquisition-sdk.ts

@@ -0,0 +1,272 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import * as assert from "assert";
+import * as express from "express";
+import * as http from "http";
+
+import * as acquisitionSdk from "../script/acquisition-sdk";
+import * as mockApi from "./acquisition-rest-mock";
+import * as rest from "../script/types/rest-definitions";
+
+var latestPackage: rest.UpdateCheckResponse = clone(mockApi.latestPackage);
+
+var configuration: acquisitionSdk.Configuration = {
+  appVersion: "1.5.0",
+  clientUniqueId: "My iPhone",
+  deploymentKey: mockApi.validDeploymentKey,
+  serverUrl: mockApi.serverUrl,
+};
+
+var templateCurrentPackage: acquisitionSdk.Package = {
+  deploymentKey: mockApi.validDeploymentKey,
+  description: "sdfsdf",
+  label: "v1",
+  appVersion: latestPackage.appVersion,
+  packageHash: "hash001",
+  isMandatory: false,
+  packageSize: 100,
+};
+
+var scriptUpdateResult: acquisitionSdk.RemotePackage = {
+  deploymentKey: mockApi.validDeploymentKey,
+  description: latestPackage.description,
+  downloadUrl: latestPackage.downloadURL,
+  label: latestPackage.label,
+  appVersion: latestPackage.appVersion,
+  isMandatory: latestPackage.isMandatory,
+  packageHash: latestPackage.packageHash,
+  packageSize: latestPackage.packageSize,
+};
+
+var nativeUpdateResult: acquisitionSdk.NativeUpdateNotification = {
+  updateAppVersion: true,
+  appVersion: latestPackage.appVersion,
+};
+
+describe("Acquisition SDK", () => {
+  it("Package with lower label and different package hash gives update", (done: Mocha.Done) => {
+    var acquisition = new acquisitionSdk.AcquisitionManager(new mockApi.HttpRequester(), configuration);
+    acquisition.queryUpdateWithCurrentPackage(
+      templateCurrentPackage,
+      (error: Error, returnPackage: acquisitionSdk.RemotePackage | acquisitionSdk.NativeUpdateNotification) => {
+        assert.equal(null, error);
+        assert.deepEqual(scriptUpdateResult, returnPackage);
+        done();
+      }
+    );
+  });
+
+  it("Package with equal package hash gives no update", (done: Mocha.Done) => {
+    var equalVersionPackage: acquisitionSdk.Package = clone(templateCurrentPackage);
+    equalVersionPackage.packageHash = latestPackage.packageHash;
+
+    var acquisition = new acquisitionSdk.AcquisitionManager(new mockApi.HttpRequester(), configuration);
+    acquisition.queryUpdateWithCurrentPackage(
+      equalVersionPackage,
+      (error: Error, returnPackage: acquisitionSdk.RemotePackage | acquisitionSdk.NativeUpdateNotification) => {
+        assert.equal(null, error);
+        assert.equal(null, returnPackage);
+        done();
+      }
+    );
+  });
+
+  it("Package with higher different hash and higher label version gives update", (done: Mocha.Done) => {
+    var higherVersionPackage: acquisitionSdk.Package = clone(templateCurrentPackage);
+    higherVersionPackage.packageHash = "hash990";
+
+    var acquisition = new acquisitionSdk.AcquisitionManager(new mockApi.HttpRequester(), configuration);
+    acquisition.queryUpdateWithCurrentPackage(
+      higherVersionPackage,
+      (error: Error, returnPackage: acquisitionSdk.RemotePackage | acquisitionSdk.NativeUpdateNotification) => {
+        assert.equal(null, error);
+        assert.deepEqual(scriptUpdateResult, returnPackage);
+        done();
+      }
+    );
+  });
+
+  it("Package with lower native version gives update notification", (done: Mocha.Done) => {
+    var lowerAppVersionPackage: acquisitionSdk.Package = clone(templateCurrentPackage);
+    lowerAppVersionPackage.appVersion = "0.0.1";
+
+    var acquisition = new acquisitionSdk.AcquisitionManager(new mockApi.HttpRequester(), configuration);
+    acquisition.queryUpdateWithCurrentPackage(
+      lowerAppVersionPackage,
+      (error: Error, returnPackage: acquisitionSdk.RemotePackage | acquisitionSdk.NativeUpdateNotification) => {
+        assert.equal(null, error);
+        assert.deepEqual(nativeUpdateResult, returnPackage);
+        done();
+      }
+    );
+  });
+
+  it("Package with higher native version gives no update", (done: Mocha.Done) => {
+    var higherAppVersionPackage: acquisitionSdk.Package = clone(templateCurrentPackage);
+    higherAppVersionPackage.appVersion = "9.9.0";
+
+    var acquisition = new acquisitionSdk.AcquisitionManager(new mockApi.HttpRequester(), configuration);
+    acquisition.queryUpdateWithCurrentPackage(
+      higherAppVersionPackage,
+      (error: Error, returnPackage: acquisitionSdk.RemotePackage | acquisitionSdk.NativeUpdateNotification) => {
+        assert.equal(null, error);
+        assert.deepEqual(null, returnPackage);
+        done();
+      }
+    );
+  });
+
+  it("An empty response gives no update", (done: Mocha.Done) => {
+    var lowerAppVersionPackage: acquisitionSdk.Package = clone(templateCurrentPackage);
+    lowerAppVersionPackage.appVersion = "0.0.1";
+
+    var emptyReponse: acquisitionSdk.Http.Response = {
+      statusCode: 200,
+      body: JSON.stringify({}),
+    };
+
+    var acquisition = new acquisitionSdk.AcquisitionManager(new mockApi.CustomResponseHttpRequester(emptyReponse), configuration);
+    acquisition.queryUpdateWithCurrentPackage(
+      lowerAppVersionPackage,
+      (error: Error, returnPackage: acquisitionSdk.RemotePackage | acquisitionSdk.NativeUpdateNotification) => {
+        assert.equal(null, error);
+        done();
+      }
+    );
+  });
+
+  it("An unexpected (but valid) JSON response gives no update", (done: Mocha.Done) => {
+    var lowerAppVersionPackage: acquisitionSdk.Package = clone(templateCurrentPackage);
+    lowerAppVersionPackage.appVersion = "0.0.1";
+
+    var unexpectedResponse: acquisitionSdk.Http.Response = {
+      statusCode: 200,
+      body: JSON.stringify({ unexpected: "response" }),
+    };
+
+    var acquisition = new acquisitionSdk.AcquisitionManager(
+      new mockApi.CustomResponseHttpRequester(unexpectedResponse),
+      configuration
+    );
+    acquisition.queryUpdateWithCurrentPackage(
+      lowerAppVersionPackage,
+      (error: Error, returnPackage: acquisitionSdk.RemotePackage | acquisitionSdk.NativeUpdateNotification) => {
+        assert.equal(null, error);
+        done();
+      }
+    );
+  });
+
+  it("Package for companion app ignores high native version and gives update", (done: Mocha.Done) => {
+    var higherAppVersionCompanionPackage: acquisitionSdk.Package = clone(templateCurrentPackage);
+    higherAppVersionCompanionPackage.appVersion = "9.9.0";
+
+    var companionAppConfiguration = clone(configuration);
+    configuration.ignoreAppVersion = true;
+
+    var acquisition = new acquisitionSdk.AcquisitionManager(new mockApi.HttpRequester(), configuration);
+    acquisition.queryUpdateWithCurrentPackage(
+      higherAppVersionCompanionPackage,
+      (error: Error, returnPackage: acquisitionSdk.RemotePackage | acquisitionSdk.NativeUpdateNotification) => {
+        assert.equal(null, error);
+        assert.deepEqual(scriptUpdateResult, returnPackage);
+        done();
+      }
+    );
+  });
+
+  it("If latest package is mandatory, returned package is mandatory", (done: Mocha.Done) => {
+    mockApi.latestPackage.isMandatory = true;
+
+    var acquisition = new acquisitionSdk.AcquisitionManager(new mockApi.HttpRequester(), configuration);
+    acquisition.queryUpdateWithCurrentPackage(templateCurrentPackage, (error: Error, returnPackage: acquisitionSdk.RemotePackage) => {
+      assert.equal(null, error);
+      assert.equal(true, returnPackage.isMandatory);
+      done();
+    });
+  });
+
+  it("If invalid arguments are provided, an error is raised", (done: Mocha.Done) => {
+    var invalidPackage: acquisitionSdk.Package = clone(templateCurrentPackage);
+    invalidPackage.appVersion = null;
+
+    var acquisition = new acquisitionSdk.AcquisitionManager(new mockApi.HttpRequester(), configuration);
+    try {
+      acquisition.queryUpdateWithCurrentPackage(
+        invalidPackage,
+        (error: Error, returnPackage: acquisitionSdk.RemotePackage | acquisitionSdk.NativeUpdateNotification) => {
+          assert.fail("Should throw an error if the native implementation gave an incorrect package");
+          done();
+        }
+      );
+    } catch (error) {
+      done();
+    }
+  });
+
+  it("If an invalid JSON response is returned by the server, an error is raised", (done: Mocha.Done) => {
+    var lowerAppVersionPackage: acquisitionSdk.Package = clone(templateCurrentPackage);
+    lowerAppVersionPackage.appVersion = "0.0.1";
+
+    var invalidJsonReponse: acquisitionSdk.Http.Response = {
+      statusCode: 200,
+      body: "invalid {{ json",
+    };
+
+    var acquisition = new acquisitionSdk.AcquisitionManager(
+      new mockApi.CustomResponseHttpRequester(invalidJsonReponse),
+      configuration
+    );
+    acquisition.queryUpdateWithCurrentPackage(
+      lowerAppVersionPackage,
+      (error: Error, returnPackage: acquisitionSdk.RemotePackage | acquisitionSdk.NativeUpdateNotification) => {
+        assert.notEqual(null, error);
+        done();
+      }
+    );
+  });
+
+  it("If deploymentKey is not valid...", (done: Mocha.Done) => {
+    // TODO: behaviour is not defined
+    done();
+  });
+
+  it("reportStatusDeploy(...) signals completion", (done: Mocha.Done): void => {
+    var acquisition = new acquisitionSdk.AcquisitionManager(new mockApi.HttpRequester(), configuration);
+
+    acquisition.reportStatusDeploy(
+      templateCurrentPackage,
+      acquisitionSdk.AcquisitionStatus.DeploymentFailed,
+      "1.5.0",
+      mockApi.validDeploymentKey,
+      (error: Error, parameter: void): void => {
+        if (error) {
+          throw error;
+        }
+
+        assert.equal(parameter, /*expected*/ null);
+
+        done();
+      }
+    );
+  });
+
+  it("reportStatusDownload(...) signals completion", (done: Mocha.Done): void => {
+    var acquisition = new acquisitionSdk.AcquisitionManager(new mockApi.HttpRequester(), configuration);
+
+    acquisition.reportStatusDownload(templateCurrentPackage, (error: Error, parameter: void): void => {
+      if (error) {
+        throw error;
+      }
+
+      assert.equal(parameter, /*expected*/ null);
+
+      done();
+    });
+  });
+});
+
+function clone<T>(initialObject: T): T {
+  return JSON.parse(JSON.stringify(initialObject));
+}