Regras de geração de dados

O gerador de constante sempre retorna o mesmo valor, que pode ser de qualquer tipo simples.

const: 0

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

const: Thursday

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

O gerador de enumeração retorna valores selecionados aleatoriamente de uma determinada lista, que pode ser de qualquer tipo simples.

enum:
  - 0
  - 1
  - 2

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

enum:
  - Thursday
  - Friday
  - Saturday

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

O gerador de padrão retorna valores de sequência que correspondem a uma determinada expressão regular

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

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

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

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

O gerador de intervalo retorna valores numéricos uniformemente distribuídos em um determinado intervalo (inclusive).

minimum: 0
maximum: 10

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

Se o terminal for omitido, ele será padronizado para o valor mais negativo ou mais positivo do tipo:

minimum: 0

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

O gerador semântico retorna valores que estão em conformidade com alguma categoria semântica predefinida, cobrindo nomes, endereços, números de cartão de crédito, etc. O conjunto de categorias é igual ao permitido nas extensões da API.

semantic: email

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

semantic: first_name

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

O gerador de recurso retorna valores que são identificadores exclusivos de instâncias de recurso de um determinado tipo, selecionados aleatoriamente no conjunto de instâncias existentes. O identificador de uma instância é obtido da propriedade id_name do tipo de recurso definido nas extensões de API e seu tipo e formato variarão de acordo.

resource: Customer

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

O gerador de matriz retorna valores de matriz cujos conteúdos são preenchidos a partir de um gerador de dados definido recursivamente. O comprimento da matriz é escolhido aleatoriamente entre minItems e maxItems inclusive.

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], ...

O gerador de objeto retorna os valores do objeto cujas propriedades são preenchidas a partir de geradores de dados nomeados, definidos recursivamente

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"}, ...

Se uma propriedade não for requerida pelo esquema de destino, ela poderá ser marcada com um atributo optional que especifica uma frequência (entre 0.0 e 1.0) que determina com que frequência a propriedade é incluída no objeto gerado (em que 0 significa nunca e 1 significa sempre).

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"}, ...

O gerador choice retorna valores selecionados aleatoriamente de uma determinada lista de geradores de dados, usando pesos opcionais para prover o resultado. As alternativas devem ser geradores simples, que exclui geradores array e object .

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, ...

Uma regra de esquema designa um gerador de dados para um esquema nomeado a partir da definição de API, localizada em definitions (OpenAPI 2.0) ou components/schema (OpenAPI 3.0). O testador automático usará o gerador especificado onde quer que o esquema nomeado ocorra em um pedido

Regras de esquema aparecem na seção esquemas da configuração de perfil, em Datatypes.

Como essa é uma substituição, o gerador pode estar incompleto para o esquema original e o testador automático retornará ao uso das regras padrão para cobrir quaisquer diferenças Em particular, se o esquema descrever um tipo de objeto, o gerador precisará nomear apenas um subconjunto das propriedades do objeto e o testador automático aplicará a substituição para essas propriedades, mas usará as regras padrão para o restante.

Por exemplo, dado esse esquema nomeado na definição de API:

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}'

A regra padrão derivada do esquema retorna valores como:

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

É possível refinar isso substituindo as regras padrão para as propriedades title e language :

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

Essa regra liga um gerador de objetos (introduzido pela palavra-chave properties) ao esquema denominado Movie que -- combinado com a regra padrão para release_date -- retorna valores como:

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

Uma regra de parâmetro liga um gerador de dados a um parâmetro nomeado dentro de uma operação localizada em paths na definição de API.

As regras de parâmetro aparecem na seção operações da configuração de perfil, em Datatypes

Por exemplo, dada essa definição de parâmetro em GET /movies na definição de API que restringe o número de filmes retornados em uma única chamada:

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

A regra padrão derivada dessa definição retornará valores do intervalo inteiro completo, mas é possível substituir isso por uma regra na configuração de perfil que especifica um intervalo mais realista, com valores discrepantes ocasionais para verificar a lógica de validação:

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

O formato da regra segue o formato da definição original mas com a palavra-chave data no lugar de schema para introduzir o gerador de dados.

Em OpenAPI,, um parâmetro é identificado exclusivamente por um nome e um local (de modo que o mesmo nome pode ser usado, por exemplo, na consulta e no cabeçalho), de modo que as regras de parâmetro permitem que a propriedade in seja opcional quando necessário para a desambiguação. Ele não é usado neste exemplo porque o parâmetro de consulta é o único denominado limit..

O testador automático suporta somente parâmetros do tipo query e path no momento (e body no OpenAPI 2.0)... As regras ligadas a outros tipos de parâmetros são ignorados

Uma regra de corpo de solicitação liga um gerador de dados ao corpo de uma solicitação em que o esquema correspondente é especificado diretamente como parte da operação na definição de API, em vez de uma referência a um esquema nomeado.

As regras de corpo da solicitação aparecem na seção operações da configuração do perfil em Datatypes

Por exemplo, dada essa definição da carga útil para uma solicitação POST :

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

A regra a seguir gera algumas palavras-chave apropriadas para anexar a um novo filme (onde o próprio filme é coberto pelas regras discutidas anteriormente):

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

Assim como com as regras de parâmetro, o formato segue aquele da definição original, mas com data no lugar de schema A definição está no estilo OpenAPI 3.0, mas a regra pode funcionar para OpenAPI 2.0 , desde que o tipo de conteúdo seja consistente; como alternativa, a partir de uma definição OpenAPI 2.0 , é possível usar uma regra de parâmetro body para especificar a carga útil, mas isso não funciona para 3.0.