Revert "Rename sdk.isAuthrnticated method to ensureAuthenticated and make behavior consistent."

We decided that the solution with `isAuthenticated(boolean)` was better
because it preserved backward compatibility.

Author: Richard Hua

cli/script/command-executor.ts

@@ -592,12 +592,13 @@ function login(command: cli.ILoginCommand): Promise<void> {
     if (command.accessKey) {
         var proxy = getProxy(command.proxy, command.noProxy);
         sdk = getSdk(command.accessKey, CLI_HEADERS, command.serverUrl, proxy);
-        return sdk.ensureAuthenticated()
-            .catch((err: CodePushError) =>{
-                throw new Error("Invalid access key."); 
-            })
-            .then((): void => {
-                serializeConnectionInfo(command.accessKey, /*preserveAccessKeyOnLogout*/ true, command.serverUrl, command.proxy, command.noProxy);
+        return sdk.isAuthenticated()
+            .then((isAuthenticated: boolean): void => {
+                if (isAuthenticated) {
+                    serializeConnectionInfo(command.accessKey, /*preserveAccessKeyOnLogout*/ true, command.serverUrl, command.proxy, command.noProxy);
+                } else {
+                    throw new Error("Invalid access key.");
+                }
             });
     } else {
         return loginWithExternalAuthentication("login", command.serverUrl, command.proxy, command.noProxy);
@@ -617,12 +618,13 @@ function loginWithExternalAuthentication(action: string, serverUrl?: string, pro
 
             sdk = getSdk(accessKey, CLI_HEADERS, serverUrl, getProxy(proxy, noProxy));
 
-            return sdk.ensureAuthenticated()
-                .catch((err: CodePushError) => {
-                    throw new Error("Invalid access key.");
-                })
-                .then((): void => {
-                    serializeConnectionInfo(accessKey, /*preserveAccessKeyOnLogout*/ false, serverUrl, proxy, noProxy);
+            return sdk.isAuthenticated()
+                .then((isAuthenticated: boolean): void => {
+                    if (isAuthenticated) {
+                        serializeConnectionInfo(accessKey, /*preserveAccessKeyOnLogout*/ false, serverUrl, proxy, noProxy);
+                    } else {
+                        throw new Error("Invalid access key.");
+                    }
                 });
         });
 }
@@ -1170,7 +1172,7 @@ export var release = (command: cli.IReleaseCommand): Promise<void> => {
 
     return getPackageFilePromise
         .then((file: IPackageFile): Promise<void> => {
-            return sdk.ensureAuthenticated()
+            return sdk.isAuthenticated(true)
                 .then((isAuth: boolean): Promise<void> => {
                     return sdk.release(command.appName, command.deploymentName, file.path, command.appStoreVersion, updateMetadata, uploadProgress);
                 })

sdk/script/management-sdk.ts

@@ -76,7 +76,7 @@ class AccountManager {
         return this._accessKey;
     }
 
-    public ensureAuthenticated(): Promise<boolean> {
+    public isAuthenticated(throwIfUnauthorized?: boolean): Promise<boolean> {
         return Promise<any>((resolve, reject, notify) => {
             var request: superagent.Request<any> = superagent.get(this._serverUrl + urlEncode `/authenticated`);
             if (this._proxy) (<any>request).proxy(this._proxy);
@@ -91,7 +91,7 @@ class AccountManager {
 
                 var authenticated: boolean = status === 200;
 
-                if (!authenticated ){
+                if (!authenticated && throwIfUnauthorized){
                     reject(this.getCodePushError(err, res));
                     return;
                 }

sdk/test/management-sdk.ts

@@ -70,32 +70,43 @@ describe("Management SDK", () => {
         }
     });
 
-    it("ensureAuthenticated handles successful auth", (done: MochaDone) => {
+    it("isAuthenticated handles successful auth", (done: MochaDone) => {
         mockReturn(JSON.stringify({ authenticated: true }), 200, {});
-        manager.ensureAuthenticated()
+        manager.isAuthenticated()
             .done((authenticated: boolean) => {
                 assert(authenticated, "Should be authenticated");
                 done();
             });
     });
 
-    it("ensureAuthenticated handles unsuccessful auth", (done: MochaDone) => {
+    it("isAuthenticated handles unsuccessful auth", (done: MochaDone) => {
         mockReturn("Unauthorized", 401, {});
-        manager.ensureAuthenticated()
+        manager.isAuthenticated()
             .done((authenticated: boolean) => {
-                assert.fail("ensureAuthenticated should have rejected the promise");
+                assert(!authenticated, "Should not be authenticated");
+                done();
+            });
+    });
+
+    it("isAuthenticated handles unsuccessful auth with promise rejection", (done: MochaDone) => {
+        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("ensureAuthenticated handles unexpected status codes", (done: MochaDone) => {
+    it("isAuthenticated handles unexpected status codes", (done: MochaDone) => {
         mockReturn("Not Found", 404, {});
-        manager.ensureAuthenticated()
+        manager.isAuthenticated()
             .done((authenticated: boolean) => {
-                assert.fail("ensureAuthenticated should have rejected the promise");
+                assert.fail("isAuthenticated should have rejected the promise");
                 done();
             }, (err) => {
                 assert.equal(err.message, "Not Found", "Error message should be 'Not Found'");