Initial commit

server/node_modules/ssh2/test/test-exec.js

@@ -0,0 +1,578 @@
+'use strict';
+
+const assert = require('assert');
+const { inspect } = require('util');
+
+const {
+  mustCall,
+  mustCallAtLeast,
+  setupSimple,
+} = require('./common.js');
+
+const DEBUG = false;
+
+const setup = setupSimple.bind(undefined, DEBUG);
+
+{
+  const { client, server } = setup('Simple exec()');
+
+  const COMMAND = 'foo --bar';
+  const STDOUT_DATA = 'stdout data!\n';
+  const STDERR_DATA = 'stderr data!\n';
+
+  server.on('connection', mustCall((conn) => {
+    conn.on('ready', mustCall(() => {
+      conn.on('session', mustCall((accept, reject) => {
+        accept().on('exec', mustCall((accept, reject, info) => {
+          assert(info.command === COMMAND,
+                 `Wrong exec command: ${info.command}`);
+          const stream = accept();
+          stream.stderr.write(STDERR_DATA);
+          stream.write(STDOUT_DATA);
+          stream.exit(100);
+          stream.end();
+          conn.end();
+        }));
+      }));
+    }));
+  }));
+
+  client.on('ready', mustCall(() => {
+    let out = '';
+    let outErr = '';
+    const events = [];
+    const EXPECTED_EVENTS = [ 'exit', 'close' ];
+    const EXPECTED_EXIT_CLOSE_ARGS = [ 100 ];
+    client.on('close', mustCall(() => {
+      assert(out === STDOUT_DATA, `Wrong stdout data: ${inspect(out)}`);
+      assert(outErr === STDERR_DATA, `Wrong stderr data: ${inspect(outErr)}`);
+      assert.deepStrictEqual(
+        events,
+        EXPECTED_EVENTS,
+        `Wrong command event order: ${events}`
+      );
+    })).exec(COMMAND, mustCall((err, stream) => {
+      assert(!err, `Unexpected exec error: ${err}`);
+      stream.on('data', mustCallAtLeast((d) => {
+        out += d;
+      })).on('exit', mustCall((...args) => {
+        assert.deepStrictEqual(args,
+                               EXPECTED_EXIT_CLOSE_ARGS,
+                               `Wrong exit args: ${inspect(args)}`);
+        events.push('exit');
+      })).on('close', mustCall((...args) => {
+        assert.deepStrictEqual(args,
+                               EXPECTED_EXIT_CLOSE_ARGS,
+                               `Wrong close args: ${inspect(args)}`);
+        events.push('close');
+      })).stderr.on('data', mustCallAtLeast((d) => {
+        outErr += d;
+      }));
+    }));
+  }));
+}
+
+{
+  const { client, server } = setup('Simple exec() (exit signal)');
+
+  const COMMAND = 'foo --bar';
+  const STDOUT_DATA = 'stdout data!\n';
+  const STDERR_DATA = 'stderr data!\n';
+
+  server.on('connection', mustCall((conn) => {
+    conn.on('ready', mustCall(() => {
+      conn.on('session', mustCall((accept, reject) => {
+        accept().on('exec', mustCall((accept, reject, info) => {
+          assert(info.command === COMMAND,
+                 `Wrong exec command: ${info.command}`);
+          const stream = accept();
+          stream.stderr.write(STDERR_DATA);
+          stream.write(STDOUT_DATA);
+          assert.throws(() => stream.exit('SIGFAKE'));
+          stream.exit('SIGKILL');
+          stream.end();
+          conn.end();
+        }));
+      }));
+    }));
+  }));
+
+  client.on('ready', mustCall(() => {
+    let out = '';
+    let outErr = '';
+    const events = [];
+    const EXPECTED_EVENTS = [ 'exit', 'close' ];
+    const EXPECTED_EXIT_CLOSE_ARGS = [ null, 'SIGKILL', false, '' ];
+    client.on('close', mustCall(() => {
+      assert(out === STDOUT_DATA, `Wrong stdout data: ${inspect(out)}`);
+      assert(outErr === STDERR_DATA, `Wrong stderr data: ${inspect(outErr)}`);
+      assert.deepStrictEqual(
+        events,
+        EXPECTED_EVENTS,
+        `Wrong command event order: ${events}`
+      );
+    })).exec(COMMAND, mustCall((err, stream) => {
+      assert(!err, `Unexpected exec error: ${err}`);
+      stream.on('data', mustCallAtLeast((d) => {
+        out += d;
+      })).on('exit', mustCall((...args) => {
+        assert.deepStrictEqual(args,
+                               EXPECTED_EXIT_CLOSE_ARGS,
+                               `Wrong exit args: ${inspect(args)}`);
+        events.push('exit');
+      })).on('close', mustCall((...args) => {
+        assert.deepStrictEqual(args,
+                               EXPECTED_EXIT_CLOSE_ARGS,
+                               `Wrong close args: ${inspect(args)}`);
+        events.push('close');
+      })).stderr.on('data', mustCallAtLeast((d) => {
+        outErr += d;
+      }));
+    }));
+  }));
+}
+
+{
+  const { client, server } = setup('Simple exec() (exit signal -- no "SIG")');
+
+  const COMMAND = 'foo --bar';
+  const STDOUT_DATA = 'stdout data!\n';
+  const STDERR_DATA = 'stderr data!\n';
+
+  server.on('connection', mustCall((conn) => {
+    conn.on('ready', mustCall(() => {
+      conn.on('session', mustCall((accept, reject) => {
+        accept().on('exec', mustCall((accept, reject, info) => {
+          assert(info.command === COMMAND,
+                 `Wrong exec command: ${info.command}`);
+          const stream = accept();
+          stream.stderr.write(STDERR_DATA);
+          stream.write(STDOUT_DATA);
+          assert.throws(() => stream.exit('FAKE'));
+          stream.exit('KILL');
+          stream.end();
+          conn.end();
+        }));
+      }));
+    }));
+  }));
+
+  client.on('ready', mustCall(() => {
+    let out = '';
+    let outErr = '';
+    const events = [];
+    const EXPECTED_EVENTS = [ 'exit', 'close' ];
+    const EXPECTED_EXIT_CLOSE_ARGS = [ null, 'SIGKILL', false, '' ];
+    client.on('close', mustCall(() => {
+      assert(out === STDOUT_DATA, `Wrong stdout data: ${inspect(out)}`);
+      assert(outErr === STDERR_DATA, `Wrong stderr data: ${inspect(outErr)}`);
+      assert.deepStrictEqual(
+        events,
+        EXPECTED_EVENTS,
+        `Wrong command event order: ${events}`
+      );
+    })).exec(COMMAND, mustCall((err, stream) => {
+      assert(!err, `Unexpected exec error: ${err}`);
+      stream.on('data', mustCallAtLeast((d) => {
+        out += d;
+      })).on('exit', mustCall((...args) => {
+        assert.deepStrictEqual(args,
+                               EXPECTED_EXIT_CLOSE_ARGS,
+                               `Wrong exit args: ${inspect(args)}`);
+        events.push('exit');
+      })).on('close', mustCall((...args) => {
+        assert.deepStrictEqual(args,
+                               EXPECTED_EXIT_CLOSE_ARGS,
+                               `Wrong close args: ${inspect(args)}`);
+        events.push('close');
+      })).stderr.on('data', mustCallAtLeast((d) => {
+        outErr += d;
+      }));
+    }));
+  }));
+}
+
+{
+  const { client, server } = setup('Exec with signal()');
+
+  const COMMAND = 'foo --bar';
+  const STDOUT_DATA = 'stdout data!\n';
+  const STDERR_DATA = 'stderr data!\n';
+
+  server.on('connection', mustCall((conn) => {
+    conn.on('ready', mustCall(() => {
+      conn.on('session', mustCall((accept, reject) => {
+        let stream;
+        accept().on('exec', mustCall((accept, reject, info) => {
+          assert(info.command === COMMAND,
+                 `Wrong exec command: ${info.command}`);
+          stream = accept();
+          stream.stderr.write(STDERR_DATA);
+          stream.write(STDOUT_DATA);
+        })).on('signal', mustCall((accept, reject, info) => {
+          assert(info.name === 'INT', `Wrong client signal name: ${info.name}`);
+          stream.exit(100);
+          stream.end();
+          conn.end();
+        }));
+      }));
+    }));
+  }));
+
+  client.on('ready', mustCall(() => {
+    let out = '';
+    let outErr = '';
+    const events = [];
+    const EXPECTED_EVENTS = [ 'exit', 'close' ];
+    const EXPECTED_EXIT_CLOSE_ARGS = [ 100 ];
+    client.on('close', mustCall(() => {
+      assert(out === STDOUT_DATA, `Wrong stdout data: ${inspect(out)}`);
+      assert(outErr === STDERR_DATA, `Wrong stderr data: ${inspect(outErr)}`);
+      assert.deepStrictEqual(
+        events,
+        EXPECTED_EVENTS,
+        `Wrong command event order: ${events}`
+      );
+    })).exec(COMMAND, mustCall((err, stream) => {
+      assert(!err, `Unexpected exec error: ${err}`);
+      const sendSignal = (() => {
+        let sent = false;
+        return () => {
+          if (sent)
+            return;
+          sent = true;
+          assert.throws(() => stream.signal('FAKE'));
+          assert.throws(() => stream.signal('SIGFAKE'));
+          stream.signal('SIGINT');
+        };
+      })();
+      stream.on('data', mustCallAtLeast((d) => {
+        out += d;
+        sendSignal();
+      })).on('exit', mustCall((...args) => {
+        assert.deepStrictEqual(args,
+                               EXPECTED_EXIT_CLOSE_ARGS,
+                               `Wrong exit args: ${inspect(args)}`);
+        events.push('exit');
+      })).on('close', mustCall((...args) => {
+        assert.deepStrictEqual(args,
+                               EXPECTED_EXIT_CLOSE_ARGS,
+                               `Wrong close args: ${inspect(args)}`);
+        events.push('close');
+      })).stderr.on('data', mustCallAtLeast((d) => {
+        outErr += d;
+      }));
+    }));
+  }));
+}
+
+{
+  const { client, server } = setup('Exec with signal() -- no "SIG"');
+
+  const COMMAND = 'foo --bar';
+  const STDOUT_DATA = 'stdout data!\n';
+  const STDERR_DATA = 'stderr data!\n';
+
+  server.on('connection', mustCall((conn) => {
+    conn.on('ready', mustCall(() => {
+      conn.on('session', mustCall((accept, reject) => {
+        let stream;
+        accept().on('exec', mustCall((accept, reject, info) => {
+          assert(info.command === COMMAND,
+                 `Wrong exec command: ${info.command}`);
+          stream = accept();
+          stream.stderr.write(STDERR_DATA);
+          stream.write(STDOUT_DATA);
+        })).on('signal', mustCall((accept, reject, info) => {
+          assert(info.name === 'INT', `Wrong client signal name: ${info.name}`);
+          stream.exit(100);
+          stream.end();
+          conn.end();
+        }));
+      }));
+    }));
+  }));
+
+  client.on('ready', mustCall(() => {
+    let out = '';
+    let outErr = '';
+    const events = [];
+    const EXPECTED_EVENTS = [ 'exit', 'close' ];
+    const EXPECTED_EXIT_CLOSE_ARGS = [ 100 ];
+    client.on('close', mustCall(() => {
+      assert(out === STDOUT_DATA, `Wrong stdout data: ${inspect(out)}`);
+      assert(outErr === STDERR_DATA, `Wrong stderr data: ${inspect(outErr)}`);
+      assert.deepStrictEqual(
+        events,
+        EXPECTED_EVENTS,
+        `Wrong command event order: ${events}`
+      );
+    })).exec(COMMAND, mustCall((err, stream) => {
+      assert(!err, `Unexpected exec error: ${err}`);
+      const sendSignal = (() => {
+        let sent = false;
+        return () => {
+          if (sent)
+            return;
+          sent = true;
+          stream.signal('INT');
+        };
+      })();
+      stream.on('data', mustCallAtLeast((d) => {
+        out += d;
+        sendSignal();
+      })).on('exit', mustCall((...args) => {
+        assert.deepStrictEqual(args,
+                               EXPECTED_EXIT_CLOSE_ARGS,
+                               `Wrong exit args: ${inspect(args)}`);
+        events.push('exit');
+      })).on('close', mustCall((...args) => {
+        assert.deepStrictEqual(args,
+                               EXPECTED_EXIT_CLOSE_ARGS,
+                               `Wrong close args: ${inspect(args)}`);
+        events.push('close');
+      })).stderr.on('data', mustCallAtLeast((d) => {
+        outErr += d;
+      }));
+    }));
+  }));
+}
+
+{
+  const { client, server } = setup('Exec with environment set');
+
+  const env = { SSH2NODETEST: 'foo' };
+
+  server.on('connection', mustCall((conn) => {
+    conn.on('ready', mustCall(() => {
+      conn.on('session', mustCall((accept, reject) => {
+        accept().on('env', mustCall((accept, reject, info) => {
+          accept && accept();
+          assert(info.key === Object.keys(env)[0],
+                 'Wrong env key');
+          assert(info.val === Object.values(env)[0],
+                 'Wrong env value');
+        })).on('exec', mustCall((accept, reject, info) => {
+          assert(info.command === 'foo --bar',
+                 `Wrong exec command: ${info.command}`);
+          const stream = accept();
+          stream.exit(100);
+          stream.end();
+          conn.end();
+        }));
+      }));
+    }));
+  }));
+
+  client.on('ready', mustCall(() => {
+    client.exec('foo --bar', { env }, mustCall((err, stream) => {
+      assert(!err, `Unexpected exec error: ${err}`);
+      stream.resume();
+    }));
+  }));
+}
+
+{
+  const { client, server } = setup('Exec with setWindow()');
+
+  const dimensions = {
+    rows: 60,
+    cols: 115,
+    height: 480,
+    width: 640,
+  };
+
+  server.on('connection', mustCall((conn) => {
+    conn.on('ready', mustCall(() => {
+      conn.on('session', mustCall((accept, reject) => {
+        accept().on('window-change', mustCall((accept, reject, info) => {
+          accept && accept();
+          assert.deepStrictEqual(info, dimensions, 'Wrong dimensions');
+        })).on('exec', mustCall((accept, reject, info) => {
+          assert(info.command === 'foo --bar',
+                 `Wrong exec command: ${info.command}`);
+          const stream = accept();
+          stream.exit(100);
+          stream.end();
+          conn.end();
+        }));
+      }));
+    }));
+  }));
+
+  client.on('ready', mustCall(() => {
+    client.exec('foo --bar', mustCall((err, stream) => {
+      assert(!err, `Unexpected exec error: ${err}`);
+      stream.setWindow(...Object.values(dimensions));
+      stream.resume();
+    }));
+  }));
+}
+
+{
+  const { client, server } = setup('Exec with pty set');
+
+  const pty = {
+    rows: 2,
+    cols: 4,
+    width: 0,
+    height: 0,
+    term: 'vt220',
+    modes: {},
+  };
+
+  server.on('connection', mustCall((conn) => {
+    conn.on('ready', mustCall(() => {
+      conn.on('session', mustCall((accept, reject) => {
+        let sawPty = false;
+        accept().on('pty', mustCall((accept, reject, info) => {
+          assert.deepStrictEqual(info, pty, 'Wrong pty info');
+          sawPty = true;
+          accept && accept();
+        })).on('exec', mustCall((accept, reject, info) => {
+          assert(sawPty, 'Expected pty to be set up');
+          assert(info.command === 'foo --bar',
+                 `Wrong exec command: ${info.command}`);
+          const stream = accept();
+          stream.exit(100);
+          stream.end();
+          conn.end();
+        }));
+      }));
+    }));
+  }));
+
+  client.on('ready', mustCall(() => {
+    client.exec('foo --bar', { pty }, mustCall((err, stream) => {
+      assert(!err, `Unexpected exec error: ${err}`);
+      stream.resume();
+    }));
+  }));
+}
+
+{
+  const { client, server } = setup('Exec with X11 forwarding');
+
+  server.on('connection', mustCall((conn) => {
+    conn.on('ready', mustCall(() => {
+      conn.on('session', mustCall((accept, reject) => {
+        let sawX11 = false;
+        accept().on('x11', mustCall((accept, reject, info) => {
+          assert.strictEqual(info.single,
+                             false,
+                             `Wrong x11 single: ${info.single}`);
+          assert.strictEqual(info.screen,
+                             0,
+                             `Wrong x11 screen: ${info.screen}`);
+          assert.strictEqual(info.protocol,
+                             'MIT-MAGIC-COOKIE-1',
+                             `Wrong x11 protocol: ${info.protocol}`);
+          assert(Buffer.isBuffer(info.cookie), 'Expected cookie Buffer');
+          assert.strictEqual(
+            info.cookie.length,
+            32,
+            `Invalid x11 cookie length: ${info.cookie.length}`
+          );
+          sawX11 = true;
+          accept && accept();
+        })).on('exec', mustCall((accept, reject, info) => {
+          assert(sawX11, 'Expected x11 before exec');
+          assert(info.command === 'foo --bar',
+                 `Wrong exec command: ${info.command}`);
+          const stream = accept();
+          conn.x11('127.0.0.1', 4321, mustCall((err, xstream) => {
+            assert(!err, `Unexpected x11() error: ${err}`);
+            xstream.resume();
+            xstream.on('end', mustCall(() => {
+              stream.exit(100);
+              stream.end();
+              conn.end();
+            })).end();
+          }));
+        }));
+      }));
+    }));
+  }));
+
+  client.on('ready', mustCall(() => {
+    client.on('x11', mustCall((info, accept, reject) => {
+      assert.strictEqual(info.srcIP,
+                         '127.0.0.1',
+                         `Invalid x11 srcIP: ${info.srcIP}`);
+      assert.strictEqual(info.srcPort,
+                         4321,
+                         `Invalid x11 srcPort: ${info.srcPort}`);
+      accept();
+    })).exec('foo --bar', { x11: true }, mustCall((err, stream) => {
+      assert(!err, `Unexpected exec error: ${err}`);
+      stream.resume();
+    }));
+  }));
+}
+
+{
+  const { client, server } = setup(
+    'Exec with X11 forwarding (custom X11 settings)'
+  );
+
+  const x11 = {
+    single: true,
+    screen: 1234,
+    protocol: 'YUMMY-MAGIC-COOKIE-1',
+    cookie: '00112233445566778899001122334455',
+  };
+
+  server.on('connection', mustCall((conn) => {
+    conn.on('ready', mustCall(() => {
+      conn.on('session', mustCall((accept, reject) => {
+        let sawX11 = false;
+        accept().on('x11', mustCall((accept, reject, info) => {
+          assert.strictEqual(info.single,
+                             x11.single,
+                             `Wrong x11 single: ${info.single}`);
+          assert.strictEqual(info.screen,
+                             x11.screen,
+                             `Wrong x11 screen: ${info.screen}`);
+          assert.strictEqual(info.protocol,
+                             x11.protocol,
+                             `Wrong x11 protocol: ${info.protocol}`);
+          assert(Buffer.isBuffer(info.cookie), 'Expected cookie Buffer');
+          assert.strictEqual(info.cookie.toString(),
+                             x11.cookie,
+                             `Wrong x11 cookie: ${info.cookie}`);
+          sawX11 = true;
+          accept && accept();
+        })).on('exec', mustCall((accept, reject, info) => {
+          assert(sawX11, 'Expected x11 before exec');
+          assert(info.command === 'foo --bar',
+                 `Wrong exec command: ${info.command}`);
+          const stream = accept();
+          conn.x11('127.0.0.1', 4321, mustCall((err, xstream) => {
+            assert(!err, `Unexpected x11() error: ${err}`);
+            xstream.resume();
+            xstream.on('end', mustCall(() => {
+              stream.exit(100);
+              stream.end();
+              conn.end();
+            })).end();
+          }));
+        }));
+      }));
+    }));
+  }));
+
+  client.on('ready', mustCall(() => {
+    client.on('x11', mustCall((info, accept, reject) => {
+      assert.strictEqual(info.srcIP,
+                         '127.0.0.1',
+                         `Invalid x11 srcIP: ${info.srcIP}`);
+      assert.strictEqual(info.srcPort,
+                         4321,
+                         `Invalid x11 srcPort: ${info.srcPort}`);
+      accept();
+    })).exec('foo --bar', { x11 }, mustCall((err, stream) => {
+      assert(!err, `Unexpected exec error: ${err}`);
+      stream.resume();
+    }));
+  }));
+}