test: http complete response after socket double end

PR-URL: #36633
Backport-PR-URL: #36940Fixes: #36620
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Danielle Adams <adamzdanielle@gmail.com>

Author: mitsos1os

test/parallel/test-http-outgoing-end-cork.js

@@ -0,0 +1,95 @@
+'use strict';
+constcommon=require('../common');
+constassert=require('assert');
+consthttp=require('http');
+
+constREQ_TIMEOUT=500;// Set max ms of request time before abort
+
+// Set total allowed test timeout to avoid infinite loop
+// that will hang test suite
+constTOTAL_TEST_TIMEOUT=1000;
+
+// Placeholder for sockets handled, to make sure that we
+// will reach a socket re-use case.
+consthandledSockets=newSet();
+
+letmetReusedSocket=false;// Flag for request loop termination.
+
+constdoubleEndResponse=(res)=>{
+// First end the request while sending some normal data
+res.end('regular end of request','utf8',common.mustCall());
+// Make sure the response socket is uncorked after first call of end
+assert.strictEqual(res.writableCorked,0);
+res.end();// Double end the response to prep for next socket re-use.
+};
+
+constsendDrainNeedingData=(res)=>{
+// Send data to socket more than the high watermark so that
+// it definitely needs drain
+consthighWaterMark=res.socket.writableHighWaterMark;
+constbufferToSend=Buffer.alloc(highWaterMark+100);
+constret=res.write(bufferToSend);// Write the request data.
+// Make sure that we had back pressure on response stream.
+assert.strictEqual(ret,false);
+res.once('drain',()=>res.end());// End on drain.
+};
+
+constserver=http.createServer((req,res)=>{
+const{socket: responseSocket}=res;
+if(handledSockets.has(responseSocket)){// re-used socket, send big data!
+metReusedSocket=true;// stop request loop
+console.debug('FOUND REUSED SOCKET!');
+sendDrainNeedingData(res);
+}else{// not used again
+// add to make sure we recognise it when we meet socket again
+handledSockets.add(responseSocket);
+doubleEndResponse(res);
+}
+});
+
+server.listen(0);// Start the server on a random port.
+
+constsendRequest=(agent)=>newPromise((resolve,reject)=>{
+consttimeout=setTimeout(common.mustNotCall(()=>{
+reject(newError('Request timed out'));
+}),REQ_TIMEOUT);
+http.get({
+port: server.address().port,
+path: '/',
+ agent
+},common.mustCall((res)=>{
+constresData=[];
+res.on('data',(data)=>resData.push(data));
+res.on('end',common.mustCall(()=>{
+consttotalData=resData.reduce((total,elem)=>total+elem.length,0);
+clearTimeout(timeout);// Cancel rejection timeout.
+resolve(totalData);// fulfill promise
+}));
+}));
+});
+
+server.once('listening',async()=>{
+consttestTimeout=setTimeout(common.mustNotCall(()=>{
+console.error('Test running for a while but could not met re-used socket');
+process.exit(1);
+}),TOTAL_TEST_TIMEOUT);
+// Explicitly start agent to force socket reuse.
+constagent=newhttp.Agent({keepAlive: true});
+// Start the request loop
+letreqNo=0;
+while(!metReusedSocket){
+try{
+console.log(`Sending req no ${++reqNo}`);
+consttotalData=awaitsendRequest(agent);
+console.log(`${totalData} bytes were received for request ${reqNo}`);
+}catch(err){
+console.error(err);
+process.exit(1);
+}
+}
+// Successfully tested conditions and ended loop
+clearTimeout(testTimeout);
+console.log('Closing server');
+agent.destroy();
+server.close();
+});

test/parallel/test-http-outgoing-end-multiple.js

@@ -5,12 +5,15 @@ const http = require('http');
 
 constserver=http.createServer(common.mustCall(function(req,res){
 res.end('testing ended state',common.mustCall());
+assert.strictEqual(res.writableCorked,0);
 res.end(common.mustCall());
+assert.strictEqual(res.writableCorked,0);
 res.on('finish',common.mustCall(()=>{
 res.end(common.mustCall((err)=>{
 assert.strictEqual(err.code,'ERR_STREAM_ALREADY_FINISHED');
 server.close();
 }));
+assert.strictEqual(res.writableCorked,0);
 }));
 }));