lukechilds
/
node
mirror of https://github.com/lukechilds/node.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

test: consolidate http2 tests in one file 

PR-URL: https://github.com/nodejs/node/pull/15624
Refs: https://github.com/nodejs/node/issues/14985
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
v9.x-staging
Trivikram Kamat 8 years ago
committed by Ruben Bridgewater
parent
af6af08482
commit
2adf68035c
No known key found for this signature in database GPG Key ID: F07496B3EB3C1762
8 changed files with 47 additions and 272 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 39
      test/parallel/test-http2-server-destroy-before-additional.js
  2. 40
      test/parallel/test-http2-server-destroy-before-priority.js
  3. 39
      test/parallel/test-http2-server-destroy-before-push.js
  4. 39
      test/parallel/test-http2-server-destroy-before-respond.js
  5. 40
      test/parallel/test-http2-server-destroy-before-rst.js
  6. 36
      test/parallel/test-http2-server-destroy-before-state.js
  7. 39
      test/parallel/test-http2-server-destroy-before-write.js
  8. 47
      test/parallel/test-http2-server-stream-session-destroy.js

39
test/parallel/test-http2-server-destroy-before-additional.js
View File

@ -1,39 +0,0 @@
'use strict';
const common = require('../common');
if (!common.hasCrypto)
common.skip('missing crypto');
const assert = require('assert');
const h2 = require('http2');
const server = h2.createServer();
// we use the lower-level API here
server.on('stream', common.mustCall(onStream));
function onStream(stream, headers, flags) {
stream.session.destroy();
assert.throws(() => stream.additionalHeaders({}),
common.expectsError({
code: 'ERR_HTTP2_INVALID_STREAM',
message: /^The stream has been destroyed$/
}));
}
server.listen(0);
server.on('listening', common.mustCall(() => {
const client = h2.connect(`http://localhost:${server.address().port}`);
const req = client.request({ ':path': '/' });
req.on('response', common.mustNotCall());
req.resume();
req.on('end', common.mustCall(() => {
server.close();
client.destroy();
}));
req.end();
}));

40
test/parallel/test-http2-server-destroy-before-priority.js
View File

@ -1,40 +0,0 @@
'use strict';
const common = require('../common');
if (!common.hasCrypto)
common.skip('missing crypto');
const assert = require('assert');
const http2 = require('http2');
const server = http2.createServer();
// Test that ERR_HTTP2_INVALID_STREAM is thrown when a stream is destroyed
// before calling stream.priority
server.on('stream', common.mustCall(onStream));
function onStream(stream, headers, flags) {
stream.session.destroy();
assert.throws(() => stream.priority(),
common.expectsError({
code: 'ERR_HTTP2_INVALID_STREAM',
message: /^The stream has been destroyed$/
}));
}
server.listen(0);
server.on('listening', common.mustCall(() => {
const client = http2.connect(`http://localhost:${server.address().port}`);
const req = client.request({ ':path': '/' });
req.on('response', common.mustNotCall());
req.resume();
req.on('end', common.mustCall(() => {
server.close();
client.destroy();
}));
req.end();
}));

39
test/parallel/test-http2-server-destroy-before-push.js
View File

@ -1,39 +0,0 @@
'use strict';
const common = require('../common');
if (!common.hasCrypto)
common.skip('missing crypto');
const assert = require('assert');
const h2 = require('http2');
const server = h2.createServer();
// we use the lower-level API here
server.on('stream', common.mustCall(onStream));
function onStream(stream, headers, flags) {
stream.session.destroy();
assert.throws(() => stream.pushStream({}, common.mustNotCall()),
common.expectsError({
code: 'ERR_HTTP2_INVALID_STREAM',
message: /^The stream has been destroyed$/
}));
}
server.listen(0);
server.on('listening', common.mustCall(() => {
const client = h2.connect(`http://localhost:${server.address().port}`);
const req = client.request({ ':path': '/' });
req.on('response', common.mustNotCall());
req.resume();
req.on('end', common.mustCall(() => {
server.close();
client.destroy();
}));
req.end();
}));

39
test/parallel/test-http2-server-destroy-before-respond.js
View File

@ -1,39 +0,0 @@
'use strict';
const common = require('../common');
if (!common.hasCrypto)
common.skip('missing crypto');
const assert = require('assert');
const h2 = require('http2');
const server = h2.createServer();
// we use the lower-level API here
server.on('stream', common.mustCall(onStream));
function onStream(stream, headers, flags) {
stream.session.destroy();
assert.throws(() => stream.respond({}),
common.expectsError({
code: 'ERR_HTTP2_INVALID_STREAM',
message: /^The stream has been destroyed$/
}));
}
server.listen(0);
server.on('listening', common.mustCall(() => {
const client = h2.connect(`http://localhost:${server.address().port}`);
const req = client.request({ ':path': '/' });
req.on('response', common.mustNotCall());
req.resume();
req.on('end', common.mustCall(() => {
server.close();
client.destroy();
}));
req.end();
}));

40
test/parallel/test-http2-server-destroy-before-rst.js
View File

@ -1,40 +0,0 @@
'use strict';
const common = require('../common');
if (!common.hasCrypto)
common.skip('missing crypto');
const assert = require('assert');
const http2 = require('http2');
const server = http2.createServer();
// Test that ERR_HTTP2_INVALID_STREAM is thrown when a stream is destroyed
// before calling stream.rstStream
server.on('stream', common.mustCall(onStream));
function onStream(stream, headers, flags) {
stream.session.destroy();
assert.throws(() => stream.rstStream(),
common.expectsError({
code: 'ERR_HTTP2_INVALID_STREAM',
message: /^The stream has been destroyed$/
}));
}
server.listen(0);
server.on('listening', common.mustCall(() => {
const client = http2.connect(`http://localhost:${server.address().port}`);
const req = client.request({ ':path': '/' });
req.on('response', common.mustNotCall());
req.resume();
req.on('end', common.mustCall(() => {
server.close();
client.destroy();
}));
req.end();
}));

36
test/parallel/test-http2-server-destroy-before-state.js
View File

@ -1,36 +0,0 @@
'use strict';
const common = require('../common');
if (!common.hasCrypto)
common.skip('missing crypto');
const assert = require('assert');
const http2 = require('http2');
const server = http2.createServer();
// Test that stream.state getter returns and empty object
// if the stream session has been destroyed
server.on('stream', common.mustCall(onStream));
function onStream(stream, headers, flags) {
stream.session.destroy();
assert.deepStrictEqual(Object.create(null), stream.state);
}
server.listen(0);
server.on('listening', common.mustCall(() => {
const client = http2.connect(`http://localhost:${server.address().port}`);
const req = client.request({ ':path': '/' });
req.on('response', common.mustNotCall());
req.resume();
req.on('end', common.mustCall(() => {
server.close();
client.destroy();
}));
req.end();
}));

39
test/parallel/test-http2-server-destroy-before-write.js
View File

@ -1,39 +0,0 @@
'use strict';
const common = require('../common');
if (!common.hasCrypto)
common.skip('missing crypto');
const assert = require('assert');
const h2 = require('http2');
const server = h2.createServer();
// we use the lower-level API here
server.on('stream', common.mustCall(onStream));
function onStream(stream, headers, flags) {
stream.session.destroy();
assert.throws(() => stream.write('data'),
common.expectsError({
code: 'ERR_HTTP2_INVALID_STREAM',
type: Error
}));
}
server.listen(0);
server.on('listening', common.mustCall(() => {
const client = h2.connect(`http://localhost:${server.address().port}`);
const req = client.request({ ':path': '/' });
req.on('response', common.mustNotCall());
req.resume();
req.on('end', common.mustCall(() => {
server.close();
client.destroy();
}));
req.end();
}));

47
test/parallel/test-http2-server-stream-session-destroy.js
View File

@ -0,0 +1,47 @@
'use strict';
const common = require('../common');
if (!common.hasCrypto)
common.skip('missing crypto');
const assert = require('assert');
const h2 = require('http2');
const server = h2.createServer();
server.on(
'stream',
common.mustCall((stream) => {
const errorObj = {
type: Error,
code: 'ERR_HTTP2_INVALID_STREAM',
message: 'The stream has been destroyed'
};
stream.session.destroy();
// Test that stream.state getter returns an empty object
// when the stream session has been destroyed
assert.deepStrictEqual(Object.create(null), stream.state);
// Test that ERR_HTTP2_INVALID_STREAM is thrown while calling
// stream operations after the stream session has been destroyed
common.expectsError(() => stream.additionalHeaders(), errorObj);
common.expectsError(() => stream.priority(), errorObj);
common.expectsError(
() => stream.pushStream({}, common.mustNotCall()),
errorObj
);
common.expectsError(() => stream.respond(), errorObj);
common.expectsError(() => stream.rstStream(), errorObj);
common.expectsError(() => stream.write('data'), errorObj);
})
);
server.listen(
0,
common.mustCall(() => {
const client = h2.connect(`http://localhost:${server.address().port}`);
const req = client.request();
req.resume();
req.on('end', common.mustCall(() => server.close()));
})
);
Write Preview
Loading…
Cancel
Save