nope/test/testModule.ts

import { assert } from "console";
import "reflect-metadata";
import { promisify } from "util";
import { EventLayer } from "../lib/communication/eventLayer";
import { getLinkedDispatcher } from "../lib/dispatcher/getLinkedDispatcher";
import { nopeDispatcher } from "../lib/dispatcher/nopeDispatcher";
import { NopeGenericModule } from "../lib/module/GenericModule";
import { NopeObservable } from "../lib/observables/NopeObservable";
import { INopePromise } from "../lib/types/nope/nopePromise.interface";
import { HelloWorldModuleWithDecorators } from "./modules/HelloWorldModuleWithDecorators";
import { IHelloWorlModule } from "./modules/IHelloWorldModule";

const sleep = promisify(setTimeout);

const communicator = new EventLayer();

const remote_01 = new nopeDispatcher(
  { communicator },
  () => new NopeObservable()
);
const remote_02 = new nopeDispatcher(
  { communicator },
  () => new NopeObservable()
);
const srv = getLinkedDispatcher({ communicator });

const main = async () => {
  const modName = HelloWorldModuleWithDecorators.prototype.constructor.name.toString();

  srv.provideInstanceGeneratorForExternalDispatchers(
    modName,
    async (dispather, identifier) => {
      const mod = new HelloWorldModuleWithDecorators(dispather);
      mod.identifier = identifier;

      console.log("Created HelloWorldModule-Instance with name", identifier);
      return mod;
    }
  );

  remote_01.registerInternalInstanceGenerator(
    modName,
    async (dispather, description) => {
      const mod = new NopeGenericModule(dispather, () => new NopeObservable());
      await mod.fromDescription(description, "overwrite");
      await mod.init();

      console.log(
        "Created HelloWorldModule-Wrapper with name",
        description.identifier
      );
      return mod;
    }
  );

  remote_02.registerInternalInstanceGenerator(
    modName,
    async (dispather, description) => {
      const mod = new NopeGenericModule(dispather, () => new NopeObservable());
      await mod.fromDescription(description, "overwrite");
      await mod.init();

      console.log(
        "Created HelloWorldModule-Wrapper with name",
        description.identifier
      );
      return mod;
    }
  );

  await sleep(100);

  const instance_01 = await remote_01.generateInstance<IHelloWorlModule>({
    identifier: "instance_01",
    params: ["hello", "world"],
    type: modName
  });

  const copy_of_instance_01 = await remote_01.generateInstance<IHelloWorlModule>(
    {
      identifier: "instance_01",
      params: ["hello", "world"],
      type: modName
    }
  );

  // await instance_01.init();
  console.log("Updating Prop");
  instance_01.testProp.setContent("hello prop #1");
  instance_01.testProp.setContent("hello prop #2");
  await sleep(100);
  console.log("Calling helloWorld");
  const greetings = await instance_01.helloWorld("You!");
  // Print the Greetings
  console.log("Result of helloWorld:", greetings);

  instance_01.testProp.subscribe((value, sender) => {
    console.log("Local update of the property", value);
  });

  console.log("Got Update by subscribing");
  console.log("Updating Variable by updateTestProp Function");
  await instance_01.updateTestProp();

  console.log("Creating new instance on other remote");
  const instance_02 = await remote_02.generateInstance<
    NopeGenericModule & IHelloWorlModule
  >({
    identifier: "instance_01",
    params: ["hello", "world"],
    type: modName
  });

  console.log("Delte Copies etc");

  remote_01.deleteInstance(instance_01);
  remote_01.deleteInstance(copy_of_instance_01);

  console.log("Delete Instance 2");

  // Quick Test of manual Cancelation.
  try {
    const promise = instance_02.sleep(5000);

    if ((promise as INopePromise<void>).cancel) {
      (promise as INopePromise<void>).cancel("Just for Fun");
    }

    await promise;
  } catch (e) {
    // The Expected Error should be :'Just for Fun'
    assert(e == "Just for Fun");
  }

  // Quick Test of manual timeout.
  try {
    const promise = instance_02.dynamicInstanceMethodsWithOptions.sleep(
      {
        timeout: 1000
      },
      5000
    );

    await promise;
  } catch (e) {
    console.log("Expect an Timeout Error", e);
  }

  remote_02.deleteInstance(instance_02);
  await sleep(100);
};

main().catch(console.error);