From 3f07473293edf0fc1b8e786952a643d70f86b645 Mon Sep 17 00:00:00 2001

From: Zuzana Svetlikova <zsvetlik@redhat.com>

Date: Thu, 7 Sep 2017 12:21:29 +0000

Subject: [PATCH 2/2] Disable failed tests

---

 test/disabled/test-env-var-no-warnings.js          |  41 ++++

 test/disabled/test-http-dns-error.js               |  43 ++++

 .../disabled/test-https-agent-create-connection.js | 144 ++++++++++++++

 .../test-https-agent-disable-session-reuse.js      |  55 +++++

 test/disabled/test-https-agent-session-eviction.js |  84 ++++++++

 test/disabled/test-https-agent-sni.js              |  49 +++++

 test/disabled/test-https-agent.js                  |  50 +++++

 test/disabled/test-https-client-reject.js          |  64 ++++++

 test/disabled/test-https-client-resume.js          |  62 ++++++

 test/disabled/test-https-host-headers.js           | 109 ++++++++++

 test/disabled/test-https-set-timeout-server.js     | 221 +++++++++++++++++++++

 test/disabled/test-https-simple.js                 |  93 +++++++++

 test/disabled/test-https-strict.js                 | 201 +++++++++++++++++++

 ...test-net-better-error-messages-port-hostname.js |  15 ++

 test/disabled/test-net-connect-immediate-finish.js |  17 ++

 test/disabled/test-npm-install.js                  |  59 ++++++

 test/parallel/test-env-var-no-warnings.js          |  41 ----

 test/parallel/test-http-dns-error.js               |  43 ----

 .../parallel/test-https-agent-create-connection.js | 144 --------------

 .../test-https-agent-disable-session-reuse.js      |  55 -----

 test/parallel/test-https-agent-session-eviction.js |  84 --------

 test/parallel/test-https-agent-sni.js              |  49 -----

 test/parallel/test-https-agent.js                  |  50 -----

 test/parallel/test-https-client-reject.js          |  64 ------

 test/parallel/test-https-client-resume.js          |  62 ------

 test/parallel/test-https-host-headers.js           | 109 ----------

 test/parallel/test-https-set-timeout-server.js     | 221 ---------------------

 test/parallel/test-https-simple.js                 |  93 ---------

 test/parallel/test-https-strict.js                 | 201 -------------------

 ...test-net-better-error-messages-port-hostname.js |  15 --

 test/parallel/test-net-connect-immediate-finish.js |  17 --

 test/parallel/test-npm-install.js                  |  59 ------

 32 files changed, 1307 insertions(+), 1307 deletions(-)

 create mode 100644 test/disabled/test-env-var-no-warnings.js

 create mode 100644 test/disabled/test-http-dns-error.js

 create mode 100644 test/disabled/test-https-agent-create-connection.js

 create mode 100644 test/disabled/test-https-agent-disable-session-reuse.js

 create mode 100644 test/disabled/test-https-agent-session-eviction.js

 create mode 100644 test/disabled/test-https-agent-sni.js

 create mode 100644 test/disabled/test-https-agent.js

 create mode 100644 test/disabled/test-https-client-reject.js

 create mode 100644 test/disabled/test-https-client-resume.js

 create mode 100644 test/disabled/test-https-host-headers.js

 create mode 100644 test/disabled/test-https-set-timeout-server.js

 create mode 100644 test/disabled/test-https-simple.js

 create mode 100644 test/disabled/test-https-strict.js

 create mode 100644 test/disabled/test-net-better-error-messages-port-hostname.js

 create mode 100644 test/disabled/test-net-connect-immediate-finish.js

 create mode 100644 test/disabled/test-npm-install.js

 delete mode 100644 test/parallel/test-env-var-no-warnings.js

 delete mode 100644 test/parallel/test-http-dns-error.js

 delete mode 100644 test/parallel/test-https-agent-create-connection.js

 delete mode 100644 test/parallel/test-https-agent-disable-session-reuse.js

 delete mode 100644 test/parallel/test-https-agent-session-eviction.js

 delete mode 100644 test/parallel/test-https-agent-sni.js

 delete mode 100644 test/parallel/test-https-agent.js

 delete mode 100644 test/parallel/test-https-client-reject.js

 delete mode 100644 test/parallel/test-https-client-resume.js

 delete mode 100644 test/parallel/test-https-host-headers.js

 delete mode 100644 test/parallel/test-https-set-timeout-server.js

 delete mode 100644 test/parallel/test-https-simple.js

 delete mode 100644 test/parallel/test-https-strict.js

 delete mode 100644 test/parallel/test-net-better-error-messages-port-hostname.js

 delete mode 100644 test/parallel/test-net-connect-immediate-finish.js

 delete mode 100644 test/parallel/test-npm-install.js

diff --git a/test/disabled/test-env-var-no-warnings.js b/test/disabled/test-env-var-no-warnings.js

new file mode 100644

index 0000000..f829443

--- /dev/null

+++ b/test/disabled/test-env-var-no-warnings.js

@@ -0,0 +1,41 @@

+'use strict';

+const common = require('../common');

+const assert = require('assert');

+const cp = require('child_process');

+

+if (process.argv[2] === 'child') {

+  process.emitWarning('foo');

+} else {

+  function test(env) {

+    const cmd = `"${process.execPath}" "${__filename}" child`;

+

+    cp.exec(cmd, { env }, common.mustCall((err, stdout, stderr) => {

+      assert.strictEqual(err, null);

+      assert.strictEqual(stdout, '');

+

+      if (env.NODE_NO_WARNINGS === '1')

+        assert.strictEqual(stderr, '');

+      else

+        assert(/Warning: foo$/.test(stderr.trim()));

+    }));

+  }

+

+  test({});

+  test(process.env);

+  test({ NODE_NO_WARNINGS: undefined });

+  test({ NODE_NO_WARNINGS: null });

+  test({ NODE_NO_WARNINGS: 'foo' });

+  test({ NODE_NO_WARNINGS: true });

+  test({ NODE_NO_WARNINGS: false });

+  test({ NODE_NO_WARNINGS: {} });

+  test({ NODE_NO_WARNINGS: [] });

+  test({ NODE_NO_WARNINGS: () => {} });

+  test({ NODE_NO_WARNINGS: 0 });

+  test({ NODE_NO_WARNINGS: -1 });

+  test({ NODE_NO_WARNINGS: '0' });

+  test({ NODE_NO_WARNINGS: '01' });

+  test({ NODE_NO_WARNINGS: '2' });

+  // Don't test the number 1 because it will come through as a string in the

+  // the child process environment.

+  test({ NODE_NO_WARNINGS: '1' });

+}

diff --git a/test/disabled/test-http-dns-error.js b/test/disabled/test-http-dns-error.js

new file mode 100644

index 0000000..bb736c5

--- /dev/null

+++ b/test/disabled/test-http-dns-error.js

@@ -0,0 +1,43 @@

+'use strict';

+const common = require('../common');

+const assert = require('assert');

+

+const http = require('http');

+

+let https;

+if (common.hasCrypto) {

+  https = require('https');

+} else {

+  common.printSkipMessage('missing crypto');

+}

+

+const host = '*'.repeat(256);

+

+function do_not_call() {

+  throw new Error('This function should not have been called.');

+}

+

+function test(mod) {

+

+  // Bad host name should not throw an uncatchable exception.

+  // Ensure that there is time to attach an error listener.

+  const req1 = mod.get({host: host, port: 42}, do_not_call);

+  req1.on('error', common.mustCall(function(err) {

+    assert.strictEqual(err.code, 'ENOTFOUND');

+  }));

+  // http.get() called req1.end() for us

+

+  const req2 = mod.request({method: 'GET', host: host, port: 42}, do_not_call);

+  req2.on('error', common.mustCall(function(err) {

+    assert.strictEqual(err.code, 'ENOTFOUND');

+  }));

+  req2.end();

+}

+

+if (common.hasCrypto) {

+  test(https);

+} else {

+  common.printSkipMessage('missing crypto');

+}

+

+test(http);

diff --git a/test/disabled/test-https-agent-create-connection.js b/test/disabled/test-https-agent-create-connection.js

new file mode 100644

index 0000000..a7c329b

--- /dev/null

+++ b/test/disabled/test-https-agent-create-connection.js

@@ -0,0 +1,144 @@

+'use strict';

+

+const common = require('../common');

+if (!common.hasCrypto)

+  common.skip('missing crypto');

+

+const assert = require('assert');

+const https = require('https');

+

+const agent = new https.Agent();

+

+const fs = require('fs');

+

+const options = {

+  key: fs.readFileSync(`${common.fixturesDir}/keys/agent1-key.pem`),

+  cert: fs.readFileSync(`${common.fixturesDir}/keys/agent1-cert.pem`),

+};

+

+const expectedHeader = /^HTTP\/1.1 200 OK/;

+const expectedBody = /hello world\n/;

+const expectCertError = /^Error: unable to verify the first certificate$/;

+

+const checkRequest = (socket, server) => {

+  let result = '';

+  socket.on('connect', common.mustCall((data) => {

+    socket.write('GET / HTTP/1.1\r\n\r\n');

+    socket.end();

+  }));

+  socket.on('data', common.mustCall((chunk) => {

+    result += chunk;

+  }));

+  socket.on('end', common.mustCall(() => {

+    assert(expectedHeader.test(result));

+    assert(expectedBody.test(result));

+    server.close();

+  }));

+};

+

+function createServer() {

+  return https.createServer(options, (req, res) => {

+    res.end('hello world\n');

+  });

+}

+

+// use option connect

+{

+  const server = createServer();

+  server.listen(0, common.mustCall(() => {

+    const port = server.address().port;

+    const host = 'localhost';

+    const options = {

+      port: port,

+      host: host,

+      rejectUnauthorized: false,

+      _agentKey: agent.getName({

+        port: port,

+        host: host,

+      }),

+    };

+

+    const socket = agent.createConnection(options);

+    checkRequest(socket, server);

+  }));

+}

+

+// use port and option connect

+{

+  const server = createServer();

+  server.listen(0, common.mustCall(() => {

+    const port = server.address().port;

+    const host = 'localhost';

+    const options = {

+      rejectUnauthorized: false,

+      _agentKey: agent.getName({

+        port: port,

+        host: host,

+      }),

+    };

+    const socket = agent.createConnection(port, options);

+    checkRequest(socket, server);

+  }));

+}

+

+// use port and host and option connect

+{

+  const server = createServer();

+  server.listen(0, common.mustCall(() => {

+    const port = server.address().port;

+    const host = 'localhost';

+    const options = {

+      rejectUnauthorized: false,

+      _agentKey: agent.getName({

+        port: port,

+        host: host,

+      }),

+    };

+    const socket = agent.createConnection(port, host, options);

+    checkRequest(socket, server);

+  }));

+}

+

+// use port and host and option does not have agentKey

+{

+  const server = createServer();

+  server.listen(0, common.mustCall(() => {

+    const port = server.address().port;

+    const host = 'localhost';

+    const options = {

+      rejectUnauthorized: false,

+    };

+    const socket = agent.createConnection(port, host, options);

+    checkRequest(socket, server);

+  }));

+}

+

+// options is null

+{

+  const server = createServer();

+  server.listen(0, common.mustCall(() => {

+    const port = server.address().port;

+    const host = 'localhost';

+    const options = null;

+    const socket = agent.createConnection(port, host, options);

+    socket.on('error', common.mustCall((e) => {

+      assert(expectCertError.test(e.toString()));

+      server.close();

+    }));

+  }));

+}

+

+// options is undefined

+{

+  const server = createServer();

+  server.listen(0, common.mustCall(() => {

+    const port = server.address().port;

+    const host = 'localhost';

+    const options = undefined;

+    const socket = agent.createConnection(port, host, options);

+    socket.on('error', common.mustCall((e) => {

+      assert(expectCertError.test(e.toString()));

+      server.close();

+    }));

+  }));

+}

diff --git a/test/disabled/test-https-agent-disable-session-reuse.js b/test/disabled/test-https-agent-disable-session-reuse.js

new file mode 100644

index 0000000..4f92547

--- /dev/null

+++ b/test/disabled/test-https-agent-disable-session-reuse.js

@@ -0,0 +1,55 @@

+'use strict';

+const common = require('../common');

+if (!common.hasCrypto)

+  common.skip('missing crypto');

+

+const assert = require('assert');

+const https = require('https');

+const fs = require('fs');

+

+const TOTAL_REQS = 2;

+

+const options = {

+  key: fs.readFileSync(`${common.fixturesDir}/keys/agent1-key.pem`),

+  cert: fs.readFileSync(`${common.fixturesDir}/keys/agent1-cert.pem`)

+};

+

+const clientSessions = [];

+let serverRequests = 0;

+

+const agent = new https.Agent({

+  maxCachedSessions: 0

+});

+

+const server = https.createServer(options, function(req, res) {

+  serverRequests++;

+  res.end('ok');

+}).listen(0, function() {

+  let waiting = TOTAL_REQS;

+  function request() {

+    const options = {

+      agent: agent,

+      port: server.address().port,

+      rejectUnauthorized: false

+    };

+

+    https.request(options, function(res) {

+      clientSessions.push(res.socket.getSession());

+

+      res.resume();

+      res.on('end', function() {

+        if (--waiting !== 0)

+          return request();

+        server.close();

+      });

+    }).end();

+  }

+  request();

+});

+

+process.on('exit', function() {

+  assert.strictEqual(serverRequests, TOTAL_REQS);

+  assert.strictEqual(clientSessions.length, TOTAL_REQS);

+  assert.notStrictEqual(clientSessions[0].toString('hex'),

+                        clientSessions[1].toString('hex'));

+});

diff --git a/test/disabled/test-https-agent-session-eviction.js b/test/disabled/test-https-agent-session-eviction.js

new file mode 100644

index 0000000..567ed80

--- /dev/null

+++ b/test/disabled/test-https-agent-session-eviction.js

@@ -0,0 +1,84 @@

+'use strict';

+

+const common = require('../common');

+

+if (!common.hasCrypto)

+  common.skip('missing crypto');

+

+const assert = require('assert');

+const https = require('https');

+const fs = require('fs');

+const SSL_OP_NO_TICKET = require('crypto').constants.SSL_OP_NO_TICKET;

+

+const options = {

+  key: fs.readFileSync(`${common.fixturesDir}/keys/agent1-key.pem`),

+  cert: fs.readFileSync(`${common.fixturesDir}/keys/agent1-cert.pem`),

+  secureOptions: SSL_OP_NO_TICKET

+};

+

+// Create TLS1.2 server

+https.createServer(options, function(req, res) {

+  res.end('ohai');

+}).listen(0, function() {

+  first(this);

+});

+

+// Do request and let agent cache the session

+function first(server) {

+  const port = server.address().port;

+  const req = https.request({

+    port: port,

+    rejectUnauthorized: false

+  }, function(res) {

+    res.resume();

+

+    server.close(function() {

+      faultyServer(port);

+    });

+  });

+  req.end();

+}

+

+// Create TLS1 server

+function faultyServer(port) {

+  options.secureProtocol = 'TLSv1_method';

+  https.createServer(options, function(req, res) {

+    res.end('hello faulty');

+  }).listen(port, function() {

+    second(this);

+  });

+}

+

+// Attempt to request using cached session

+function second(server, session) {

+  const req = https.request({

+    port: server.address().port,

+    rejectUnauthorized: false

+  }, function(res) {

+    res.resume();

+  });

+

+  // Let it fail

+  req.on('error', common.mustCall(function(err) {

+    assert(/wrong version number/.test(err.message));

+

+    req.on('close', function() {

+      third(server);

+    });

+  }));

+  req.end();

+}

+

+// Try one more time - session should be evicted!

+function third(server) {

+  const req = https.request({

+    port: server.address().port,

+    rejectUnauthorized: false

+  }, function(res) {

+    res.resume();

+    assert(!req.socket.isSessionReused());

+    server.close();

+  });

+  req.on('error', common.mustNotCall());

+  req.end();

+}

diff --git a/test/disabled/test-https-agent-sni.js b/test/disabled/test-https-agent-sni.js

new file mode 100644

index 0000000..a06ce43

--- /dev/null

+++ b/test/disabled/test-https-agent-sni.js

@@ -0,0 +1,49 @@

+'use strict';

+const common = require('../common');

+if (!common.hasCrypto)

+  common.skip('missing crypto');

+

+const assert = require('assert');

+const https = require('https');

+const fs = require('fs');

+

+const options = {

+  key: fs.readFileSync(`${common.fixturesDir}/keys/agent1-key.pem`),

+  cert: fs.readFileSync(`${common.fixturesDir}/keys/agent1-cert.pem`)

+};

+

+const TOTAL = 4;

+let waiting = TOTAL;

+

+const server = https.Server(options, function(req, res) {

+  if (--waiting === 0) server.close();

+

+  res.writeHead(200, {

+    'x-sni': req.socket.servername

+  });

+  res.end('hello world');

+});

+

+server.listen(0, function() {

+  function expectResponse(id) {

+    return common.mustCall(function(res) {

+      res.resume();

+      assert.strictEqual(res.headers['x-sni'], `sni.${id}`);

+    });

+  }

+

+  const agent = new https.Agent({

+    maxSockets: 1

+  });

+  for (let j = 0; j < TOTAL; j++) {

+    https.get({

+      agent: agent,

+

+      path: '/',

+      port: this.address().port,

+      host: '127.0.0.1',

+      servername: `sni.${j}`,

+      rejectUnauthorized: false

+    }, expectResponse(j));

+  }

+});

diff --git a/test/disabled/test-https-agent.js b/test/disabled/test-https-agent.js

new file mode 100644

index 0000000..24086d1

--- /dev/null

+++ b/test/disabled/test-https-agent.js

@@ -0,0 +1,50 @@

+'use strict';

+const common = require('../common');

+if (!common.hasCrypto)

+  common.skip('missing crypto');

+

+const assert = require('assert');

+const https = require('https');

+const fs = require('fs');

+

+const options = {

+  key: fs.readFileSync(`${common.fixturesDir}/keys/agent1-key.pem`),

+  cert: fs.readFileSync(`${common.fixturesDir}/keys/agent1-cert.pem`)

+};

+

+

+const server = https.Server(options, function(req, res) {

+  res.writeHead(200);

+  res.end('hello world\n');

+});

+

+

+let responses = 0;

+const N = 4;

+const M = 4;

+

+

+server.listen(0, function() {

+  for (let i = 0; i < N; i++) {

+    setTimeout(function() {

+      for (let j = 0; j < M; j++) {

+        https.get({

+          path: '/',

+          port: server.address().port,

+          rejectUnauthorized: false

+        }, function(res) {

+          res.resume();

+          assert.strictEqual(res.statusCode, 200);

+          if (++responses === N * M) server.close();

+        }).on('error', function(e) {

+          throw e;

+        });

+      }

+    }, i);

+  }

+});

+

+

+process.on('exit', function() {

+  assert.strictEqual(N * M, responses);

+});

diff --git a/test/disabled/test-https-client-reject.js b/test/disabled/test-https-client-reject.js

new file mode 100644

index 0000000..8369e9a

--- /dev/null

+++ b/test/disabled/test-https-client-reject.js

@@ -0,0 +1,64 @@

+'use strict';

+const common = require('../common');

+if (!common.hasCrypto)

+  common.skip('missing crypto');

+

+const assert = require('assert');

+const https = require('https');

+const fs = require('fs');

+const path = require('path');

+

+const options = {

+  key: fs.readFileSync(path.join(common.fixturesDir, 'test_key.pem')),

+  cert: fs.readFileSync(path.join(common.fixturesDir, 'test_cert.pem'))

+};

+

+const server = https.createServer(options, common.mustCall(function(req, res) {

+  res.writeHead(200);

+  res.end();

+  req.resume();

+}, 2)).listen(0, function() {

+  unauthorized();

+});

+

+function unauthorized() {

+  const req = https.request({

+    port: server.address().port,

+    rejectUnauthorized: false

+  }, function(res) {

+    assert(!req.socket.authorized);

+    res.resume();

+    rejectUnauthorized();

+  });

+  req.on('error', function(err) {

+    throw err;

+  });

+  req.end();

+}

+

+function rejectUnauthorized() {

+  const options = {

+    port: server.address().port

+  };

+  options.agent = new https.Agent(options);

+  const req = https.request(options, common.mustNotCall());

+  req.on('error', function(err) {

+    authorized();

+  });

+  req.end();

+}

+

+function authorized() {

+  const options = {

+    port: server.address().port,

+    ca: [fs.readFileSync(path.join(common.fixturesDir, 'test_cert.pem'))]

+  };

+  options.agent = new https.Agent(options);

+  const req = https.request(options, function(res) {

+    res.resume();

+    assert(req.socket.authorized);

+    server.close();

+  });

+  req.on('error', common.mustNotCall());

+  req.end();

+}

diff --git a/test/disabled/test-https-client-resume.js b/test/disabled/test-https-client-resume.js

new file mode 100644

index 0000000..6ba40dc

--- /dev/null

+++ b/test/disabled/test-https-client-resume.js

@@ -0,0 +1,62 @@

+'use strict';

+// Create an ssl server.  First connection, validate that not resume.

+// Cache session and close connection.  Use session on second connection.

+// ASSERT resumption.

+const common = require('../common');

+if (!common.hasCrypto)

+  common.skip('missing crypto');

+

+const assert = require('assert');

+const https = require('https');

+const tls = require('tls');

+const fs = require('fs');

+

+const options = {

+  key: fs.readFileSync(`${common.fixturesDir}/keys/agent2-key.pem`),

+  cert: fs.readFileSync(`${common.fixturesDir}/keys/agent2-cert.pem`)

+};

+

+// create server

+const server = https.createServer(options, common.mustCall(function(req, res) {

+  res.end('Goodbye');

+}, 2));

+

+// start listening

+server.listen(0, function() {

+

+  let session1 = null;

+  const client1 = tls.connect({

+    port: this.address().port,

+    rejectUnauthorized: false

+  }, function() {

+    console.log('connect1');

+    assert.ok(!client1.isSessionReused(), 'Session *should not* be reused.');

+    session1 = client1.getSession();

+    client1.write('GET / HTTP/1.0\r\n' +

+                  'Server: 127.0.0.1\r\n' +

+                  '\r\n');

+  });

+

+  client1.on('close', function() {

+    console.log('close1');

+

+    const opts = {

+      port: server.address().port,

+      rejectUnauthorized: false,

+      session: session1

+    };

+

+    const client2 = tls.connect(opts, function() {

+      console.log('connect2');

+      assert.ok(client2.isSessionReused(), 'Session *should* be reused.');

+      client2.write('GET / HTTP/1.0\r\n' +

+                    'Server: 127.0.0.1\r\n' +

+                    '\r\n');

+    });

+

+    client2.on('close', function() {

+      console.log('close2');

+      server.close();

+    });

+  });

+});

diff --git a/test/disabled/test-https-host-headers.js b/test/disabled/test-https-host-headers.js

new file mode 100644