1 files changed, 55 insertions, 0 deletions
diff --git a/tests/drivers/stream_test.js b/tests/drivers/stream_test.js
new file mode 100644
index 0000000..e783862
--- /dev/null
+++ b/tests/drivers/stream_test.js
@@ -0,0 +1,55 @@
+// large checks stream partial diagnostics, and a check is dropped when newer input is already waiting.
+// usage: node tests/drivers/stream_test.js path/to/zclsp
+const assert = require('assert');
+const cp = require('child_process');
+const server = process.argv[2];
+const frame = m => { const b = Buffer.from(JSON.stringify(m)); return Buffer.concat([Buffer.from('Content-Length: ' + b.length + '\r\n\r\n'), b]); };
+const doc = (n, tail) => { let t = ''; for (let i = 0; i < n; i++) t += `int f${i}(int a) { return a + ${i}; }\n`; return t + tail; };
+function messages(out) {
+    const res = [];
+    let d = out;
+    while (d.length) {
+        const e = d.indexOf('\r\n\r\n'), n = Number(/Content-Length:\s*(\d+)/i.exec(d.subarray(0, e).toString())[1]);
+        res.push(JSON.parse(d.subarray(e + 4, e + 4 + n))); d = d.subarray(e + 4 + n);
+    }
+    return res;
+}
+const published = (msgs, uri) => msgs.filter(m => m.method === 'textDocument/publishDiagnostics' && m.params.uri === uri);
+// spawn the server and write each step after the previous one has had time to run (delay in ms)
+function session(steps) {
+    return new Promise(resolve => {
+        const p = cp.spawn(server, process.argv.slice(3));
+        let out = Buffer.alloc(0);
+        p.stdout.on('data', c => { out = Buffer.concat([out, c]); });
+        p.on('exit', () => resolve(messages(out)));
+        let at = 0;
+        const next = () => {
+            if (at >= steps.length) { p.stdin.write(frame({ jsonrpc: '2.0', method: 'exit' })); return; }
+            const [delay, msgs] = steps[at++];
+            p.stdin.write(Buffer.concat(msgs.map(frame)));
+            setTimeout(next, delay);
+        };
+        next();
+    });
+}
+const init = { jsonrpc: '2.0', id: 1, method: 'initialize', params: {} };
+const open = (uri, version, text) => ({ jsonrpc: '2.0', method: 'textDocument/didOpen', params: { textDocument: { uri, version, languageId: 'zc', text } } });
+const change = (uri, version, text) => ({ jsonrpc: '2.0', method: 'textDocument/didChange', params: { textDocument: { uri, version }, contentChanges: [{ text }] } });
+(async () => {
+    const A = 'file:///stream.zc';
+    // a large document with an error at the top: partial lists arrive before the end, the last holds everything
+    const bad = 'int broken( { }\n' + doc(1500, 'fn main() { return f0(1); }\n');
+    let msgs = published(await session([[3000, [init, open(A, 1, bad)]]]), A);
+    assert.ok(msgs.length >= 2, 'a large check streams several lists: ' + msgs.length);
+    assert.ok(msgs[0].params.diagnostics.some(d => d.severity === 1), 'the first list already has the error');
+    assert.ok(msgs[msgs.length - 1].params.diagnostics.length >= msgs[0].params.diagnostics.length, 'later lists grow');
+    // a change that is already waiting drops the stale check: only the newer version is published
+    const ok = doc(1500, 'fn main() { return f0(1); }\n');
+    msgs = published(await session([[3000, [init, open(A, 1, ok), change(A, 2, 'fn main() { return 0; }\n')]]]), A);
+    assert.ok(msgs.length >= 1 && msgs.every(m => m.params.version === 2), 'the stale version 1 is never published: ' + JSON.stringify(msgs.map(m => m.params.version)));
+    // an interrupted open of another document is still answered once nothing newer waits
+    const B = 'file:///other.zc';
+    msgs = await session([[3000, [init, open(A, 1, ok), open(B, 1, 'fn main() { return 0; }\n')]]]);
+    assert.ok(published(msgs, A).length >= 1 && published(msgs, B).length >= 1, 'both documents are published');
+    console.log('ok   large checks stream partial diagnostics and drop stale checks');
+})();