initial error handling for SSH

Author: pcoop

__tests__/api/BundlePush/BundlePusher.test.ts

@@ -30,29 +30,31 @@ const DEFAULT_PARAMTERS: IHandlerParameters = {
     response: {
         data: {
             setMessage: jest.fn((setMsgArgs) => {
-                expect("" + setMsgArgs).toMatchSnapshot();
+                throw new Error("Unexpected use of setMessage in Mock: " + setMsgArgs.toString());
             }),
             setObj: jest.fn((setObjArgs) => {
-                expect(setObjArgs).toMatchSnapshot();
+                throw new Error("Unexpected use of setObj in Mock: " + setObjArgs.toString());
             })
         },
         console: {
             log: jest.fn((logs) => {
-                expect("" + logs).toMatchSnapshot();
+                consoleText += logs.toString();
             }),
             error: jest.fn((errors) => {
-                expect("" + errors).toMatchSnapshot();
+                throw new Error("Unexpected use of error log in Mock: " + errors.toString());
             }),
             errorHeader: jest.fn(() => undefined)
         },
         progress: {
             startBar: jest.fn((parms) => undefined),
             endBar: jest.fn(() => undefined)
-        }
+        },
+        consoleText: ""
     } as any,
     definition: PushBundleDefinition.PushBundleDefinition,
     fullDefinition: PushBundleDefinition.PushBundleDefinition,
 };
+let consoleText = "";
 
 // Initialise xml2json before mocking anything
 const parser = require("xml2json");
@@ -87,6 +89,7 @@ describe("BundlePusher01", () => {
           }
         });
         uploadSpy = jest.spyOn(Upload, "dirToUSSDirRecursive").mockImplementation(() => ({}));
+        consoleText = "";
     });
     afterEach(() => {
         jest.restoreAllMocks();
@@ -355,6 +358,40 @@ describe("BundlePusher01", () => {
         expect(readSpy).toHaveBeenCalledTimes(1);
         expect(uploadSpy).toHaveBeenCalledTimes(1);
     });
+    it("should handle failure of remote npm install", async () => {
+        shellSpy.mockImplementation((session: any, cmd: string, dir: string, stdoutHandler: (data: string) => void) => {
+          if (cmd.indexOf("npm install") > -1) {
+            stdoutHandler("Injected stdout error message");
+          }
+          else {
+            return true;
+          }
+        });
+        existsSpy.mockImplementation((data: string) => {
+          if (data.indexOf(".zosattributes") > -1) {
+            return false;
+          }
+          if (data.indexOf("package.json") > -1) {
+            return true;
+          }
+        });
+
+        await runPushTestWithError("__tests__/__resources__/ExampleBundle01", false,
+              "A problem occurred attempting to run 'npm install' in remote directory '/u/ThisDoesNotExist/12345678'. " +
+              "Problem is: The output from the remote command implied that an error occurred.");
+
+        expect(consoleText).toContain("Injected stdout error message");
+        expect(zosMFSpy).toHaveBeenCalledTimes(1);
+        expect(sshSpy).toHaveBeenCalledTimes(1);
+        expect(createSpy).toHaveBeenCalledTimes(1);
+        expect(listSpy).toHaveBeenCalledTimes(1);
+        expect(shellSpy).toHaveBeenCalledTimes(1);
+        expect(membersSpy).toHaveBeenCalledTimes(0);
+        expect(submitSpy).toHaveBeenCalledTimes(0);
+        expect(existsSpy).toHaveBeenCalledTimes(2);
+        expect(readSpy).toHaveBeenCalledTimes(1);
+        expect(uploadSpy).toHaveBeenCalledTimes(1);
+    });
     it("should handle error with remote bundle deploy", async () => {
         submitSpy.mockImplementationOnce(() => { throw new Error("Injected deploy error"); });
 
@@ -388,6 +425,41 @@ describe("BundlePusher01", () => {
         expect(readSpy).toHaveBeenCalledTimes(1);
         expect(uploadSpy).toHaveBeenCalledTimes(1);
     });
+    it("should run to completion with verbose output", async () => {
+        const parms = getCommonParmsForPushTests();
+        parms.arguments.verbose = true;
+        shellSpy.mockImplementation((session: any, cmd: string, dir: string, stdoutHandler: (data: string) => void) => {
+          stdoutHandler("Injected stdout shell message");
+        });
+        existsSpy.mockImplementation((data: string) => {
+          if (data.indexOf(".zosattributes") > -1) {
+            return false;
+          }
+          if (data.indexOf("package.json") > -1) {
+            return true;
+          }
+        });
+
+        await runPushTest("__tests__/__resources__/ExampleBundle01", false, "PUSH operation completed.", parms);
+
+        expect(consoleText).toContain("Making remote bundle directory");
+        expect(consoleText).toContain("Accessing contents of remote bundle directory");
+        expect(consoleText).toContain("Uploading the bundle to the remote bundle directory");
+        expect(consoleText).toContain("Running npm install for the remote bundle");
+        expect(consoleText).toContain("Injected stdout shell message");
+        expect(consoleText).toContain("Deploying the bundle to CICS");
+        expect(consoleText).toContain("Deployed existing bundle to CICS");
+        expect(zosMFSpy).toHaveBeenCalledTimes(1);
+        expect(sshSpy).toHaveBeenCalledTimes(1);
+        expect(listSpy).toHaveBeenCalledTimes(1);
+        expect(createSpy).toHaveBeenCalledTimes(1);
+        expect(shellSpy).toHaveBeenCalledTimes(1);
+        expect(membersSpy).toHaveBeenCalledTimes(2);
+        expect(submitSpy).toHaveBeenCalledTimes(1);
+        expect(existsSpy).toHaveBeenCalledTimes(2);
+        expect(readSpy).toHaveBeenCalledTimes(1);
+        expect(uploadSpy).toHaveBeenCalledTimes(1);
+    });
 });
 
 async function runPushTestWithError(localBundleDir: string, overwrite: boolean, errorText: string, parmsIn?: IHandlerParameters) {
@@ -411,8 +483,14 @@ async function runPushTestWithError(localBundleDir: string, overwrite: boolean,
   expect(err.message).toContain(errorText);
 }
 
-async function runPushTest(localBundleDir: string, overwrite: boolean, expectedResponse: string) {
-  const parms = getCommonParmsForPushTests();
+async function runPushTest(localBundleDir: string, overwrite: boolean, expectedResponse: string, parmsIn?: IHandlerParameters) {
+  let parms: IHandlerParameters;
+  if (parmsIn === undefined) {
+    parms = getCommonParmsForPushTests();
+  }
+  else {
+    parms = parmsIn;
+  }
   parms.arguments.overwrite = overwrite;
 
   let err: Error;

src/api/BundlePush/BundlePusher.ts

@@ -243,6 +243,11 @@ export class BundlePusher {
   }
 
   private sshOutput(data: string) {
+    // If verbose output is requested then log SSH output directly to the console
+    if (this.params.arguments.verbose) {
+      this.params.response.console.log(data);
+    }
+
     this.sshOutputText += data;
   }
 
@@ -287,6 +292,17 @@ export class BundlePusher {
     try {
       this.sshOutputText = "";
       const shell = await Shell.executeSshCwd(sshSession, sshCommand, directory, this.sshOutput.bind(this));
+
+      // Did the SSH command work? It's unclear how to tell, but for starters let's look for the word
+      // 'error' in the output text.
+      if (this.sshOutputText.toUpperCase().indexOf("ERROR ") > -1) {
+        // if we've not already logged the output, log it now
+        if (this.params.arguments.verbose !== true)
+        {
+          this.params.response.console.log(this.sshOutputText);
+        }
+        throw new Error("The output from the remote command implied that an error occurred.");
+      }
     }
     catch (error) {
       throw new Error("A problem occurred attempting to run '" + sshCommand + "' in remote directory '" + directory +
@@ -330,7 +346,7 @@ export class BundlePusher {
     this.progressBar.statusMessage = status;
 
     if (this.params.arguments.verbose) {
-      this.params.response.console.log(status);
+      this.params.response.console.log(status + "\n");
     }
   }
 }