test_runner: fix test deserialize edge cases

PR-URL: #48106Fixes: #48103 Reviewed-By: Colin Ihrig <[email protected]> Reviewed-By: Benjamin Gruenbaum <[email protected]>

Author: MoLow

lib/internal/test_runner/reporter/v8-serializer.js

@@ -1,12 +1,17 @@
 'use strict';
 
+const{
+ TypedArrayPrototypeGetLength,
+}=primordials;
 const{ DefaultSerializer }=require('v8');
 const{ Buffer }=require('buffer');
 const{ serializeError }=require('internal/error_serdes');
 
 
 module.exports=asyncfunction*v8Reporter(source){
 constserializer=newDefaultSerializer();
+serializer.writeHeader();
+constheaderLength=TypedArrayPrototypeGetLength(serializer.releaseBuffer());
 
 forawait(constitemofsource){
 constoriginalError=item.data.details?.error;
@@ -16,6 +21,7 @@ module.exports = async function* v8Reporter(source){
 // Error is restored after serialization.
 item.data.details.error=serializeError(originalError);
 }
+serializer.writeHeader();
 // Add 4 bytes, to later populate with message length
 serializer.writeRawBytes(Buffer.allocUnsafe(4));
 serializer.writeHeader();
@@ -26,14 +32,14 @@ module.exports = async function* v8Reporter(source){
 }
 
 constserializedMessage=serializer.releaseBuffer();
-constserializedMessageLength=serializedMessage.length-4;
+constserializedMessageLength=serializedMessage.length-(4+headerLength);
 
 serializedMessage.set([
 serializedMessageLength>>24&0xFF,
 serializedMessageLength>>16&0xFF,
 serializedMessageLength>>8&0xFF,
 serializedMessageLength&0xFF,
-],0);
+],headerLength);
 yieldserializedMessage;
 }
 };

lib/internal/test_runner/runner.js

@@ -163,7 +163,8 @@ function getRunArgs({path, inspectPort, testNamePatterns }){
 constserializer=newDefaultSerializer();
 serializer.writeHeader();
 constv8Header=serializer.releaseBuffer();
-constkSerializedSizeHeader=4;
+constkV8HeaderLength=TypedArrayPrototypeGetLength(v8Header);
+constkSerializedSizeHeader=4+kV8HeaderLength;
 
 classFileTestextendsTest{
 // This class maintains two buffers:
@@ -236,22 +237,42 @@ class FileTest extends Test{
 this.#handleReportItem(item);
 }
 reportStarted(){}
-report(){
+drain(){
 this.#drainRawBuffer();
 this.#drainReportBuffer();
+}
+report(){
+this.drain();
 constskipReporting=this.#skipReporting();
 if(!skipReporting){
 super.reportStarted();
 super.report();
 }
 }
 parseMessage(readData){
-constdataLength=TypedArrayPrototypeGetLength(readData);
+letdataLength=TypedArrayPrototypeGetLength(readData);
 if(dataLength===0)return;
+constpartialV8Header=readData[dataLength-1]===v8Header[0];
+
+if(partialV8Header){
+// This will break if v8Header length (2 bytes) is changed.
+// However it is covered by tests.
+readData=TypedArrayPrototypeSubarray(readData,0,dataLength-1);
+dataLength--;
+}
 
-ArrayPrototypePush(this.#rawBuffer,readData);
+if(this.#rawBuffer[0]&&TypedArrayPrototypeGetLength(this.#rawBuffer[0])<kSerializedSizeHeader){
+this.#rawBuffer[0]=Buffer.concat([this.#rawBuffer[0],readData]);
+}else{
+ArrayPrototypePush(this.#rawBuffer,readData);
+}
 this.#rawBufferSize +=dataLength;
 this.#proccessRawBuffer();
+
+if(partialV8Header){
+ArrayPrototypePush(this.#rawBuffer,TypedArrayPrototypeSubarray(v8Header,0,1));
+this.#rawBufferSize++;
+}
 }
  #drainRawBuffer(){
 while(this.#rawBuffer.length>0){
@@ -264,16 +285,16 @@ class FileTest extends Test{
 letheaderIndex=bufferHead.indexOf(v8Header);
 letnonSerialized=Buffer.alloc(0);
 
-while(bufferHead&&headerIndex!==kSerializedSizeHeader){
+while(bufferHead&&headerIndex!==0){
 constnonSerializedData=headerIndex===-1 ?
 bufferHead :
-bufferHead.slice(0,headerIndex-kSerializedSizeHeader);
+bufferHead.slice(0,headerIndex);
 nonSerialized=Buffer.concat([nonSerialized,nonSerializedData]);
 this.#rawBufferSize -=TypedArrayPrototypeGetLength(nonSerializedData);
 if(headerIndex===-1){
 ArrayPrototypeShift(this.#rawBuffer);
 }else{
-this.#rawBuffer[0]=bufferHead.subarray(headerIndex-kSerializedSizeHeader);
+this.#rawBuffer[0]=TypedArrayPrototypeSubarray(bufferHead,headerIndex);
 }
 bufferHead=this.#rawBuffer[0];
 headerIndex=bufferHead?.indexOf(v8Header);
@@ -295,10 +316,10 @@ class FileTest extends Test{
 // We call `readUInt32BE` manually here, because this is faster than first converting
 // it to a buffer and using `readUInt32BE` on that.
 constfullMessageSize=(
-bufferHead[0]<<24|
-bufferHead[1]<<16|
-bufferHead[2]<<8|
-bufferHead[3]
+bufferHead[kV8HeaderLength]<<24|
+bufferHead[kV8HeaderLength+1]<<16|
+bufferHead[kV8HeaderLength+2]<<8|
+bufferHead[kV8HeaderLength+3]
 )+kSerializedSizeHeader;
 
 if(this.#rawBufferSize <fullMessageSize)break;
@@ -474,4 +495,7 @@ function run(options){
 returnroot.reporter;
 }
 
-module.exports={ run };
+module.exports={
+ FileTest,// Exported for tests only
+ run,
+};

test/parallel/test-runner-v8-deserializer.mjs

@@ -0,0 +1,103 @@
+// Flags: --expose-internals --no-warnings
+
+import'../common/index.mjs';
+import{describe,it,beforeEach}from'node:test';
+importassertfrom'node:assert';
+import{finished}from'node:stream/promises';
+import{DefaultSerializer}from'node:v8';
+importserializerfrom'internal/test_runner/reporter/v8-serializer';
+importrunnerfrom'internal/test_runner/runner';
+
+asyncfunctiontoArray(chunks){
+constarr=[];
+forawait(constiofchunks)arr.push(i);
+returnarr;
+}
+
+constchunks=awaittoArray(serializer([
+{type: 'test:diagnostic',data: {nesting: 0,details: {},message: 'diagnostic'}},
+]));
+constdefaultSerializer=newDefaultSerializer();
+defaultSerializer.writeHeader();
+constheaderLength=defaultSerializer.releaseBuffer().length;
+
+describe('v8 deserializer',()=>{
+letfileTest;
+letreported;
+beforeEach(()=>{
+reported=[];
+fileTest=newrunner.FileTest({name: 'filetest'});
+fileTest.reporter.on('data',(data)=>reported.push(data));
+assert(fileTest.isClearToSend());
+});
+
+asyncfunctioncollectReported(chunks){
+chunks.forEach((chunk)=>fileTest.parseMessage(chunk));
+fileTest.drain();
+fileTest.reporter.end();
+awaitfinished(fileTest.reporter);
+returnreported;
+}
+
+it('should do nothing when no chunks',async()=>{
+constreported=awaitcollectReported([]);
+assert.deepStrictEqual(reported,[]);
+});
+
+it('should deserialize a chunk with no serialization',async()=>{
+constreported=awaitcollectReported([Buffer.from('unknown')]);
+assert.deepStrictEqual(reported,[
+{data: {__proto__: null,file: 'filetest',message: 'unknown'},type: 'test:stdout'},
+]);
+});
+
+it('should deserialize a serialized chunk',async()=>{
+constreported=awaitcollectReported(chunks);
+assert.deepStrictEqual(reported,[
+{data: {nesting: 0,details: {},message: 'diagnostic'},type: 'test:diagnostic'},
+]);
+});
+
+it('should deserialize a serialized chunk after non-serialized chunk',async()=>{
+constreported=awaitcollectReported([Buffer.concat([Buffer.from('unknown'), ...chunks])]);
+assert.deepStrictEqual(reported,[
+{data: {__proto__: null,file: 'filetest',message: 'unknown'},type: 'test:stdout'},
+{data: {nesting: 0,details: {},message: 'diagnostic'},type: 'test:diagnostic'},
+]);
+});
+
+it('should deserialize a serialized chunk before non-serialized output',async()=>{
+constreported=awaitcollectReported([Buffer.concat([ ...chunks,Buffer.from('unknown')])]);
+assert.deepStrictEqual(reported,[
+{data: {nesting: 0,details: {},message: 'diagnostic'},type: 'test:diagnostic'},
+{data: {__proto__: null,file: 'filetest',message: 'unknown'},type: 'test:stdout'},
+]);
+});
+
+constheaderPosition=headerLength*2+4;
+for(leti=0;i<headerPosition+5;i++){
+constmessage=`should deserialize a serialized message split into two chunks{...${i},${i+1}...}`;
+it(message,async()=>{
+constdata=chunks[0];
+constreported=awaitcollectReported([data.subarray(0,i),data.subarray(i)]);
+assert.deepStrictEqual(reported,[
+{data: {nesting: 0,details: {},message: 'diagnostic'},type: 'test:diagnostic'},
+]);
+});
+
+it(`${message} wrapped by non-serialized data`,async()=>{
+constdata=chunks[0];
+constreported=awaitcollectReported([
+Buffer.concat([Buffer.from('unknown'),data.subarray(0,i)]),
+Buffer.concat([data.subarray(i),Buffer.from('unknown')]),
+]);
+assert.deepStrictEqual(reported,[
+{data: {__proto__: null,file: 'filetest',message: 'unknown'},type: 'test:stdout'},
+{data: {nesting: 0,details: {},message: 'diagnostic'},type: 'test:diagnostic'},
+{data: {__proto__: null,file: 'filetest',message: 'unknown'},type: 'test:stdout'},
+]);
+}
+);
+}
+
+});