fix(core): update

test/test.ts

@@ -0,0 +1,109 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+import * as typedserver from '@api.global/typedserver';
+
+import * as typedrequest from '../ts/index.js';
+import * as typedrequestInterfaces from '@api.global/typedrequest-interfaces';
+
+let testServer: typedserver.servertools.Server;
+let testTypedRouter: typedrequest.TypedRouter;
+let testTypedHandler: typedrequest.TypedHandler<ITestReqRes>;
+
+// lets define an interface
+interface ITestReqRes {
+  method: 'hi';
+  request: {
+    name: string;
+  };
+  response: {
+    surname: string;
+  };
+}
+
+interface ITestStream {
+  method: 'handleStream';
+  request: {
+    requestStream: typedrequestInterfaces.IVirtualStream;
+  };
+  response: {
+    responseStream: typedrequestInterfaces.IVirtualStream;
+  };
+}
+
+tap.test('should create a typedHandler', async () => {
+  // lets use the interface in a TypedHandler
+  testTypedHandler = new typedrequest.TypedHandler<ITestReqRes>('hi', async (reqArg) => {
+    return {
+      surname: 'wow',
+    };
+  });
+});
+
+tap.test('should spawn a server to test with', async () => {
+  testServer = new typedserver.servertools.Server({
+    cors: true,
+    forceSsl: false,
+    port: 3000,
+  });
+});
+
+tap.test('should define a testHandler', async () => {
+  testTypedRouter = new typedrequest.TypedRouter(); // typed routers can broker typedrequests between handlers
+  testTypedRouter.addTypedHandler(testTypedHandler);
+  testServer.addRoute(
+    '/testroute',
+    new typedserver.servertools.HandlerTypedRouter(testTypedRouter as any) // the "any" is testspecific, since smartexpress ships with its own version of typedrequest.
+  );
+});
+
+tap.test('should start the server', async () => {
+  await testServer.start();
+});
+
+tap.test('should fire a request', async () => {
+  const typedRequest = new typedrequest.TypedRequest<ITestReqRes>(
+    'http://localhost:3000/testroute',
+    'hi'
+  );
+  const response = await typedRequest.fire({
+    name: 'really',
+  });
+  console.log('this is the response:');
+  console.log(response);
+  expect(response.surname).toEqual('wow');
+});
+
+tap.test('should allow VirtualStreams', async () => {
+  const newRequestingVS = new typedrequest.VirtualStream();
+  const newRespondingVS = new typedrequest.VirtualStream();
+  let generatedRequestingVS: typedrequestInterfaces.IVirtualStream;
+  let generatedRespondingVS: typedrequestInterfaces.IVirtualStream;
+  testTypedRouter.addTypedHandler(new typedrequest.TypedHandler<ITestStream>('handleStream', async (reqArg) => {
+    console.log('hey there');
+    console.log(reqArg.requestStream);
+    generatedRequestingVS = reqArg.requestStream;
+    return {
+      responseStream: newRespondingVS,
+    };
+  }));
+  const typedRequest = new typedrequest.TypedRequest<ITestStream>(
+    'http://localhost:3000/testroute',
+    'handleStream'
+  );
+  const response = await typedRequest.fire({
+    requestStream: newRequestingVS,
+  });
+  console.log(response.responseStream);
+
+  newRequestingVS.sendData(Buffer.from('hello'));
+  const data = await generatedRequestingVS.fetchData();
+  const decodedData = data.toString();
+  expect(data.toString()).toEqual('hello');
+});
+
+tap.test('should end the server', async (toolsArg) => {
+  await toolsArg.delayFor(1000);
+  await testServer.stop();
+  setTimeout(() => process.exit(0), 100);
+});
+
+tap.start();