JS: Add tests with missing flow.

Author: MathiasVP

javascript/ql/test/library-tests/frameworks/NodeJSLib/stream-pipe.js

@@ -137,3 +137,101 @@ function importedBufferInput() {
     }
   });
 }
+
+class HookDestination extends Writable {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+
+  _write(chunk, encoding, callback) {
+    consumeChunk(chunk); // $ MISSING: flow=write-hook flow=inherited-write-hook
+    consumeChunk(this.value); // $ MISSING: flow=hook-receiver
+    consumeChunk(encoding);
+    consumeChunk(callback);
+    callback();
+  }
+}
+
+Readable.from([source("write-hook")]).pipe(new HookDestination(source("hook-receiver")));
+
+class InheritedHookDestination extends HookDestination {}
+
+const DestinationAlias = InheritedHookDestination;
+const inheritedDestination = new DestinationAlias();
+const inheritedAlias = inheritedDestination;
+Readable.from([source("inherited-write-hook")]).pipe(inheritedAlias);
+
+const { Transform, Duplex } = require("stream");
+
+class HookTransform extends Transform {
+  _transform(chunk, encoding, callback) {
+    consumeChunk(chunk); // $ MISSING: flow=transform-hook
+    callback(null, chunk);
+  }
+}
+
+Readable.from([source("transform-hook")]).pipe(new HookTransform());
+
+class OverriddenWriteDestination extends Writable {
+  write(chunk) {
+    consumeChunk(chunk); // $ flow=overridden-write flow=inherited-overridden-write
+    return true;
+  }
+
+  _write(chunk, encoding, callback) {
+    consumeChunk(chunk);
+    callback();
+  }
+}
+
+Readable.from([source("overridden-write")]).pipe(new OverriddenWriteDestination());
+
+class IntermediateWriteDestination extends OverriddenWriteDestination {}
+class InheritedWriteDestination extends IntermediateWriteDestination {}
+
+Readable.from([source("inherited-overridden-write")]).pipe(new InheritedWriteDestination());
+
+class HookDuplex extends Duplex {
+  _read() {}
+
+  _write(chunk, encoding, callback) {
+    consumeChunk(chunk); // $ MISSING: flow=duplex-hook
+    callback();
+  }
+}
+
+Readable.from([source("duplex-hook")]).pipe(new HookDuplex());
+
+class OverriddenTransform extends Transform {
+  _write(chunk, encoding, callback) {
+    consumeChunk(chunk); // $ MISSING: flow=transform-write-hook flow=inherited-transform-write-hook
+    callback();
+  }
+
+  _transform(chunk, encoding, callback) {
+    consumeChunk(chunk);
+    callback(null, chunk);
+  }
+}
+
+Readable.from([source("transform-write-hook")]).pipe(new OverriddenTransform());
+
+class IntermediateTransform extends OverriddenTransform {}
+class InheritedTransform extends IntermediateTransform {}
+
+Readable.from([source("inherited-transform-write-hook")]).pipe(new InheritedTransform());
+
+class InstanceOverrideDestination extends Writable {
+  _write(chunk, encoding, callback) {
+    consumeChunk(chunk);
+    callback();
+  }
+}
+
+const instanceOverride = new InstanceOverrideDestination();
+instanceOverride.write = function(chunk) {
+  consumeChunk(chunk); // $ flow=instance-override
+  return true;
+};
+Readable.from([source("instance-override")]).pipe(instanceOverride);