@toa.io/extensions.exposition 1.0.0-alpha.27 → 1.0.0-alpha.270

package/features/query.feature

@@ -259,3 +259,104 @@ Feature: Queries
         volume: 100
         temperature: 80
       """
+
+  Scenario: Query parameters
+    Given the `echo` is running with the following manifest:
+      """yaml
+      exposition:
+        /:
+          GET:
+            io:output: true
+            query:
+              parameters: [name]
+            endpoint: compute
+      """
+    When the following request is received:
+      """
+      GET /echo/?name=John HTTP/1.1
+      host: nex.toa.io
+      accept: text/plain
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+
+      Hello John
+      """
+    When the following request is received:
+      """
+      GET /echo/?foo=bar HTTP/1.1
+      host: nex.toa.io
+      accept: text/plain
+      """
+    Then the following reply is sent:
+      """
+      400 Bad Request
+
+      Query parameter 'foo' is not allowed
+      """
+
+  Scenario: Text search
+    Given the `pots` is running with the following manifest:
+      """yaml
+      exposition:
+        /:
+          GET:
+            io:output: true
+            query:
+              search: true
+            endpoint: enumerate
+          /non-searchable:
+            GET:
+              io:output: true
+              endpoint: enumerate
+      """
+    When the following request is received:
+      """
+      GET /pots/?search=fourth HTTP/1.1
+      host: nex.toa.io
+      accept: application/yaml
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+
+      - id: bc6913d317334d76acd07d9f25f73535
+        title: Fourth pot
+        volume: 400
+      """
+    And the reply does not contain:
+      """
+      - id: 4c4759e6f9c74da989d64511df42d6f4
+        title: First pot
+        volume: 100
+      """
+    When the following request is received:
+      """
+      GET /pots/non-searchable/?search=first HTTP/1.1
+      host: nex.toa.io
+      accept: application/yaml
+      """
+    Then the following reply is sent:
+      """
+      400 Bad Request
+      """
+
+  Scenario: Querying sample
+    Given the `pots` is running with the following manifest:
+      """yaml
+      exposition:
+        /:
+          GET:
+            io:output: true
+            endpoint: enumerate
+      """
+    When the following request is received:
+      """
+      GET /pots/?sample=2 HTTP/1.1
+      accept: application/yaml
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+      """

package/features/realtime.feature

@@ -0,0 +1,34 @@
+Feature: Realtime events
+
+  Background:
+    Given the Realtime is running with the following annotation:
+      """yaml
+      users.properties.sync: id
+      """
+    And the identity Bob is consuming realtime events
+
+  Scenario: Getting realtime events
+    Given the `users.properties` is running with the following manifest:
+      """yaml
+      exposition:
+        /:id:
+          anonymous: true
+          io:output: false
+          PATCH: transit
+      """
+    When the following request is received:
+      """
+      PATCH /users/properties/${{ Bob.id }}/ HTTP/1.1
+      host: nex.toa.io
+      content-type: application/yaml
+
+      newbie: false
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+      """
+    And the following event `users.properties.sync` is received by Bob:
+      """yaml
+      newbie: false
+      """

package/features/response.feature

@@ -22,6 +22,35 @@ Feature: Response
       content-type: application/json
       vary: accept
 
+      {"hello":"world"}
+      """
+    When the following request is received:
+      """
+      GET / HTTP/1.1
+      host: nex.toa.io
+      accept: application/yaml
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+      content-type: application/yaml
+      vary: accept
+
+      hello: world
+      """
+
+    # default is JSON
+    When the following request is received:
+      """
+      GET / HTTP/1.1
+      host: nex.toa.io
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+      content-type: application/json
+      vary: accept
+
       {"hello":"world"}
       """
 

package/features/routes.feature

@@ -137,3 +137,88 @@ Feature: Routes
       """
       201 Created
       """
+
+  Scenario: Routes with default namespace conflicts
+    Given the `echo` is running with the following manifest:
+      """yaml
+      exposition:
+        /:foo:
+          io:output: true
+          PUT: compute
+      """
+    And the `echo.beacon` is running with the following manifest:
+      """yaml
+      exposition:
+        /:
+          io:output: true
+          GET: hello
+      """
+    When the following request is received:
+      """
+      GET /echo/beacon/ HTTP/1.1
+      host: nex.toa.io
+      accept: application/yaml
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+      """
+
+  Scenario: Routes with parameters
+    Given the `echo` is running with the following manifest:
+      """yaml
+      exposition:
+        /:a/:b:
+          io:output: true
+          GET: parameters
+      """
+    When the following request is received:
+      """
+      GET /echo/foo/bar/ HTTP/1.1
+      host: nex.toa.io
+      accept: application/yaml
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+
+      a: foo
+      b: bar
+      """
+
+  Scenario: Route forwarding
+    Given the `echo` is running with the following manifest:
+      """yaml
+      exposition:
+        /show/:a/:b:
+          io:output: true
+          GET: parameters
+        /hello: /echo/show/foo/bar
+        /mirror/:a/:b: /echo/show/:a/:b
+      """
+    When the following request is received:
+      """
+      GET /echo/hello/ HTTP/1.1
+      host: nex.toa.io
+      accept: application/yaml
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+
+      a: foo
+      b: bar
+      """
+    When the following request is received:
+      """
+      GET /echo/mirror/bar/baz/ HTTP/1.1
+      host: nex.toa.io
+      accept: application/yaml
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+
+      a: bar
+      b: baz
+      """

package/features/server.feature

@@ -0,0 +1,21 @@
+Feature: `Server` response header
+
+  Scenario: `Server` response header
+    Given the annotation:
+      """yaml
+      /:
+        GET:
+          anonymous: true
+          dev:stub:
+            access: granted!
+      """
+    When the following request is received:
+      """
+      GET / HTTP/1.1
+      host: nex.toa.io
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+      server: Exposition/
+      """

package/features/steps/.env.example

@@ -0,0 +1,5 @@
+CLOUDINARY_ENVIRONMENT=
+TOA_STORAGES_CLOUDINARY_API_KEY=
+TOA_STORAGES_CLOUDINARY_API_SECRET=
+TOA_STORAGES_CLOUDINARY_VIDEO_API_KEY=
+TOA_STORAGES_CLOUDINARY_VIDEO_API_SECRET=

package/features/steps/Captures.ts

@@ -3,4 +3,16 @@ import { binding } from 'cucumber-tsflow'
 
 @binding()
 export class Captures extends http.Captures {
+  public constructor () {
+    super(functions)
+  }
+}
+
+const functions: http.Functions = {
+  otp: function (this: Captures, value: string, arg: string): string {
+    const identity = this.get(arg + '.id')
+    const code = this.get(arg + '.code')
+
+    return Buffer.from(`${identity}:${code}`).toString('base64')
+  }
 }

package/features/steps/Common.ts

@@ -7,4 +7,8 @@ export class Common {
   public async timeout (interval: number): Promise<void> {
     await timeout(interval * 1000)
   }
+
+  @given('the process is running')
+  public async noop (): Promise<void> {
+  }
 }

package/features/steps/Components.ts

@@ -5,6 +5,9 @@ import { timeout } from '@toa.io/generic'
 import { type Connector } from '@toa.io/core'
 import { parse } from '@toa.io/yaml'
 import { Workspace } from './Workspace'
+import { components as map } from './map'
+
+const MAP = 'introspection'
 
 @binding([Workspace])
 export class Components {
@@ -27,6 +30,17 @@ export class Components {
     await this.runComponent(name, manifest)
   }
 
+  /** One composition, as the explorer hosts them. */
+  @given('the introspection components are running')
+  public async runMap (): Promise<void> {
+    assert.ok(!(MAP in this.compositions), `Composition '${MAP}' is already running`)
+
+    this.compositions[MAP] = await boot.composition(map())
+
+    await this.compositions[MAP].connect()
+    await timeout(50) // discovery
+  }
+
   @given('the `{word}` is stopped')
   public async stop (name: string): Promise<void> {
     assert.ok(name in this.compositions, `Composition '${name}' is not running`)

package/features/steps/Database.ts

@@ -25,7 +25,11 @@ export class Database {
           ? int
           : str === 'null'
             ? null
-            : str
+            : str === 'true'
+              ? true
+              : str === 'false'
+                ? false
+                : str
       }
 
       documents.push(document)
@@ -62,4 +66,4 @@ export class Database {
   }
 }
 
-type Document = Record<string, string | number | null>
+type Document = Record<string, string | number | boolean | null>

package/features/steps/Gateway.ts

@@ -6,6 +6,7 @@ import { encode, timeout } from '@toa.io/generic'
 import { Factory } from '../../source'
 import * as syntax from '../../source/RTD/syntax'
 import { shortcuts } from '../../source/Directive'
+import { manifests } from './map'
 import type * as http from '../../source/HTTP'
 
 let instance: Connector | null = null
@@ -24,15 +25,12 @@ export class Gateway {
       process.env.TOA_EXPOSITION = encode(tree)
     }
 
-    const { debug, trace, authorities } = annotation
+    const { debug, authorities } = annotation
     const properties = Object.assign({}, DEFAULT_PROPERTIES)
 
     if (debug !== undefined)
       properties.debug = debug
 
-    if (trace !== undefined)
-      properties.trace = trace
-
     if (authorities !== undefined)
       properties.authorities = authorities
 
@@ -43,6 +41,31 @@ export class Gateway {
     this.default = false
   }
 
+  /**
+   * The routes of the introspection map, taken from its own manifests. `norm` runs the
+   * exposition extension over them, so what lands here is what a deployment would carry.
+   */
+  @given('the annotation of the introspection map')
+  public async annotateMap (): Promise<void> {
+    const tree: syntax.Node = { routes: [], methods: [], directives: [] }
+
+    for (const manifest of await manifests()) {
+      const node = manifest.extensions?.[EXPOSITION] as syntax.Node | undefined
+
+      if (node === undefined)
+        throw new Error(`'${manifest.namespace}.${manifest.name}' declares no exposition`)
+
+      tree.routes.push(...node.routes)
+    }
+
+    process.env.TOA_EXPOSITION = encode(tree)
+    process.env.TOA_EXPOSITION_PROPERTIES = encode(DEFAULT_PROPERTIES)
+
+    await Gateway.stop()
+
+    this.default = false
+  }
+
   @given('the `{word}` configuration:')
   public async configure (id: string, yaml: string): Promise<void> {
     const [name, namespace = 'default'] = id.split('.').reverse()
@@ -58,6 +81,15 @@ export class Gateway {
     this.default = false
   }
 
+  @given('the branch TTL is {float} second(s)')
+  public async setBranchTTL (seconds: number): Promise<void> {
+    process.env.__TESTING_EXPOSITION_BRANCH_TTL = String(seconds * 1000)
+
+    await Gateway.stop()
+
+    this.default = false
+  }
+
   @given('the Gateway is running')
   public async start (): Promise<void> {
     if (instance !== null)
@@ -82,6 +114,8 @@ export class Gateway {
 
   @after()
   public async cleanup (): Promise<void> {
+    delete process.env.__TESTING_EXPOSITION_BRANCH_TTL
+
     if (this.default)
       return
 
@@ -107,6 +141,8 @@ export class Gateway {
   }
 }
 
+const EXPOSITION = '@toa.io/extensions.exposition'
+
 const DEFAULT_TREE = encode({
   routes: [],
   methods: [],
@@ -127,6 +163,16 @@ const DEFAULT_PROPERTIES: Partial<http.Options> = {
 
 const DEFAULT_CONFIGURATION: Record<string, object> = {
   'identity.tokens': {
-    key0: 'k3.local.pIZT8-9Fa6U_QtfQHOSStfGtmyzPINyKQq2Xk-hd7vA'
+    keys: [
+      {
+        id: 'key0',
+        key: 'sTxL6qVOadKkUJwh3FveU53XgTEo3Sdfg7k2FfiIKfs'
+      },
+      {
+        id: 'legacy0',
+        key: 'k3.local.pIZT8-9Fa6U_QtfQHOSStfGtmyzPINyKQq2Xk-hd7vA',
+        format: 'paseto'
+      }
+    ]
   }
 }

package/features/steps/HTTP.ts

@@ -23,6 +23,7 @@ export class HTTP extends http.Agent {
   @when('the following request is received:')
   public override async request (input: string): Promise<any> {
     await this.gateway.start()
+
     this.fetched = await super.request(input)
   }
 
@@ -36,7 +37,7 @@ export class HTTP extends http.Agent {
     assert.ok(this.fetched !== null, 'Response is null')
 
     const buf = await this.fetched.arrayBuffer()
-    const value = encoders[format]?.(buf as Buffer)
+    const value = encoders[format]?.(buf as unknown as Buffer)
     const expected = YAML.load(yaml)
 
     assert.deepEqual(value, expected, 'Values are not equal')
@@ -61,12 +62,35 @@ export class HTTP extends http.Agent {
 
     await super.streamMatch(head, stream)
   }
+
+  @when('the following request is interrupted after {float} second(s):')
+  public async interrupt (delay: number, input: string): Promise<any> {
+    const controller = new AbortController()
+
+    await this.gateway.start()
+
+    setTimeout(() => {
+      if (pending)
+        controller.abort()
+      else
+        console.error('Request cannot be interrupted as it is already completed')
+    }, delay * 1000)
+
+    let pending = true
+
+    await super.fetch(input, { signal: controller.signal }).catch((e) => {
+      if (e.name !== 'AbortError')
+        throw e
+    })
+
+    pending = false
+  }
 }
 
-const FILEDIR = path.resolve(__dirname, '../../../storages/source/test')
+const FILES_DIR = path.resolve(__dirname, '../../../storages/source/test')
 
 function open (filename: string): Readable {
-  return fs.createReadStream(path.join(FILEDIR, filename))
+  return fs.createReadStream(path.join(FILES_DIR, filename))
 }
 
 const encoders: Record<string, (buf: Buffer | Uint8Array) => any> = {