@ikonintegration/ikapi 4.0.1 → 5.0.0

package/tests/Publisher/Publisher.test.ts

@@ -0,0 +1,60 @@
+import { SNSClient, PublishCommand } from '@aws-sdk/client-sns'
+import { mockClient } from 'aws-sdk-client-mock'
+import { expect } from 'chai'
+
+import Publisher from '../../src/Publisher/Publisher.js'
+
+const SNSMock = mockClient(SNSClient)
+
+describe('SNS Pub-Sub', () => {
+  // reset mock
+  beforeEach(() => {
+    SNSMock.reset()
+  })
+
+  const provider = new Publisher({
+    region: 'ca-central-1',
+  })
+
+  test('Publishes with success', async () => {
+    const msg = { text: '123' }
+    const topic = '123'
+    const messageId = 'id-123'
+    SNSMock.on(PublishCommand, {
+      Message: JSON.stringify(msg),
+      TopicArn: topic,
+    }).resolves({
+      MessageId: messageId,
+    })
+    const res = await provider.publishOnTopic(msg, topic)
+    expect(res).is.not.null
+    expect(res?.MessageId).to.be.equals(messageId)
+  })
+
+  test('Publishes with success (additional props)', async () => {
+    const msg = { text: '123' }
+    const topic = '123'
+    const messageId = 'id-123'
+    SNSMock.on(PublishCommand, {
+      Message: JSON.stringify(msg),
+      TopicArn: topic,
+    }).resolves({
+      MessageId: messageId,
+    })
+    const res = await provider.publishOnTopic(msg, topic, {
+      FifoGroup: 123,
+    })
+    expect(res).is.not.null
+    expect(res?.MessageId).to.be.equals(messageId)
+  })
+
+  test('Publish failure', async () => {
+    const msg = { text: '123' }
+    const topic = '123'
+    SNSMock.on(PublishCommand).rejects(new Error('failed!'))
+    const res = await provider.publishOnTopic(msg, topic)
+    expect(res).is.undefined
+  })
+})
+
+export {}

package/tests/Server/RouteResolver.test.ts

@@ -0,0 +1,116 @@
+import { HttpMethod } from '../../src/API/Request.js'
+import { Route } from '../../src/Server/Router.js'
+import RouteResolver from '../../src/Server/RouteResolver.js'
+
+const mockRoute = (method: HttpMethod, path: string | string[]) =>
+  ({
+    method: method,
+    path: path,
+  }) as any as Route
+
+describe('RouteResolver', () => {
+  test('no routes configured', () => {
+    parameterizedTest({}, () => [
+      [HttpMethod.GET, '/', undefined],
+      [HttpMethod.GET, '', undefined],
+      [HttpMethod.GET, 'hjdah', undefined],
+    ])
+  })
+
+  test('one route', () => {
+    parameterizedTest(
+      {
+        route: mockRoute(HttpMethod.GET, '/'),
+      },
+      routes => [
+        [HttpMethod.GET, '/', routes.route],
+        [HttpMethod.GET, '', routes.route],
+        [HttpMethod.GET, 'hjdah', undefined],
+        [HttpMethod.POST, '/', undefined],
+        [HttpMethod.DELETE, '/', undefined],
+      ]
+    )
+  })
+
+  test('basic matching', () => {
+    parameterizedTest(
+      {
+        getBase: mockRoute(HttpMethod.GET, '/'),
+        getA: mockRoute(HttpMethod.GET, '/a'),
+        getB: mockRoute(HttpMethod.GET, '/b'),
+        postBase: mockRoute(HttpMethod.POST, '/'),
+        postA: mockRoute(HttpMethod.POST, '/a'),
+        variable: mockRoute(HttpMethod.GET, '/:a'),
+        getAb: mockRoute(HttpMethod.GET, '/a/b'),
+      },
+      routes => [
+        [HttpMethod.GET, '/', routes.getBase],
+        [HttpMethod.GET, '/a', routes.getA],
+        [HttpMethod.GET, '/b', routes.getB],
+        [HttpMethod.POST, '/', routes.postBase],
+        [HttpMethod.POST, '/a', routes.postA],
+        [HttpMethod.GET, '/c', routes.variable],
+        [HttpMethod.GET, '/a/b', routes.getAb],
+      ]
+    )
+  })
+
+  test('multi matching', () => {
+    parameterizedTest(
+      {
+        getA: mockRoute(HttpMethod.GET, ['/a', '/b']),
+        variable: mockRoute(HttpMethod.GET, '/:a'),
+      },
+      routes => [
+        [HttpMethod.GET, '/a', routes.getA],
+        [HttpMethod.GET, '/b', routes.getA],
+        [HttpMethod.GET, '/c', routes.variable],
+      ]
+    )
+  })
+
+  test('path variables', () => {
+    parameterizedTest(
+      {
+        path_vars: mockRoute(HttpMethod.GET, '/base/:a/:b/:c'),
+        abc: mockRoute(HttpMethod.GET, '/base/a/b/c'),
+        abcd: mockRoute(HttpMethod.GET, '/base/a/b/c/d'),
+        abc_path: mockRoute(HttpMethod.GET, '/base/a/b/c/:d'),
+      },
+      routes => [
+        [HttpMethod.GET, '/base/1/2/3', routes.path_vars],
+        [HttpMethod.GET, '/base/a/b/c', routes.abc],
+        [HttpMethod.GET, '/base/a/b/c/d', routes.abcd],
+        [HttpMethod.GET, '/base/a/b/c/u', routes.abc_path],
+        [HttpMethod.GET, '/base/a/b', undefined],
+        [HttpMethod.GET, '/base/a/b/c/d/e', undefined],
+        [HttpMethod.GET, '/base/a/b/c/d/e/f', undefined],
+      ]
+    )
+  })
+
+  test('fails to construct with duplicate routes', () => {
+    expect(
+      () =>
+        new RouteResolver({
+          routes: [
+            mockRoute(HttpMethod.GET, '/a/b/c/:d/:e/b') as any,
+            mockRoute(HttpMethod.GET, '/a/b/c/:jshj/:e/b') as any,
+          ],
+        })
+    ).toThrowError('Duplicate route: GET: /a/b/c/:jshj/:e/b')
+  })
+})
+
+const parameterizedTest = <T extends { [k: string]: Route }>(
+  routes: T,
+  tests: (routes: T) => [HttpMethod, string, Route?][]
+) => {
+  const underTest = new RouteResolver({
+    routes: Object.values(routes) as any,
+  })
+
+  tests(routes).forEach(([method, path, expected]) =>
+    expect(underTest.resolveRoute(method, path)).toBe(expected)
+  )
+}

package/tests/Server/Router.test.ts

@@ -0,0 +1,39 @@
+import { jest } from '@jest/globals'
+import { expect } from 'chai'
+
+import ContainerServer from '../../src/Server/lib/ContainerServer.js'
+import Server from '../../src/Server/lib/Server.js'
+import Router from '../../src/Server/Router.js'
+
+describe('Router basics', () => {
+  // @ts-ignore
+  let mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {})
+  beforeAll(() => {
+    // @ts-ignore
+    mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {})
+  })
+  afterAll(() => {
+    mockExit.mockRestore()
+  })
+  beforeEach(() => {
+    mockExit.mockReset()
+  })
+
+  test('Serverless server', async () => {
+    process.env['HYBRIDLESS_RUNTIME'] = undefined
+    const router = new Router({ routes: [] })
+    expect(router.getExport()).to.not.be.undefined
+    expect(router['server']).to.be.an.instanceof(Server)
+    expect(router['server']).to.not.be.an.instanceof(ContainerServer)
+  })
+  test('Container server', async () => {
+    process.env['HYBRIDLESS_RUNTIME'] = 'true'
+    const router = new Router({ routes: [] })
+    expect(router.getExport()).to.not.be.undefined
+    expect(router['server']).to.be.an.instanceof(Server)
+    expect(router['server']).to.be.an.instanceof(ContainerServer)
+    await router['server']['stop']()
+  })
+})
+
+export {}