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

package/test/rpc.spec.ts

@@ -1,198 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,210 +0,0 @@
-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');
-  });
-});