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

package/features/introspection.map.feature

@@ -0,0 +1,92 @@
+@security
+Feature: Reading the introspection map
+
+  The map declares how it is exposed in its own manifests, and those manifests are what
+  this mounts — not a copy of them. A route the gateway cannot answer, or an answer it
+  drops for want of a directive, is caught here rather than in a running application.
+
+  Background:
+    # developer:secret, user:12345
+    Given the `identity.basic` database contains:
+      | _id                              | authority | username  | password                                                     |
+      | efe3a65ebbee47ed95a73edd911ea328 | nex       | developer | $2b$10$ZRSKkgZoGnrcTNA5w5eCcu3pxDzdTduhteVYXcp56AaNcilNkwJ.O |
+      | e8e4f9c2a68d419b861403d71fabc915 | nex       | user      | $2b$10$Frszmrmsz9iwSXzBbRRMKeDVKsNxozkrLNSsN.SnVC.KPxLtQr/bK |
+    And the `identity.roles` database contains:
+      | _id                              | identity                         | role                 |
+      | 3e2b0c8a1f7d4e9ab0c6d5e4f3a2b1c0 | efe3a65ebbee47ed95a73edd911ea328 | system:introspection |
+    And the `identity.bans` database is empty
+    And the annotation of the introspection map
+    And the introspection components are running
+
+  Scenario: Reading the nodes
+    Given the `introspection.nodes` database contains:
+      | _id                              | namespace | component | version  | _version | _deleted |
+      | 70e1a6551346c6932657cdb2526df0fa | pots      | tea       | 7bb04bba | 1        | null     |
+    When the following request is received:
+      """
+      GET /introspection/nodes/ HTTP/1.1
+      host: nex.toa.io
+      authorization: Basic ZGV2ZWxvcGVyOnNlY3JldA==
+      accept: application/yaml
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+      content-type: application/yaml
+
+      - id: 70e1a6551346c6932657cdb2526df0fa
+        namespace: pots
+        component: tea
+        version: 7bb04bba
+      """
+
+  Scenario: Reading one node
+    Given the `introspection.nodes` database contains:
+      | _id                              | namespace | component | version  | _version | _deleted |
+      | 70e1a6551346c6932657cdb2526df0fa | pots      | tea       | 7bb04bba | 1        | null     |
+    When the following request is received:
+      """
+      GET /introspection/nodes/70e1a6551346c6932657cdb2526df0fa/ HTTP/1.1
+      host: nex.toa.io
+      authorization: Basic ZGV2ZWxvcGVyOnNlY3JldA==
+      accept: application/yaml
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+      content-type: application/yaml
+
+      namespace: pots
+      component: tea
+      """
+
+  Scenario: Reading the edges
+    An empty map is still a body — the directive that would drop it is the point.
+
+    Given the `introspection.edges` database is empty
+    When the following request is received:
+      """
+      GET /introspection/edges/ HTTP/1.1
+      host: nex.toa.io
+      authorization: Basic ZGV2ZWxvcGVyOnNlY3JldA==
+      accept: application/yaml
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+      content-type: application/yaml
+
+      []
+      """
+
+  Scenario: The map is not readable without the role
+    When the following request is received:
+      """
+      GET /introspection/nodes/ HTTP/1.1
+      host: nex.toa.io
+      authorization: Basic dXNlcjoxMjM0NQ==
+      """
+    Then the following reply is sent:
+      """
+      403 Forbidden
+      """

package/features/io.feature

@@ -50,7 +50,6 @@ Feature: IO restrictions
       """
       GET /pots/4c4759e6f9c74da989d64511df42d6f4/ HTTP/1.1
       host: nex.toa.io
-      accept: application/yaml
       """
     Then the following reply is sent:
       """

package/features/io.throttle.feature

@@ -0,0 +1,165 @@
+Feature: Request throttling
+
+  Scenario: Throttle requests to a path
+    Given the `echo.beacon` is running with the following manifest:
+      """yaml
+      exposition:
+        /:
+          io:throttle:
+            key: [path]
+            requests: 1
+            interval: 1
+          GET:
+            endpoint: hello
+      """
+    When the following request is received:
+      """
+      GET /echo/beacon/ HTTP/1.1
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+      """
+    When the following request is received:
+      """
+      GET /echo/beacon/ HTTP/1.1
+      """
+    # an emission is a second, which is what the budget takes to earn one back
+    Then the following reply is sent:
+      """
+      429 Too Many Requests
+      retry-after: 1
+      """
+    Then after 2 seconds
+    When the following request is received:
+      """
+      GET /echo/beacon/ HTTP/1.1
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+      """
+
+  Scenario: Throttle requests to a route, whichever path they came in on
+    Given the `echo.beacon` is running with the following manifest:
+      """yaml
+      exposition:
+        /:
+          /:id:
+            io:throttle:
+              key: [route]
+              requests: 1
+              interval: 5
+            GET:
+              dev:stub:
+                hello: true
+      """
+    When the following request is received:
+      """
+      GET /echo/beacon/1/ HTTP/1.1
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+      """
+    # a different path of the same route, and the budget is already spent —
+    # keyed on `path` this would be 200
+    When the following request is received:
+      """
+      GET /echo/beacon/2/ HTTP/1.1
+      """
+    Then the following reply is sent:
+      """
+      429 Too Many Requests
+      """
+
+  Scenario: Throttle requests per route segment
+    Given the `echo.beacon` is running with the following manifest:
+      """yaml
+      exposition:
+        /:
+          /:id:
+            io:throttle:
+              key:
+                - segment: id
+              requests: 1
+              interval: 5
+            GET:
+              dev:stub:
+                hello: true
+      """
+    When the following request is received:
+      """
+      GET /echo/beacon/1/ HTTP/1.1
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+      """
+    When the following request is received:
+      """
+      GET /echo/beacon/1/ HTTP/1.1
+      """
+    Then the following reply is sent:
+      """
+      429 Too Many Requests
+      """
+    # another segment value, another budget
+    When the following request is received:
+      """
+      GET /echo/beacon/2/ HTTP/1.1
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+      """
+
+  Scenario: Throttle requests per identity
+    Given the `echo.beacon` is running with the following manifest:
+      """yaml
+      exposition:
+        /:
+          auth:anyone: true
+          GET:
+            # declared after `auth:` on the node, and mandatory families run in
+            # their own order regardless: `auth` has to resolve the identity
+            # before `io` can key a quota on it
+            io:throttle:
+              key: [identity]
+              requests: 1
+              interval: 5
+            endpoint: hello
+      """
+    And transient identity alice
+    And transient identity bob
+    When the following request is received:
+      """
+      GET /echo/beacon/ HTTP/1.1
+      host: nex.toa.io
+      authorization: Token ${{ alice.token }}
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+      """
+    When the following request is received:
+      """
+      GET /echo/beacon/ HTTP/1.1
+      host: nex.toa.io
+      authorization: Token ${{ alice.token }}
+      """
+    Then the following reply is sent:
+      """
+      429 Too Many Requests
+      """
+    # bob's own budget, which requires auth to have resolved him before io keyed on him
+    When the following request is received:
+      """
+      GET /echo/beacon/ HTTP/1.1
+      host: nex.toa.io
+      authorization: Token ${{ bob.token }}
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+      """

package/features/map.feature

@@ -0,0 +1,357 @@
+Feature: HTTP context mapping
+
+  Scenario Outline: Mapping `<result>` language code
+    Given the `echo` is running with the following manifest:
+      """yaml
+      exposition:
+        /:
+          io:output: true
+          map:languages: [en, fr]
+          GET:
+            map:language: name # map resolved language code to the `name` property of the operation input
+            endpoint: compute
+      """
+    When the following request is received:
+      """
+      GET /echo/ HTTP/1.1
+      host: nex.toa.io
+      accept: application/yaml
+      accept-language: <accept>
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+      content-language: <result>
+      vary: origin, accept-language, accept
+      content-type: application/yaml
+
+      Hello <result>
+      """
+    Examples:
+      | accept | result |
+      | en     | en     |
+      | en_US  | en     |
+      | fr     | fr     |
+      | sw     | en     |
+
+  Scenario: Listing languages on the root
+    Given the annotation:
+    """
+    /:
+      languages: [en, fr]
+    """
+    And the `echo` is running with the following manifest:
+      """yaml
+      exposition:
+        /:
+          io:output: true
+          GET:
+            anonymous: true
+            map:language: name
+            endpoint: compute
+      """
+    When the following request is received:
+      """
+      GET /echo/ HTTP/1.1
+      host: nex.toa.io
+      accept-language: fr
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+      content-language: fr
+      """
+
+  Scenario: Headers used by mappings are added to CORS permissions
+    Given the `echo` is running with the following manifest:
+      """yaml
+      exposition:
+        /:
+          io:output: true
+          map:languages: [en, fr]
+          GET:
+            map:language: name
+            map:headers:
+              name: foo
+            endpoint: compute
+      """
+    When the following request is received:
+      """
+      OPTIONS / HTTP/1.1
+      host: nex.toa.io
+      origin: https://example.com
+      """
+    Then the following reply is sent:
+      """
+      204 No Content
+      access-control-allow-headers: accept, accept-language, authorization, content-type, foo, if-match, if-none-match, origin
+      """
+
+  Scenario: Mapping the value of an arbitrary header
+    Given the `echo` is running with the following manifest:
+      """yaml
+      exposition:
+        /:
+          io:output: true
+          GET:
+            map:headers:
+              name: foo
+            endpoint: compute
+      """
+    When the following request is received:
+      """
+      GET /echo/ HTTP/1.1
+      host: nex.toa.io
+      accept: application/yaml
+      foo: bar
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+      vary: origin, foo, accept
+      content-type: application/yaml
+
+      Hello bar
+      """
+
+  Scenario: Mapping the `host` header value
+    Given the `echo` is running with the following manifest:
+      """yaml
+      exposition:
+        /:
+          io:output: true
+          GET:
+            map:headers:
+              name: host
+            endpoint: compute
+      """
+    When the following request is received:
+      """
+      GET /echo/ HTTP/1.1
+      host: nex.toa.io
+      accept: application/yaml
+      foo: bar
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+      vary: origin, accept
+      content-type: application/yaml
+
+      Hello nex.toa.io
+      """
+
+  Scenario: Mapping a route parameter
+    Given the `echo` is running with the following manifest:
+      """yaml
+      exposition:
+        /:friend:
+          io:output: true
+          GET:
+            map:segments:
+              name: ~friend
+            endpoint: compute
+      """
+    When the following request is received:
+      """
+      GET /echo/Ken/ HTTP/1.1
+      host: nex.toa.io
+      accept: text/plain
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+
+      Hello Ken
+      """
+
+  Scenario: Mapping wildcard route parameter
+    Given the `echo` is running with the following manifest:
+      """yaml
+      exposition:
+        /foo/**:
+          io:output: true
+          GET:
+            map:segments:
+              name: '**'
+            endpoint: compute
+      """
+    When the following request is received:
+      """
+      GET /echo/foo/bar/baz/ HTTP/1.1
+      host: nex.toa.io
+      accept: text/plain
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+
+      Hello bar/baz
+      """
+
+  Scenario: Mapping the authority
+    Given the annotation:
+      """yaml
+      authorities:
+        one: the.one.com
+      """
+    Given the `echo` is running with the following manifest:
+      """yaml
+      exposition:
+        /:
+          GET:
+            io:output: true
+            map:authority: name
+            endpoint: compute
+      """
+    When the following request is received:
+      """
+      GET /echo/ HTTP/1.1
+      host: the.one.com
+      accept: text/plain
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+
+      Hello one
+      """
+    When the following request is received:
+      """
+      GET /echo/ HTTP/1.1
+      host: the.two.com
+      accept: text/plain
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+
+      Hello the.two.com
+      """
+
+  Scenario: Mapping OIDC token claims
+    Given local IDP is running
+    And the `identity.federation` configuration:
+      """yaml
+      trust:
+        - iss: http://localhost:44444
+      """
+    And the `echo` is running with the following manifest:
+      """yaml
+      exposition:
+        /:
+          GET:
+            anyone: true
+            io:output: true
+            map:claims:
+              name: email
+            endpoint: compute
+      """
+    And the IDP token for Alice is issued
+
+    When the following request is received:
+      """
+      GET /echo/ HTTP/1.1
+      authorization: Bearer ${{ Alice.id_token }}
+      host: the.two.com
+      accept: text/plain
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+
+      Hello Alice@test.local
+      """
+
+  Scenario: Mapping Bearer token claims during inception
+    Given local IDP is running
+    And the `identity.federation` configuration:
+      """yaml
+      trust:
+        - iss: http://localhost:44444
+      assert: false
+      """
+    And the `pots` is running with the following manifest:
+      """yaml
+      exposition:
+        /:
+          POST:
+            auth:incept: id
+            io:input: [title, volume]
+            io:output: [id, title, volume]
+            map:claims:
+              title: email
+            endpoint: create
+      """
+    And the IDP random token is issued
+
+    When the following request is received:
+      """
+      POST /pots/ HTTP/1.1
+      host: the.two.com
+      authorization: Bearer ${{ random.id_token }}
+      accept: application/yaml
+      content-type: application/yaml
+
+      volume: 1.5
+      """
+    Then the following reply is sent:
+      """
+      201 Created
+
+      id: ${{ id }}
+      volume: 1.5
+      title: ${{ random.email }}
+      """
+
+  Scenario: Mapping non-exposed properties
+    Given the `echo` is running with the following manifest:
+      """yaml
+      exposition:
+        /:
+          GET:
+            io:output: true
+            io:input: [] # disallow input
+            map:authority: name
+            endpoint: compute
+      """
+    When the following request is received:
+      """
+      GET /echo/ HTTP/1.1
+      host: the.one.com
+      accept: text/plain
+      """
+    Then the following reply is sent:
+      """
+      200 OK
+
+      Hello the.one.com
+      """
+
+  Scenario: Mapping the raw request body
+    Given the `echo` is running with the following manifest:
+      """yaml
+      exposition:
+        /:
+          POST:
+            io:output: true
+            map:buffer: buf
+            endpoint: unwrap
+      """
+    When the following request is received:
+      """
+      POST /echo/ HTTP/1.1
+      host: nex.toa.io
+      accept: application/json
+      content-type: application/json; charset=utf-8
+
+      {"foo":"bar"}
+      """
+    Then the following reply is sent:
+      """
+      201 Created
+      content-type: application/json
+      vary: accept
+
+      {"foo":"bar"}
+      """

package/features/methods.feature

@@ -0,0 +1,47 @@
+Feature: Supported methods
+
+  Scenario Outline: <method> is supported
+    Given the annotation:
+      """yaml
+      /:
+        <method>:
+          dev:stub:
+            hello: world
+      """
+    And the `greeter` is running with the following manifest:
+      """yaml
+      exposition:
+        /:
+          <method>:
+            dev:stub:
+              hello: world
+      """
+    Examples:
+      | method |
+      | GET    |
+      | POST   |
+      | PUT    |
+      | DELETE |
+      | PATCH  |
+      | LOCK   |
+      | UNLOCK |
+
+  Scenario: CORS allowed methods
+    Given the annotation:
+      """yaml
+      /:
+        GET:
+          dev:stub:
+            hello: world
+      """
+    When the following request is received:
+      """
+      OPTIONS / HTTP/1.1
+      host: nex.toa.io
+      origin: https://hello.world
+      """
+    Then the following reply is sent:
+      """
+      204 No Content
+      access-control-allow-methods: GET, POST, PUT, PATCH, DELETE, LOCK, UNLOCK
+      """