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

'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();
    }));
  }));
}