@rdfc/js-runner 2.0.0-alpha.9 → 3.0.0

package/lib/testUtils/index.js

@@ -0,0 +1,243 @@
+import { extractShapes } from 'rdf-lens';
+import { NamedNode, Parser, Writer as N3Writer } from 'n3';
+import { readFile } from 'fs/promises';
+import winston, { createLogger } from 'winston';
+import { Runner } from '../runner.js';
+import { createTermNamespace } from '@treecg/types';
+import { MockClientDuplexStream } from './duplex.js';
+import { promisify } from 'util';
+export function channel(runner, name) {
+    const n = new NamedNode(name);
+    const reader = runner.createReader(n);
+    const writer = runner.createWriter(n);
+    return [writer, reader];
+}
+export class StreamMsgMock {
+    data = [];
+    resolveId;
+    constructor(resolveId) {
+        this.resolveId = resolveId;
+    }
+    sendStreamMessage() {
+        const sendingStream = new MockClientDuplexStream();
+        let at = 0;
+        sendingStream.register((x) => x.data, (d, send) => {
+            setTimeout(() => send({ streamSequenceNumber: ++at }), 20);
+            this.data.push(d);
+        });
+        sendingStream.register((x) => x.id, (d, send) => send({ streamSequenceNumber: this.resolveId(d) }));
+        return sendingStream;
+    }
+}
+export class OrchestratorMock {
+    connectStream;
+    streamMsgs = {};
+    streamMsgCount = 0;
+    connect() {
+        const connectStream = new MockClientDuplexStream();
+        connectStream.register((msg) => msg.processed, ({ channel, globalSequenceNumber }, send) => {
+            send({
+                processed: { channel, localSequenceNumber: globalSequenceNumber },
+            });
+        });
+        connectStream.register((msg) => msg.msg, ({ localSequenceNumber, data, channel }, send) => {
+            send({
+                msg: { globalSequenceNumber: localSequenceNumber, channel, data },
+            });
+        });
+        connectStream.register((msg) => msg.close, (close, send) => {
+            send({ close });
+        });
+        this.connectStream = connectStream;
+        return connectStream;
+    }
+    sendStreamMessage() {
+        const out = new MockClientDuplexStream();
+        const id = this.streamMsgCount;
+        this.streamMsgCount++;
+        out.registerOnce((x) => x.id, ({ channel }, toProducingStream) => {
+            this.streamMsgs[id] = { toProducingStream };
+            this.connectStream.send({
+                streamMsg: { channel, globalSequenceNumber: id },
+            });
+        });
+        out.register((x) => x.data, (data) => {
+            this.streamMsgs[id].receivingStream.send(data);
+        });
+        out.on('end', () => {
+            this.streamMsgs[id].receivingStream.end();
+        });
+        return out;
+    }
+    receiveStreamMessage() {
+        const receivingStream = new MockClientDuplexStream();
+        let streamId = 0;
+        receivingStream.registerOnce((x) => x.globalSequenceNumber, (id) => {
+            streamId = id;
+            this.streamMsgs[id].receivingStream = receivingStream;
+            this.streamMsgs[id].toProducingStream({ streamSequenceNumber: 0 });
+        });
+        receivingStream.register((x) => x.streamSequenceNumber, (streamSequenceNumber) => {
+            this.streamMsgs[streamId].toProducingStream({ streamSequenceNumber });
+        });
+        return receivingStream;
+    }
+    logStream() {
+        const logStream = new MockClientDuplexStream();
+        logStream.register((x) => x, console.log);
+        return logStream;
+    }
+}
+export function createRunner(uri = 'http://example.com/ns#') {
+    const logger = createLogger({
+        transports: new winston.transports.Console({
+            level: process.env['DEBUG'] || 'info',
+        }),
+    });
+    const client = new OrchestratorMock();
+    const stream = client.connect();
+    const writable = promisify(stream.write.bind(stream));
+    const runner = new Runner(client, writable, uri, logger);
+    stream.on('data', (msg) => runner.handleOrchMessage(msg));
+    return runner;
+}
+export async function one(iter) {
+    for await (const item of iter) {
+        return item;
+    }
+}
+const shapeQuads = `
+@prefix rdfc: <https://w3id.org/rdf-connect#>.
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
+@prefix sh: <http://www.w3.org/ns/shacl#>.
+[ ] a sh:NodeShape;
+  sh:targetClass <JsProcessorShape>;
+  sh:property [
+    sh:path rdfc:entrypoint;
+    sh:name "location";
+    sh:minCount 1;
+    sh:maxCount 1;
+    sh:datatype xsd:string;
+  ], [
+    sh:path rdfc:file;
+    sh:name "file";
+    sh:minCount 1;
+    sh:maxCount 1;
+    sh:datatype xsd:string;
+  ], [
+    sh:path rdfc:class;
+    sh:name "clazz";
+    sh:maxCount 1;
+    sh:datatype xsd:string;
+  ].
+`;
+const OWL = createTermNamespace('http://www.w3.org/2002/07/owl#', 'imports');
+const processorShapes = extractShapes(new Parser().parse(shapeQuads));
+const base = 'https://w3id.org/rdf-connect#';
+export async function importFile(file, content) {
+    const done = new Set();
+    const quads = [];
+    const todo = [];
+    const parse = (content, baseIRI) => {
+        done.add(baseIRI.toString());
+        const extras = new Parser({ baseIRI: baseIRI.toString() }).parse(content);
+        for (const o of extras
+            .filter((x) => x.subject.value === baseIRI?.toString() &&
+            x.predicate.equals(OWL.imports))
+            .map((x) => x.object.value)) {
+            todo.push(new URL(o));
+        }
+        quads.push(...extras);
+    };
+    if (content) {
+        parse(content, new URL('file://' + file));
+    }
+    else {
+        todo.push(new URL('file://' + file));
+    }
+    let item = todo.pop();
+    while (item !== undefined) {
+        if (done.has(item.toString())) {
+            item = todo.pop();
+            continue;
+        }
+        if (item.protocol !== 'file:') {
+            throw 'No supported protocol ' + item.protocol;
+        }
+        const txt = await readFile(item.pathname, { encoding: 'utf8' });
+        parse(txt, item);
+        item = todo.pop();
+    }
+    return quads;
+}
+export class ProcHelper {
+    runner;
+    quads = [];
+    config;
+    proc;
+    constructor(uri) {
+        this.runner = createRunner(uri);
+    }
+    async importInline(baseIRI, config) {
+        const configQuads = await importFile(baseIRI, config);
+        this.quads.push(...configQuads);
+    }
+    async importFile(file) {
+        const configQuads = await importFile(file);
+        this.quads.push(...configQuads);
+    }
+    getConfig(ty) {
+        const id = typeof ty === 'string' ? new NamedNode(base + ty) : ty;
+        const procConfig = processorShapes.lenses['JsProcessorShape'].execute({
+            id,
+            quads: this.quads,
+        });
+        this.config = procConfig;
+        return procConfig;
+    }
+    async getProcessor(uri = 'http://example.com/ns#processor') {
+        await this.runner.handleOrchMessage({
+            pipeline: new N3Writer().quadsToString(this.quads),
+        });
+        const proc = await this.runner.addProcessor({
+            config: JSON.stringify(this.config),
+            arguments: '',
+            uri,
+        });
+        return proc;
+    }
+}
+export async function getProcInline(config, ty, runner, baseIRI, uri = 'http://example.com/ns#processor') {
+    const configQuads = await importFile(baseIRI, config);
+    const procConfig = processorShapes.lenses['JsProcessorShape'].execute({
+        id: new NamedNode(base + ty),
+        quads: configQuads,
+    });
+    await runner.handleOrchMessage({
+        pipeline: new N3Writer().quadsToString(configQuads),
+    });
+    const proc = await runner.addProcessor({
+        config: JSON.stringify(procConfig),
+        arguments: '',
+        uri,
+    });
+    return proc;
+}
+export async function getProc(config, ty, runner, configLocation, uri = 'http://example.com/ns#processor') {
+    const configQuads = await importFile(configLocation);
+    const procConfig = processorShapes.lenses['JsProcessorShape'].execute({
+        id: new NamedNode(base + ty),
+        quads: configQuads,
+    });
+    configQuads.push(...new Parser().parse(config));
+    await runner.handleOrchMessage({
+        pipeline: new N3Writer().quadsToString(configQuads),
+    });
+    const proc = await runner.addProcessor({
+        config: JSON.stringify(procConfig),
+        arguments: '',
+        uri,
+    });
+    return proc;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/testUtils/index.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  DataChunk,\n  FromRunner,\n  LogMessage,\n  Processor as ProcConfig,\n  ToRunner,\n} from '@rdfc/proto'\nimport {} from '../reexports'\nimport { extractShapes } from 'rdf-lens'\nimport { NamedNode, Parser, Writer as N3Writer } from 'n3'\nimport { readFile } from 'fs/promises'\nimport winston, { createLogger } from 'winston'\nimport { Processor } from '../processor'\nimport { FullProc, Runner, Writable } from '../runner'\nimport { Quad } from '@rdfjs/types'\nimport { createTermNamespace } from '@treecg/types'\nimport {\n  ReceivingStreamControl,\n  SendingStreamControl,\n  StreamChunk,\n  StreamIdentify,\n} from '@rdfc/proto/lib/generated/common'\nimport { MockClientDuplexStream } from './duplex'\nimport { promisify } from 'util'\nimport { Reader } from '../reader'\nimport { Writer } from '../writer'\n\nexport function channel(runner: Runner, name: string): [Writer, Reader] {\n  const n = new NamedNode(name)\n  const reader = runner.createReader(n)\n  const writer = runner.createWriter(n)\n\n  return [writer, reader]\n}\n\nexport class StreamMsgMock {\n  data: DataChunk[] = []\n\n  private readonly resolveId: (id: StreamIdentify) => number\n\n  constructor(resolveId: (id: StreamIdentify) => number) {\n    this.resolveId = resolveId\n  }\n\n  sendStreamMessage(): MockClientDuplexStream<\n    StreamChunk,\n    ReceivingStreamControl\n  > {\n    const sendingStream = new MockClientDuplexStream<\n      StreamChunk,\n      ReceivingStreamControl\n    >()\n\n    let at = 0\n    sendingStream.register(\n      (x) => x.data,\n      (d, send) => {\n        setTimeout(() => send({ streamSequenceNumber: ++at }), 20)\n        this.data.push(d)\n      },\n    )\n    sendingStream.register(\n      (x) => x.id,\n      (d, send) => send({ streamSequenceNumber: this.resolveId(d) }),\n    )\n    return sendingStream\n  }\n}\n\nexport class OrchestratorMock {\n  connectStream: MockClientDuplexStream<FromRunner, ToRunner>\n\n  streamMsgs: {\n    [id: string]: {\n      toProducingStream: (id: ReceivingStreamControl) => void\n      receivingStream?: MockClientDuplexStream<SendingStreamControl, DataChunk>\n    }\n  } = {}\n\n  streamMsgCount = 0\n\n  connect(): MockClientDuplexStream<FromRunner, ToRunner> {\n    const connectStream = new MockClientDuplexStream<FromRunner, ToRunner>()\n    // Always bounce processed msgs back to the runner\n    connectStream.register(\n      (msg) => msg.processed,\n      ({ channel, globalSequenceNumber }, send) => {\n        send({\n          processed: { channel, localSequenceNumber: globalSequenceNumber },\n        })\n      },\n    )\n\n    // Always bounce data msgs back to the runner\n    connectStream.register(\n      (msg) => msg.msg,\n      ({ localSequenceNumber, data, channel }, send) => {\n        send({\n          msg: { globalSequenceNumber: localSequenceNumber, channel, data },\n        })\n      },\n    )\n\n    // Always bounce close msgs back to the runner\n    connectStream.register(\n      (msg) => msg.close,\n      (close, send) => {\n        send({ close })\n      },\n    )\n\n    this.connectStream = connectStream\n    return connectStream\n  }\n\n  sendStreamMessage(): MockClientDuplexStream<\n    StreamChunk,\n    ReceivingStreamControl\n  > {\n    const out = new MockClientDuplexStream<\n      StreamChunk,\n      ReceivingStreamControl\n    >()\n    const id = this.streamMsgCount\n    this.streamMsgCount++\n\n    out.registerOnce(\n      (x) => x.id,\n      ({ channel }, toProducingStream) => {\n        this.streamMsgs[id] = { toProducingStream }\n\n        // Notify stream message\n        this.connectStream.send({\n          streamMsg: { channel, globalSequenceNumber: id },\n        })\n      },\n    )\n\n    out.register(\n      (x) => x.data,\n      (data) => {\n        // bounce data to receiving stream\n        this.streamMsgs[id].receivingStream!.send(data)\n      },\n    )\n\n    out.on('end', () => {\n      // end receiving stream\n      this.streamMsgs[id].receivingStream!.end()\n    })\n\n    return out\n  }\n\n  receiveStreamMessage(): MockClientDuplexStream<\n    SendingStreamControl,\n    DataChunk\n  > {\n    const receivingStream = new MockClientDuplexStream<\n      SendingStreamControl,\n      DataChunk\n    >()\n    let streamId = 0\n\n    receivingStream.registerOnce(\n      (x) => x.globalSequenceNumber,\n      (id) => {\n        streamId = id\n        this.streamMsgs[id].receivingStream = receivingStream\n        this.streamMsgs[id].toProducingStream({ streamSequenceNumber: 0 })\n      },\n    )\n\n    receivingStream.register(\n      (x) => x.streamSequenceNumber,\n      (streamSequenceNumber) => {\n        // Bounce processed message to producing stream\n        this.streamMsgs[streamId].toProducingStream({ streamSequenceNumber })\n      },\n    )\n\n    return receivingStream\n  }\n\n  logStream(): MockClientDuplexStream<LogMessage, null> {\n    const logStream = new MockClientDuplexStream<LogMessage, null>()\n    logStream.register((x) => x, console.log)\n    return logStream\n  }\n}\n\nexport function createRunner(uri = 'http://example.com/ns#') {\n  const logger = createLogger({\n    transports: new winston.transports.Console({\n      level: process.env['DEBUG'] || 'info',\n    }),\n  })\n\n  // Mock the GRPC\n  const client = new OrchestratorMock()\n\n  // Connect just like client.ts:start()\n  const stream = client.connect()\n  const writable = promisify(stream.write.bind(stream))\n\n  const runner = new Runner(\n    /* eslint-disable @typescript-eslint/no-explicit-any */\n    client as any, // Type assertion for testing\n    writable as Writable,\n    uri,\n    logger,\n  )\n\n  stream.on('data', (msg: ToRunner) => runner.handleOrchMessage(msg))\n\n  return runner\n}\n\nexport async function one<T>(iter: AsyncIterable<T>): Promise<T | undefined> {\n  for await (const item of iter) {\n    return item\n  }\n}\n\nconst shapeQuads = `\n@prefix rdfc: <https://w3id.org/rdf-connect#>.\n@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.\n@prefix sh: <http://www.w3.org/ns/shacl#>.\n[ ] a sh:NodeShape;\n  sh:targetClass <JsProcessorShape>;\n  sh:property [\n    sh:path rdfc:entrypoint;\n    sh:name \"location\";\n    sh:minCount 1;\n    sh:maxCount 1;\n    sh:datatype xsd:string;\n  ], [\n    sh:path rdfc:file;\n    sh:name \"file\";\n    sh:minCount 1;\n    sh:maxCount 1;\n    sh:datatype xsd:string;\n  ], [\n    sh:path rdfc:class;\n    sh:name \"clazz\";\n    sh:maxCount 1;\n    sh:datatype xsd:string;\n  ].\n`\nexport type ConfigType = {\n  location: string\n  file: string\n  clazz: string\n}\n\nconst OWL = createTermNamespace('http://www.w3.org/2002/07/owl#', 'imports')\nconst processorShapes = extractShapes(new Parser().parse(shapeQuads))\nconst base = 'https://w3id.org/rdf-connect#'\n\nexport async function importFile(\n  file: string,\n  content?: string,\n): Promise<Quad[]> {\n  const done = new Set<string>()\n\n  const quads: Quad[] = []\n  const todo: URL[] = []\n\n  const parse = (content: string, baseIRI: URL) => {\n    done.add(baseIRI.toString())\n\n    const extras = new Parser({ baseIRI: baseIRI.toString() }).parse(content)\n\n    for (const o of extras\n      .filter(\n        (x) =>\n          x.subject.value === baseIRI?.toString() &&\n          x.predicate.equals(OWL.imports),\n      )\n      .map((x) => x.object.value)) {\n      todo.push(new URL(o))\n    }\n\n    quads.push(...extras)\n  }\n\n  if (content) {\n    parse(content, new URL('file://' + file))\n  } else {\n    todo.push(new URL('file://' + file))\n  }\n\n  let item = todo.pop()\n  while (item !== undefined) {\n    if (done.has(item.toString())) {\n      item = todo.pop()\n      continue\n    }\n\n    if (item.protocol !== 'file:') {\n      throw 'No supported protocol ' + item.protocol\n    }\n    const txt = await readFile(item.pathname, { encoding: 'utf8' })\n    parse(txt, item)\n\n    item = todo.pop()\n  }\n\n  return quads\n}\n\n/**\n * Helper class to gradually test your processors.\n * Possible flow:\n * - import the JsRunner index file\n * - import your processor config file\n * - test if the config is as you would expect (from getConfig())\n * - import your processor definition (inline)\n * - build your processor\n * - test your processor\n */\nexport class ProcHelper<T extends Processor<unknown>> {\n  runner: Runner\n  quads: Quad[] = []\n  config: ConfigType\n  proc: FullProc<T>\n\n  constructor(uri?: string) {\n    this.runner = createRunner(uri)\n  }\n\n  async importInline(baseIRI: string, config: string) {\n    const configQuads = await importFile(baseIRI, config)\n    this.quads.push(...configQuads)\n  }\n\n  async importFile(file: string) {\n    const configQuads = await importFile(file)\n    this.quads.push(...configQuads)\n  }\n\n  getConfig(ty: string | NamedNode): ConfigType {\n    const id = typeof ty === 'string' ? new NamedNode(base + ty) : ty\n    const procConfig = <ConfigType>processorShapes.lenses[\n      'JsProcessorShape'\n    ].execute({\n      id,\n      quads: this.quads,\n    })\n\n    this.config = procConfig\n    return procConfig\n  }\n\n  async getProcessor(\n    uri: string = 'http://example.com/ns#processor',\n  ): Promise<FullProc<T>> {\n    await this.runner.handleOrchMessage({\n      pipeline: new N3Writer().quadsToString(this.quads),\n    })\n\n    const proc = await this.runner.addProcessor<T>({\n      config: JSON.stringify(this.config),\n      arguments: '',\n      uri,\n    })\n    return proc\n  }\n}\n\n/**\n * @deprecated use {@link ProcHelper}\n */\nexport async function getProcInline<T extends Processor<unknown>>(\n  config: string,\n  ty: string,\n  runner: Runner,\n  baseIRI: string,\n  uri = 'http://example.com/ns#processor',\n): Promise<FullProc<T>> {\n  const configQuads = await importFile(baseIRI, config)\n  const procConfig = <ProcConfig>processorShapes.lenses[\n    'JsProcessorShape'\n  ].execute({\n    id: new NamedNode(base + ty),\n    quads: configQuads,\n  })\n\n  await runner.handleOrchMessage({\n    pipeline: new N3Writer().quadsToString(configQuads),\n  })\n\n  const proc = await runner.addProcessor<T>({\n    config: JSON.stringify(procConfig),\n    arguments: '',\n    uri,\n  })\n\n  return proc\n}\n\n/**\n * @deprecated use {@link ProcHelper}\n */\nexport async function getProc<T extends Processor<unknown>>(\n  config: string,\n  ty: string,\n  runner: Runner,\n  configLocation: string,\n  uri = 'http://example.com/ns#processor',\n): Promise<FullProc<T>> {\n  const configQuads = await importFile(configLocation)\n  const procConfig = processorShapes.lenses['JsProcessorShape'].execute({\n    id: new NamedNode(base + ty),\n    quads: configQuads,\n  })\n\n  configQuads.push(...new Parser().parse(config))\n  await runner.handleOrchMessage({\n    pipeline: new N3Writer().quadsToString(configQuads),\n  })\n\n  const proc = await runner.addProcessor<T>({\n    config: JSON.stringify(procConfig),\n    arguments: '',\n    uri,\n  })\n\n  return proc\n}\n"]}

package/lib/testUtils.d.ts

@@ -3,6 +3,9 @@ import { ClientReadableStream } from '@grpc/grpc-js';
 import winston from 'winston';
 import { WriterInstance } from './writer.js';
 import { ReaderInstance } from './reader.js';
+import { Processor } from './processor.js';
+import { FullProc } from './runner.js';
+import { Quad } from '@rdfjs/types';
 export declare function getProcessorShape(baseIRI?: string): Promise<import("rdf-lens").Shapes>;
 export declare class TestClient extends RunnerClient {
     next: (stream: ClientReadableStream<DataChunk>) => unknown;
@@ -16,3 +19,6 @@ export declare const uri = "someUri";
 export declare const logger: winston.Logger;
 export declare function createWriter(iri?: string): [WriterInstance, ReaderInstance];
 export declare function createReader(iri?: string): ReaderInstance;
+export declare function importFile(file: string): Promise<Quad[]>;
+export declare function getProc<T extends Processor<unknown>>(config: string, ty: string, configLocation: string, uri?: string): Promise<FullProc<T>>;
+export declare function checkProcDefinition(file: string, n: string): Promise<void>;

package/lib/testUtils.js

@@ -2,11 +2,14 @@ import { RunnerClient } from '@rdfc/proto';
 import * as grpc from '@grpc/grpc-js';
 import { ClientReadableStreamImpl } from './reexports.js';
 import { extractShapes } from 'rdf-lens';
-import { Parser } from 'n3';
+import { NamedNode, Parser, Writer } from 'n3';
 import { readFile } from 'fs/promises';
 import winston, { createLogger } from 'winston';
 import { WriterInstance } from './writer.js';
 import { ReaderInstance } from './reader.js';
+import { Runner } from './runner.js';
+import { createTermNamespace } from '@treecg/types';
+import { expect } from 'vitest';
 export async function getProcessorShape(baseIRI = process.cwd() + '/node_modules/@rdfc/js-runner/index.ttl') {
     const configFile = await readFile(baseIRI, { encoding: 'utf8' });
     const configQuads = new Parser().parse(configFile);
@@ -57,4 +60,91 @@ export function createReader(iri = uri) {
     const reader = new ReaderInstance(iri, client, logger);
     return reader;
 }
-//# sourceMappingURL=data:application/json;base64,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
+const shapeQuads = `
+@prefix rdfc: <https://w3id.org/rdf-connect#>.
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
+@prefix sh: <http://www.w3.org/ns/shacl#>.
+[ ] a sh:NodeShape;
+  sh:targetClass <JsProcessorShape>;
+  sh:property [
+    sh:path rdfc:entrypoint;
+    sh:name "location";
+    sh:minCount 1;
+    sh:maxCount 1;
+    sh:datatype xsd:string;
+  ], [
+    sh:path rdfc:file;
+    sh:name "file";
+    sh:minCount 1;
+    sh:maxCount 1;
+    sh:datatype xsd:string;
+  ], [
+    sh:path rdfc:class;
+    sh:name "clazz";
+    sh:maxCount 1;
+    sh:datatype xsd:string;
+  ].
+`;
+const OWL = createTermNamespace('http://www.w3.org/2002/07/owl#', 'imports');
+const processorShapes = extractShapes(new Parser().parse(shapeQuads));
+const base = 'https://w3id.org/rdf-connect#';
+export async function importFile(file) {
+    const done = new Set();
+    const todo = [new URL('file://' + file)];
+    const quads = [];
+    let item = todo.pop();
+    while (item !== undefined) {
+        if (done.has(item.toString())) {
+            item = todo.pop();
+            continue;
+        }
+        done.add(item.toString());
+        if (item.protocol !== 'file:') {
+            throw 'No supported protocol ' + item.protocol;
+        }
+        const txt = await readFile(item.pathname, { encoding: 'utf8' });
+        const extras = new Parser({ baseIRI: item.toString() }).parse(txt);
+        for (const o of extras
+            .filter((x) => x.subject.value === item?.toString() &&
+            x.predicate.equals(OWL.imports))
+            .map((x) => x.object.value)) {
+            todo.push(new URL(o));
+        }
+        quads.push(...extras);
+        item = todo.pop();
+    }
+    return quads;
+}
+export async function getProc(config, ty, configLocation, uri = 'http://example.com/ns#processor') {
+    const configQuads = await importFile(configLocation);
+    const procConfig = processorShapes.lenses['JsProcessorShape'].execute({
+        id: new NamedNode(base + ty),
+        quads: configQuads,
+    });
+    const msgs = [];
+    const write = async (x) => {
+        msgs.push(x);
+    };
+    const runner = new Runner(new TestClient(), write, 'http://example.com/ns#', logger);
+    configQuads.push(...new Parser().parse(config));
+    await runner.handleOrchMessage({
+        pipeline: new Writer().quadsToString(configQuads),
+    });
+    const proc = await runner.addProcessor({
+        config: JSON.stringify(procConfig),
+        arguments: '',
+        uri,
+    });
+    return proc;
+}
+export async function checkProcDefinition(file, n) {
+    const quads = await importFile(file);
+    const procConfig = (processorShapes.lenses['JsProcessorShape'].execute({
+        id: new NamedNode(base + n),
+        quads: quads,
+    }));
+    expect(procConfig.file, n + ' has file').toBeDefined();
+    expect(procConfig.location, n + ' has location').toBeDefined();
+    expect(procConfig.clazz, n + ' has clazz').toBeDefined();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"testUtils.js","sourceRoot":"","sources":["../src/testUtils.ts"],"names":[],"mappings":"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","sourcesContent":["import { DataChunk, RunnerClient } from '@rdfc/proto'\nimport * as grpc from '@grpc/grpc-js'\nimport { ClientReadableStream } from '@grpc/grpc-js'\nimport { ClientReadableStreamImpl, OrchestratorMessage } from './reexports'\nimport { extractShapes } from 'rdf-lens'\nimport { NamedNode, Parser, Writer } from 'n3'\nimport { readFile } from 'fs/promises'\nimport winston, { createLogger } from 'winston'\nimport { WriterInstance } from './writer'\nimport { ReaderInstance } from './reader'\nimport { Processor } from './processor'\nimport { FullProc, Runner } from './runner'\nimport { Quad, Term } from '@rdfjs/types'\nimport { createTermNamespace } from '@treecg/types'\nimport { expect } from 'vitest'\n\nexport async function getProcessorShape(\n  baseIRI = process.cwd() + '/node_modules/@rdfc/js-runner/index.ttl',\n) {\n  const configFile = await readFile(baseIRI, { encoding: 'utf8' })\n  const configQuads = new Parser().parse(configFile)\n  const shapes = extractShapes(configQuads)\n\n  return shapes\n}\n\nexport class TestClient extends RunnerClient {\n  next: (stream: ClientReadableStream<DataChunk>) => unknown\n\n  constructor() {\n    super('localhost:5400', grpc.credentials.createInsecure())\n  }\n\n  nextStream(): Promise<ClientReadableStream<DataChunk>> {\n    return new Promise((res) => (this.next = res))\n  }\n\n  receiveStreamMessage(): ClientReadableStream<DataChunk> {\n    const stream = new ClientReadableStreamImpl<DataChunk>((data: Buffer) => {\n      return { data }\n    })\n    this.next(stream)\n    return stream\n  }\n}\n\nexport async function one<T>(iter: AsyncIterable<T>): Promise<T | undefined> {\n  for await (const item of iter) {\n    return item\n  }\n}\n\nexport const client = new TestClient()\nexport const uri = 'someUri'\nexport const logger = createLogger({\n  transports: new winston.transports.Console({\n    level: process.env['DEBUG'] || 'info',\n  }),\n})\n\nexport function createWriter(iri = uri): [WriterInstance, ReaderInstance] {\n  const reader = createReader(iri)\n  const writeStream = new WriterInstance(\n    iri,\n    client,\n    async (msg) => {\n      if (msg.msg) {\n        reader.handleMsg(msg.msg)\n      }\n      if (msg.close) {\n        reader.close()\n      }\n    },\n    logger,\n  )\n  return [writeStream, reader]\n}\n\nexport function createReader(iri = uri): ReaderInstance {\n  const reader = new ReaderInstance(iri, client, logger)\n  return reader\n}\n\nconst shapeQuads = `\n@prefix rdfc: <https://w3id.org/rdf-connect#>.\n@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.\n@prefix sh: <http://www.w3.org/ns/shacl#>.\n[ ] a sh:NodeShape;\n  sh:targetClass <JsProcessorShape>;\n  sh:property [\n    sh:path rdfc:entrypoint;\n    sh:name \"location\";\n    sh:minCount 1;\n    sh:maxCount 1;\n    sh:datatype xsd:string;\n  ], [\n    sh:path rdfc:file;\n    sh:name \"file\";\n    sh:minCount 1;\n    sh:maxCount 1;\n    sh:datatype xsd:string;\n  ], [\n    sh:path rdfc:class;\n    sh:name \"clazz\";\n    sh:maxCount 1;\n    sh:datatype xsd:string;\n  ].\n`\nconst OWL = createTermNamespace('http://www.w3.org/2002/07/owl#', 'imports')\nconst processorShapes = extractShapes(new Parser().parse(shapeQuads))\nconst base = 'https://w3id.org/rdf-connect#'\n\nexport async function importFile(file: string): Promise<Quad[]> {\n  const done = new Set<string>()\n  const todo = [new URL('file://' + file)]\n  const quads: Quad[] = []\n\n  let item = todo.pop()\n  while (item !== undefined) {\n    if (done.has(item.toString())) {\n      item = todo.pop()\n      continue\n    }\n    done.add(item.toString())\n    if (item.protocol !== 'file:') {\n      throw 'No supported protocol ' + item.protocol\n    }\n\n    const txt = await readFile(item.pathname, { encoding: 'utf8' })\n    const extras = new Parser({ baseIRI: item.toString() }).parse(txt)\n\n    for (const o of extras\n      .filter(\n        (x) =>\n          x.subject.value === item?.toString() &&\n          x.predicate.equals(OWL.imports),\n      )\n      .map((x) => x.object.value)) {\n      todo.push(new URL(o))\n    }\n    quads.push(...extras)\n\n    item = todo.pop()\n  }\n\n  return quads\n}\n\nexport async function getProc<T extends Processor<unknown>>(\n  config: string,\n  ty: string,\n  configLocation: string,\n  uri = 'http://example.com/ns#processor',\n): Promise<FullProc<T>> {\n  const configQuads = await importFile(configLocation)\n  const procConfig = processorShapes.lenses['JsProcessorShape'].execute({\n    id: new NamedNode(base + ty),\n    quads: configQuads,\n  })\n\n  const msgs: OrchestratorMessage[] = []\n  const write = async (x: OrchestratorMessage) => {\n    msgs.push(x)\n  }\n  const runner = new Runner(\n    new TestClient(),\n    write,\n    'http://example.com/ns#',\n    logger,\n  )\n  configQuads.push(...new Parser().parse(config))\n  await runner.handleOrchMessage({\n    pipeline: new Writer().quadsToString(configQuads),\n  })\n\n  const proc = await runner.addProcessor<T>({\n    config: JSON.stringify(procConfig),\n    arguments: '',\n    uri,\n  })\n\n  return proc\n}\n\nexport async function checkProcDefinition(file: string, n: string) {\n  const quads = await importFile(file)\n  const procConfig = <{ file: Term; location: string; clazz: string }>(\n    processorShapes.lenses['JsProcessorShape'].execute({\n      id: new NamedNode(base + n),\n      quads: quads,\n    })\n  )\n  expect(procConfig.file, n + ' has file').toBeDefined()\n  expect(procConfig.location, n + ' has location').toBeDefined()\n  expect(procConfig.clazz, n + ' has clazz').toBeDefined()\n}\n"]}