Datengenerierungsregeln

Konstante

Der Generator für Konstanten gibt immer denselben Wert zurück, der einen beliebigen einfachen Typ haben kann.

const: 0

# ==> 0, 0, 0, ...

const: Thursday

# ==> "Thursday", "Thursday", "Thursday", ...

Auflistung

Der Generator für Aufzählungen gibt Zufallswerte aus einer bestimmten Liste zurück, die einen beliebigen einfachen Typ haben können.

enum:
  - 0
  - 1
  - 2

# ==> 1, 0, 2, 0, ...

enum:
  - Thursday
  - Friday
  - Saturday

# ==> "Friday", "Saturday", "Saturday", ...

Muster

Der Generator Muster gibt Zeichenfolgewerte zurück, die einem bestimmten regulären Ausdruck entsprechen.

pattern: '[0-9]{3}'

# ==> "884", "924", "121", ...

pattern: '[a-z][a-z_]{0,15}'

# ==> "dbe", "kg_cfsv", "dhbfgbjxavmsaxq", ...

Bereich

Der Generator range gibt numerische Werte zurück, die gleichmäßig über einen bestimmten Bereich verteilt sind (einschließlich).

minimum: 0
maximum: 10

# ==> 10, 6, 8, ...

Wenn einer der Endpunkte weggelassen wird, wird standardmäßig der negativste oder positivste Wert des Typs verwendet:

minimum: 0

# ==> 10029625, 3162517758, 841054690, ...

Semantisch

Der Generator semantisch gibt Werte zurück, die einer vordefinierten semantischen Kategorie entsprechen und Namen, Adressen, Kreditkartennummern usw. abdecken. Die Gruppe der Kategorien entspricht der Gruppe, die in den API-Erweiterungenzulässig ist.

semantic: email

# ==> "herbertschaden@fahey.net", "emmyfarrell@cruickshank.com", "vilmaprohaska@zboncak.org", ...

semantic: first_name

# ==> "Antwan", "Connie", "Modesto", ...

Ressource

Der Generator für Ressourcen gibt Werte zurück, die eindeutige IDs von Ressourceninstanzen eines bestimmten Typs sind, die zufällig aus dem Pool vorhandener Instanzen ausgewählt werden. Die ID einer Instanz wird der Eigenschaft id_name des Ressourcentyps entnommen, der in den API-Erweiterungen definiert ist, und ihr Typ und Format variieren entsprechend.

resource: Customer

# ==> "e5537298-9041-47fc-b97e-c910d8f9d971", "f60521c8-2ccb-4036-a742-9f350271675f", "e5537298-9041-47fc-b97e-c910d8f9d971", ...

Bereich

Der Generator array gibt Arraywerte zurück, deren Inhalt aus einem rekursiv definierten Datengenerator gefüllt wird. Die Länge des Arrays wird zufällig zwischen minItems und maxItems einschließlich gewählt.

items:
  pattern: '[0-9]{3}'
minItems: 3
maxItems: 3

# ==> ["770", "496", "219"], ["431", "895", "331"], ["864", "130", "204"], ...

items:
  enum:
    - 0
    - 1
minItems: 0
maxItems: 5

# ==> [], [1, 0, 1, 1], [0], ...

Objekt

Der Generator für Objekte gibt Objektwerte zurück, deren Eigenschaften aus rekursiv definierten benannten Datengeneratoren gefüllt werden.

properties:
  x:
    minimum: 0
    maximum: 100
  y:
    minimum: 0
    maximum: 100

# ==> {"x": 59, "y": 63}, {"x": 22, "y": 8}, {"x": 95, "y": 57}, ...

properties:
  code:
    pattern: '[0-9]{3}'
  language:
    enum:
      - en
      - fr
      - de

# ==> {"code": "452", "language": "fr"}, {"code": "504", "language": "en"}, {"code": "846", "language": "fr"}, ...

Wenn eine Eigenschaft vom Zielschema nicht benötigt wird, kann sie mit einem Attribut optional markiert werden, das eine Häufigkeit (zwischen 0.0 und 1.0) angibt, die bestimmt, wie oft die Eigenschaft in das generierte Objekt eingeschlossen wird (wobei 0 für nie und 1 für immer steht).

properties:
  code:
    pattern: '[0-9]{3}'
  language:
    optional: 0.5
    enum:
      - en
      - fr
      - de
  tag:
    optional: 0.0

# ==> {"code": "452", "language": "fr"}, {"code": "504", "language": "en"}, {"code": "846"}, ...

Auswahloption

Der Generator choice gibt Werte zurück, die zufällig aus einer bestimmten Liste von Datengeneratoren ausgewählt wurden. Dabei werden optionale Gewichtungen verwendet, um das Ergebnis zu beeinflussen. Die Alternativen müssen einfache Generatoren sein, die array -und object -Generatoren ausschließen.

choice:
  # bias the selection towards English
  - const: en
    weight: 5
  - const: fr
  - const: de

# ==> "en", "en", "en", ..., "de", "en", ...

choice:
  # normal values in the range 1-10
  - minimum: 1
    maximum: 10
    weight: 98
  # with a small percentage of outliers
  - const: 999
    weight: 2

# ==> 6, 3, 9, 1, ..., 999, 6, ...

Benannte Schemas

Eine Schemaregel weist einem benannten Schema aus der API-Definition einen Datengenerator zu, der sich entweder unter definitions (OpenAPI 2.0) oder components/schema (OpenAPI 3.0) befindet. Der Autotester verwendet den angegebenen Generator überall dort, wo das benannte Schema in einer Anforderung vorkommt.

Schemaregeln werden im Abschnitt schemas der Profilkonfiguration unter Datatypesangezeigt.

Da es sich hierbei um eine Überschreibung handelt, ist der Generator möglicherweise für das ursprüngliche Schema unvollständig und der automatische Tester verwendet die Standardregeln, um Lücken zu schließen. Wenn das Schema einen Objekttyp beschreibt, muss der Generator nur eine Untergruppe der Objekteigenschaften benennen. Der automatische Tester wendet die Überschreibung für diese Eigenschaften an, verwendet jedoch Standardregeln für die übrigen Eigenschaften.

Beispiel für dieses benannte Schema in der API-Definition:

Movie:
  type: object
  properties:
    title:
      type: string
    release_date:
      type: string
      format: date
    language:
      description: Two-letter ISO 639-1 language code
      type: string
      pattern: '[a-z]{2}'

Die vom Schema abgeleitete Standardregel gibt Werte wie die folgenden zurück:

{
  "title": "mkLHM22Ohabb6YG4-wdZFUwxQa7dn",
  "release_date": "2018-09-14",
  "language": "jq"
}

Sie können dies eingrenzen, indem Sie die Standardregeln für die Eigenschaften title und language überschreiben:

Datatypes:
  schemas:
    Movie:
      properties:
        title:
          semantic: sentence
        language:
          enum:
            - en
            - fr
            - de

Diese Regel bindet einen Objektgenerator (eingeführt durch das Schlüsselwort properties) an das Schema Movie , das in Kombination mit der Standardregel für release_date Werte wie die folgenden zurückgibt:

{
  "title": "What dog everybody am myself hourly meeting how group over example her",
  "release_date": "2094-06-31",
  "language": "de"
}

Parameter

Eine Parameterregel bindet einen Datengenerator an einen benannten Parameter innerhalb einer Operation unter paths in der API-Definition.

Parameterregeln werden im Bereich Operationen der Profilkonfiguration unter Datatypesangezeigt.

Angenommen, die folgende Parameterdefinition für GET /movies in der API-Definition beschränkt die Anzahl der Filme, die in einem einzigen Aufruf zurückgegeben werden:

paths:
  /movies:
    get:
      parameters:
        - name: limit
          in: query
          description: Sets an upper bound on the number of movies returned
          schema:
            type: integer

Die Standardregel, die von dieser Definition abgeleitet wird, gibt Werte aus dem vollständigen ganzzahligen Bereich zurück, aber Sie können dies mit einer Regel in der Profilkonfiguration überschreiben, die einen realistischeren Bereich mit gelegentlichen Ausreißern angibt, um die Validierungslogik zu überprüfen:

Datatypes:
  operations:
    /movies:
      get:
        parameters:
          - name: limit
            data:
              choice:
                - minimum: 1
                  maximum: 500
                  weight: 95
                - const: 0
                  weight: 3
                - const: 8000000
                  weight: 2

Das Format der Regel folgt dem Format der ursprünglichen Definition, jedoch mit dem Schlüsselwort data anstelle von schema , um den Datengenerator einzuführen.

In OpenAPI, wird ein Parameter durch einen Namen und einen Ort eindeutig identifiziert (so dass derselbe Name z. B. sowohl in der Abfrage als auch in der Kopfzeile verwendet werden kann), so dass die Parameterregeln die Eigenschaft in als optional zulassen, wenn dies zur Disambiguierung erforderlich ist. In diesem Beispiel wird es nicht verwendet, weil der Abfrageparameter der einzige mit dem Namen limitist.

Der Autotester unterstützt derzeit nur Parameter des Typs query und path (und body in OpenAPI 2.0). Regeln, die an andere Parametertypen gebunden sind, werden ignoriert.

Anforderungshauptteil

Eine Regel für den Anforderungshauptteil bindet einen Datengenerator an den Hauptteil einer Anforderung, wobei das entsprechende Schema direkt als Teil der Operation in der API-Definition und nicht über einen Verweis auf ein benanntes Schema angegeben wird.

Regeln für den Anforderungshauptteil werden im Bereich Operationen der Profilkonfiguration unter Datatypesangezeigt.

Angenommen, Sie haben die folgende Definition der Nutzdaten für eine POST -Anforderung:

paths:
  /movies:
    post:
      requestBody:
        content:
          application/json:
            schema:
              type: object
              allOf:
                - $ref: '#/components/schemas/Movie'
                - properties:
                    keywords:
                      type: array
                      items:
                        type: string

Die folgende Regel generiert einige geeignete Schlüsselwörter für die Zuordnung zu einem neuen Film (wobei der Film selbst von den oben beschriebenen Regeln abgedeckt wird):

Datatypes:
  operations:
    /movies:
      post:
        requestBody:
          content:
            application/json:
              data:
                properties:
                  keywords:
                    # pick up to 3 items from the following list
                    items:
                      enum:
                        - avant-garde
                        - dystopia
                        - epic
                        - postmodern
                        - remake
                        - shootout
                    minItems: 0
                    maxItems: 3

Wie bei den Parameterregeln folgt das Format der ursprünglichen Definition, jedoch mit data anstelle von schema. Die Definition hat den Stil OpenAPI 3.0, aber die Regel kann für OpenAPI 2.0 funktionieren, solange der Inhaltstyp konsistent ist. Alternativ können Sie ausgehend von einer OpenAPI 2.0 -Definition eine body -Parameterregel verwenden, um die Nutzdaten anzugeben, aber dies funktioniert nicht für 3.0.