JS: Add tests.

Author: MathiasVP

javascript/ql/test/library-tests/frameworks/NodeJSLib/StreamPipeDataFlow.expected

@@ -0,0 +1,35 @@
+import javascript
+import utils.test.InlineExpectationsTest
+
+module StreamPipeConfig implements DataFlow::ConfigSig {
+  predicate isSource(DataFlow::Node source) {
+    source.getFile().getBaseName() = ["stream-pipe.js", "stream-pipe.mjs"] and
+    source.(DataFlow::CallNode).getCalleeName() = "source"
+  }
+
+  predicate isSink(DataFlow::Node sink) {
+    exists(DataFlow::CallNode call |
+      call.getFile().getBaseName() = ["stream-pipe.js", "stream-pipe.mjs"] and
+      call.getCalleeName() = "consumeChunk" and
+      sink = call.getArgument(0)
+    )
+  }
+}
+
+module Flow = DataFlow::Global<StreamPipeConfig>;
+
+module InlineTest implements TestSig {
+  string getARelevantTag() { result = "flow" }
+
+  predicate hasActualResult(Location location, string element, string tag, string value) {
+    tag = "flow" and
+    element = "" and
+    exists(DataFlow::CallNode source, DataFlow::Node sink |
+      Flow::flow(source, sink) and
+      value = source.getArgument(0).getStringValue() and
+      location = sink.getLocation()
+    )
+  }
+}
+
+import MakeTest<InlineTest>

javascript/ql/test/library-tests/frameworks/NodeJSLib/StreamPipeDataFlow.ql

@@ -0,0 +1,87 @@
+const { Readable, Writable } = require("stream");
+
+class DirectDestination extends Writable {
+  write(chunk) {
+    consumeChunk(chunk); // $ flow=direct
+    return true;
+  }
+}
+
+class PipedDestination extends Writable {
+  write(chunk) {
+    consumeChunk(chunk); // $ MISSING: flow=piped flow=piped-second
+    return true;
+  }
+}
+
+new DirectDestination().write(source("direct"));
+Readable.from([source("piped"), source("piped-second")]).pipe(new PipedDestination());
+
+
+class SetDestination extends Writable {
+  write(chunk) {
+    consumeChunk(chunk); // $ MISSING: flow=set
+    return true;
+  }
+}
+
+Readable.from(new Set([source("set")])).pipe(new SetDestination());
+
+class GeneratorDestination extends Writable {
+  write(chunk) {
+    consumeChunk(chunk); // $ MISSING: flow=generator
+    return true;
+  }
+}
+
+function* chunks() {
+  yield source("generator");
+}
+
+Readable.from(chunks()).pipe(new GeneratorDestination());
+
+class CleanDestination extends Writable {
+  write(chunk) {
+    consumeChunk(chunk);
+    return true;
+  }
+}
+
+const cleanReadable = Readable.from(["clean"]);
+cleanReadable.metadata = source("metadata");
+cleanReadable.pipe(new CleanDestination());
+
+class ReceiverDestination extends Writable {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+
+  write(chunk) {
+    consumeChunk(this.value); // $ MISSING: flow=receiver
+    return true;
+  }
+}
+
+const returnedDestination =
+  Readable.from(["clean"]).pipe(new ReceiverDestination(source("receiver")));
+consumeChunk(returnedDestination.value); // $ MISSING: flow=receiver
+
+class UncalledDestination extends Writable {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+
+  write(chunk) {
+    consumeChunk(this.value);
+    return true;
+  }
+}
+
+const unrelated = {
+  pipe(destination) {
+    return destination;
+  }
+};
+unrelated.pipe(new UncalledDestination(source("unrelated")));