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

package/test/event.spec.ts

@@ -0,0 +1,155 @@
+import { FlowEvent } from '../src';
+
+describe('Events', () => {
+  test('FLOW.EVE.1 test logging of events', () => {
+    let event;
+
+    event = createEvent('test');
+    expect(event.data).toEqual('test');
+    expect(event.datacontenttype).toEqual('text/plain');
+
+    event = createEvent('{ hello }');
+    expect(event.data).toEqual('{ hello }');
+    expect(event.datacontenttype).toEqual('text/plain');
+
+    event = createEvent('{ "hello": "world" }');
+    expect(event.data).toEqual({ hello: 'world' });
+    expect(event.datacontenttype).toEqual('application/json');
+
+    event = createEvent('[0, 1, 2, 3]');
+    expect(event.data).toEqual([0, 1, 2, 3]);
+    expect(event.datacontenttype).toEqual('application/json');
+
+    event = createEvent('["a", "b", "c"]');
+    expect(event.data).toEqual(['a', 'b', 'c']);
+    expect(event.datacontenttype).toEqual('application/json');
+
+    event = createEvent('[{ "hello": "world" }]');
+    expect(event.data).toEqual([{ hello: 'world' }]);
+    expect(event.datacontenttype).toEqual('application/json');
+
+    event = createEvent('true');
+    expect(event.data).toEqual(true);
+    expect(event.datacontenttype).toEqual('application/json');
+
+    event = createEvent('null');
+    expect(event.data).toEqual(null);
+    expect(event.datacontenttype).toEqual('application/json');
+
+    event = createEvent(42);
+    expect(event.data).toEqual('42');
+    expect(event.datacontenttype).toEqual('text/plain');
+
+    event = createEvent(true);
+    expect(event.data).toEqual('true');
+    expect(event.datacontenttype).toEqual('text/plain');
+
+    event = createEvent(false);
+    expect(event.data).toEqual('false');
+    expect(event.datacontenttype).toEqual('text/plain');
+
+    event = createEvent(undefined);
+    expect(event.data).toEqual({});
+    expect(event.datacontenttype).toEqual('application/json');
+
+    event = createEvent(null);
+    expect(event.data).toEqual({});
+    expect(event.datacontenttype).toEqual('application/json');
+
+    event = createEvent(NaN);
+    expect(event.data).toEqual('NaN');
+    expect(event.datacontenttype).toEqual('text/plain');
+
+    event = createEvent({ test: 123 });
+    expect(event.data).toEqual({ test: 123 });
+    expect(event.datacontenttype).toEqual('application/json');
+
+    event = createEvent({ test: 'abc', nested: { foo: 'bar' } });
+    expect(event.data.test).toEqual('abc');
+    expect(event.data.nested.foo).toEqual('bar');
+    expect(event.datacontenttype).toEqual('application/json');
+
+    const testInst = new TestClass();
+    testInst.stringProp = 'abc';
+    testInst.numProp = 42;
+    testInst.boolProp = false;
+    event = createEvent(testInst);
+    expect(event.data).toEqual({ stringProp: 'abc', numProp: 42, boolProp: false });
+    expect(event.datacontenttype).toEqual('application/json');
+
+    event = createEvent(new Error('err'));
+    expect(event.data.message).toEqual('err');
+    expect(event.data.stack).toBeDefined();
+    expect(typeof event.data.stack).toBe('string');
+    expect(event.datacontenttype).toEqual('application/json');
+  });
+
+  test('FLOW.EVE.2 test imutability of event data', () => {
+    let data;
+    let event;
+    let eventData;
+
+    data = { test: 'abc' };
+    event = new FlowEvent({ id: 'test' }, data);
+    expect(event.getData()).toEqual(data);
+    data.test = 'xyz';
+    expect(event.getData()).not.toEqual(data);
+    expect(event.getData()).toEqual({ ...data, test: 'abc' });
+
+    data = { test: 'abc', x: { y: 'z' } };
+    event = new FlowEvent({ id: 'test' }, data);
+    expect(event.getData()).toEqual(data);
+    data.test = 'xyz';
+    data.x.y = 'A';
+    expect(event.getData()).not.toEqual(data);
+    expect(event.getData()).toEqual({ test: 'abc', x: { y: 'z' } });
+
+    data = 'foo';
+    event = new FlowEvent({ id: 'test' }, data);
+    expect(event.getData()).toEqual(data);
+    data = 'bar';
+    expect(event.getData()).not.toEqual(data);
+    expect(event.getData()).toEqual('foo');
+
+    data = { test: 'abc' };
+    event = new FlowEvent({ id: 'test' }, data);
+    eventData = event.getData();
+    expect(eventData).toEqual(data);
+    data.test = 'xyz';
+    expect(eventData).not.toEqual(data);
+    expect(eventData).toEqual({ test: 'abc' });
+
+    data = { test: 'abc' };
+    event = new FlowEvent({ id: 'test' }, data);
+    eventData = event.getData();
+    expect(eventData).toEqual(data);
+    eventData.test = 'xyz';
+    expect(eventData).not.toEqual(data);
+    expect(eventData).toEqual({ test: 'xyz' });
+    expect(event.getData()).toEqual({ test: 'abc' });
+    expect(data).toEqual({ test: 'abc' });
+
+    data = {};
+    event = new FlowEvent({ id: 'test' }, data);
+    expect(event.getData()).toEqual({});
+
+    data = null;
+    event = new FlowEvent({ id: 'test' }, data);
+    expect(event.getData()).toEqual({});
+
+    data = undefined;
+    event = new FlowEvent({ id: 'test' }, data);
+    expect(event.getData()).toEqual({});
+  });
+});
+
+function createEvent(message: any) {
+  const event = new FlowEvent({ id: 'test' }, message);
+  return JSON.parse(JSON.stringify(event.format()));
+}
+
+class TestClass {
+  stringProp: string;
+  numProp: number;
+  boolProp: boolean;
+}

package/test/extra-validators.spec.ts

@@ -0,0 +1,84 @@
+import { validate } from 'class-validator';
+
+import { IncompatableWith } from '../src';
+
+class Test {
+  @IncompatableWith(['test2'])
+  test1: string;
+
+  @IncompatableWith(['test1'])
+  test2: string;
+}
+
+class Test2 {
+  @IncompatableWith(['test2', 'test3'])
+  test1: string;
+
+  @IncompatableWith(['test1'])
+  test2: string;
+
+  @IncompatableWith(['test1'])
+  test3: string;
+}
+
+describe('extra validators', () => {
+  test('FLOW.EXV.1 should work when no incompatible field is present', (done) => {
+    const test = new Test();
+    test.test1 = 'test';
+    validate(test).then((errors) => {
+      expect(errors.length).toEqual(0);
+      done();
+    });
+  });
+
+  test('FLOW.EXV.2 should fail if both are not present', (done) => {
+    const test = new Test();
+    validate(test).then((errors) => {
+      expect(errors.length).toEqual(2);
+      done();
+    });
+  });
+
+  test('FLOW.EXV.3 validation should fail when incompatible fields are present', (done) => {
+    const test = new Test();
+    test.test1 = 'test';
+    test.test2 = 'test';
+    validate(test).then((errors) => {
+      expect(errors.length).toEqual(2);
+      done();
+    });
+  });
+
+  test('FLOW.EXV.4 validation should work with multiple incompatible fields', (done) => {
+    const test = new Test2();
+    test.test1 = 'test';
+    validate(test).then((errors) => {
+      expect(errors.length).toEqual(0);
+      done();
+    });
+  });
+
+  test('FLOW.EXV.5 validation should fail when multiple incompatible fields are present', (done) => {
+    const test = new Test2();
+    test.test1 = 'test';
+    test.test2 = 'test';
+    validate(test).then((errors) => {
+      expect(errors.length).toEqual(2);
+    });
+
+    const test2 = new Test2();
+    test2.test1 = 'test';
+    test2.test3 = 'test';
+    validate(test2).then((errors) => {
+      expect(errors.length).toEqual(2);
+    });
+
+    const test3 = new Test2();
+    test3.test2 = 'test';
+    test3.test3 = 'test';
+    validate(test3).then((errors) => {
+      expect(errors.length).toEqual(0);
+      done();
+    });
+  });
+});

package/test/flow-logger.spec.ts

@@ -0,0 +1,104 @@
+import { FlowLogger } from '../src';
+import { loggerMock } from './mocks/logger.mock';
+
+describe('Flow Logger', () => {
+  let flowLogger: FlowLogger;
+  let parseLogMessageSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    flowLogger = new FlowLogger({ id: 'testLogger' }, loggerMock);
+    parseLogMessageSpy = jest.spyOn(flowLogger as any, 'parseMessageToFlowLog');
+  });
+
+  it('FLOW.FL.0: init', () => {
+    expect(flowLogger).toBeDefined();
+  });
+
+  describe('FLOW.FL.1: parse log message correctly', () => {
+    it('FLOW.FL.1.1: log with plain string', () => {
+      const message = 'test debug message';
+      const parsedMessage = (flowLogger as any).parseMessageToFlowLog(message);
+      expect(Object.keys(parsedMessage)).toEqual(['message']);
+      expect(typeof parsedMessage.message).toBe('string');
+      expect(parsedMessage.message).toBe(message);
+    });
+
+    it('FLOW.FL.1.2: log with int', () => {
+      const message = 1;
+      const parsedMessage = (flowLogger as any).parseMessageToFlowLog(message);
+      expect(Object.keys(parsedMessage)).toEqual(['message']);
+      expect(typeof parsedMessage.message).toBe('string');
+      expect(parsedMessage.message).toBe('1');
+    });
+
+    it('FLOW.FL.1.3: log with object', () => {
+      const message = { rolf: 1 };
+      const parsedMessage = (flowLogger as any).parseMessageToFlowLog(message);
+      expect(Object.keys(parsedMessage)).toEqual(['message']);
+      expect(typeof parsedMessage.message).toBe('string');
+      expect(parsedMessage.message).toBe(JSON.stringify(message));
+    });
+
+    it('FLOW.FL.1.4: log with correct object', () => {
+      const message = { message: 'test debug message 1' };
+      const parsedMessage = (flowLogger as any).parseMessageToFlowLog(message);
+      expect(Object.keys(parsedMessage)).toEqual(['message']);
+      expect(typeof parsedMessage.message).toBe('string');
+      expect(parsedMessage.message).toBe(message.message);
+    });
+  });
+
+  describe('FLOW.FL.2: FlowLogger should parse every log message to FlowLog', () => {
+    it('FLOW.FL.2.1: log with plain string', () => {
+      const logSpy = jest.spyOn(flowLogger, 'debug');
+      const message = 'test debug message';
+      flowLogger.debug(message);
+      expect(logSpy).toHaveBeenCalledWith(message);
+      expect(parseLogMessageSpy).toHaveBeenCalledWith(message, 'debug', undefined);
+      expect(parseLogMessageSpy).toHaveReturnedWith(
+        expect.objectContaining({
+          message: 'test debug message',
+        }),
+      );
+    });
+
+    it('FLOW.FL.2.2: log with int', () => {
+      const logSpy = jest.spyOn(flowLogger, 'debug');
+      const message = 1;
+      flowLogger.debug(message);
+      expect(logSpy).toHaveBeenCalledWith(message);
+      expect(parseLogMessageSpy).toHaveBeenCalledWith(message, 'debug', undefined);
+      expect(parseLogMessageSpy).toHaveReturnedWith(
+        expect.objectContaining({
+          message: '1',
+        }),
+      );
+    });
+
+    it('FLOW.FL.2.3: log with object', () => {
+      const logSpy = jest.spyOn(flowLogger, 'debug');
+      const message = { rolf: 1 };
+      flowLogger.debug(message);
+      expect(logSpy).toHaveBeenCalledWith(message);
+      expect(parseLogMessageSpy).toHaveBeenCalledWith(message, 'debug', undefined);
+      expect(parseLogMessageSpy).toHaveReturnedWith(
+        expect.objectContaining({
+          message: JSON.stringify({ rolf: 1 }),
+        }),
+      );
+    });
+
+    it('FLOW.FL.2.4: log with correct object', () => {
+      const logSpy = jest.spyOn(flowLogger, 'debug');
+      const message = { message: '1' };
+      flowLogger.debug(message);
+      expect(logSpy).toHaveBeenCalledWith(message);
+      expect(parseLogMessageSpy).toHaveBeenCalledWith(message, 'debug', undefined);
+      expect(parseLogMessageSpy).toHaveReturnedWith(
+        expect.objectContaining({
+          message: message.message,
+        }),
+      );
+    });
+  });
+});