@hahnpro/flow-sdk 9.6.4 → 2025.2.0-beta.1

package/test/rpc.spec.ts

@@ -0,0 +1,198 @@
+import { join } from 'path';
+import { setTimeout } from 'timers/promises';
+
+import type { PythonShell } from 'python-shell';
+
+import { FlowApplication, FlowEvent, FlowFunction, FlowModule, FlowResource, InputStream } from '../src';
+import { loggerMock } from './mocks/logger.mock';
+
+/* eslint-disable no-console */
+describe('Flow RPC', () => {
+  let flowApp: FlowApplication;
+
+  beforeEach(async () => {
+    const flow = {
+      elements: [
+        { id: 'testResource', module: 'test-module', functionFqn: 'test.resource.TestResource' },
+        { id: 'testResource2', module: 'test-module', functionFqn: 'test.resource.TestResource' },
+      ],
+      connections: [
+        { id: 'testConnection1', source: 'testTrigger', sourceStream: 'a', target: 'testResource', targetStream: 'a' },
+        { id: 'testConnection2', source: 'testTrigger', sourceStream: 'b', target: 'testResource2', targetStream: 'b' },
+        { id: 'testConnection1', source: 'testTrigger', sourceStream: 'b', target: 'testResource', targetStream: 'b' },
+        { id: 'testConnection1', source: 'testTrigger', sourceStream: 'c', target: 'testResource', targetStream: 'c' },
+        { id: 'testConnection1', source: 'testTrigger', sourceStream: 'd', target: 'testResource', targetStream: 'd' },
+        { id: 'testConnection1', source: 'testTrigger', sourceStream: 'e', target: 'testResource', targetStream: 'e' },
+        { id: 'testConnection1', source: 'testTrigger', sourceStream: 'f', target: 'testResource', targetStream: 'f' },
+      ],
+      context: {
+        flowId: 'testFlow',
+        deploymentId: 'testDeployment',
+      },
+    };
+    flowApp = new FlowApplication([TestModule], flow, {
+      amqpConfig: {},
+      skipApi: true,
+      explicitInit: true,
+      logger: loggerMock,
+    });
+    await flowApp.init();
+    await setTimeout(2000);
+  });
+
+  test('FLOW.RPC.1 publish message', (done) => {
+    flowApp.subscribe('testResource.a', {
+      next: async (event: FlowEvent) => {
+        expect(event.getData()).toEqual({ res: 'foo' });
+        await flowApp.destroy();
+        done();
+      },
+    });
+
+    flowApp.emit(new FlowEvent({ id: 'testTrigger' }, {}, 'a'));
+  });
+
+  test('FLOW.RPC.2 return sent value', (done) => {
+    flowApp.subscribe('testResource.b', {
+      next: async (event: FlowEvent) => {
+        expect(event.getData()).toEqual(expect.objectContaining({ res: 'bar' }));
+        await flowApp.destroy();
+        done();
+      },
+    });
+
+    flowApp.emit(new FlowEvent({ id: 'testTrigger' }, { value: 'bar' }, 'b'));
+  });
+
+  test('FLOW.RPC.3 error in remote procedure', (done) => {
+    flowApp.subscribe('testResource.c', {
+      next: async (event: FlowEvent) => {
+        console.log(event.getData());
+        expect(event.getData().err).toBeDefined();
+        await flowApp.destroy();
+        done();
+      },
+    });
+
+    flowApp.emit(new FlowEvent({ id: 'testTrigger' }, {}, 'c'));
+  });
+
+  test('FLOW.RPC.4 should return argument', (done) => {
+    flowApp.subscribe('testResource.d', {
+      next: async (event: FlowEvent) => {
+        expect(event.getData()).toEqual({ res: '10' });
+        await flowApp.destroy();
+        done();
+      },
+    });
+
+    flowApp.emit(new FlowEvent({ id: 'testTrigger' }, {}, 'd'));
+  });
+
+  test('FLOW.RPC.5 rpc function does not exist', (done) => {
+    flowApp.subscribe('testResource.e', {
+      next: async (event: FlowEvent) => {
+        expect(event.getData().err).toBeDefined();
+        await flowApp.destroy();
+        done();
+      },
+    });
+
+    flowApp.emit(new FlowEvent({ id: 'testTrigger' }, {}, 'e'));
+  });
+
+  test('FLOW.RPC.6 rpc function returns numpy object', (done) => {
+    flowApp.subscribe('testResource.f', {
+      next: async (event: FlowEvent) => {
+        expect(event.getData()).toEqual({ res: '100000000' });
+        await flowApp.destroy();
+        done();
+      },
+    });
+
+    flowApp.emit(
+      new FlowEvent(
+        { id: 'testTrigger' },
+        {
+          powers: [
+            { timestamp: 1234, powers: 567 },
+            { timestamp: 89, powers: 1011 },
+          ],
+        },
+        'f',
+      ),
+    );
+  });
+});
+
+@FlowFunction('test.resource.TestResource')
+class TestResource extends FlowResource {
+  private shell: PythonShell;
+
+  constructor(context) {
+    super(context);
+    this.shell = this.runPyRpcScript(join(__dirname, 'rpc.test.py'), 10);
+    this.shell.on('error', (error) => console.log(error));
+    this.shell.on('pythonError', (error) => console.log(error));
+    this.shell.on('stderr', (error) => console.log(error));
+    this.shell.on('message', (error) => console.log(error));
+  }
+
+  onDestroy = () => this.shell.kill();
+
+  @InputStream('a')
+  public async onA(event) {
+    this.callRpcFunction('testA')
+      .then((res: any) => {
+        this.emitEvent({ res }, event, 'a');
+      })
+      .catch((err) => console.error(err));
+  }
+
+  @InputStream('b')
+  public async onB(event) {
+    this.callRpcFunction('testB', 'bar')
+      .then((res: any) => this.emitEvent({ res }, event, 'b'))
+      .catch((err) => this.logger.error(err));
+  }
+
+  @InputStream('c')
+  public async onC(event) {
+    this.callRpcFunction('testC')
+      .then((res: any) => this.emitEvent({ res }, event, 'c'))
+      .catch((err) => this.emitEvent({ err }, event, 'c'));
+  }
+
+  @InputStream('d')
+  public async onD(event) {
+    this.callRpcFunction('testD')
+      .then((res: any) => this.emitEvent({ res }, event, 'd'))
+      .catch((err) => this.emitEvent({ err }, event, 'd'));
+  }
+
+  @InputStream('e')
+  public async onE(event) {
+    this.callRpcFunction('testE')
+      .then((res: any) => this.emitEvent({ res }, event, 'e'))
+      .catch((err) => {
+        this.logger.error(err);
+        this.emitEvent({ err }, event, 'e');
+      });
+  }
+
+  @InputStream('f')
+  public async onF(event) {
+    this.callRpcFunction('testF')
+      .then((res: any) => this.emitOutput({ res }, 'f'))
+      .catch((err) => {
+        this.logger.error(err);
+        this.emitOutput({ err }, 'f');
+      });
+  }
+}
+
+@FlowModule({
+  name: 'test-module',
+  declarations: [TestResource],
+})
+class TestModule {}

package/test/rpc.test.py

@@ -0,0 +1,45 @@
+import sys
+import numpy as np
+import json
+
+sys.path.append(sys.argv[1])
+from rpc_server import RemoteProcedure, start_consumer
+
+
+class NpEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, np.integer):
+            return int(obj)
+        if isinstance(obj, np.floating):
+            return float(obj)
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        return json.JSONEncoder.default(self, obj)
+
+
+@RemoteProcedure
+def testA():
+    return "foo"
+
+
+@RemoteProcedure
+def testB(arg):
+    return arg
+
+
+@RemoteProcedure
+def testC():
+    return 1 / 0
+
+
+@RemoteProcedure
+def testD():
+    return sys.argv[3]
+
+
+@RemoteProcedure
+def testF():
+    return np.power(100, 4, dtype=np.int64), NpEncoder
+
+
+start_consumer(sys.argv[2])

package/test/rx.spec.ts

@@ -0,0 +1,92 @@
+import { interval, Subject } from 'rxjs';
+import { take } from 'rxjs/operators';
+
+import { delay, FlowApplication, FlowEvent, FlowFunction, FlowModule, FlowResource, FlowTask, InputStream } from '../src';
+import { loggerMock } from './mocks/logger.mock';
+
+/* eslint-disable no-console */
+describe('rx', () => {
+  test('FLOW.RX.1 rx', (done) => {
+    const size = 3;
+    const flow = {
+      elements: [
+        { id: 'testTrigger', module: 'test-module', functionFqn: 'test.resource.TestResource1' },
+        { id: 'testResource1', module: 'test-module', functionFqn: 'test.resource.TestResource1' },
+        { id: 'testResource2', module: 'test-module', functionFqn: 'test.resource.TestResource2' },
+        { id: 'tap', module: 'test-module', functionFqn: 'operators.tap' },
+      ],
+      connections: [
+        { id: 'testConnection1', source: 'testTrigger', target: 'testResource1' },
+        { id: 'testConnection2', source: 'testResource1', target: 'testResource2' },
+        { id: 'testConnection3', source: 'testResource1', target: 'tap' },
+      ],
+    };
+    const flowApp = new FlowApplication([TestModule], flow, { skipApi: true, logger: loggerMock });
+
+    flowApp.subscribe('tap.default', {
+      next: (event: FlowEvent) => {
+        expect(event.getData()).toEqual({ hello: 'world' });
+      },
+    });
+
+    let count = 0;
+    flowApp.subscribe('testResource2.default', {
+      next: (event: FlowEvent) => {
+        count++;
+        expect(event.getData()).toEqual(expect.objectContaining({ foo: 'bar' }));
+        if (count === size) {
+          done();
+        }
+      },
+    });
+
+    const triggers = interval(1000);
+    triggers.pipe(take(size)).subscribe((x) => {
+      flowApp.emit(new FlowEvent({ id: 'testTrigger' }, {}));
+    });
+  }, 60000);
+});
+
+@FlowFunction('test.resource.TestResource1')
+class TestResource extends FlowResource {
+  @InputStream('default')
+  public async onDefault(event) {
+    await delay(2000);
+    return this.emitEvent({ hello: 'world' }, event);
+  }
+}
+
+@FlowFunction('operators.tap')
+class Tap extends FlowTask {
+  tap$: Subject<FlowEvent>;
+
+  constructor(context) {
+    super(context);
+    this.tap$ = new Subject<FlowEvent>();
+    this.tap$.subscribe({
+      next: (event) => {
+        this.emitEvent({}, event);
+      },
+    });
+  }
+
+  @InputStream()
+  public async onDefault(event) {
+    this.tap$.next(event);
+  }
+}
+
+@FlowFunction('test.resource.TestResource2')
+class TestResource2 extends FlowResource {
+  @InputStream('default', { concurrent: 1 })
+  public async onDefault(event) {
+    await delay(1000);
+    return this.emitEvent({ foo: 'bar' }, event);
+  }
+}
+
+@FlowModule({
+  name: 'test-module',
+  declarations: [TestResource, TestResource2, Tap],
+})
+class TestModule {}

package/test/unit-decorator.spec.ts

@@ -0,0 +1,57 @@
+import { validationMetadatasToSchemas } from 'class-validator-jsonschema';
+
+import { IsVoltage } from '../src/lib/unit-decorators';
+import { computeUnitOptions, verifyUnit } from '../src/lib/unit-utils';
+
+class Test {
+  @IsVoltage('YV')
+  arg: number;
+}
+
+describe('unit decorators', () => {
+  test('FLOW.UD.1 voltage', async () => {
+    const schemas = validationMetadatasToSchemas({
+      additionalConverters: {
+        UnitArgsValidator: (meta) => {
+          return {
+            measure: meta.constraints[0],
+            unit: meta.constraints[1],
+            type: 'number',
+          };
+        },
+      },
+    });
+
+    expect(schemas['Test'].properties.arg).toEqual({
+      measure: 'voltage',
+      unit: 'YV',
+      type: 'number',
+    });
+  });
+
+  test('FLOW.UD.2 verifyUnit', () => {
+    expect(verifyUnit('in', 'length')).toEqual(1 / 39.3701);
+    expect(verifyUnit('kNcm', 'torque')).toEqual(10);
+    expect(verifyUnit('m/s', 'translationalVelocity')).toEqual(1);
+    expect(verifyUnit('km/h', 'translationalVelocity')).toEqual(0.2777777777777778);
+    expect(verifyUnit('kgm^2/s^2', 'torque')).toEqual(1);
+    expect(verifyUnit('kgkm^2/s^2', 'torque')).toEqual(1e6);
+    expect(verifyUnit('1/s', 'electricalFrequency')).toEqual(1);
+    expect(verifyUnit('kHz', 'electricalFrequency')).toEqual(1000);
+    expect(verifyUnit('W/m^2K', 'thermalTransmittance')).toEqual(1);
+    expect(verifyUnit('Btu/hft^2F', 'thermalTransmittance')).toBeCloseTo(5.678);
+    expect(verifyUnit('J/hm^2K', 'thermalTransmittance')).toEqual(1 / 3600);
+    expect(verifyUnit('ft^2', 'area')).toBeCloseTo(0.0929);
+
+    expect(verifyUnit('in', 'time')).toEqual(-1);
+    expect(verifyUnit('kNmmm', 'torque')).toEqual(-1);
+
+    expect(verifyUnit('', 'time')).toEqual(-1);
+    expect(verifyUnit('min', '')).toEqual(-1);
+    expect(verifyUnit('', '')).toEqual(-1);
+  });
+
+  test('FLOW.UD.3 computeUnits', () => {
+    expect(computeUnitOptions('L-2')).toEqual(computeUnitOptions('L2'));
+  });
+});

package/test/utils.spec.ts

@@ -0,0 +1,210 @@
+import { fillTemplate } from '../src';
+
+describe('utils', () => {
+  test('FLOW.UTIL.1 template string interpolation for flow properties', () => {
+    let tmplString = '${test}';
+    let tmplVars: any = { test: 'hello world' };
+    let filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('hello world');
+
+    tmplString = '${foo.bar}';
+    tmplVars = { foo: { bar: 'baz' } };
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('baz');
+
+    tmplString = '${path}';
+    tmplVars = { path: 'Some.Random.path' };
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('Some.Random.path');
+
+    tmplString = 'foo';
+    tmplVars = { foo: 'bar' };
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('foo');
+
+    tmplString = '${foo}';
+    tmplVars = { foo: 0 };
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('0');
+
+    tmplString = '';
+    tmplVars = { foo: 'bar' };
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('');
+
+    tmplString = null;
+    tmplVars = null;
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual(null);
+
+    tmplString = '${foo}';
+    tmplVars = { foo: 'bar' };
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('bar');
+
+    tmplString = '4${foo}';
+    tmplVars = { foo: 2 };
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('42');
+
+    tmplString = '${foo}';
+    tmplVars = { foo: 42 };
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('42');
+
+    tmplString = '${foo.bar}';
+    tmplVars = { foo: { bar: 'baz' } };
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('baz');
+
+    tmplString = '${foo}';
+    tmplVars = { foo: 'bar', 'a-b': 'x' };
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('bar');
+
+    tmplString = '${x} ${y} c';
+    tmplVars = { x: 'a', y: 'b' };
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('a b c');
+
+    tmplString = '${x}${y}${z}';
+    tmplVars = { x: 'a', z: 'c' };
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('ac');
+
+    tmplString = '${foo}';
+    tmplVars = {};
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual(undefined);
+
+    tmplString = '${foo.bar.baz}';
+    tmplVars = {};
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual(undefined);
+
+    tmplString = '${foo}';
+    tmplVars = undefined;
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual(undefined);
+
+    tmplVars = null;
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual(undefined);
+
+    tmplString = 'foo';
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('foo');
+  });
+
+  test('FLOW.UTIL.2 deep interpolation', () => {
+    let input: any = { foo: '${bar}' };
+    let props: any = { bar: 'baz' };
+    let res = fillTemplate(input, props);
+    expect(res).toEqual({ foo: 'baz' });
+
+    input = { foo: { x: ['a', 'b', '${bar}'] } };
+    props = { bar: 'c' };
+    res = fillTemplate(input, props);
+    expect(res).toEqual({ foo: { x: ['a', 'b', 'c'] } });
+
+    input = { a: { b: { c: { d: '${x}' } } } };
+    props = { x: '42' };
+    res = fillTemplate(input, props);
+    expect(res).toEqual({ a: { b: { c: { d: '42' } } } });
+
+    input = { a: { b: { c: { d: ['${x}', '${y}'] } } } };
+    props = { x: '42', y: '23' };
+    res = fillTemplate(input, props);
+    expect(res).toEqual({ a: { b: { c: { d: ['42', '23'] } } } });
+
+    input = { foo: [{ a: 'x', b: '${bar}' }, { c: '${baz}' }] };
+    props = { bar: 'y', baz: 'z' };
+    res = fillTemplate(input, props);
+    expect(res).toEqual({ foo: [{ a: 'x', b: 'y' }, { c: 'z' }] });
+
+    input = { foo: { x: ['a', 'b', '${bar}'] } };
+    props = {};
+    res = fillTemplate(input, props);
+    expect(res).toEqual({ foo: { x: ['a', 'b', undefined] } });
+
+    input = { foo: { x: ['a', 'b', '${bar}'] } };
+    props = null;
+    res = fillTemplate(input, props);
+    expect(res).toEqual({ foo: { x: ['a', 'b', undefined] } });
+  });
+
+  test('FLOW.UTIL.3 fillTemplate', () => {
+    let tmplString = 'foo';
+    let tmplVars: any = { foo: 'bar' };
+    let filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('foo');
+
+    tmplString = '';
+    tmplVars = { foo: 'bar' };
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('');
+
+    tmplString = null;
+    tmplVars = null;
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual(null);
+
+    tmplString = '${foo}';
+    tmplVars = { foo: 'bar' };
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('bar');
+
+    tmplString = '4${foo}';
+    tmplVars = { foo: 2 };
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('42');
+
+    tmplString = '${foo}';
+    tmplVars = { foo: 42 };
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('42');
+
+    tmplString = '${foo.bar}';
+    tmplVars = { foo: { bar: 'baz' } };
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('baz');
+
+    tmplString = '${foo}';
+    tmplVars = { foo: 'bar', 'a-b': 'x' };
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('bar');
+
+    tmplString = '${x} ${y} c';
+    tmplVars = { x: 'a', y: 'b' };
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('a b c');
+
+    tmplString = '${x}${y}${z}';
+    tmplVars = { x: 'a', z: 'c' };
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('ac');
+
+    tmplString = '${foo}';
+    tmplVars = {};
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual(undefined);
+
+    tmplString = '${foo.bar.baz}';
+    tmplVars = {};
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual(undefined);
+
+    tmplString = '${foo}';
+    tmplVars = undefined;
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual(undefined);
+
+    tmplVars = null;
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual(undefined);
+
+    tmplString = 'foo';
+    filled = fillTemplate(tmplString, tmplVars);
+    expect(filled).toEqual('foo');
+  });
+});