@toa.io/extensions.exposition 1.0.0-alpha.292 → 1.0.0-alpha.293

package/features/introspection.feature

@@ -1,565 +0,0 @@
-Feature: Introspection
-
-  Scenario: Resource introspection
-    Given the `pots` is running with the following manifest:
-      """yaml
-      exposition:
-        /:
-          io:output: true
-          GET: enumerate
-          POST: create
-      """
-    When the following request is received:
-      """
-      OPTIONS /pots/ HTTP/1.1
-      host: nex.toa.io
-      accept: application/yaml
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-      Allow: GET, POST
-
-      GET:
-        output:
-          type: array
-          items:
-            properties:
-              id:
-                type: string
-                pattern: ^[a-fA-F0-9]{32}$
-              title:
-                type: string
-                maxLength: 64
-              volume:
-                type: number
-                exclusiveMinimum: 0
-                maximum: 1000
-              temperature:
-                type: number
-                exclusiveMinimum: 0
-                maximum: 300
-            type: object
-            required:
-              - id
-              - title
-              - volume
-      POST:
-        input:
-          properties:
-            temperature:
-              type: number
-              exclusiveMinimum: 0
-              maximum: 300
-            title:
-              type: string
-              maxLength: 64
-            volume:
-              type: number
-              exclusiveMinimum: 0
-              maximum: 1000
-          type: object
-          required:
-            - title
-            - volume
-        output:
-          type: object
-          properties:
-            title:
-              type: string
-              maxLength: 64
-        errors:
-          - NO_WAY
-          - WONT_CREATE
-      """
-
-  Scenario: What a method states it is
-    An operation states what it is for the Introspection to read, and that is not what a
-    resource is: an operation is written without knowledge of any route, and the same one
-    mounted twice is two methods. What a method states is what its route states.
-
-    Given the `pots` is running with the following manifest:
-      """yaml
-      exposition:
-        /:
-          io:output: true
-          GET:
-            help:method:
-              description: Every pot there is, newest first.
-            endpoint: enumerate
-          POST: create
-      """
-    When the following request is received:
-      """
-      OPTIONS /pots/ HTTP/1.1
-      host: nex.toa.io
-      accept: application/yaml
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-      Allow: GET, POST
-
-      GET:
-        description: Every pot there is, newest first.
-      """
-    And the reply does not contain:
-      """
-      Put a pot on to brew.
-      """
-
-  Scenario: What the directives of the route admit
-    A schema states what may be sent and what comes back, which is what the route's
-    directives leave of what the operation declared — not what the operation declared.
-
-    Given the `pots` is running with the following manifest:
-      """yaml
-      exposition:
-        /:
-          io:input: [title]
-          io:output: [id, title]
-          GET: enumerate
-          POST: create
-      """
-    When the following request is received:
-      """
-      OPTIONS /pots/ HTTP/1.1
-      host: nex.toa.io
-      accept: application/yaml
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-      Allow: GET, POST
-
-      GET:
-        output:
-          type: array
-          items:
-            properties:
-              id:
-                type: string
-                pattern: ^[a-fA-F0-9]{32}$
-              title:
-                type: string
-                maxLength: 64
-            type: object
-            required:
-              - id
-              - title
-      POST:
-        input:
-          properties:
-            title:
-              type: string
-              maxLength: 64
-          type: object
-          required:
-            - title
-      """
-    And the reply does not contain:
-      """
-      volume
-      """
-
-  Scenario: A method whose reply is dropped describes none
-    Without an `io:output` nothing of the reply is sent, so there is no output to state.
-
-    Given the `pots` is running with the following manifest:
-      """yaml
-      exposition:
-        /:
-          GET: enumerate
-      """
-    When the following request is received:
-      """
-      OPTIONS /pots/ HTTP/1.1
-      host: nex.toa.io
-      accept: application/yaml
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-      Allow: GET
-      """
-    And the reply does not contain:
-      """
-      output
-      """
-
-  Scenario: A method the caller cannot reach is not described
-    What a resource says about itself is what this caller may use of it, so a method they
-    could only be refused is not in the answer, nor in `Allow`.
-
-    Given the `pots` is running with the following manifest:
-      """yaml
-      exposition:
-        /:
-          isolated: true
-          io:output: true
-          GET:
-            anonymous: true
-            endpoint: enumerate
-          POST:
-            auth:role: admin
-            endpoint: create
-      """
-    When the following request is received:
-      """
-      OPTIONS /pots/ HTTP/1.1
-      host: nex.toa.io
-      accept: application/yaml
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-      Allow: GET
-      """
-    And the reply does not contain:
-      """
-      POST:
-      """
-
-  Scenario: A credential does not hide what is anonymous
-    A credential refuses an `anonymous` route because it would make the reply uncacheable,
-    and a description is not that reply — it is what the resource is, and it varies by who
-    asked in any case. Without this an identity would be told less than someone presenting
-    nothing at all.
-
-    Given the `pots` is running with the following manifest:
-      """yaml
-      exposition:
-        /:
-          isolated: true
-          anonymous: true
-          io:output: [id]
-          GET: enumerate
-      """
-    When the following request is received:
-      """
-      OPTIONS /pots/ HTTP/1.1
-      host: nex.toa.io
-      authorization: Basic ZGV2ZWxvcGVyOnNlY3JldA==
-      accept: application/yaml
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-      Allow: GET
-      """
-
-  Scenario: A method that takes an identity is not described to nobody
-    Which identity it is about cannot be told from a description, which has no route
-    variable to read. That there must be one can, and a caller with none is refused
-    whatever the value would have been — so they are not shown it.
-
-    Given the `identity.basic` database contains:
-      # developer:secret
-      | _id                              | authority | username  | password                                                     |
-      | efe3a65ebbee47ed95a73edd911ea328 | nex       | developer | $2b$10$ZRSKkgZoGnrcTNA5w5eCcu3pxDzdTduhteVYXcp56AaNcilNkwJ.O |
-    And the `identity.bans` database is empty
-    And the `pots` is running with the following manifest:
-      """yaml
-      exposition:
-        /:id:
-          isolated: true
-          io:output: [id]
-          GET:
-            anonymous: true
-            endpoint: observe
-          PATCH:
-            auth:id: id
-            endpoint: assign
-      """
-    When the following request is received:
-      """
-      OPTIONS /pots/:id/ HTTP/1.1
-      host: nex.toa.io
-      accept: application/yaml
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-      Allow: GET
-      """
-    And the reply does not contain:
-      """
-      PATCH:
-      """
-    When the following request is received:
-      """
-      OPTIONS /pots/:id/ HTTP/1.1
-      host: nex.toa.io
-      authorization: Basic ZGV2ZWxvcGVyOnNlY3JldA==
-      accept: application/yaml
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-      Allow: GET, PATCH
-      """
-
-  Scenario: A resource the caller cannot reach at all
-    Given the `pots` is running with the following manifest:
-      """yaml
-      exposition:
-        /:
-          isolated: true
-          io:output: true
-          GET:
-            auth:role: admin
-            endpoint: enumerate
-      """
-    When the following request is received:
-      """
-      OPTIONS /pots/ HTTP/1.1
-      host: nex.toa.io
-      accept: application/yaml
-      """
-    Then the following reply is sent:
-      """
-      403 Forbidden
-      """
-
-  Scenario: Introspection with route parameters
-    Given the `echo` is running with the following manifest:
-      """yaml
-      exposition:
-        /:a:
-          io:output: true
-          PATCH: parameters
-      """
-    When the following request is received:
-      """
-      OPTIONS /echo/:a/ HTTP/1.1
-      host: nex.toa.io
-      accept: application/yaml
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-      Allow: PATCH
-
-      PATCH:
-        route:
-          a:
-            type: string
-        input:
-          type: object
-          properties:
-            b:
-              type: string
-        output:
-          type: object
-          properties:
-            a:
-              type: string
-            b:
-              type: string
-      """
-
-  Scenario: A property a header carries
-    `map:headers` fills the property from the request, so it is not the body's to send.
-    Which header it reads is not answered: what an application takes off a request is its
-    own, and a caller has nowhere to put one.
-
-    Given the `echo` is running with the following manifest:
-      """yaml
-      exposition:
-        /:
-          io:output: true
-          PATCH:
-            map:headers:
-              a: x-first
-            endpoint: parameters
-      """
-    When the following request is received:
-      """
-      OPTIONS /echo/ HTTP/1.1
-      host: nex.toa.io
-      accept: application/yaml
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-      Allow: PATCH
-
-      PATCH:
-        input:
-          type: object
-          properties:
-            b:
-              type: string
-      """
-    And the reply does not contain:
-      """
-      x-first
-      """
-
-  Scenario: A property a segment carries under another name
-    `map:segments` names the property differently from the segment it reads, so the route
-    states the property — which is what a caller writes.
-
-    Given the `echo` is running with the following manifest:
-      """yaml
-      exposition:
-        /:first:
-          io:output: true
-          PATCH:
-            map:segments:
-              a: ~first
-            endpoint: parameters
-      """
-    When the following request is received:
-      """
-      OPTIONS /echo/:first/ HTTP/1.1
-      host: nex.toa.io
-      accept: application/yaml
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-      Allow: PATCH
-
-      PATCH:
-        route:
-          a:
-            type: string
-        input:
-          type: object
-          properties:
-            b:
-              type: string
-      """
-
-  Scenario: A property the token carries
-    `map:claims` reads the identity, and a caller has nowhere to put one.
-
-    Given the `echo` is running with the following manifest:
-      """yaml
-      exposition:
-        /:
-          io:output: true
-          anonymous: true
-          PATCH:
-            map:claims:
-              a: email
-            endpoint: parameters
-      """
-    When the following request is received:
-      """
-      OPTIONS /echo/ HTTP/1.1
-      host: nex.toa.io
-      accept: application/yaml
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-      Allow: PATCH
-
-      PATCH:
-        input:
-          type: object
-          properties:
-            b:
-              type: string
-      """
-    And the reply does not contain:
-      """
-      headers
-      """
-
-  Scenario: Two routes on one endpoint
-    A route takes its variables out of the operation's input to state them as its own. The
-    input it takes them out of is the operation's, shared by every route that mounts it, so
-    the one that describes itself second must still find them there.
-
-    Given the `echo` is running with the following manifest:
-      """yaml
-      exposition:
-        /:
-          io:output: true
-          /:a:
-            PATCH: parameters
-          /plain:
-            PATCH: parameters
-      """
-    When the following request is received:
-      """
-      OPTIONS /echo/:a/ HTTP/1.1
-      host: nex.toa.io
-      accept: application/yaml
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-
-      PATCH:
-        route:
-          a:
-            type: string
-        input:
-          type: object
-          properties:
-            b:
-              type: string
-      """
-    When the following request is received:
-      """
-      OPTIONS /echo/plain/ HTTP/1.1
-      host: nex.toa.io
-      accept: application/yaml
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-
-      PATCH:
-        input:
-          type: object
-          properties:
-            a:
-              type: string
-            b:
-              type: string
-      """
-
-  Scenario: Introspection with query parameters
-    Given the `echo` is running with the following manifest:
-      """yaml
-      exposition:
-        /:
-          io:output: true
-          PATCH:
-            query:
-              parameters: [a]
-            endpoint: parameters
-      """
-    When the following request is received:
-      """
-      OPTIONS /echo/ HTTP/1.1
-      host: nex.toa.io
-      accept: application/yaml
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-      Allow: PATCH
-
-      PATCH:
-        query:
-          a:
-            type: string
-        input:
-          type: object
-          properties:
-            b:
-              type: string
-        output:
-          type: object
-          properties:
-            a:
-              type: string
-            b:
-              type: string
-      """

package/features/introspection.map.feature

@@ -1,108 +0,0 @@
-@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
-      """
-
-  Scenario: The map does not take the application's root directives
-    Given the annotation of the introspection map under:
-      """yaml
-      /:
-        auth:anonymous: true
-      """
-    When the following request is received:
-      """
-      GET /introspection/nodes/ HTTP/1.1
-      host: nex.toa.io
-      """
-    Then the following reply is sent:
-      """
-      401 Unauthorized
-      """