nope/test/testDispatcher.ts

import 'reflect-metadata';

import { EventLayer } from "../lib/communication/eventLayer";
import { getLinkedDispatcher } from "../lib/dispatcher/getLinkedDispatcher";
import { nopeDispatcher } from "../lib/dispatcher/nopeDispatcher";
import { exportFunctionToDispatcher } from "../lib/dispatcher/nopeDispatcherDecorators";
import { generateBenchmarkFunction } from "../modules/funcs/generateBenchmarkFunction";
import { nopeObservable } from '../lib/observables/nopeObservable';

let max = 100000;
const communicator = new EventLayer(
  'generic',
  'generic'
);
const local = new nopeDispatcher({ communicator });
const _functionRemote = exportFunctionToDispatcher(async (a: number, b: number, operation: (a: number, b: number) => number) => {
  return await operation(a, b);
}, {
  uri: 'functionRemote'
});
const _benchmark = exportFunctionToDispatcher(generateBenchmarkFunction(max, ''), {
  uri: 'benchmark'
});
const remote = getLinkedDispatcher({ communicator });
const remoteObservable = new nopeObservable<number>()
remote.registerObservable(remoteObservable,{
  mode: 'publish',
  topic: 'topic'
});

const main = async () => {

  const localObservable = new nopeObservable<number>();
  localObservable.subscribe((data) => {
    console.log(data)
  });

  remoteObservable.setContent(1337);
  console.log('No output of the emitter');

  local.registerObservable(localObservable,{
    mode: 'subscribe',
    topic:'topic'
  });

  remoteObservable.setContent(1338)


  try {
    await local.performCall('unkown', []);
  } catch (e) {
    console.log('Successfully thrown Error. Function isnt available.');
    console.error(e)
  }

  let res = await local.performCall<number>('functionRemote', [1, 2, async (a, b) => {
    console.log('local callback')
    return a + b;
  }]);

  console.log('1', res)

  res = await local.methodInterface.functionRemote<number>(1, 2, async (a, b) => {
    console.log('local callback')
    return a * b;
  });


  let i = 0;

  const benchmark = generateBenchmarkFunction(max, '');

  while (i < max * 10) {
    await local.performCall<number>('functionRemote', [1, 2, async (a, b) => {
      return 1
    }], {
      deletableCallbacks: [2],
    });

    benchmark();

    i++;
  }

  const opts = {
    deletableCallbacks: []
  };
  const args = []

  i = 0;
  while (i < max * 10) {
    await local.performCall<void>('benchmark', args, opts);
    i++;
  }

}

main().catch(console.error);

setTimeout(console.log, 10000, 'done');